{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.DataBrew.Types.Input
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.DataBrew.Types.Input where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.DataBrew.Types.DataCatalogInputDefinition
import Amazonka.DataBrew.Types.DatabaseInputDefinition
import Amazonka.DataBrew.Types.Metadata
import Amazonka.DataBrew.Types.S3Location
import qualified Amazonka.Prelude as Prelude

-- | Represents information on how DataBrew can find data, in either the Glue
-- Data Catalog or Amazon S3.
--
-- /See:/ 'newInput' smart constructor.
data Input = Input'
  { -- | The Glue Data Catalog parameters for the data.
    Input -> Maybe DataCatalogInputDefinition
dataCatalogInputDefinition :: Prelude.Maybe DataCatalogInputDefinition,
    -- | Connection information for dataset input files stored in a database.
    Input -> Maybe DatabaseInputDefinition
databaseInputDefinition :: Prelude.Maybe DatabaseInputDefinition,
    -- | Contains additional resource information needed for specific datasets.
    Input -> Maybe Metadata
metadata :: Prelude.Maybe Metadata,
    -- | The Amazon S3 location where the data is stored.
    Input -> Maybe S3Location
s3InputDefinition :: Prelude.Maybe S3Location
  }
  deriving (Input -> Input -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Input -> Input -> Bool
$c/= :: Input -> Input -> Bool
== :: Input -> Input -> Bool
$c== :: Input -> Input -> Bool
Prelude.Eq, ReadPrec [Input]
ReadPrec Input
Int -> ReadS Input
ReadS [Input]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Input]
$creadListPrec :: ReadPrec [Input]
readPrec :: ReadPrec Input
$creadPrec :: ReadPrec Input
readList :: ReadS [Input]
$creadList :: ReadS [Input]
readsPrec :: Int -> ReadS Input
$creadsPrec :: Int -> ReadS Input
Prelude.Read, Int -> Input -> ShowS
[Input] -> ShowS
Input -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Input] -> ShowS
$cshowList :: [Input] -> ShowS
show :: Input -> String
$cshow :: Input -> String
showsPrec :: Int -> Input -> ShowS
$cshowsPrec :: Int -> Input -> ShowS
Prelude.Show, forall x. Rep Input x -> Input
forall x. Input -> Rep Input x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Input x -> Input
$cfrom :: forall x. Input -> Rep Input x
Prelude.Generic)

-- |
-- Create a value of 'Input' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'dataCatalogInputDefinition', 'input_dataCatalogInputDefinition' - The Glue Data Catalog parameters for the data.
--
-- 'databaseInputDefinition', 'input_databaseInputDefinition' - Connection information for dataset input files stored in a database.
--
-- 'metadata', 'input_metadata' - Contains additional resource information needed for specific datasets.
--
-- 's3InputDefinition', 'input_s3InputDefinition' - The Amazon S3 location where the data is stored.
newInput ::
  Input
newInput :: Input
newInput =
  Input'
    { $sel:dataCatalogInputDefinition:Input' :: Maybe DataCatalogInputDefinition
dataCatalogInputDefinition =
        forall a. Maybe a
Prelude.Nothing,
      $sel:databaseInputDefinition:Input' :: Maybe DatabaseInputDefinition
databaseInputDefinition = forall a. Maybe a
Prelude.Nothing,
      $sel:metadata:Input' :: Maybe Metadata
metadata = forall a. Maybe a
Prelude.Nothing,
      $sel:s3InputDefinition:Input' :: Maybe S3Location
s3InputDefinition = forall a. Maybe a
Prelude.Nothing
    }

-- | The Glue Data Catalog parameters for the data.
input_dataCatalogInputDefinition :: Lens.Lens' Input (Prelude.Maybe DataCatalogInputDefinition)
input_dataCatalogInputDefinition :: Lens' Input (Maybe DataCatalogInputDefinition)
input_dataCatalogInputDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe DataCatalogInputDefinition
dataCatalogInputDefinition :: Maybe DataCatalogInputDefinition
$sel:dataCatalogInputDefinition:Input' :: Input -> Maybe DataCatalogInputDefinition
dataCatalogInputDefinition} -> Maybe DataCatalogInputDefinition
dataCatalogInputDefinition) (\s :: Input
s@Input' {} Maybe DataCatalogInputDefinition
a -> Input
s {$sel:dataCatalogInputDefinition:Input' :: Maybe DataCatalogInputDefinition
dataCatalogInputDefinition = Maybe DataCatalogInputDefinition
a} :: Input)

-- | Connection information for dataset input files stored in a database.
input_databaseInputDefinition :: Lens.Lens' Input (Prelude.Maybe DatabaseInputDefinition)
input_databaseInputDefinition :: Lens' Input (Maybe DatabaseInputDefinition)
input_databaseInputDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe DatabaseInputDefinition
databaseInputDefinition :: Maybe DatabaseInputDefinition
$sel:databaseInputDefinition:Input' :: Input -> Maybe DatabaseInputDefinition
databaseInputDefinition} -> Maybe DatabaseInputDefinition
databaseInputDefinition) (\s :: Input
s@Input' {} Maybe DatabaseInputDefinition
a -> Input
s {$sel:databaseInputDefinition:Input' :: Maybe DatabaseInputDefinition
databaseInputDefinition = Maybe DatabaseInputDefinition
a} :: Input)

