{-# 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.ExecuteStatement
-- 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 an SQL statement, which can be data manipulation language (DML) or
-- data definition language (DDL). This statement must be a single SQL
-- statement. 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.ExecuteStatement
  ( -- * Creating a Request
    ExecuteStatement (..),
    newExecuteStatement,

    -- * Request Lenses
    executeStatement_clientToken,
    executeStatement_clusterIdentifier,
    executeStatement_dbUser,
    executeStatement_parameters,
    executeStatement_secretArn,
    executeStatement_statementName,
    executeStatement_withEvent,
    executeStatement_workgroupName,
    executeStatement_database,
    executeStatement_sql,

    -- * Destructuring the Response
    ExecuteStatementResponse (..),
    newExecuteStatementResponse,

    -- * Response Lenses
    executeStatementResponse_clusterIdentifier,
    executeStatementResponse_createdAt,
    executeStatementResponse_database,
    executeStatementResponse_dbUser,
    executeStatementResponse_id,
    executeStatementResponse_secretArn,
    executeStatementResponse_workgroupName,
    executeStatementResponse_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:/ 'newExecuteStatement' smart constructor.
data ExecuteStatement = ExecuteStatement'
  { -- | A unique, case-sensitive identifier that you provide to ensure the
    -- idempotency of the request.
    ExecuteStatement -> 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.
    ExecuteStatement -> 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.
    ExecuteStatement -> Maybe Text
dbUser :: Prelude.Maybe Prelude.Text,
    -- | The parameters for the SQL statement.
    ExecuteStatement -> Maybe (NonEmpty SqlParameter)
parameters :: Prelude.Maybe (Prelude.NonEmpty SqlParameter),
    -- | The name or ARN of the secret that enables access to the database. This
    -- parameter is required when authenticating using Secrets Manager.
    ExecuteStatement -> Maybe Text
secretArn :: Prelude.Maybe Prelude.Text,
    -- | The name of the SQL statement. You can name the SQL statement when you
    -- create it to identify the query.
    ExecuteStatement -> 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 statement runs.
    ExecuteStatement -> 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.
    ExecuteStatement -> 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.
    ExecuteStatement -> Text
database :: Prelude.Text,
    -- | The SQL statement text to run.
    ExecuteStatement -> Text
sql :: Prelude.Text
  }
  deriving (ExecuteStatement -> ExecuteStatement -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecuteStatement -> ExecuteStatement -> Bool
$c/= :: ExecuteStatement -> ExecuteStatement -> Bool
== :: ExecuteStatement -> ExecuteStatement -> Bool
$c== :: ExecuteStatement -> ExecuteStatement -> Bool
Prelude.Eq, ReadPrec [ExecuteStatement]
ReadPrec ExecuteStatement
Int -> ReadS ExecuteStatement
ReadS [ExecuteStatement]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExecuteStatement]
$creadListPrec :: ReadPrec [ExecuteStatement]
readPrec :: ReadPrec ExecuteStatement
$creadPrec :: ReadPrec ExecuteStatement
readList :: ReadS [ExecuteStatement]
$creadList :: ReadS [ExecuteStatement]
readsPrec :: Int -> ReadS ExecuteStatement
$creadsPrec :: Int -> ReadS ExecuteStatement
Prelude.Read, Int -> ExecuteStatement -> ShowS
[ExecuteStatement] -> ShowS
ExecuteStatement -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecuteStatement] -> ShowS
$cshowList :: [ExecuteStatement] -> ShowS
show :: ExecuteStatement -> String
$cshow :: ExecuteStatement -> String
showsPrec :: Int -> ExecuteStatement -> ShowS
$cshowsPrec :: Int -> ExecuteStatement -> ShowS
Prelude.Show, forall x. Rep ExecuteStatement x -> ExecuteStatement
forall x. ExecuteStatement -> Rep ExecuteStatement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ExecuteStatement x -> ExecuteStatement
$cfrom :: forall x. ExecuteStatement -> Rep ExecuteStatement x
Prelude.Generic)

-- |
-- Create a value of 'ExecuteStatement' 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', 'executeStatement_clientToken' - A unique, case-sensitive identifier that you provide to ensure the
-- idempotency of the request.
--
-- 'clusterIdentifier', 'executeStatement_clusterIdentifier' - The cluster identifier. This parameter is required when connecting to a
-- cluster and authenticating using either Secrets Manager or temporary
-- credentials.
--
-- 'dbUser', 'executeStatement_dbUser' - The database user name. This parameter is required when connecting to a
-- cluster and authenticating using temporary credentials.
--
-- 'parameters', 'executeStatement_parameters' - The parameters for the SQL statement.
--
-- 'secretArn', 'executeStatement_secretArn' - The name or ARN of the secret that enables access to the database. This
-- parameter is required when authenticating using Secrets Manager.
--
-- 'statementName', 'executeStatement_statementName' - The name of the SQL statement. You can name the SQL statement when you
-- create it to identify the query.
--
-- 'withEvent', 'executeStatement_withEvent' - A value that indicates whether to send an event to the Amazon
-- EventBridge event bus after the SQL statement runs.
--
-- 'workgroupName', 'executeStatement_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', 'executeStatement_database' - The name of the database. This parameter is required when authenticating
-- using either Secrets Manager or temporary credentials.
--
-- 'sql', 'executeStatement_sql' - The SQL statement text to run.
newExecuteStatement ::
  -- | 'database'
  Prelude.Text ->
  -- | 'sql'
  Prelude.Text ->
  ExecuteStatement
newExecuteStatement :: Text -> Text -> ExecuteStatement
newExecuteStatement Text
pDatabase_ Text
pSql_ =
  ExecuteStatement'
    { $sel:clientToken:ExecuteStatement' :: Maybe Text
clientToken = forall a. Maybe a
Prelude.Nothing,
      $sel:clusterIdentifier:ExecuteStatement' :: Maybe Text
clusterIdentifier = forall a. Maybe a
Prelude.Nothing,
      $sel:dbUser:ExecuteStatement' :: Maybe Text
dbUser = forall a. Maybe a
Prelude.Nothing,
      $sel:parameters:ExecuteStatement' :: Maybe (NonEmpty SqlParameter)
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:secretArn:ExecuteStatement' :: Maybe Text
secretArn = forall a. Maybe a
Prelude.Nothing,
      $sel:statementName:ExecuteStatement' :: Maybe Text
statementName = forall a. Maybe a
Prelude.Nothing,
      $sel:withEvent:ExecuteStatement' :: Maybe Bool
withEvent = forall a. Maybe a
Prelude.Nothing,
      $sel:workgroupName:ExecuteStatement' :: Maybe Text
workgroupName = forall a. Maybe a
Prelude.Nothing,
      $sel:database:ExecuteStatement' :: Text
database = Text
pDatabase_,
      $sel:sql:ExecuteStatement' :: Text
sql = Text
pSql_
    }

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

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

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

-- | The parameters for the SQL statement.
executeStatement_parameters :: Lens.Lens' ExecuteStatement (Prelude.Maybe (Prelude.NonEmpty SqlParameter))
executeStatement_parameters :: Lens' ExecuteStatement (Maybe (NonEmpty SqlParameter))
executeStatement_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteStatement' {Maybe (NonEmpty SqlParameter)
parameters :: Maybe (NonEmpty SqlParameter)
$sel:parameters:ExecuteStatement' :: ExecuteStatement -> Maybe (NonEmpty SqlParameter)
parameters} -> Maybe (NonEmpty SqlParameter)
parameters) (\s :: ExecuteStatement
s@ExecuteStatement' {} Maybe (NonEmpty SqlParameter)
a -> ExecuteStatement
s {$sel:parameters:ExecuteStatement' :: Maybe (NonEmpty SqlParameter)
parameters = Maybe (NonEmpty SqlParameter)
a} :: ExecuteStatement) 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 s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

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

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

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

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

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

-- | The SQL statement text to run.
executeStatement_sql :: Lens.Lens' ExecuteStatement Prelude.Text
executeStatement_sql :: Lens' ExecuteStatement Text
executeStatement_sql = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteStatement' {Text
sql :: Text
$sel:sql:ExecuteStatement' :: ExecuteStatement -> Text
sql} -> Text
sql) (\s :: ExecuteStatement
s@ExecuteStatement' {} Text
a -> ExecuteStatement
s {$sel:sql:ExecuteStatement' :: Text
sql = Text
a} :: ExecuteStatement)

instance Core.AWSRequest ExecuteStatement where
  type
    AWSResponse ExecuteStatement =
      ExecuteStatementResponse
  request :: (Service -> Service)
-> ExecuteStatement -> Request ExecuteStatement
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 ExecuteStatement
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse ExecuteStatement)))
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
-> ExecuteStatementResponse
ExecuteStatementResponse'
            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 ExecuteStatement where
  hashWithSalt :: Int -> ExecuteStatement -> Int
hashWithSalt Int
_salt ExecuteStatement' {Maybe Bool
Maybe (NonEmpty SqlParameter)
Maybe Text
Text
sql :: Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
parameters :: Maybe (NonEmpty SqlParameter)
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sql:ExecuteStatement' :: ExecuteStatement -> Text
$sel:database:ExecuteStatement' :: ExecuteStatement -> Text
$sel:workgroupName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:withEvent:ExecuteStatement' :: ExecuteStatement -> Maybe Bool
$sel:statementName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:secretArn:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:parameters:ExecuteStatement' :: ExecuteStatement -> Maybe (NonEmpty SqlParameter)
$sel:dbUser:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clusterIdentifier:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clientToken:ExecuteStatement' :: ExecuteStatement -> 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 (NonEmpty SqlParameter)
parameters
      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` Text
sql

instance Prelude.NFData ExecuteStatement where
  rnf :: ExecuteStatement -> ()
rnf ExecuteStatement' {Maybe Bool
Maybe (NonEmpty SqlParameter)
Maybe Text
Text
sql :: Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
parameters :: Maybe (NonEmpty SqlParameter)
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sql:ExecuteStatement' :: ExecuteStatement -> Text
$sel:database:ExecuteStatement' :: ExecuteStatement -> Text
$sel:workgroupName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:withEvent:ExecuteStatement' :: ExecuteStatement -> Maybe Bool
$sel:statementName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:secretArn:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:parameters:ExecuteStatement' :: ExecuteStatement -> Maybe (NonEmpty SqlParameter)
$sel:dbUser:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clusterIdentifier:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clientToken:ExecuteStatement' :: ExecuteStatement -> 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 (NonEmpty SqlParameter)
parameters
      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 Text
sql

instance Data.ToHeaders ExecuteStatement where
  toHeaders :: ExecuteStatement -> 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.ExecuteStatement" ::
                          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 ExecuteStatement where
  toJSON :: ExecuteStatement -> Value
toJSON ExecuteStatement' {Maybe Bool
Maybe (NonEmpty SqlParameter)
Maybe Text
Text
sql :: Text
database :: Text
workgroupName :: Maybe Text
withEvent :: Maybe Bool
statementName :: Maybe Text
secretArn :: Maybe Text
parameters :: Maybe (NonEmpty SqlParameter)
dbUser :: Maybe Text
clusterIdentifier :: Maybe Text
clientToken :: Maybe Text
$sel:sql:ExecuteStatement' :: ExecuteStatement -> Text
$sel:database:ExecuteStatement' :: ExecuteStatement -> Text
$sel:workgroupName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:withEvent:ExecuteStatement' :: ExecuteStatement -> Maybe Bool
$sel:statementName:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:secretArn:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:parameters:ExecuteStatement' :: ExecuteStatement -> Maybe (NonEmpty SqlParameter)
$sel:dbUser:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clusterIdentifier:ExecuteStatement' :: ExecuteStatement -> Maybe Text
$sel:clientToken:ExecuteStatement' :: ExecuteStatement -> 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
"Parameters" 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 (NonEmpty SqlParameter)
parameters,
            (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
"Sql" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sql)
          ]
      )

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

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

-- | /See:/ 'newExecuteStatementResponse' smart constructor.
data ExecuteStatementResponse = ExecuteStatementResponse'
  { -- | The cluster identifier. This element is not returned when connecting to
    -- a serverless workgroup.
    ExecuteStatementResponse -> Maybe Text
clusterIdentifier :: Prelude.Maybe Prelude.Text,
    -- | The date and time (UTC) the statement was created.
    ExecuteStatementResponse -> Maybe POSIX
createdAt :: Prelude.Maybe Data.POSIX,
    -- | The name of the database.
    ExecuteStatementResponse -> Maybe Text
database :: Prelude.Maybe Prelude.Text,
    -- | The database user name.
    ExecuteStatementResponse -> 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.
    ExecuteStatementResponse -> Maybe Text
id :: Prelude.Maybe Prelude.Text,
    -- | The name or ARN of the secret that enables access to the database.
    ExecuteStatementResponse -> Maybe Text
secretArn :: Prelude.Maybe Prelude.Text,
    -- | The serverless workgroup name. This element is not returned when
    -- connecting to a provisioned cluster.
    ExecuteStatementResponse -> Maybe Text
workgroupName :: Prelude.Maybe Prelude.Text,
    -- | The response's http status code.
    ExecuteStatementResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ExecuteStatementResponse -> ExecuteStatementResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ExecuteStatementResponse -> ExecuteStatementResponse -> Bool
$c/= :: ExecuteStatementResponse -> ExecuteStatementResponse -> Bool
== :: ExecuteStatementResponse -> ExecuteStatementResponse -> Bool
$c== :: ExecuteStatementResponse -> ExecuteStatementResponse -> Bool
Prelude.Eq, ReadPrec [ExecuteStatementResponse]
ReadPrec ExecuteStatementResponse
Int -> ReadS ExecuteStatementResponse
ReadS [ExecuteStatementResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ExecuteStatementResponse]
$creadListPrec :: ReadPrec [ExecuteStatementResponse]
readPrec :: ReadPrec ExecuteStatementResponse
$creadPrec :: ReadPrec ExecuteStatementResponse
readList :: ReadS [ExecuteStatementResponse]
$creadList :: ReadS [ExecuteStatementResponse]
readsPrec :: Int -> ReadS ExecuteStatementResponse
$creadsPrec :: Int -> ReadS ExecuteStatementResponse
Prelude.Read, Int -> ExecuteStatementResponse -> ShowS
[ExecuteStatementResponse] -> ShowS
ExecuteStatementResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ExecuteStatementResponse] -> ShowS
$cshowList :: [ExecuteStatementResponse] -> ShowS
show :: ExecuteStatementResponse -> String
$cshow :: ExecuteStatementResponse -> String
showsPrec :: Int -> ExecuteStatementResponse -> ShowS
$cshowsPrec :: Int -> ExecuteStatementResponse -> ShowS
Prelude.Show, forall x.
Rep ExecuteStatementResponse x -> ExecuteStatementResponse
forall x.
ExecuteStatementResponse -> Rep ExecuteStatementResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep ExecuteStatementResponse x -> ExecuteStatementResponse
$cfrom :: forall x.
ExecuteStatementResponse -> Rep ExecuteStatementResponse x
Prelude.Generic)

-- |
-- Create a value of 'ExecuteStatementResponse' 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', 'executeStatementResponse_clusterIdentifier' - The cluster identifier. This element is not returned when connecting to
-- a serverless workgroup.
--
-- 'createdAt', 'executeStatementResponse_createdAt' - The date and time (UTC) the statement was created.
--
-- 'database', 'executeStatementResponse_database' - The name of the database.
--
-- 'dbUser', 'executeStatementResponse_dbUser' - The database user name.
--
-- 'id', 'executeStatementResponse_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.
--
-- 'secretArn', 'executeStatementResponse_secretArn' - The name or ARN of the secret that enables access to the database.
--
-- 'workgroupName', 'executeStatementResponse_workgroupName' - The serverless workgroup name. This element is not returned when
-- connecting to a provisioned cluster.
--
-- 'httpStatus', 'executeStatementResponse_httpStatus' - The response's http status code.
newExecuteStatementResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ExecuteStatementResponse
newExecuteStatementResponse :: Int -> ExecuteStatementResponse
newExecuteStatementResponse Int
pHttpStatus_ =
  ExecuteStatementResponse'
    { $sel:clusterIdentifier:ExecuteStatementResponse' :: Maybe Text
clusterIdentifier =
        forall a. Maybe a
Prelude.Nothing,
      $sel:createdAt:ExecuteStatementResponse' :: Maybe POSIX
createdAt = forall a. Maybe a
Prelude.Nothing,
      $sel:database:ExecuteStatementResponse' :: Maybe Text
database = forall a. Maybe a
Prelude.Nothing,
      $sel:dbUser:ExecuteStatementResponse' :: Maybe Text
dbUser = forall a. Maybe a
Prelude.Nothing,
      $sel:id:ExecuteStatementResponse' :: Maybe Text
id = forall a. Maybe a
Prelude.Nothing,
      $sel:secretArn:ExecuteStatementResponse' :: Maybe Text
secretArn = forall a. Maybe a
Prelude.Nothing,
      $sel:workgroupName:ExecuteStatementResponse' :: Maybe Text
workgroupName = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ExecuteStatementResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

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

-- | The date and time (UTC) the statement was created.
executeStatementResponse_createdAt :: Lens.Lens' ExecuteStatementResponse (Prelude.Maybe Prelude.UTCTime)
executeStatementResponse_createdAt :: Lens' ExecuteStatementResponse (Maybe UTCTime)
executeStatementResponse_createdAt = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteStatementResponse' {Maybe POSIX
createdAt :: Maybe POSIX
$sel:createdAt:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe POSIX
createdAt} -> Maybe POSIX
createdAt) (\s :: ExecuteStatementResponse
s@ExecuteStatementResponse' {} Maybe POSIX
a -> ExecuteStatementResponse
s {$sel:createdAt:ExecuteStatementResponse' :: Maybe POSIX
createdAt = Maybe POSIX
a} :: ExecuteStatementResponse) 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.
executeStatementResponse_database :: Lens.Lens' ExecuteStatementResponse (Prelude.Maybe Prelude.Text)
executeStatementResponse_database :: Lens' ExecuteStatementResponse (Maybe Text)
executeStatementResponse_database = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteStatementResponse' {Maybe Text
database :: Maybe Text
$sel:database:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
database} -> Maybe Text
database) (\s :: ExecuteStatementResponse
s@ExecuteStatementResponse' {} Maybe Text
a -> ExecuteStatementResponse
s {$sel:database:ExecuteStatementResponse' :: Maybe Text
database = Maybe Text
a} :: ExecuteStatementResponse)

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

-- | 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.
executeStatementResponse_id :: Lens.Lens' ExecuteStatementResponse (Prelude.Maybe Prelude.Text)
executeStatementResponse_id :: Lens' ExecuteStatementResponse (Maybe Text)
executeStatementResponse_id = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ExecuteStatementResponse' {Maybe Text
id :: Maybe Text
$sel:id:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
id} -> Maybe Text
id) (\s :: ExecuteStatementResponse
s@ExecuteStatementResponse' {} Maybe Text
a -> ExecuteStatementResponse
s {$sel:id:ExecuteStatementResponse' :: Maybe Text
id = Maybe Text
a} :: ExecuteStatementResponse)

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

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

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

instance Prelude.NFData ExecuteStatementResponse where
  rnf :: ExecuteStatementResponse -> ()
rnf ExecuteStatementResponse' {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:ExecuteStatementResponse' :: ExecuteStatementResponse -> Int
$sel:workgroupName:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
$sel:secretArn:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
$sel:id:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
$sel:dbUser:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
$sel:database:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe Text
$sel:createdAt:ExecuteStatementResponse' :: ExecuteStatementResponse -> Maybe POSIX
$sel:clusterIdentifier:ExecuteStatementResponse' :: ExecuteStatementResponse -> 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