{-# 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.RedshiftServerLess.RestoreTableFromSnapshot
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Restores a table from a snapshot to your Amazon Redshift Serverless
-- instance.
module Amazonka.RedshiftServerLess.RestoreTableFromSnapshot
  ( -- * Creating a Request
    RestoreTableFromSnapshot (..),
    newRestoreTableFromSnapshot,

    -- * Request Lenses
    restoreTableFromSnapshot_activateCaseSensitiveIdentifier,
    restoreTableFromSnapshot_sourceSchemaName,
    restoreTableFromSnapshot_targetDatabaseName,
    restoreTableFromSnapshot_targetSchemaName,
    restoreTableFromSnapshot_namespaceName,
    restoreTableFromSnapshot_newTableName,
    restoreTableFromSnapshot_snapshotName,
    restoreTableFromSnapshot_sourceDatabaseName,
    restoreTableFromSnapshot_sourceTableName,
    restoreTableFromSnapshot_workgroupName,

    -- * Destructuring the Response
    RestoreTableFromSnapshotResponse (..),
    newRestoreTableFromSnapshotResponse,

    -- * Response Lenses
    restoreTableFromSnapshotResponse_tableRestoreStatus,
    restoreTableFromSnapshotResponse_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.RedshiftServerLess.Types
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newRestoreTableFromSnapshot' smart constructor.
data RestoreTableFromSnapshot = RestoreTableFromSnapshot'
  { -- | Indicates whether name identifiers for database, schema, and table are
    -- case sensitive. If true, the names are case sensitive. If false, the
    -- names are not case sensitive. The default is false.
    RestoreTableFromSnapshot -> Maybe Bool
activateCaseSensitiveIdentifier :: Prelude.Maybe Prelude.Bool,
    -- | The name of the source schema that contains the table being restored.
    RestoreTableFromSnapshot -> Maybe Text
sourceSchemaName :: Prelude.Maybe Prelude.Text,
    -- | The name of the database to restore the table to.
    RestoreTableFromSnapshot -> Maybe Text
targetDatabaseName :: Prelude.Maybe Prelude.Text,
    -- | The name of the schema to restore the table to.
    RestoreTableFromSnapshot -> Maybe Text
targetSchemaName :: Prelude.Maybe Prelude.Text,
    -- | The namespace of the snapshot to restore from.
    RestoreTableFromSnapshot -> Text
namespaceName :: Prelude.Text,
    -- | The name of the table to create from the restore operation.
    RestoreTableFromSnapshot -> Text
newTableName' :: Prelude.Text,
    -- | The name of the snapshot to restore the table from.
    RestoreTableFromSnapshot -> Text
snapshotName :: Prelude.Text,
    -- | The name of the source database that contains the table being restored.
    RestoreTableFromSnapshot -> Text
sourceDatabaseName :: Prelude.Text,
    -- | The name of the source table being restored.
    RestoreTableFromSnapshot -> Text
sourceTableName :: Prelude.Text,
    -- | The workgroup to restore the table to.
    RestoreTableFromSnapshot -> Text
workgroupName :: Prelude.Text
  }
  deriving (RestoreTableFromSnapshot -> RestoreTableFromSnapshot -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreTableFromSnapshot -> RestoreTableFromSnapshot -> Bool
$c/= :: RestoreTableFromSnapshot -> RestoreTableFromSnapshot -> Bool
== :: RestoreTableFromSnapshot -> RestoreTableFromSnapshot -> Bool
$c== :: RestoreTableFromSnapshot -> RestoreTableFromSnapshot -> Bool
Prelude.Eq, ReadPrec [RestoreTableFromSnapshot]
ReadPrec RestoreTableFromSnapshot
Int -> ReadS RestoreTableFromSnapshot
ReadS [RestoreTableFromSnapshot]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreTableFromSnapshot]
$creadListPrec :: ReadPrec [RestoreTableFromSnapshot]
readPrec :: ReadPrec RestoreTableFromSnapshot
$creadPrec :: ReadPrec RestoreTableFromSnapshot
readList :: ReadS [RestoreTableFromSnapshot]
$creadList :: ReadS [RestoreTableFromSnapshot]
readsPrec :: Int -> ReadS RestoreTableFromSnapshot
$creadsPrec :: Int -> ReadS RestoreTableFromSnapshot
Prelude.Read, Int -> RestoreTableFromSnapshot -> ShowS
[RestoreTableFromSnapshot] -> ShowS
RestoreTableFromSnapshot -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreTableFromSnapshot] -> ShowS
$cshowList :: [RestoreTableFromSnapshot] -> ShowS
show :: RestoreTableFromSnapshot -> String
$cshow :: RestoreTableFromSnapshot -> String
showsPrec :: Int -> RestoreTableFromSnapshot -> ShowS
$cshowsPrec :: Int -> RestoreTableFromSnapshot -> ShowS
Prelude.Show, forall x.
Rep RestoreTableFromSnapshot x -> RestoreTableFromSnapshot
forall x.
RestoreTableFromSnapshot -> Rep RestoreTableFromSnapshot x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreTableFromSnapshot x -> RestoreTableFromSnapshot
$cfrom :: forall x.
RestoreTableFromSnapshot -> Rep RestoreTableFromSnapshot x
Prelude.Generic)

