{-# 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.DatasetParameter
-- 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.DatasetParameter 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.DatetimeOptions
import Amazonka.DataBrew.Types.FilterExpression
import Amazonka.DataBrew.Types.ParameterType
import qualified Amazonka.Prelude as Prelude

-- | Represents a dataset parameter that defines type and conditions for a
-- parameter in the Amazon S3 path of the dataset.
--
-- /See:/ 'newDatasetParameter' smart constructor.
data DatasetParameter = DatasetParameter'
  { -- | Optional boolean value that defines whether the captured value of this
    -- parameter should be used to create a new column in a dataset.
    DatasetParameter -> Maybe Bool
createColumn :: Prelude.Maybe Prelude.Bool,
    -- | Additional parameter options such as a format and a timezone. Required
    -- for datetime parameters.
    DatasetParameter -> Maybe DatetimeOptions
datetimeOptions :: Prelude.Maybe DatetimeOptions,
    -- | The optional filter expression structure to apply additional matching
    -- criteria to the parameter.
    DatasetParameter -> Maybe FilterExpression
filter' :: Prelude.Maybe FilterExpression,
    -- | The name of the parameter that is used in the dataset\'s Amazon S3 path.
    DatasetParameter -> Text
name :: Prelude.Text,
    -- | The type of the dataset parameter, can be one of a \'String\',
    -- \'Number\' or \'Datetime\'.
    DatasetParameter -> ParameterType
type' :: ParameterType
  }
  deriving (DatasetParameter -> DatasetParameter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DatasetParameter -> DatasetParameter -> Bool
$c/= :: DatasetParameter -> DatasetParameter -> Bool
== :: DatasetParameter -> DatasetParameter -> Bool
$c== :: DatasetParameter -> DatasetParameter -> Bool
Prelude.Eq, ReadPrec [DatasetParameter]
ReadPrec DatasetParameter
Int -> ReadS DatasetParameter
ReadS [DatasetParameter]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DatasetParameter]
$creadListPrec :: ReadPrec [DatasetParameter]
readPrec :: ReadPrec DatasetParameter
$creadPrec :: ReadPrec DatasetParameter
readList :: ReadS [DatasetParameter]
$creadList :: ReadS [DatasetParameter]
readsPrec :: Int -> ReadS DatasetParameter
$creadsPrec :: Int -> ReadS DatasetParameter
Prelude.Read, Int -> DatasetParameter -> ShowS
[DatasetParameter] -> ShowS
DatasetParameter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DatasetParameter] -> ShowS
$cshowList :: [DatasetParameter] -> ShowS
show :: DatasetParameter -> String
$cshow :: DatasetParameter -> String
showsPrec :: Int -> DatasetParameter -> ShowS
$cshowsPrec :: Int -> DatasetParameter -> ShowS
Prelude.Show, forall x. Rep DatasetParameter x -> DatasetParameter
forall x. DatasetParameter -> Rep DatasetParameter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DatasetParameter x -> DatasetParameter
$cfrom :: forall x. DatasetParameter -> Rep DatasetParameter x
Prelude.Generic)

-- |
-- Create a value of 'DatasetParameter' 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:
--
-- 'createColumn', 'datasetParameter_createColumn' - Optional boolean value that defines whether the captured value of this
-- parameter should be used to create a new column in a dataset.
--
-- 'datetimeOptions', 'datasetParameter_datetimeOptions' - Additional parameter options such as a format and a timezone. Required
-- for datetime parameters.
--
-- 'filter'', 'datasetParameter_filter' - The optional filter expression structure to apply additional matching
-- criteria to the parameter.
--
-- 'name', 'datasetParameter_name' - The name of the parameter that is used in the dataset\'s Amazon S3 path.
--
-- 'type'', 'datasetParameter_type' - The type of the dataset parameter, can be one of a \'String\',
-- \'Number\' or \'Datetime\'.
newDatasetParameter ::
  -- | 'name'
  Prelude.Text ->
  -- | 'type''
  ParameterType ->
  DatasetParameter
