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

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

-- |
-- Module      : Amazonka.RedshiftData.BatchExecuteStatement
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Runs one or more SQL statements, which can be data manipulation language
-- (DML) or data definition language (DDL). Depending on the authorization
-- method, use one of the following combinations of request parameters:
--
-- -   Secrets Manager - when connecting to a cluster, specify the Amazon
--     Resource Name (ARN) of the secret, the database name, and the
--     cluster identifier that matches the cluster in the secret. When
--     connecting to a serverless workgroup, specify the Amazon Resource
--     Name (ARN) of the secret and the database name.
--
-- -   Temporary credentials - when connecting to a cluster, specify the
--     cluster identifier, the database name, and the database user name.
--     Also, permission to call the @redshift:GetClusterCredentials@
--     operation is required. When connecting to a serverless workgroup,
--     specify the workgroup name and database name. Also, permission to
--     call the @redshift-serverless:GetCredentials@ operation is required.
--
-- For more information about the Amazon Redshift Data API and CLI usage
-- examples, see
-- <https://docs.aws.amazon.com/redshift/latest/mgmt/data-api.html Using the Amazon Redshift Data API>
-- in the /Amazon Redshift Management Guide/.
module Amazonka.RedshiftData.BatchExecuteStatement
  ( -- * Creating a Request
    BatchExecuteStatement (..),
    newBatchExecuteStatement,

    -- * Request Lenses
    batchExecuteStatement_clientToken,
    batchExecuteStatement_clusterIdentifier,
    batchExecuteStatement_dbUser,
    batchExecuteStatement_secretArn,
    batchExecuteStatement_statementName,
    batchExecuteStatement_withEvent,
    batchExecuteStatement_workgroupName,
    batchExecuteStatement_database,
    batchExecuteStatement_sqls,

    -- * Destructuring the Response
    BatchExecuteStatementResponse (..),
    newBatchExecuteStatementResponse,

    -- * Response Lenses
    batchExecuteStatementResponse_clusterIdentifier,
    batchExecuteStatementResponse_createdAt,
    batchExecuteStatementResponse_database,
    batchExecuteStatementResponse_dbUser,
    batchExecuteStatementResponse_id,
    batchExecuteStatementResponse_secretArn,
    batchExecuteStatementResponse_workgroupName,
    batchExecuteStatementResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.RedshiftData.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newBatchExecuteStatement' smart constructor.
data BatchExecuteStatement = BatchExecuteStatement'
  { -- | A unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request.
    BatchExecuteStatement -> Maybe Text
clientToken :: Prelude.Maybe Prelude.Text,
    -- | The cluster identifier. This parameter is required when connecting to a
    -- cluster and authenticating using either Secrets Manager or temporary
    -- credentials.
    BatchExecuteStatement -> Maybe Text
clusterIdentifier :: Prelude.Maybe Prelude.Text,
    -- | The database user name. This parameter is required when connecting to a
    -- cluster and authenticating using temporary credentials.
    BatchExecuteStatement -> Maybe Text
dbUser :: Prelude.Maybe Prelude.Text,
    -- | The name or ARN of the secret that enables access to the database. This
    -- parameter is required when authenticating using Secrets Manager.
    BatchExecuteStatement -> Maybe Text
secretArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the SQL statements. You can name the SQL statements when you
    -- create them to identify the query.
    BatchExecuteStatement -> Maybe Text
statementName :: Prelude.Maybe Prelude.Text,
    -- | A value that indicates whether to send an event to the Amazon
    -- EventBridge event bus after the SQL statements run.
    BatchExecuteStatement -> Maybe Bool
withEvent :: Prelude.Maybe Prelude.Bool,
    -- | The serverless workgroup name. This parameter is required when
    -- connecting to a serverless workgroup and authenticating using either
    -- Secrets Manager or temporary credentials.
    BatchExecuteStatement -> Maybe Text
workgroupName :: Prelude.Maybe Prelude.Text,
    -- | The name of the database. This parameter is required when authenticating
    -- using either Secrets Manager or temporary credentials.
    BatchExecuteStatement -> Text
database :: Prelude.Text,
    -- | One or more SQL statements to run.
    --
    -- >  The SQL statements are run as a single transaction. They run serially in the order of the array. Subsequent SQL statements don't start until the previous statement in the array completes. If any SQL statement fails, then because they are run as one transaction, all work is rolled back.</p>
    BatchExecuteStatement -> NonEmpty Text
sqls :: Prelude.NonEmpty Prelude.Text
  }
  deriving (BatchExecuteStatement -> BatchExecuteStatement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchExecuteStatement -> BatchExecuteStatement -> Bool
$c/= :: BatchExecuteStatement -> BatchExecuteStatement -> Bool
== :: BatchExecuteStatement -> BatchExecuteStatement -> Bool
$c== :: BatchExecuteStatement -> BatchExecuteStatement -> Bool
Prelude.Eq, ReadPrec [BatchExecuteStatement]
ReadPrec BatchExecuteStatement
Int -> ReadS BatchExecuteStatement
ReadS [BatchExecuteStatement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchExecuteStatement]
$creadListPrec :: ReadPrec [BatchExecuteStatement]
readPrec :: ReadPrec BatchExecuteStatement
$creadPrec :: ReadPrec BatchExecuteStatement
readList :: ReadS [BatchExecuteStatement]
$creadList :: ReadS [BatchExecuteStatement]
readsPrec :: Int -> ReadS BatchExecuteStatement
$creadsPrec :: Int -> ReadS BatchExecuteStatement
Prelude.Read, Int -> BatchExecuteStatement -> ShowS
[BatchExecuteStatement] -> ShowS
BatchExecuteStatement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchExecuteStatement] -> ShowS
$cshowList :: [BatchExecuteStatement] -> ShowS
show :: BatchExecuteStatement -> String
$cshow :: BatchExecuteStatement -> String
showsPrec :: Int -> BatchExecuteStatement -> ShowS
$cshowsPrec :: Int -> BatchExecuteStatement -> ShowS
Prelude.Show, forall x. Rep BatchExecuteStatement x -> BatchExecuteStatement
forall x. BatchExecuteStatement -> Rep BatchExecuteStatement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BatchExecuteStatement x -> BatchExecuteStatement
$cfrom :: forall x. BatchExecuteStatement -> Rep BatchExecuteStatement x
Prelude.Generic)

-- |
-- Create a value of 'BatchExecuteStatement' 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:
--
-- 'clientToken', 'batchExecuteStatement_clientToken' - A unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
--
-- 'clusterIdentifier', 'batchExecuteStatement_clusterIdentifier' - The cluster identifier. This parameter is required when connecting to a
-- cluster and authenticating using either Secrets Manager or temporary
-- credentials.
--
-- 'dbUser', 'batchExecuteStatement_dbUser' - The database user name. This parameter is required when connecting to a
-- cluster and authenticating using temporary credentials.
--
-- 'secretArn', 'batchExecuteStatement_secretArn' - The name or ARN of the secret that enables access to the database. This
-- parameter is required when authenticating using Secrets Manager.
--
-- 'statementName', 'batchExecuteStatement_statementName' - The name of the SQL statements. You can name the SQL statements when you
-- create them to identify the query.
--
-- 'withEvent', 'batchExecuteStatement_withEvent' - A value that indicates whether to send an event to the Amazon
-- EventBridge event bus after the SQL statements run.
--
-- 'workgroupName', 'batchExecuteStatement_workgroupName' - The serverless workgroup name. This parameter is required when
-- connecting to a serverless workgroup and authenticating using either
-- Secrets Manager or temporary credentials.
--
-- 'database', 'batchExecuteStatement_database' - The name of the database. This parameter is required when authenticating
-- using either Secrets Manager or temporary credentials.
--
-- 'sqls', 'batchExecuteStatement_sqls' - One or more SQL statements to run.
--
-- >  The SQL statements are run as a single transaction. They run serially in the order of the array. Subsequent SQL statements don't start until the previous statement in the array completes. If any SQL statement fails, then because they are run as one transaction, all work is rolled back.</p>
newBatchExecuteStatement ::
  -- | 'database'
  Prelude.Text ->
  -- | 'sqls'
  Prelude.NonEmpty Prelude.Text ->
  BatchExecuteStatement
newBatchExecuteStatement :: Text -> NonEmpty Text -> BatchExecuteStatement
newBatchExecuteStatement Text
pDatabase_ NonEmpty Text
pSqls_ =
  BatchExecuteStatement'
    { $sel:clientToken:BatchExecuteStatement' :: Maybe Text
clientToken =
        forall a. Maybe a
Prelude.Nothing,
      $sel:clusterIdentifier:BatchExecuteStatement' :: Maybe Text
clusterIdentifier = forall a. Maybe a
Prelude.Nothing,
      $sel:dbUser:BatchExecuteStatement' :: Maybe Text
dbUser = forall a. Maybe a
Prelude.Nothing,
      $sel:secretArn:BatchExecuteStatement' :: Maybe Text
secretArn = forall a. Maybe a
Prelude.Nothing,
      $sel:statementName:BatchExecuteStatement' :: Maybe Text
statementName = forall a. Maybe a
Prelude.Nothing,
      $sel:withEvent:BatchExecuteStatement' :: Maybe Bool
withEvent = forall a. Maybe a
Prelude.Nothing,
      $sel:workgroupName:BatchExecuteStatement' :: Maybe Text
workgroupName = forall a. Maybe a
Prelude.Nothing,
      $sel:database:BatchExecuteStatement' :: Text
database = Text
pDatabase_,
      $sel:sqls:BatchExecuteStatement' :: NonEmpty Text
sqls = forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced forall t b. AReview t b -> b -> t
Lens.# NonEmpty Text
pSqls_
    }

-- | A unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
batchExecuteStatement_clientToken :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_clientToken :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_clientToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
clientToken :: Maybe Text
$sel:clientToken:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
clientToken} -> Maybe Text
clientToken) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:clientToken:BatchExecuteStatement' :: Maybe Text
clientToken = Maybe Text
a} :: BatchExecuteStatement)

-- | The cluster identifier. This parameter is required when connecting to a
-- cluster and authenticating using either Secrets Manager or temporary
-- credentials.
batchExecuteStatement_clusterIdentifier :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_clusterIdentifier :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_clusterIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
clusterIdentifier :: Maybe Text
$sel:clusterIdentifier:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
clusterIdentifier} -> Maybe Text
clusterIdentifier) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:clusterIdentifier:BatchExecuteStatement' :: Maybe Text
clusterIdentifier = Maybe Text
a} :: BatchExecuteStatement)

-- | The database user name. This parameter is required when connecting to a
-- cluster and authenticating using temporary credentials.
batchExecuteStatement_dbUser :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_dbUser :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_dbUser = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
dbUser :: Maybe Text
$sel:dbUser:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
dbUser} -> Maybe Text
dbUser) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:dbUser:BatchExecuteStatement' :: Maybe Text
dbUser = Maybe Text
a} :: BatchExecuteStatement)

-- | The name or ARN of the secret that enables access to the database. This
-- parameter is required when authenticating using Secrets Manager.
batchExecuteStatement_secretArn :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_secretArn :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_secretArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
secretArn :: Maybe Text
$sel:secretArn:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
secretArn} -> Maybe Text
secretArn) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:secretArn:BatchExecuteStatement' :: Maybe Text
secretArn = Maybe Text
a} :: BatchExecuteStatement)

-- | The name of the SQL statements. You can name the SQL statements when you
-- create them to identify the query.
batchExecuteStatement_statementName :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_statementName :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_statementName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
statementName :: Maybe Text
$sel:statementName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
statementName} -> Maybe Text
statementName) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:statementName:BatchExecuteStatement' :: Maybe Text
statementName = Maybe Text
a} :: BatchExecuteStatement)

-- | A value that indicates whether to send an event to the Amazon
-- EventBridge event bus after the SQL statements run.
batchExecuteStatement_withEvent :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Bool)
batchExecuteStatement_withEvent :: Lens' BatchExecuteStatement (Maybe Bool)
batchExecuteStatement_withEvent = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Bool
withEvent :: Maybe Bool
$sel:withEvent:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Bool
withEvent} -> Maybe Bool
withEvent) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Bool
a -> BatchExecuteStatement
s {$sel:withEvent:BatchExecuteStatement' :: Maybe Bool
withEvent = Maybe Bool
a} :: BatchExecuteStatement)

-- | The serverless workgroup name. This parameter is required when
-- connecting to a serverless workgroup and authenticating using either
-- Secrets Manager or temporary credentials.
batchExecuteStatement_workgroupName :: Lens.Lens' BatchExecuteStatement (Prelude.Maybe Prelude.Text)
batchExecuteStatement_workgroupName :: Lens' BatchExecuteStatement (Maybe Text)
batchExecuteStatement_workgroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Maybe Text
workgroupName :: Maybe Text
$sel:workgroupName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
workgroupName} -> Maybe Text
workgroupName) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Maybe Text
a -> BatchExecuteStatement
s {$sel:workgroupName:BatchExecuteStatement' :: Maybe Text
workgroupName = Maybe Text
a} :: BatchExecuteStatement)

-- | The name of the database. This parameter is required when authenticating
-- using either Secrets Manager or temporary credentials.
batchExecuteStatement_database :: Lens.Lens' BatchExecuteStatement Prelude.Text
batchExecuteStatement_database :: Lens' BatchExecuteStatement Text
batchExecuteStatement_database = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {Text
database :: Text
$sel:database:BatchExecuteStatement' :: BatchExecuteStatement -> Text
database} -> Text
database) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} Text
a -> BatchExecuteStatement
s {$sel:database:BatchExecuteStatement' :: Text
database = Text
a} :: BatchExecuteStatement)

-- | One or more SQL statements to run.
--
-- >  The SQL statements are run as a single transaction. They run serially in the order of the array. Subsequent SQL statements don't start until the previous statement in the array completes. If any SQL statement fails, then because they are run as one transaction, all work is rolled back.</p>
batchExecuteStatement_sqls :: Lens.Lens' BatchExecuteStatement (Prelude.NonEmpty Prelude.Text)
batchExecuteStatement_sqls :: Lens' BatchExecuteStatement (NonEmpty Text)
batchExecuteStatement_sqls = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatement' {NonEmpty Text
sqls :: NonEmpty Text
$sel:sqls:BatchExecuteStatement' :: BatchExecuteStatement -> NonEmpty Text
sqls} -> NonEmpty Text
sqls) (\s :: BatchExecuteStatement
s@BatchExecuteStatement' {} NonEmpty Text
a -> BatchExecuteStatement
s {$sel:sqls:BatchExecuteStatement' :: NonEmpty Text
sqls = NonEmpty Text
a} :: BatchExecuteStatement) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

instance Core.AWSRequest BatchExecuteStatement where
  type
    AWSResponse BatchExecuteStatement =
      BatchExecuteStatementResponse
  request :: (Service -> Service)
-> BatchExecuteStatement -> Request BatchExecuteStatement
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy BatchExecuteStatement
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse BatchExecuteStatement)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Int
-> BatchExecuteStatementResponse
BatchExecuteStatementResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"ClusterIdentifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"CreatedAt")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Database")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"DbUser")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Id")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"SecretArn")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"WorkgroupName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable BatchExecuteStatement where
  hashWithSalt :: Int -> BatchExecuteStatement -> Int
hashWithSalt Int
_salt BatchExecuteStatement' {Maybe Bool
Maybe Text
NonEmpty Text
Text
sqls :: NonEmpty Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sqls:BatchExecuteStatement' :: BatchExecuteStatement -> NonEmpty Text
$sel:database:BatchExecuteStatement' :: BatchExecuteStatement -> Text
$sel:workgroupName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:withEvent:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Bool
$sel:statementName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:secretArn:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:dbUser:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clusterIdentifier:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clientToken:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clientToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
clusterIdentifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
dbUser
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
secretArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
statementName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
withEvent
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
workgroupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
database
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NonEmpty Text
sqls

instance Prelude.NFData BatchExecuteStatement where
  rnf :: BatchExecuteStatement -> ()