-- | Contains additional resource information needed for specific datasets.
input_metadata :: Lens.Lens' Input (Prelude.Maybe Metadata)
input_metadata :: Lens' Input (Maybe Metadata)
input_metadata = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe Metadata
metadata :: Maybe Metadata
$sel:metadata:Input' :: Input -> Maybe Metadata
metadata} -> Maybe Metadata
metadata) (\s :: Input
s@Input' {} Maybe Metadata
a -> Input
s {$sel:metadata:Input' :: Maybe Metadata
metadata = Maybe Metadata
a} :: Input)

-- | The Amazon S3 location where the data is stored.
input_s3InputDefinition :: Lens.Lens' Input (Prelude.Maybe S3Location)
input_s3InputDefinition :: Lens' Input (Maybe S3Location)
input_s3InputDefinition = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Input' {Maybe S3Location
s3InputDefinition :: Maybe S3Location
$sel:s3InputDefinition:Input' :: Input -> Maybe S3Location
s3InputDefinition} -> Maybe S3Location
s3InputDefinition) (\s :: Input
s@Input' {} Maybe S3Location
a -> Input
s {$sel:s3InputDefinition:Input' :: Maybe S3Location
s3InputDefinition = Maybe S3Location
a} :: Input)

instance Data.FromJSON Input where
  parseJSON :: Value -> Parser Input
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Input"
      ( \Object
x ->
          Maybe DataCatalogInputDefinition
-> Maybe DatabaseInputDefinition
-> Maybe Metadata
-> Maybe S3Location
-> Input
Input'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DataCatalogInputDefinition")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DatabaseInputDefinition")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Metadata")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"S3InputDefinition")
      )

instance Prelude.Hashable Input where
  hashWithSalt :: Int -> Input -> Int
hashWithSalt Int
_salt Input' {Maybe Metadata
Maybe S3Location
Maybe DatabaseInputDefinition
Maybe DataCatalogInputDefinition
s3InputDefinition :: Maybe S3Location
metadata :: Maybe Metadata
databaseInputDefinition :: Maybe DatabaseInputDefinition
dataCatalogInputDefinition :: Maybe DataCatalogInputDefinition
$sel:s3InputDefinition:Input' :: Input -> Maybe S3Location
$sel:metadata:Input' :: Input -> Maybe Metadata
$sel:databaseInputDefinition:Input' :: Input -> Maybe DatabaseInputDefinition
$sel:dataCatalogInputDefinition:Input' :: Input -> Maybe DataCatalogInputDefinition
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DataCatalogInputDefinition
dataCatalogInputDefinition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DatabaseInputDefinition
databaseInputDefinition
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Metadata
metadata
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe S3Location
s3InputDefinition

instance Prelude.NFData Input where
  rnf :: Input -> ()
rnf Input' {Maybe Metadata
Maybe S3Location
Maybe DatabaseInputDefinition
Maybe DataCatalogInputDefinition
s3InputDefinition :: Maybe S3Location
metadata :: Maybe Metadata
databaseInputDefinition :: Maybe DatabaseInputDefinition
dataCatalogInputDefinition :: Maybe DataCatalogInputDefinition
$sel:s3InputDefinition:Input' :: Input -> Maybe S3Location
$sel:metadata:Input' :: Input -> Maybe Metadata
$sel:databaseInputDefinition:Input' :: Input -> Maybe DatabaseInputDefinition
$sel:dataCatalogInputDefinition:Input' :: Input -> Maybe DataCatalogInputDefinition
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DataCatalogInputDefinition
dataCatalogInputDefinition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DatabaseInputDefinition
databaseInputDefinition
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Metadata
metadata
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe S3Location
s3InputDefinition

instance Data.ToJSON Input where
  toJSON :: Input -> Value
toJSON Input' {Maybe Metadata
Maybe S3Location
Maybe DatabaseInputDefinition
Maybe DataCatalogInputDefinition
s3InputDefinition :: Maybe S3Location
metadata :: Maybe Metadata
databaseInputDefinition :: Maybe DatabaseInputDefinition
dataCatalogInputDefinition :: Maybe DataCatalogInputDefinition
$sel:s3InputDefinition:Input' :: Input -> Maybe S3Location
$sel:metadata:Input' :: Input -> Maybe Metadata
$sel:databaseInputDefinition:Input' :: Input -> Maybe DatabaseInputDefinition
$sel:dataCatalogInputDefinition:Input' :: Input -> Maybe DataCatalogInputDefinition
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"DataCatalogInputDefinition" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DataCatalogInputDefinition
dataCatalogInputDefinition,
            (Key
"DatabaseInputDefinition" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe DatabaseInputDefinition
databaseInputDefinition,
            (Key
"Metadata" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Metadata
metadata,
            (Key
"S3InputDefinition" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=)
              forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe S3Location
s3InputDefinition
          ]
      )