newDatasetParameter :: Text -> ParameterType -> DatasetParameter
newDatasetParameter Text
pName_ ParameterType
pType_ =
  DatasetParameter'
    { $sel:createColumn:DatasetParameter' :: Maybe Bool
createColumn = forall a. Maybe a
Prelude.Nothing,
      $sel:datetimeOptions:DatasetParameter' :: Maybe DatetimeOptions
datetimeOptions = forall a. Maybe a
Prelude.Nothing,
      $sel:filter':DatasetParameter' :: Maybe FilterExpression
filter' = forall a. Maybe a
Prelude.Nothing,
      $sel:name:DatasetParameter' :: Text
name = Text
pName_,
      $sel:type':DatasetParameter' :: ParameterType
type' = ParameterType
pType_
    }

-- | Optional boolean value that defines whether the captured value of this
-- parameter should be used to create a new column in a dataset.
datasetParameter_createColumn :: Lens.Lens' DatasetParameter (Prelude.Maybe Prelude.Bool)
datasetParameter_createColumn :: Lens' DatasetParameter (Maybe Bool)
datasetParameter_createColumn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatasetParameter' {Maybe Bool
createColumn :: Maybe Bool
$sel:createColumn:DatasetParameter' :: DatasetParameter -> Maybe Bool
createColumn} -> Maybe Bool
createColumn) (\s :: DatasetParameter
s@DatasetParameter' {} Maybe Bool
a -> DatasetParameter
s {$sel:createColumn:DatasetParameter' :: Maybe Bool
createColumn = Maybe Bool
a} :: DatasetParameter)

-- | Additional parameter options such as a format and a timezone. Required
-- for datetime parameters.
datasetParameter_datetimeOptions :: Lens.Lens' DatasetParameter (Prelude.Maybe DatetimeOptions)
datasetParameter_datetimeOptions :: Lens' DatasetParameter (Maybe DatetimeOptions)
datasetParameter_datetimeOptions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatasetParameter' {Maybe DatetimeOptions
datetimeOptions :: Maybe DatetimeOptions
$sel:datetimeOptions:DatasetParameter' :: DatasetParameter -> Maybe DatetimeOptions
datetimeOptions} -> Maybe DatetimeOptions
datetimeOptions) (\s :: DatasetParameter
s@DatasetParameter' {} Maybe DatetimeOptions
a -> DatasetParameter
s {$sel:datetimeOptions:DatasetParameter' :: Maybe DatetimeOptions
datetimeOptions = Maybe DatetimeOptions
a} :: DatasetParameter)

-- | The optional filter expression structure to apply additional matching
-- criteria to the parameter.
datasetParameter_filter :: Lens.Lens' DatasetParameter (Prelude.Maybe FilterExpression)
datasetParameter_filter :: Lens' DatasetParameter (Maybe FilterExpression)
datasetParameter_filter = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatasetParameter' {Maybe FilterExpression
filter' :: Maybe FilterExpression
$sel:filter':DatasetParameter' :: DatasetParameter -> Maybe FilterExpression
filter'} -> Maybe FilterExpression
filter') (\s :: DatasetParameter
s@DatasetParameter' {} Maybe FilterExpression
a -> DatasetParameter
s {$sel:filter':DatasetParameter' :: Maybe FilterExpression
filter' = Maybe FilterExpression
a} :: DatasetParameter)

-- | The name of the parameter that is used in the dataset\'s Amazon S3 path.
datasetParameter_name :: Lens.Lens' DatasetParameter Prelude.Text
datasetParameter_name :: Lens' DatasetParameter Text
datasetParameter_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatasetParameter' {Text
name :: Text
$sel:name:DatasetParameter' :: DatasetParameter -> Text
name} -> Text
name) (\s :: DatasetParameter
s@DatasetParameter' {} Text
a -> DatasetParameter
s {$sel:name:DatasetParameter' :: Text
name = Text
a} :: DatasetParameter)

-- | The type of the dataset parameter, can be one of a \'String\',
-- \'Number\' or \'Datetime\'.
datasetParameter_type :: Lens.Lens' DatasetParameter ParameterType
datasetParameter_type :: Lens' DatasetParameter ParameterType
datasetParameter_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DatasetParameter' {ParameterType
type' :: ParameterType
$sel:type':DatasetParameter' :: DatasetParameter -> ParameterType
type'} -> ParameterType
type') (\s :: DatasetParameter
s@DatasetParameter' {} ParameterType
a -> DatasetParameter
s {$sel:type':DatasetParameter' :: ParameterType
type' = ParameterType
a} :: DatasetParameter)

instance Data.FromJSON DatasetParameter where
  parseJSON :: Value -> Parser DatasetParameter
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"DatasetParameter"
      ( \Object
x ->
          Maybe Bool
-> Maybe DatetimeOptions
-> Maybe FilterExpression
-> Text
-> ParameterType
-> DatasetParameter
DatasetParameter'
            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
"CreateColumn")
            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
"DatetimeOptions")
            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
"Filter")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Name")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Type")
      )

instance Prelude.Hashable DatasetParameter where
  hashWithSalt :: Int -> DatasetParameter -> Int
hashWithSalt Int
_salt DatasetParameter' {Maybe Bool
Maybe DatetimeOptions
Maybe FilterExpression
Text
ParameterType
type' :: ParameterType
name :: Text
filter' :: Maybe FilterExpression
datetimeOptions :: Maybe DatetimeOptions
createColumn :: Maybe Bool
$sel:type':DatasetParameter' :: DatasetParameter -> ParameterType
$sel:name:DatasetParameter' :: DatasetParameter -> Text
$sel:filter':DatasetParameter' :: DatasetParameter -> Maybe FilterExpression
$sel:datetimeOptions:DatasetParameter' :: DatasetParameter -> Maybe DatetimeOptions
$sel:createColumn:DatasetParameter' :: DatasetParameter -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
createColumn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DatetimeOptions
datetimeOptions
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FilterExpression
filter'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` ParameterType
type'

instance Prelude.NFData DatasetParameter where
  rnf :: DatasetParameter -> ()
rnf DatasetParameter' {Maybe Bool
Maybe DatetimeOptions
Maybe FilterExpression
Text
ParameterType
type' :: ParameterType
name :: Text
filter' :: Maybe FilterExpression
datetimeOptions :: Maybe DatetimeOptions
createColumn :: Maybe Bool
$sel:type':DatasetParameter' :: DatasetParameter -> ParameterType
$sel:name:DatasetParameter' :: DatasetParameter -> Text
$sel:filter':DatasetParameter' :: DatasetParameter -> Maybe FilterExpression
$sel:datetimeOptions:DatasetParameter' :: DatasetParameter -> Maybe DatetimeOptions
$sel:createColumn:DatasetParameter' :: DatasetParameter -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
createColumn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DatetimeOptions
datetimeOptions
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FilterExpression
filter'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf ParameterType
type'

instance Data.ToJSON DatasetParameter where
  toJSON :: DatasetParameter -> Value
toJSON DatasetParameter' {Maybe Bool
Maybe DatetimeOptions
Maybe FilterExpression
Text
ParameterType
type' :: ParameterType
name :: Text
filter' :: Maybe FilterExpression
datetimeOptions :: Maybe DatetimeOptions
createColumn :: Maybe Bool
$sel:type':DatasetParameter' :: DatasetParameter -> ParameterType
$sel:name:DatasetParameter' :: DatasetParameter -> Text
$sel:filter':DatasetParameter' :: DatasetParameter -> Maybe FilterExpression
$sel:datetimeOptions:DatasetParameter' :: DatasetParameter -> Maybe DatetimeOptions
$sel:createColumn:DatasetParameter' :: DatasetParameter -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CreateColumn" 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 Bool
createColumn,
            (Key
"DatetimeOptions" 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 DatetimeOptions
datetimeOptions,
            (Key
"Filter" 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 FilterExpression
filter',
            forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name),
            forall a. a -> Maybe a
Prelude.Just (Key
"Type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= ParameterType
type')
          ]
      )