rnf BatchExecuteStatement' {Maybe Bool
Maybe Text
NonEmpty Text
Text
sqls :: NonEmpty Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sqls:BatchExecuteStatement' :: BatchExecuteStatement -> NonEmpty Text
$sel:database:BatchExecuteStatement' :: BatchExecuteStatement -> Text
$sel:workgroupName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:withEvent:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Bool
$sel:statementName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:secretArn:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:dbUser:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clusterIdentifier:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clientToken:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clientToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clusterIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbUser
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
secretArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
statementName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
withEvent
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
workgroupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
database
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NonEmpty Text
sqls

instance Data.ToHeaders BatchExecuteStatement where
  toHeaders :: BatchExecuteStatement -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"RedshiftData.BatchExecuteStatement" ::
                          Prelude.ByteString
                      ),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON BatchExecuteStatement where
  toJSON :: BatchExecuteStatement -> Value
toJSON BatchExecuteStatement' {Maybe Bool
Maybe Text
NonEmpty Text
Text
sqls :: NonEmpty Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sqls:BatchExecuteStatement' :: BatchExecuteStatement -> NonEmpty Text
$sel:database:BatchExecuteStatement' :: BatchExecuteStatement -> Text
$sel:workgroupName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:withEvent:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Bool
$sel:statementName:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:secretArn:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:dbUser:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clusterIdentifier:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
$sel:clientToken:BatchExecuteStatement' :: BatchExecuteStatement -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"ClientToken" 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 Text
clientToken,
            (Key
"ClusterIdentifier" 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 Text
clusterIdentifier,
            (Key
"DbUser" 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 Text
dbUser,
            (Key
"SecretArn" 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 Text
secretArn,
            (Key
"StatementName" 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 Text
statementName,
            (Key
"WithEvent" 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
withEvent,
            (Key
"WorkgroupName" 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 Text
workgroupName,
            forall a. a -> Maybe a
Prelude.Just (Key
"Database" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
database),
            forall a. a -> Maybe a
Prelude.Just (Key
"Sqls" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NonEmpty Text
sqls)
          ]
      )

instance Data.ToPath BatchExecuteStatement where
  toPath :: BatchExecuteStatement -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery BatchExecuteStatement where
  toQuery :: BatchExecuteStatement -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newBatchExecuteStatementResponse' smart constructor.
data BatchExecuteStatementResponse = BatchExecuteStatementResponse'
  { -- | The cluster identifier. This element is not returned when connecting to
    -- a serverless workgroup.
    BatchExecuteStatementResponse -> Maybe Text
clusterIdentifier :: Prelude.Maybe Prelude.Text,
    -- | The date and time (UTC) the statement was created.
    BatchExecuteStatementResponse -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The name of the database.
    BatchExecuteStatementResponse -> Maybe Text
database :: Prelude.Maybe Prelude.Text,
    -- | The database user name.
    BatchExecuteStatementResponse -> Maybe Text
dbUser :: Prelude.Maybe Prelude.Text,
    -- | The identifier of the SQL statement whose results are to be fetched.
    -- This value is a universally unique identifier (UUID) generated by Amazon
    -- Redshift Data API. This identifier is returned by
    -- @BatchExecuteStatment@.
    BatchExecuteStatementResponse -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The name or ARN of the secret that enables access to the database.
    BatchExecuteStatementResponse -> Maybe Text
secretArn :: Prelude.Maybe Prelude.Text,
    -- | The serverless workgroup name. This element is not returned when
    -- connecting to a provisioned cluster.
    BatchExecuteStatementResponse -> Maybe Text
workgroupName :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    BatchExecuteStatementResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (BatchExecuteStatementResponse
-> BatchExecuteStatementResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BatchExecuteStatementResponse
-> BatchExecuteStatementResponse -> Bool
$c/= :: BatchExecuteStatementResponse
-> BatchExecuteStatementResponse -> Bool
== :: BatchExecuteStatementResponse
-> BatchExecuteStatementResponse -> Bool
$c== :: BatchExecuteStatementResponse
-> BatchExecuteStatementResponse -> Bool
Prelude.Eq, ReadPrec [BatchExecuteStatementResponse]
ReadPrec BatchExecuteStatementResponse
Int -> ReadS BatchExecuteStatementResponse
ReadS [BatchExecuteStatementResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [BatchExecuteStatementResponse]
$creadListPrec :: ReadPrec [BatchExecuteStatementResponse]
readPrec :: ReadPrec BatchExecuteStatementResponse
$creadPrec :: ReadPrec BatchExecuteStatementResponse
readList :: ReadS [BatchExecuteStatementResponse]
$creadList :: ReadS [BatchExecuteStatementResponse]
readsPrec :: Int -> ReadS BatchExecuteStatementResponse
$creadsPrec :: Int -> ReadS BatchExecuteStatementResponse
Prelude.Read, Int -> BatchExecuteStatementResponse -> ShowS
[BatchExecuteStatementResponse] -> ShowS
BatchExecuteStatementResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BatchExecuteStatementResponse] -> ShowS
$cshowList :: [BatchExecuteStatementResponse] -> ShowS
show :: BatchExecuteStatementResponse -> String
$cshow :: BatchExecuteStatementResponse -> String
showsPrec :: Int -> BatchExecuteStatementResponse -> ShowS
$cshowsPrec :: Int -> BatchExecuteStatementResponse -> ShowS
Prelude.Show, forall x.
Rep BatchExecuteStatementResponse x
-> BatchExecuteStatementResponse
forall x.
BatchExecuteStatementResponse
-> Rep BatchExecuteStatementResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep BatchExecuteStatementResponse x
-> BatchExecuteStatementResponse
$cfrom :: forall x.
BatchExecuteStatementResponse
-> Rep BatchExecuteStatementResponse x
Prelude.Generic)

-- |
-- Create a value of 'BatchExecuteStatementResponse' 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:
--
-- 'clusterIdentifier', 'batchExecuteStatementResponse_clusterIdentifier' - The cluster identifier. This element is not returned when connecting to
-- a serverless workgroup.
--
-- 'createdAt', 'batchExecuteStatementResponse_createdAt' - The date and time (UTC) the statement was created.
--
-- 'database', 'batchExecuteStatementResponse_database' - The name of the database.
--
-- 'dbUser', 'batchExecuteStatementResponse_dbUser' - The database user name.
--
-- 'id', 'batchExecuteStatementResponse_id' - The identifier of the SQL statement whose results are to be fetched.
-- This value is a universally unique identifier (UUID) generated by Amazon
-- Redshift Data API. This identifier is returned by
-- @BatchExecuteStatment@.
--
-- 'secretArn', 'batchExecuteStatementResponse_secretArn' - The name or ARN of the secret that enables access to the database.
--
-- 'workgroupName', 'batchExecuteStatementResponse_workgroupName' - The serverless workgroup name. This element is not returned when
-- connecting to a provisioned cluster.
--
-- 'httpStatus', 'batchExecuteStatementResponse_httpStatus' - The response's http status code.
newBatchExecuteStatementResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  BatchExecuteStatementResponse
newBatchExecuteStatementResponse :: Int -> BatchExecuteStatementResponse
newBatchExecuteStatementResponse Int
pHttpStatus_ =
  BatchExecuteStatementResponse'
    { $sel:clusterIdentifier:BatchExecuteStatementResponse' :: Maybe Text
clusterIdentifier =
        forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:BatchExecuteStatementResponse' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:database:BatchExecuteStatementResponse' :: Maybe Text
database = forall a. Maybe a
Prelude.Nothing,
      $sel:dbUser:BatchExecuteStatementResponse' :: Maybe Text
dbUser = forall a. Maybe a
Prelude.Nothing,
      $sel:id:BatchExecuteStatementResponse' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:secretArn:BatchExecuteStatementResponse' :: Maybe Text
secretArn = forall a. Maybe a
Prelude.Nothing,
      $sel:workgroupName:BatchExecuteStatementResponse' :: Maybe Text
workgroupName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:BatchExecuteStatementResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The cluster identifier. This element is not returned when connecting to
-- a serverless workgroup.
batchExecuteStatementResponse_clusterIdentifier :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_clusterIdentifier :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_clusterIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
clusterIdentifier :: Maybe Text
$sel:clusterIdentifier:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
clusterIdentifier} -> Maybe Text
clusterIdentifier) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:clusterIdentifier:BatchExecuteStatementResponse' :: Maybe Text
clusterIdentifier = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The date and time (UTC) the statement was created.
batchExecuteStatementResponse_createdAt :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.UTCTime)
batchExecuteStatementResponse_createdAt :: Lens' BatchExecuteStatementResponse (Maybe UTCTime)
batchExecuteStatementResponse_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe POSIX
a -> BatchExecuteStatementResponse
s {$sel:createdAt:BatchExecuteStatementResponse' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: BatchExecuteStatementResponse) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The name of the database.
batchExecuteStatementResponse_database :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_database :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_database = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
database :: Maybe Text
$sel:database:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
database} -> Maybe Text
database) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:database:BatchExecuteStatementResponse' :: Maybe Text
database = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The database user name.
batchExecuteStatementResponse_dbUser :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_dbUser :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_dbUser = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
dbUser :: Maybe Text
$sel:dbUser:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
dbUser} -> Maybe Text
dbUser) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:dbUser:BatchExecuteStatementResponse' :: Maybe Text
dbUser = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The identifier of the SQL statement whose results are to be fetched.
-- This value is a universally unique identifier (UUID) generated by Amazon
-- Redshift Data API. This identifier is returned by
-- @BatchExecuteStatment@.
batchExecuteStatementResponse_id :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_id :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
id :: Maybe Text
$sel:id:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
id} -> Maybe Text
id) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:id:BatchExecuteStatementResponse' :: Maybe Text
id = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The name or ARN of the secret that enables access to the database.
batchExecuteStatementResponse_secretArn :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_secretArn :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_secretArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
secretArn :: Maybe Text
$sel:secretArn:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
secretArn} -> Maybe Text
secretArn) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:secretArn:BatchExecuteStatementResponse' :: Maybe Text
secretArn = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The serverless workgroup name. This element is not returned when
-- connecting to a provisioned cluster.
batchExecuteStatementResponse_workgroupName :: Lens.Lens' BatchExecuteStatementResponse (Prelude.Maybe Prelude.Text)
batchExecuteStatementResponse_workgroupName :: Lens' BatchExecuteStatementResponse (Maybe Text)
batchExecuteStatementResponse_workgroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Maybe Text
workgroupName :: Maybe Text
$sel:workgroupName:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
workgroupName} -> Maybe Text
workgroupName) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Maybe Text
a -> BatchExecuteStatementResponse
s {$sel:workgroupName:BatchExecuteStatementResponse' :: Maybe Text
workgroupName = Maybe Text
a} :: BatchExecuteStatementResponse)

-- | The response's http status code.
batchExecuteStatementResponse_httpStatus :: Lens.Lens' BatchExecuteStatementResponse Prelude.Int
batchExecuteStatementResponse_httpStatus :: Lens' BatchExecuteStatementResponse Int
batchExecuteStatementResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\BatchExecuteStatementResponse' {Int
httpStatus :: Int
$sel:httpStatus:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: BatchExecuteStatementResponse
s@BatchExecuteStatementResponse' {} Int
a -> BatchExecuteStatementResponse
s {$sel:httpStatus:BatchExecuteStatementResponse' :: Int
httpStatus = Int
a} :: BatchExecuteStatementResponse)

instance Prelude.NFData BatchExecuteStatementResponse where
  rnf :: BatchExecuteStatementResponse -> ()
rnf BatchExecuteStatementResponse' {Int
Maybe Text
Maybe POSIX
httpStatus :: Int
workgroupName :: Maybe Text
secretArn :: Maybe Text
id :: Maybe Text
dbUser :: Maybe Text
database :: Maybe Text
createdAt :: Maybe POSIX
clusterIdentifier :: Maybe Text
$sel:httpStatus:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Int
$sel:workgroupName:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
$sel:secretArn:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
$sel:id:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
$sel:dbUser:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
$sel:database:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
$sel:createdAt:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe POSIX
$sel:clusterIdentifier:BatchExecuteStatementResponse' :: BatchExecuteStatementResponse -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
clusterIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
createdAt
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
database
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
dbUser
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
id
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
secretArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
workgroupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus