{-# 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 #-}
module Amazonka.RedshiftServerLess.RestoreTableFromSnapshot
(
RestoreTableFromSnapshot (..),
newRestoreTableFromSnapshot,
restoreTableFromSnapshot_activateCaseSensitiveIdentifier,
restoreTableFromSnapshot_sourceSchemaName,
restoreTableFromSnapshot_targetDatabaseName,
restoreTableFromSnapshot_targetSchemaName,
restoreTableFromSnapshot_namespaceName,
restoreTableFromSnapshot_newTableName,
restoreTableFromSnapshot_snapshotName,
restoreTableFromSnapshot_sourceDatabaseName,
restoreTableFromSnapshot_sourceTableName,
restoreTableFromSnapshot_workgroupName,
RestoreTableFromSnapshotResponse (..),
newRestoreTableFromSnapshotResponse,
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
data RestoreTableFromSnapshot = RestoreTableFromSnapshot'
{
RestoreTableFromSnapshot -> Maybe Bool
activateCaseSensitiveIdentifier :: Prelude.Maybe Prelude.Bool,
RestoreTableFromSnapshot -> Maybe Text
sourceSchemaName :: Prelude.Maybe Prelude.Text,
RestoreTableFromSnapshot -> Maybe Text
targetDatabaseName :: Prelude.Maybe Prelude.Text,
RestoreTableFromSnapshot -> Maybe Text
targetSchemaName :: Prelude.Maybe Prelude.Text,
RestoreTableFromSnapshot -> Text
namespaceName :: Prelude.Text,
RestoreTableFromSnapshot -> Text
newTableName' :: Prelude.Text,
RestoreTableFromSnapshot -> Text
snapshotName :: Prelude.Text,
RestoreTableFromSnapshot -> Text
sourceDatabaseName :: Prelude.Text,
RestoreTableFromSnapshot -> Text
sourceTableName :: Prelude.Text,
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)
newRestoreTableFromSnapshot ::
Prelude.Text ->
Prelude.Text ->
Prelude.Text ->
Prelude.Text ->
Prelude.Text ->
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_
}
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)
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)
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)
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)
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)
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)
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)
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)
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)
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
data RestoreTableFromSnapshotResponse = RestoreTableFromSnapshotResponse'
{
RestoreTableFromSnapshotResponse -> Maybe TableRestoreStatus
tableRestoreStatus :: Prelude.Maybe TableRestoreStatus,
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)
newRestoreTableFromSnapshotResponse ::
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_
}
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)
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