-- |
-- Create a value of 'RestoreTableFromSnapshot' 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:
--
-- 'activateCaseSensitiveIdentifier', 'restoreTableFromSnapshot_activateCaseSensitiveIdentifier' - Indicates whether name identifiers for database, schema, and table are
-- case sensitive. If true, the names are case sensitive. If false, the
-- names are not case sensitive. The default is false.
--
-- 'sourceSchemaName', 'restoreTableFromSnapshot_sourceSchemaName' - The name of the source schema that contains the table being restored.
--
-- 'targetDatabaseName', 'restoreTableFromSnapshot_targetDatabaseName' - The name of the database to restore the table to.
--
-- 'targetSchemaName', 'restoreTableFromSnapshot_targetSchemaName' - The name of the schema to restore the table to.
--
-- 'namespaceName', 'restoreTableFromSnapshot_namespaceName' - The namespace of the snapshot to restore from.
--
-- 'newTableName'', 'restoreTableFromSnapshot_newTableName' - The name of the table to create from the restore operation.
--
-- 'snapshotName', 'restoreTableFromSnapshot_snapshotName' - The name of the snapshot to restore the table from.
--
-- 'sourceDatabaseName', 'restoreTableFromSnapshot_sourceDatabaseName' - The name of the source database that contains the table being restored.
--
-- 'sourceTableName', 'restoreTableFromSnapshot_sourceTableName' - The name of the source table being restored.
--
-- 'workgroupName', 'restoreTableFromSnapshot_workgroupName' - The workgroup to restore the table to.
newRestoreTableFromSnapshot ::
  -- | 'namespaceName'
  Prelude.Text ->
  -- | 'newTableName''
  Prelude.Text ->
  -- | 'snapshotName'
  Prelude.Text ->
  -- | 'sourceDatabaseName'
  Prelude.Text ->
  -- | 'sourceTableName'
  Prelude.Text ->
  -- | 'workgroupName'
  Prelude.Text ->
  RestoreTableFromSnapshot
newRestoreTableFromSnapshot :: Text
-> Text -> Text -> Text -> Text -> Text -> RestoreTableFromSnapshot
newRestoreTableFromSnapshot
  Text
pNamespaceName_
  Text
pNewTableName_
  Text
pSnapshotName_
  Text
pSourceDatabaseName_
  Text
pSourceTableName_
  Text
pWorkgroupName_ =
    RestoreTableFromSnapshot'
      { $sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: Maybe Bool
activateCaseSensitiveIdentifier =
          forall a. Maybe a
Prelude.Nothing,
        $sel:sourceSchemaName:RestoreTableFromSnapshot' :: Maybe Text
sourceSchemaName = forall a. Maybe a
Prelude.Nothing,
        $sel:targetDatabaseName:RestoreTableFromSnapshot' :: Maybe Text
targetDatabaseName = forall a. Maybe a
Prelude.Nothing,
        $sel:targetSchemaName:RestoreTableFromSnapshot' :: Maybe Text
targetSchemaName = forall a. Maybe a
Prelude.Nothing,
        $sel:namespaceName:RestoreTableFromSnapshot' :: Text
namespaceName = Text
pNamespaceName_,
        $sel:newTableName':RestoreTableFromSnapshot' :: Text
newTableName' = Text
pNewTableName_,
        $sel:snapshotName:RestoreTableFromSnapshot' :: Text
snapshotName = Text
pSnapshotName_,
        $sel:sourceDatabaseName:RestoreTableFromSnapshot' :: Text
sourceDatabaseName = Text
pSourceDatabaseName_,
        $sel:sourceTableName:RestoreTableFromSnapshot' :: Text
sourceTableName = Text
pSourceTableName_,
        $sel:workgroupName:RestoreTableFromSnapshot' :: Text
workgroupName = Text
pWorkgroupName_
      }

-- | Indicates whether name identifiers for database, schema, and table are
-- case sensitive. If true, the names are case sensitive. If false, the
-- names are not case sensitive. The default is false.
restoreTableFromSnapshot_activateCaseSensitiveIdentifier :: Lens.Lens' RestoreTableFromSnapshot (Prelude.Maybe Prelude.Bool)
restoreTableFromSnapshot_activateCaseSensitiveIdentifier :: Lens' RestoreTableFromSnapshot (Maybe Bool)
restoreTableFromSnapshot_activateCaseSensitiveIdentifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Maybe Bool
activateCaseSensitiveIdentifier :: Maybe Bool
$sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Bool
activateCaseSensitiveIdentifier} -> Maybe Bool
activateCaseSensitiveIdentifier) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Maybe Bool
a -> RestoreTableFromSnapshot
s {$sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: Maybe Bool
activateCaseSensitiveIdentifier = Maybe Bool
a} :: RestoreTableFromSnapshot)

-- | The name of the source schema that contains the table being restored.
restoreTableFromSnapshot_sourceSchemaName :: Lens.Lens' RestoreTableFromSnapshot (Prelude.Maybe Prelude.Text)
restoreTableFromSnapshot_sourceSchemaName :: Lens' RestoreTableFromSnapshot (Maybe Text)
restoreTableFromSnapshot_sourceSchemaName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Maybe Text
sourceSchemaName :: Maybe Text
$sel:sourceSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
sourceSchemaName} -> Maybe Text
sourceSchemaName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Maybe Text
a -> RestoreTableFromSnapshot
s {$sel:sourceSchemaName:RestoreTableFromSnapshot' :: Maybe Text
sourceSchemaName = Maybe Text
a} :: RestoreTableFromSnapshot)

-- | The name of the database to restore the table to.
restoreTableFromSnapshot_targetDatabaseName :: Lens.Lens' RestoreTableFromSnapshot (Prelude.Maybe Prelude.Text)
restoreTableFromSnapshot_targetDatabaseName :: Lens' RestoreTableFromSnapshot (Maybe Text)
restoreTableFromSnapshot_targetDatabaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Maybe Text
targetDatabaseName :: Maybe Text
$sel:targetDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
targetDatabaseName} -> Maybe Text
targetDatabaseName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Maybe Text
a -> RestoreTableFromSnapshot
s {$sel:targetDatabaseName:RestoreTableFromSnapshot' :: Maybe Text
targetDatabaseName = Maybe Text
a} :: RestoreTableFromSnapshot)

-- | The name of the schema to restore the table to.
restoreTableFromSnapshot_targetSchemaName :: Lens.Lens' RestoreTableFromSnapshot (Prelude.Maybe Prelude.Text)
restoreTableFromSnapshot_targetSchemaName :: Lens' RestoreTableFromSnapshot (Maybe Text)
restoreTableFromSnapshot_targetSchemaName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Maybe Text
targetSchemaName :: Maybe Text
$sel:targetSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
targetSchemaName} -> Maybe Text
targetSchemaName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Maybe Text
a -> RestoreTableFromSnapshot
s {$sel:targetSchemaName:RestoreTableFromSnapshot' :: Maybe Text
targetSchemaName = Maybe Text
a} :: RestoreTableFromSnapshot)

-- | The namespace of the snapshot to restore from.
restoreTableFromSnapshot_namespaceName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_namespaceName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_namespaceName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
namespaceName :: Text
$sel:namespaceName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
namespaceName} -> Text
namespaceName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:namespaceName:RestoreTableFromSnapshot' :: Text
namespaceName = Text
a} :: RestoreTableFromSnapshot)

-- | The name of the table to create from the restore operation.
restoreTableFromSnapshot_newTableName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_newTableName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_newTableName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
newTableName' :: Text
$sel:newTableName':RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
newTableName'} -> Text
newTableName') (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:newTableName':RestoreTableFromSnapshot' :: Text
newTableName' = Text
a} :: RestoreTableFromSnapshot)

-- | The name of the snapshot to restore the table from.
restoreTableFromSnapshot_snapshotName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_snapshotName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_snapshotName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
snapshotName :: Text
$sel:snapshotName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
snapshotName} -> Text
snapshotName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:snapshotName:RestoreTableFromSnapshot' :: Text
snapshotName = Text
a} :: RestoreTableFromSnapshot)

-- | The name of the source database that contains the table being restored.
restoreTableFromSnapshot_sourceDatabaseName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_sourceDatabaseName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_sourceDatabaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
sourceDatabaseName :: Text
$sel:sourceDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
sourceDatabaseName} -> Text
sourceDatabaseName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:sourceDatabaseName:RestoreTableFromSnapshot' :: Text
sourceDatabaseName = Text
a} :: RestoreTableFromSnapshot)

-- | The name of the source table being restored.
restoreTableFromSnapshot_sourceTableName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_sourceTableName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_sourceTableName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
sourceTableName :: Text
$sel:sourceTableName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
sourceTableName} -> Text
sourceTableName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:sourceTableName:RestoreTableFromSnapshot' :: Text
sourceTableName = Text
a} :: RestoreTableFromSnapshot)

-- | The workgroup to restore the table to.
restoreTableFromSnapshot_workgroupName :: Lens.Lens' RestoreTableFromSnapshot Prelude.Text
restoreTableFromSnapshot_workgroupName :: Lens' RestoreTableFromSnapshot Text
restoreTableFromSnapshot_workgroupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshot' {Text
workgroupName :: Text
$sel:workgroupName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
workgroupName} -> Text
workgroupName) (\s :: RestoreTableFromSnapshot
s@RestoreTableFromSnapshot' {} Text
a -> RestoreTableFromSnapshot
s {$sel:workgroupName:RestoreTableFromSnapshot' :: Text
workgroupName = Text
a} :: RestoreTableFromSnapshot)

instance Core.AWSRequest RestoreTableFromSnapshot where
  type
    AWSResponse RestoreTableFromSnapshot =
      RestoreTableFromSnapshotResponse
  request :: (Service -> Service)
-> RestoreTableFromSnapshot -> Request RestoreTableFromSnapshot
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 RestoreTableFromSnapshot
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse RestoreTableFromSnapshot)))
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 TableRestoreStatus -> Int -> RestoreTableFromSnapshotResponse
RestoreTableFromSnapshotResponse'
            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
"tableRestoreStatus")
            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 RestoreTableFromSnapshot where
  hashWithSalt :: Int -> RestoreTableFromSnapshot -> Int
hashWithSalt Int
_salt RestoreTableFromSnapshot' {Maybe Bool
Maybe Text
Text
workgroupName :: Text
sourceTableName :: Text
sourceDatabaseName :: Text
snapshotName :: Text
newTableName' :: Text
namespaceName :: Text
targetSchemaName :: Maybe Text
targetDatabaseName :: Maybe Text
sourceSchemaName :: Maybe Text
activateCaseSensitiveIdentifier :: Maybe Bool
$sel:workgroupName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceTableName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:snapshotName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:newTableName':RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:namespaceName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:targetSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:targetDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:sourceSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Bool
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
activateCaseSensitiveIdentifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
sourceSchemaName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
targetDatabaseName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
targetSchemaName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
namespaceName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
newTableName'
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
snapshotName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sourceDatabaseName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
sourceTableName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
workgroupName

instance Prelude.NFData RestoreTableFromSnapshot where
  rnf :: RestoreTableFromSnapshot -> ()
rnf RestoreTableFromSnapshot' {Maybe Bool
Maybe Text
Text
workgroupName :: Text
sourceTableName :: Text
sourceDatabaseName :: Text
snapshotName :: Text
newTableName' :: Text
namespaceName :: Text
targetSchemaName :: Maybe Text
targetDatabaseName :: Maybe Text
sourceSchemaName :: Maybe Text
activateCaseSensitiveIdentifier :: Maybe Bool
$sel:workgroupName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceTableName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:snapshotName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:newTableName':RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:namespaceName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:targetSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:targetDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:sourceSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Bool
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
activateCaseSensitiveIdentifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
sourceSchemaName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
targetDatabaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
targetSchemaName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
namespaceName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
newTableName'
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
snapshotName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
sourceDatabaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
sourceTableName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
workgroupName

instance Data.ToHeaders RestoreTableFromSnapshot where
  toHeaders :: RestoreTableFromSnapshot -> 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
"RedshiftServerless.RestoreTableFromSnapshot" ::
                          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 RestoreTableFromSnapshot where
  toJSON :: RestoreTableFromSnapshot -> Value
toJSON RestoreTableFromSnapshot' {Maybe Bool
Maybe Text
Text
workgroupName :: Text
sourceTableName :: Text
sourceDatabaseName :: Text
snapshotName :: Text
newTableName' :: Text
namespaceName :: Text
targetSchemaName :: Maybe Text
targetDatabaseName :: Maybe Text
sourceSchemaName :: Maybe Text
activateCaseSensitiveIdentifier :: Maybe Bool
$sel:workgroupName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceTableName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:sourceDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:snapshotName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:newTableName':RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:namespaceName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Text
$sel:targetSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:targetDatabaseName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:sourceSchemaName:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Text
$sel:activateCaseSensitiveIdentifier:RestoreTableFromSnapshot' :: RestoreTableFromSnapshot -> Maybe Bool
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"activateCaseSensitiveIdentifier" 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
activateCaseSensitiveIdentifier,
            (Key
"sourceSchemaName" 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
sourceSchemaName,
            (Key
"targetDatabaseName" 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
targetDatabaseName,
            (Key
"targetSchemaName" 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
targetSchemaName,
            forall a. a -> Maybe a
Prelude.Just (Key
"namespaceName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
namespaceName),
            forall a. a -> Maybe a
Prelude.Just (Key
"newTableName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
newTableName'),
            forall a. a -> Maybe a
Prelude.Just (Key
"snapshotName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
snapshotName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"sourceDatabaseName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sourceDatabaseName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"sourceTableName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
sourceTableName),
            forall a. a -> Maybe a
Prelude.Just
              (Key
"workgroupName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
workgroupName)
          ]
      )

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

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

-- | /See:/ 'newRestoreTableFromSnapshotResponse' smart constructor.
data RestoreTableFromSnapshotResponse = RestoreTableFromSnapshotResponse'
  { -- | The TableRestoreStatus object that contains the status of the restore
    -- operation.
    RestoreTableFromSnapshotResponse -> Maybe TableRestoreStatus
tableRestoreStatus :: Prelude.Maybe TableRestoreStatus,
    -- | The response's http status code.
    RestoreTableFromSnapshotResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (RestoreTableFromSnapshotResponse
-> RestoreTableFromSnapshotResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RestoreTableFromSnapshotResponse
-> RestoreTableFromSnapshotResponse -> Bool
$c/= :: RestoreTableFromSnapshotResponse
-> RestoreTableFromSnapshotResponse -> Bool
== :: RestoreTableFromSnapshotResponse
-> RestoreTableFromSnapshotResponse -> Bool
$c== :: RestoreTableFromSnapshotResponse
-> RestoreTableFromSnapshotResponse -> Bool
Prelude.Eq, ReadPrec [RestoreTableFromSnapshotResponse]
ReadPrec RestoreTableFromSnapshotResponse
Int -> ReadS RestoreTableFromSnapshotResponse
ReadS [RestoreTableFromSnapshotResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RestoreTableFromSnapshotResponse]
$creadListPrec :: ReadPrec [RestoreTableFromSnapshotResponse]
readPrec :: ReadPrec RestoreTableFromSnapshotResponse
$creadPrec :: ReadPrec RestoreTableFromSnapshotResponse
readList :: ReadS [RestoreTableFromSnapshotResponse]
$creadList :: ReadS [RestoreTableFromSnapshotResponse]
readsPrec :: Int -> ReadS RestoreTableFromSnapshotResponse
$creadsPrec :: Int -> ReadS RestoreTableFromSnapshotResponse
Prelude.Read, Int -> RestoreTableFromSnapshotResponse -> ShowS
[RestoreTableFromSnapshotResponse] -> ShowS
RestoreTableFromSnapshotResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RestoreTableFromSnapshotResponse] -> ShowS
$cshowList :: [RestoreTableFromSnapshotResponse] -> ShowS
show :: RestoreTableFromSnapshotResponse -> String
$cshow :: RestoreTableFromSnapshotResponse -> String
showsPrec :: Int -> RestoreTableFromSnapshotResponse -> ShowS
$cshowsPrec :: Int -> RestoreTableFromSnapshotResponse -> ShowS
Prelude.Show, forall x.
Rep RestoreTableFromSnapshotResponse x
-> RestoreTableFromSnapshotResponse
forall x.
RestoreTableFromSnapshotResponse
-> Rep RestoreTableFromSnapshotResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep RestoreTableFromSnapshotResponse x
-> RestoreTableFromSnapshotResponse
$cfrom :: forall x.
RestoreTableFromSnapshotResponse
-> Rep RestoreTableFromSnapshotResponse x
Prelude.Generic)

-- |
-- Create a value of 'RestoreTableFromSnapshotResponse' 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:
--
-- 'tableRestoreStatus', 'restoreTableFromSnapshotResponse_tableRestoreStatus' - The TableRestoreStatus object that contains the status of the restore
-- operation.
--
-- 'httpStatus', 'restoreTableFromSnapshotResponse_httpStatus' - The response's http status code.
newRestoreTableFromSnapshotResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  RestoreTableFromSnapshotResponse
newRestoreTableFromSnapshotResponse :: Int -> RestoreTableFromSnapshotResponse
newRestoreTableFromSnapshotResponse Int
pHttpStatus_ =
  RestoreTableFromSnapshotResponse'
    { $sel:tableRestoreStatus:RestoreTableFromSnapshotResponse' :: Maybe TableRestoreStatus
tableRestoreStatus =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:RestoreTableFromSnapshotResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The TableRestoreStatus object that contains the status of the restore
-- operation.
restoreTableFromSnapshotResponse_tableRestoreStatus :: Lens.Lens' RestoreTableFromSnapshotResponse (Prelude.Maybe TableRestoreStatus)
restoreTableFromSnapshotResponse_tableRestoreStatus :: Lens' RestoreTableFromSnapshotResponse (Maybe TableRestoreStatus)
restoreTableFromSnapshotResponse_tableRestoreStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RestoreTableFromSnapshotResponse' {Maybe TableRestoreStatus
tableRestoreStatus :: Maybe TableRestoreStatus
$sel:tableRestoreStatus:RestoreTableFromSnapshotResponse' :: RestoreTableFromSnapshotResponse -> Maybe TableRestoreStatus
tableRestoreStatus} -> Maybe TableRestoreStatus
tableRestoreStatus) (\s :: RestoreTableFromSnapshotResponse
s@RestoreTableFromSnapshotResponse' {} Maybe TableRestoreStatus
a -> RestoreTableFromSnapshotResponse
s {$sel:tableRestoreStatus:RestoreTableFromSnapshotResponse' :: Maybe TableRestoreStatus
tableRestoreStatus = Maybe TableRestoreStatus
a} :: RestoreTableFromSnapshotResponse)

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

instance
  Prelude.NFData
    RestoreTableFromSnapshotResponse
  where
  rnf :: RestoreTableFromSnapshotResponse -> ()
rnf RestoreTableFromSnapshotResponse' {Int
Maybe TableRestoreStatus
httpStatus :: Int
tableRestoreStatus :: Maybe TableRestoreStatus
$sel:httpStatus:RestoreTableFromSnapshotResponse' :: RestoreTableFromSnapshotResponse -> Int
$sel:tableRestoreStatus:RestoreTableFromSnapshotResponse' :: RestoreTableFromSnapshotResponse -> Maybe TableRestoreStatus
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe TableRestoreStatus
tableRestoreStatus
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus