{-# 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.QLDBSession.SendCommand
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Sends a command to an Amazon QLDB ledger.
--
-- Instead of interacting directly with this API, we recommend using the
-- QLDB driver or the QLDB shell to execute data transactions on a ledger.
--
-- -   If you are working with an AWS SDK, use the QLDB driver. The driver
--     provides a high-level abstraction layer above this /QLDB Session/
--     data plane and manages @SendCommand@ API calls for you. For
--     information and a list of supported programming languages, see
--     <https://docs.aws.amazon.com/qldb/latest/developerguide/getting-started-driver.html Getting started with the driver>
--     in the /Amazon QLDB Developer Guide/.
--
-- -   If you are working with the AWS Command Line Interface (AWS CLI),
--     use the QLDB shell. The shell is a command line interface that uses
--     the QLDB driver to interact with a ledger. For information, see
--     <https://docs.aws.amazon.com/qldb/latest/developerguide/data-shell.html Accessing Amazon QLDB using the QLDB shell>.
module Amazonka.QLDBSession.SendCommand
  ( -- * Creating a Request
    SendCommand (..),
    newSendCommand,

    -- * Request Lenses
    sendCommand_abortTransaction,
    sendCommand_commitTransaction,
    sendCommand_endSession,
    sendCommand_executeStatement,
    sendCommand_fetchPage,
    sendCommand_sessionToken,
    sendCommand_startSession,
    sendCommand_startTransaction,

    -- * Destructuring the Response
    SendCommandResponse (..),
    newSendCommandResponse,

    -- * Response Lenses
    sendCommandResponse_abortTransaction,
    sendCommandResponse_commitTransaction,
    sendCommandResponse_endSession,
    sendCommandResponse_executeStatement,
    sendCommandResponse_fetchPage,
    sendCommandResponse_startSession,
    sendCommandResponse_startTransaction,
    sendCommandResponse_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.QLDBSession.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newSendCommand' smart constructor.
data SendCommand = SendCommand'
  { -- | Command to abort the current transaction.
    SendCommand -> Maybe AbortTransactionRequest
abortTransaction :: Prelude.Maybe AbortTransactionRequest,
    -- | Command to commit the specified transaction.
    SendCommand -> Maybe CommitTransactionRequest
commitTransaction :: Prelude.Maybe CommitTransactionRequest,
    -- | Command to end the current session.
    SendCommand -> Maybe EndSessionRequest
endSession :: Prelude.Maybe EndSessionRequest,
    -- | Command to execute a statement in the specified transaction.
    SendCommand -> Maybe ExecuteStatementRequest
executeStatement :: Prelude.Maybe ExecuteStatementRequest,
    -- | Command to fetch a page.
    SendCommand -> Maybe FetchPageRequest
fetchPage :: Prelude.Maybe FetchPageRequest,
    -- | Specifies the session token for the current command. A session token is
    -- constant throughout the life of the session.
    --
    -- To obtain a session token, run the @StartSession@ command. This
    -- @SessionToken@ is required for every subsequent command that is issued
    -- during the current session.
    SendCommand -> Maybe Text
sessionToken :: Prelude.Maybe Prelude.Text,
    -- | Command to start a new session. A session token is obtained as part of
    -- the response.
    SendCommand -> Maybe StartSessionRequest
startSession :: Prelude.Maybe StartSessionRequest,
    -- | Command to start a new transaction.
    SendCommand -> Maybe StartTransactionRequest
startTransaction :: Prelude.Maybe StartTransactionRequest
  }
  deriving (SendCommand -> SendCommand -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendCommand -> SendCommand -> Bool
$c/= :: SendCommand -> SendCommand -> Bool
== :: SendCommand -> SendCommand -> Bool
$c== :: SendCommand -> SendCommand -> Bool
Prelude.Eq, ReadPrec [SendCommand]
ReadPrec SendCommand
Int -> ReadS SendCommand
ReadS [SendCommand]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendCommand]
$creadListPrec :: ReadPrec [SendCommand]
readPrec :: ReadPrec SendCommand
$creadPrec :: ReadPrec SendCommand
readList :: ReadS [SendCommand]
$creadList :: ReadS [SendCommand]
readsPrec :: Int -> ReadS SendCommand
$creadsPrec :: Int -> ReadS SendCommand
Prelude.Read, Int -> SendCommand -> ShowS
[SendCommand] -> ShowS
SendCommand -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendCommand] -> ShowS
$cshowList :: [SendCommand] -> ShowS
show :: SendCommand -> String
$cshow :: SendCommand -> String
showsPrec :: Int -> SendCommand -> ShowS
$cshowsPrec :: Int -> SendCommand -> ShowS
Prelude.Show, forall x. Rep SendCommand x -> SendCommand
forall x. SendCommand -> Rep SendCommand x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SendCommand x -> SendCommand
$cfrom :: forall x. SendCommand -> Rep SendCommand x
Prelude.Generic)

-- |
-- Create a value of 'SendCommand' 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:
--
-- 'abortTransaction', 'sendCommand_abortTransaction' - Command to abort the current transaction.
--
-- 'commitTransaction', 'sendCommand_commitTransaction' - Command to commit the specified transaction.
--
-- 'endSession', 'sendCommand_endSession' - Command to end the current session.
--
-- 'executeStatement', 'sendCommand_executeStatement' - Command to execute a statement in the specified transaction.
--
-- 'fetchPage', 'sendCommand_fetchPage' - Command to fetch a page.
--
-- 'sessionToken', 'sendCommand_sessionToken' - Specifies the session token for the current command. A session token is
-- constant throughout the life of the session.
--
-- To obtain a session token, run the @StartSession@ command. This
-- @SessionToken@ is required for every subsequent command that is issued
-- during the current session.
--
-- 'startSession', 'sendCommand_startSession' - Command to start a new session. A session token is obtained as part of
-- the response.
--
-- 'startTransaction', 'sendCommand_startTransaction' - Command to start a new transaction.
newSendCommand ::
  SendCommand
newSendCommand :: SendCommand
newSendCommand =
  SendCommand'
    { $sel:abortTransaction:SendCommand' :: Maybe AbortTransactionRequest
abortTransaction = forall a. Maybe a
Prelude.Nothing,
      $sel:commitTransaction:SendCommand' :: Maybe CommitTransactionRequest
commitTransaction = forall a. Maybe a
Prelude.Nothing,
      $sel:endSession:SendCommand' :: Maybe EndSessionRequest
endSession = forall a. Maybe a
Prelude.Nothing,
      $sel:executeStatement:SendCommand' :: Maybe ExecuteStatementRequest
executeStatement = forall a. Maybe a
Prelude.Nothing,
      $sel:fetchPage:SendCommand' :: Maybe FetchPageRequest
fetchPage = forall a. Maybe a
Prelude.Nothing,
      $sel:sessionToken:SendCommand' :: Maybe Text
sessionToken = forall a. Maybe a
Prelude.Nothing,
      $sel:startSession:SendCommand' :: Maybe StartSessionRequest
startSession = forall a. Maybe a
Prelude.Nothing,
      $sel:startTransaction:SendCommand' :: Maybe StartTransactionRequest
startTransaction = forall a. Maybe a
Prelude.Nothing
    }

-- | Command to abort the current transaction.
sendCommand_abortTransaction :: Lens.Lens' SendCommand (Prelude.Maybe AbortTransactionRequest)
sendCommand_abortTransaction :: Lens' SendCommand (Maybe AbortTransactionRequest)
sendCommand_abortTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe AbortTransactionRequest
abortTransaction :: Maybe AbortTransactionRequest
$sel:abortTransaction:SendCommand' :: SendCommand -> Maybe AbortTransactionRequest
abortTransaction} -> Maybe AbortTransactionRequest
abortTransaction) (\s :: SendCommand
s@SendCommand' {} Maybe AbortTransactionRequest
a -> SendCommand
s {$sel:abortTransaction:SendCommand' :: Maybe AbortTransactionRequest
abortTransaction = Maybe AbortTransactionRequest
a} :: SendCommand)

-- | Command to commit the specified transaction.
sendCommand_commitTransaction :: Lens.Lens' SendCommand (Prelude.Maybe CommitTransactionRequest)
sendCommand_commitTransaction :: Lens' SendCommand (Maybe CommitTransactionRequest)
sendCommand_commitTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe CommitTransactionRequest
commitTransaction :: Maybe CommitTransactionRequest
$sel:commitTransaction:SendCommand' :: SendCommand -> Maybe CommitTransactionRequest
commitTransaction} -> Maybe CommitTransactionRequest
commitTransaction) (\s :: SendCommand
s@SendCommand' {} Maybe CommitTransactionRequest
a -> SendCommand
s {$sel:commitTransaction:SendCommand' :: Maybe CommitTransactionRequest
commitTransaction = Maybe CommitTransactionRequest
a} :: SendCommand)

-- | Command to end the current session.
sendCommand_endSession :: Lens.Lens' SendCommand (Prelude.Maybe EndSessionRequest)
sendCommand_endSession :: Lens' SendCommand (Maybe EndSessionRequest)
sendCommand_endSession = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe EndSessionRequest
endSession :: Maybe EndSessionRequest
$sel:endSession:SendCommand' :: SendCommand -> Maybe EndSessionRequest
endSession} -> Maybe EndSessionRequest
endSession) (\s :: SendCommand
s@SendCommand' {} Maybe EndSessionRequest
a -> SendCommand
s {$sel:endSession:SendCommand' :: Maybe EndSessionRequest
endSession = Maybe EndSessionRequest
a} :: SendCommand)

-- | Command to execute a statement in the specified transaction.
sendCommand_executeStatement :: Lens.Lens' SendCommand (Prelude.Maybe ExecuteStatementRequest)
sendCommand_executeStatement :: Lens' SendCommand (Maybe ExecuteStatementRequest)
sendCommand_executeStatement = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe ExecuteStatementRequest
executeStatement :: Maybe ExecuteStatementRequest
$sel:executeStatement:SendCommand' :: SendCommand -> Maybe ExecuteStatementRequest
executeStatement} -> Maybe ExecuteStatementRequest
executeStatement) (\s :: SendCommand
s@SendCommand' {} Maybe ExecuteStatementRequest
a -> SendCommand
s {$sel:executeStatement:SendCommand' :: Maybe ExecuteStatementRequest
executeStatement = Maybe ExecuteStatementRequest
a} :: SendCommand)

-- | Command to fetch a page.
sendCommand_fetchPage :: Lens.Lens' SendCommand (Prelude.Maybe FetchPageRequest)
sendCommand_fetchPage :: Lens' SendCommand (Maybe FetchPageRequest)
sendCommand_fetchPage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe FetchPageRequest
fetchPage :: Maybe FetchPageRequest
$sel:fetchPage:SendCommand' :: SendCommand -> Maybe FetchPageRequest
fetchPage} -> Maybe FetchPageRequest
fetchPage) (\s :: SendCommand
s@SendCommand' {} Maybe FetchPageRequest
a -> SendCommand
s {$sel:fetchPage:SendCommand' :: Maybe FetchPageRequest
fetchPage = Maybe FetchPageRequest
a} :: SendCommand)

-- | Specifies the session token for the current command. A session token is
-- constant throughout the life of the session.
--
-- To obtain a session token, run the @StartSession@ command. This
-- @SessionToken@ is required for every subsequent command that is issued
-- during the current session.
sendCommand_sessionToken :: Lens.Lens' SendCommand (Prelude.Maybe Prelude.Text)
sendCommand_sessionToken :: Lens' SendCommand (Maybe Text)
sendCommand_sessionToken = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe Text
sessionToken :: Maybe Text
$sel:sessionToken:SendCommand' :: SendCommand -> Maybe Text
sessionToken} -> Maybe Text
sessionToken) (\s :: SendCommand
s@SendCommand' {} Maybe Text
a -> SendCommand
s {$sel:sessionToken:SendCommand' :: Maybe Text
sessionToken = Maybe Text
a} :: SendCommand)

-- | Command to start a new session. A session token is obtained as part of
-- the response.
sendCommand_startSession :: Lens.Lens' SendCommand (Prelude.Maybe StartSessionRequest)
sendCommand_startSession :: Lens' SendCommand (Maybe StartSessionRequest)
sendCommand_startSession = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe StartSessionRequest
startSession :: Maybe StartSessionRequest
$sel:startSession:SendCommand' :: SendCommand -> Maybe StartSessionRequest
startSession} -> Maybe StartSessionRequest
startSession) (\s :: SendCommand
s@SendCommand' {} Maybe StartSessionRequest
a -> SendCommand
s {$sel:startSession:SendCommand' :: Maybe StartSessionRequest
startSession = Maybe StartSessionRequest
a} :: SendCommand)

-- | Command to start a new transaction.
sendCommand_startTransaction :: Lens.Lens' SendCommand (Prelude.Maybe StartTransactionRequest)
sendCommand_startTransaction :: Lens' SendCommand (Maybe StartTransactionRequest)
sendCommand_startTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommand' {Maybe StartTransactionRequest
startTransaction :: Maybe StartTransactionRequest
$sel:startTransaction:SendCommand' :: SendCommand -> Maybe StartTransactionRequest
startTransaction} -> Maybe StartTransactionRequest
startTransaction) (\s :: SendCommand
s@SendCommand' {} Maybe StartTransactionRequest
a -> SendCommand
s {$sel:startTransaction:SendCommand' :: Maybe StartTransactionRequest
startTransaction = Maybe StartTransactionRequest
a} :: SendCommand)

instance Core.AWSRequest SendCommand where
  type AWSResponse SendCommand = SendCommandResponse
  request :: (Service -> Service) -> SendCommand -> Request SendCommand
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 SendCommand
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse SendCommand)))
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 AbortTransactionResult
-> Maybe CommitTransactionResult
-> Maybe EndSessionResult
-> Maybe ExecuteStatementResult
-> Maybe FetchPageResult
-> Maybe StartSessionResult
-> Maybe StartTransactionResult
-> Int
-> SendCommandResponse
SendCommandResponse'
            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
"AbortTransaction")
            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
"CommitTransaction")
            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
"EndSession")
            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
"ExecuteStatement")
            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
"FetchPage")
            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
"StartSession")
            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
"StartTransaction")
            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 SendCommand where
  hashWithSalt :: Int -> SendCommand -> Int
hashWithSalt Int
_salt SendCommand' {Maybe Text
Maybe AbortTransactionRequest
Maybe CommitTransactionRequest
Maybe EndSessionRequest
Maybe FetchPageRequest
Maybe StartSessionRequest
Maybe StartTransactionRequest
Maybe ExecuteStatementRequest
startTransaction :: Maybe StartTransactionRequest
startSession :: Maybe StartSessionRequest
sessionToken :: Maybe Text
fetchPage :: Maybe FetchPageRequest
executeStatement :: Maybe ExecuteStatementRequest
endSession :: Maybe EndSessionRequest
commitTransaction :: Maybe CommitTransactionRequest
abortTransaction :: Maybe AbortTransactionRequest
$sel:startTransaction:SendCommand' :: SendCommand -> Maybe StartTransactionRequest
$sel:startSession:SendCommand' :: SendCommand -> Maybe StartSessionRequest
$sel:sessionToken:SendCommand' :: SendCommand -> Maybe Text
$sel:fetchPage:SendCommand' :: SendCommand -> Maybe FetchPageRequest
$sel:executeStatement:SendCommand' :: SendCommand -> Maybe ExecuteStatementRequest
$sel:endSession:SendCommand' :: SendCommand -> Maybe EndSessionRequest
$sel:commitTransaction:SendCommand' :: SendCommand -> Maybe CommitTransactionRequest
$sel:abortTransaction:SendCommand' :: SendCommand -> Maybe AbortTransactionRequest
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AbortTransactionRequest
abortTransaction
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CommitTransactionRequest
commitTransaction
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe EndSessionRequest
endSession
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ExecuteStatementRequest
executeStatement
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe FetchPageRequest
fetchPage
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
sessionToken
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StartSessionRequest
startSession
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StartTransactionRequest
startTransaction

instance Prelude.NFData SendCommand where
  rnf :: SendCommand -> ()
rnf SendCommand' {Maybe Text
Maybe AbortTransactionRequest
Maybe CommitTransactionRequest
Maybe EndSessionRequest
Maybe FetchPageRequest
Maybe StartSessionRequest
Maybe StartTransactionRequest
Maybe ExecuteStatementRequest
startTransaction :: Maybe StartTransactionRequest
startSession :: Maybe StartSessionRequest
sessionToken :: Maybe Text
fetchPage :: Maybe FetchPageRequest
executeStatement :: Maybe ExecuteStatementRequest
endSession :: Maybe EndSessionRequest
commitTransaction :: Maybe CommitTransactionRequest
abortTransaction :: Maybe AbortTransactionRequest
$sel:startTransaction:SendCommand' :: SendCommand -> Maybe StartTransactionRequest
$sel:startSession:SendCommand' :: SendCommand -> Maybe StartSessionRequest
$sel:sessionToken:SendCommand' :: SendCommand -> Maybe Text
$sel:fetchPage:SendCommand' :: SendCommand -> Maybe FetchPageRequest
$sel:executeStatement:SendCommand' :: SendCommand -> Maybe ExecuteStatementRequest
$sel:endSession:SendCommand' :: SendCommand -> Maybe EndSessionRequest
$sel:commitTransaction:SendCommand' :: SendCommand -> Maybe CommitTransactionRequest
$sel:abortTransaction:SendCommand' :: SendCommand -> Maybe AbortTransactionRequest
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe AbortTransactionRequest
abortTransaction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CommitTransactionRequest
commitTransaction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EndSessionRequest
endSession
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ExecuteStatementRequest
executeStatement
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FetchPageRequest
fetchPage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
sessionToken
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StartSessionRequest
startSession
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StartTransactionRequest
startTransaction

instance Data.ToHeaders SendCommand where
  toHeaders :: SendCommand -> 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
"QLDBSession.SendCommand" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON SendCommand where
  toJSON :: SendCommand -> Value
toJSON SendCommand' {Maybe Text
Maybe AbortTransactionRequest
Maybe CommitTransactionRequest
Maybe EndSessionRequest
Maybe FetchPageRequest
Maybe StartSessionRequest
Maybe StartTransactionRequest
Maybe ExecuteStatementRequest
startTransaction :: Maybe StartTransactionRequest
startSession :: Maybe StartSessionRequest
sessionToken :: Maybe Text
fetchPage :: Maybe FetchPageRequest
executeStatement :: Maybe ExecuteStatementRequest
endSession :: Maybe EndSessionRequest
commitTransaction :: Maybe CommitTransactionRequest
abortTransaction :: Maybe AbortTransactionRequest
$sel:startTransaction:SendCommand' :: SendCommand -> Maybe StartTransactionRequest
$sel:startSession:SendCommand' :: SendCommand -> Maybe StartSessionRequest
$sel:sessionToken:SendCommand' :: SendCommand -> Maybe Text
$sel:fetchPage:SendCommand' :: SendCommand -> Maybe FetchPageRequest
$sel:executeStatement:SendCommand' :: SendCommand -> Maybe ExecuteStatementRequest
$sel:endSession:SendCommand' :: SendCommand -> Maybe EndSessionRequest
$sel:commitTransaction:SendCommand' :: SendCommand -> Maybe CommitTransactionRequest
$sel:abortTransaction:SendCommand' :: SendCommand -> Maybe AbortTransactionRequest
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AbortTransaction" 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 AbortTransactionRequest
abortTransaction,
            (Key
"CommitTransaction" 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 CommitTransactionRequest
commitTransaction,
            (Key
"EndSession" 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 EndSessionRequest
endSession,
            (Key
"ExecuteStatement" 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 ExecuteStatementRequest
executeStatement,
            (Key
"FetchPage" 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 FetchPageRequest
fetchPage,
            (Key
"SessionToken" 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
sessionToken,
            (Key
"StartSession" 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 StartSessionRequest
startSession,
            (Key
"StartTransaction" 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 StartTransactionRequest
startTransaction
          ]
      )

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

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

-- | /See:/ 'newSendCommandResponse' smart constructor.
data SendCommandResponse = SendCommandResponse'
  { -- | Contains the details of the aborted transaction.
    SendCommandResponse -> Maybe AbortTransactionResult
abortTransaction :: Prelude.Maybe AbortTransactionResult,
    -- | Contains the details of the committed transaction.
    SendCommandResponse -> Maybe CommitTransactionResult
commitTransaction :: Prelude.Maybe CommitTransactionResult,
    -- | Contains the details of the ended session.
    SendCommandResponse -> Maybe EndSessionResult
endSession :: Prelude.Maybe EndSessionResult,
    -- | Contains the details of the executed statement.
    SendCommandResponse -> Maybe ExecuteStatementResult
executeStatement :: Prelude.Maybe ExecuteStatementResult,
    -- | Contains the details of the fetched page.
    SendCommandResponse -> Maybe FetchPageResult
fetchPage :: Prelude.Maybe FetchPageResult,
    -- | Contains the details of the started session that includes a session
    -- token. This @SessionToken@ is required for every subsequent command that
    -- is issued during the current session.
    SendCommandResponse -> Maybe StartSessionResult
startSession :: Prelude.Maybe StartSessionResult,
    -- | Contains the details of the started transaction.
    SendCommandResponse -> Maybe StartTransactionResult
startTransaction :: Prelude.Maybe StartTransactionResult,
    -- | The response's http status code.
    SendCommandResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (SendCommandResponse -> SendCommandResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SendCommandResponse -> SendCommandResponse -> Bool
$c/= :: SendCommandResponse -> SendCommandResponse -> Bool
== :: SendCommandResponse -> SendCommandResponse -> Bool
$c== :: SendCommandResponse -> SendCommandResponse -> Bool
Prelude.Eq, ReadPrec [SendCommandResponse]
ReadPrec SendCommandResponse
Int -> ReadS SendCommandResponse
ReadS [SendCommandResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SendCommandResponse]
$creadListPrec :: ReadPrec [SendCommandResponse]
readPrec :: ReadPrec SendCommandResponse
$creadPrec :: ReadPrec SendCommandResponse
readList :: ReadS [SendCommandResponse]
$creadList :: ReadS [SendCommandResponse]
readsPrec :: Int -> ReadS SendCommandResponse
$creadsPrec :: Int -> ReadS SendCommandResponse
Prelude.Read, Int -> SendCommandResponse -> ShowS
[SendCommandResponse] -> ShowS
SendCommandResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SendCommandResponse] -> ShowS
$cshowList :: [SendCommandResponse] -> ShowS
show :: SendCommandResponse -> String
$cshow :: SendCommandResponse -> String
showsPrec :: Int -> SendCommandResponse -> ShowS
$cshowsPrec :: Int -> SendCommandResponse -> ShowS
Prelude.Show, forall x. Rep SendCommandResponse x -> SendCommandResponse
forall x. SendCommandResponse -> Rep SendCommandResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SendCommandResponse x -> SendCommandResponse
$cfrom :: forall x. SendCommandResponse -> Rep SendCommandResponse x
Prelude.Generic)

-- |
-- Create a value of 'SendCommandResponse' 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:
--
-- 'abortTransaction', 'sendCommandResponse_abortTransaction' - Contains the details of the aborted transaction.
--
-- 'commitTransaction', 'sendCommandResponse_commitTransaction' - Contains the details of the committed transaction.
--
-- 'endSession', 'sendCommandResponse_endSession' - Contains the details of the ended session.
--
-- 'executeStatement', 'sendCommandResponse_executeStatement' - Contains the details of the executed statement.
--
-- 'fetchPage', 'sendCommandResponse_fetchPage' - Contains the details of the fetched page.
--
-- 'startSession', 'sendCommandResponse_startSession' - Contains the details of the started session that includes a session
-- token. This @SessionToken@ is required for every subsequent command that
-- is issued during the current session.
--
-- 'startTransaction', 'sendCommandResponse_startTransaction' - Contains the details of the started transaction.
--
-- 'httpStatus', 'sendCommandResponse_httpStatus' - The response's http status code.
newSendCommandResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  SendCommandResponse
newSendCommandResponse :: Int -> SendCommandResponse
newSendCommandResponse Int
pHttpStatus_ =
  SendCommandResponse'
    { $sel:abortTransaction:SendCommandResponse' :: Maybe AbortTransactionResult
abortTransaction =
        forall a. Maybe a
Prelude.Nothing,
      $sel:commitTransaction:SendCommandResponse' :: Maybe CommitTransactionResult
commitTransaction = forall a. Maybe a
Prelude.Nothing,
      $sel:endSession:SendCommandResponse' :: Maybe EndSessionResult
endSession = forall a. Maybe a
Prelude.Nothing,
      $sel:executeStatement:SendCommandResponse' :: Maybe ExecuteStatementResult
executeStatement = forall a. Maybe a
Prelude.Nothing,
      $sel:fetchPage:SendCommandResponse' :: Maybe FetchPageResult
fetchPage = forall a. Maybe a
Prelude.Nothing,
      $sel:startSession:SendCommandResponse' :: Maybe StartSessionResult
startSession = forall a. Maybe a
Prelude.Nothing,
      $sel:startTransaction:SendCommandResponse' :: Maybe StartTransactionResult
startTransaction = forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:SendCommandResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | Contains the details of the aborted transaction.
sendCommandResponse_abortTransaction :: Lens.Lens' SendCommandResponse (Prelude.Maybe AbortTransactionResult)
sendCommandResponse_abortTransaction :: Lens' SendCommandResponse (Maybe AbortTransactionResult)
sendCommandResponse_abortTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe AbortTransactionResult
abortTransaction :: Maybe AbortTransactionResult
$sel:abortTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe AbortTransactionResult
abortTransaction} -> Maybe AbortTransactionResult
abortTransaction) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe AbortTransactionResult
a -> SendCommandResponse
s {$sel:abortTransaction:SendCommandResponse' :: Maybe AbortTransactionResult
abortTransaction = Maybe AbortTransactionResult
a} :: SendCommandResponse)

-- | Contains the details of the committed transaction.
sendCommandResponse_commitTransaction :: Lens.Lens' SendCommandResponse (Prelude.Maybe CommitTransactionResult)
sendCommandResponse_commitTransaction :: Lens' SendCommandResponse (Maybe CommitTransactionResult)
sendCommandResponse_commitTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe CommitTransactionResult
commitTransaction :: Maybe CommitTransactionResult
$sel:commitTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe CommitTransactionResult
commitTransaction} -> Maybe CommitTransactionResult
commitTransaction) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe CommitTransactionResult
a -> SendCommandResponse
s {$sel:commitTransaction:SendCommandResponse' :: Maybe CommitTransactionResult
commitTransaction = Maybe CommitTransactionResult
a} :: SendCommandResponse)

-- | Contains the details of the ended session.
sendCommandResponse_endSession :: Lens.Lens' SendCommandResponse (Prelude.Maybe EndSessionResult)
sendCommandResponse_endSession :: Lens' SendCommandResponse (Maybe EndSessionResult)
sendCommandResponse_endSession = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe EndSessionResult
endSession :: Maybe EndSessionResult
$sel:endSession:SendCommandResponse' :: SendCommandResponse -> Maybe EndSessionResult
endSession} -> Maybe EndSessionResult
endSession) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe EndSessionResult
a -> SendCommandResponse
s {$sel:endSession:SendCommandResponse' :: Maybe EndSessionResult
endSession = Maybe EndSessionResult
a} :: SendCommandResponse)

-- | Contains the details of the executed statement.
sendCommandResponse_executeStatement :: Lens.Lens' SendCommandResponse (Prelude.Maybe ExecuteStatementResult)
sendCommandResponse_executeStatement :: Lens' SendCommandResponse (Maybe ExecuteStatementResult)
sendCommandResponse_executeStatement = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe ExecuteStatementResult
executeStatement :: Maybe ExecuteStatementResult
$sel:executeStatement:SendCommandResponse' :: SendCommandResponse -> Maybe ExecuteStatementResult
executeStatement} -> Maybe ExecuteStatementResult
executeStatement) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe ExecuteStatementResult
a -> SendCommandResponse
s {$sel:executeStatement:SendCommandResponse' :: Maybe ExecuteStatementResult
executeStatement = Maybe ExecuteStatementResult
a} :: SendCommandResponse)

-- | Contains the details of the fetched page.
sendCommandResponse_fetchPage :: Lens.Lens' SendCommandResponse (Prelude.Maybe FetchPageResult)
sendCommandResponse_fetchPage :: Lens' SendCommandResponse (Maybe FetchPageResult)
sendCommandResponse_fetchPage = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe FetchPageResult
fetchPage :: Maybe FetchPageResult
$sel:fetchPage:SendCommandResponse' :: SendCommandResponse -> Maybe FetchPageResult
fetchPage} -> Maybe FetchPageResult
fetchPage) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe FetchPageResult
a -> SendCommandResponse
s {$sel:fetchPage:SendCommandResponse' :: Maybe FetchPageResult
fetchPage = Maybe FetchPageResult
a} :: SendCommandResponse)

-- | Contains the details of the started session that includes a session
-- token. This @SessionToken@ is required for every subsequent command that
-- is issued during the current session.
sendCommandResponse_startSession :: Lens.Lens' SendCommandResponse (Prelude.Maybe StartSessionResult)
sendCommandResponse_startSession :: Lens' SendCommandResponse (Maybe StartSessionResult)
sendCommandResponse_startSession = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe StartSessionResult
startSession :: Maybe StartSessionResult
$sel:startSession:SendCommandResponse' :: SendCommandResponse -> Maybe StartSessionResult
startSession} -> Maybe StartSessionResult
startSession) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe StartSessionResult
a -> SendCommandResponse
s {$sel:startSession:SendCommandResponse' :: Maybe StartSessionResult
startSession = Maybe StartSessionResult
a} :: SendCommandResponse)

-- | Contains the details of the started transaction.
sendCommandResponse_startTransaction :: Lens.Lens' SendCommandResponse (Prelude.Maybe StartTransactionResult)
sendCommandResponse_startTransaction :: Lens' SendCommandResponse (Maybe StartTransactionResult)
sendCommandResponse_startTransaction = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SendCommandResponse' {Maybe StartTransactionResult
startTransaction :: Maybe StartTransactionResult
$sel:startTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe StartTransactionResult
startTransaction} -> Maybe StartTransactionResult
startTransaction) (\s :: SendCommandResponse
s@SendCommandResponse' {} Maybe StartTransactionResult
a -> SendCommandResponse
s {$sel:startTransaction:SendCommandResponse' :: Maybe StartTransactionResult
startTransaction = Maybe StartTransactionResult
a} :: SendCommandResponse)

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

instance Prelude.NFData SendCommandResponse where
  rnf :: SendCommandResponse -> ()
rnf SendCommandResponse' {Int
Maybe StartTransactionResult
Maybe StartSessionResult
Maybe EndSessionResult
Maybe CommitTransactionResult
Maybe AbortTransactionResult
Maybe FetchPageResult
Maybe ExecuteStatementResult
httpStatus :: Int
startTransaction :: Maybe StartTransactionResult
startSession :: Maybe StartSessionResult
fetchPage :: Maybe FetchPageResult
executeStatement :: Maybe ExecuteStatementResult
endSession :: Maybe EndSessionResult
commitTransaction :: Maybe CommitTransactionResult
abortTransaction :: Maybe AbortTransactionResult
$sel:httpStatus:SendCommandResponse' :: SendCommandResponse -> Int
$sel:startTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe StartTransactionResult
$sel:startSession:SendCommandResponse' :: SendCommandResponse -> Maybe StartSessionResult
$sel:fetchPage:SendCommandResponse' :: SendCommandResponse -> Maybe FetchPageResult
$sel:executeStatement:SendCommandResponse' :: SendCommandResponse -> Maybe ExecuteStatementResult
$sel:endSession:SendCommandResponse' :: SendCommandResponse -> Maybe EndSessionResult
$sel:commitTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe CommitTransactionResult
$sel:abortTransaction:SendCommandResponse' :: SendCommandResponse -> Maybe AbortTransactionResult
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe AbortTransactionResult
abortTransaction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe CommitTransactionResult
commitTransaction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe EndSessionResult
endSession
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ExecuteStatementResult
executeStatement
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe FetchPageResult
fetchPage
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StartSessionResult
startSession
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StartTransactionResult
startTransaction
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus