{-# 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.Glue.DeleteTableVersion
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Deletes a specified version of a table.
module Amazonka.Glue.DeleteTableVersion
  ( -- * Creating a Request
    DeleteTableVersion (..),
    newDeleteTableVersion,

    -- * Request Lenses
    deleteTableVersion_catalogId,
    deleteTableVersion_databaseName,
    deleteTableVersion_tableName,
    deleteTableVersion_versionId,

    -- * Destructuring the Response
    DeleteTableVersionResponse (..),
    newDeleteTableVersionResponse,

    -- * Response Lenses
    deleteTableVersionResponse_httpStatus,
  )
where

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

-- | /See:/ 'newDeleteTableVersion' smart constructor.
data DeleteTableVersion = DeleteTableVersion'
  { -- | The ID of the Data Catalog where the tables reside. If none is provided,
    -- the Amazon Web Services account ID is used by default.
    DeleteTableVersion -> Maybe Text
catalogId :: Prelude.Maybe Prelude.Text,
    -- | The database in the catalog in which the table resides. For Hive
    -- compatibility, this name is entirely lowercase.
    DeleteTableVersion -> Text
databaseName :: Prelude.Text,
    -- | The name of the table. For Hive compatibility, this name is entirely
    -- lowercase.
    DeleteTableVersion -> Text
tableName :: Prelude.Text,
    -- | The ID of the table version to be deleted. A @VersionID@ is a string
    -- representation of an integer. Each version is incremented by 1.
    DeleteTableVersion -> Text
versionId :: Prelude.Text
  }
  deriving (DeleteTableVersion -> DeleteTableVersion -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DeleteTableVersion -> DeleteTableVersion -> Bool
$c/= :: DeleteTableVersion -> DeleteTableVersion -> Bool
== :: DeleteTableVersion -> DeleteTableVersion -> Bool
$c== :: DeleteTableVersion -> DeleteTableVersion -> Bool
Prelude.Eq, ReadPrec [DeleteTableVersion]
ReadPrec DeleteTableVersion
Int -> ReadS DeleteTableVersion
ReadS [DeleteTableVersion]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DeleteTableVersion]
$creadListPrec :: ReadPrec [DeleteTableVersion]
readPrec :: ReadPrec DeleteTableVersion
$creadPrec :: ReadPrec DeleteTableVersion
readList :: ReadS [DeleteTableVersion]
$creadList :: ReadS [DeleteTableVersion]
readsPrec :: Int -> ReadS DeleteTableVersion
$creadsPrec :: Int -> ReadS DeleteTableVersion
Prelude.Read, Int -> DeleteTableVersion -> ShowS
[DeleteTableVersion] -> ShowS
DeleteTableVersion -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DeleteTableVersion] -> ShowS
$cshowList :: [DeleteTableVersion] -> ShowS
show :: DeleteTableVersion -> String
$cshow :: DeleteTableVersion -> String
showsPrec :: Int -> DeleteTableVersion -> ShowS
$cshowsPrec :: Int -> DeleteTableVersion -> ShowS
Prelude.Show, forall x. Rep DeleteTableVersion x -> DeleteTableVersion
forall x. DeleteTableVersion -> Rep DeleteTableVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DeleteTableVersion x -> DeleteTableVersion
$cfrom :: forall x. DeleteTableVersion -> Rep DeleteTableVersion x
Prelude.Generic)

-- |
-- Create a value of 'DeleteTableVersion' 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:
--
-- 'catalogId', 'deleteTableVersion_catalogId' - The ID of the Data Catalog where the tables reside. If none is provided,
-- the Amazon Web Services account ID is used by default.
--
-- 'databaseName', 'deleteTableVersion_databaseName' - The database in the catalog in which the table resides. For Hive
-- compatibility, this name is entirely lowercase.
--
-- 'tableName', 'deleteTableVersion_tableName' - The name of the table. For Hive compatibility, this name is entirely
-- lowercase.
--
-- 'versionId', 'deleteTableVersion_versionId' - The ID of the table version to be deleted. A @VersionID@ is a string
-- representation of an integer. Each version is incremented by 1.
newDeleteTableVersion ::
  -- | 'databaseName'
  Prelude.Text ->
  -- | 'tableName'
  Prelude.Text ->
  -- | 'versionId'
  Prelude.Text ->
  DeleteTableVersion
newDeleteTableVersion :: Text -> Text -> Text -> DeleteTableVersion
newDeleteTableVersion
  Text
pDatabaseName_
  Text
pTableName_
  Text
pVersionId_ =
    DeleteTableVersion'
      { $sel:catalogId:DeleteTableVersion' :: Maybe Text
catalogId = forall a. Maybe a
Prelude.Nothing,
        $sel:databaseName:DeleteTableVersion' :: Text
databaseName = Text
pDatabaseName_,
        $sel:tableName:DeleteTableVersion' :: Text
tableName = Text
pTableName_,
        $sel:versionId:DeleteTableVersion' :: Text
versionId = Text
pVersionId_
      }

-- | The ID of the Data Catalog where the tables reside. If none is provided,
-- the Amazon Web Services account ID is used by default.
deleteTableVersion_catalogId :: Lens.Lens' DeleteTableVersion (Prelude.Maybe Prelude.Text)
deleteTableVersion_catalogId :: Lens' DeleteTableVersion (Maybe Text)
deleteTableVersion_catalogId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTableVersion' {Maybe Text
catalogId :: Maybe Text
$sel:catalogId:DeleteTableVersion' :: DeleteTableVersion -> Maybe Text
catalogId} -> Maybe Text
catalogId) (\s :: DeleteTableVersion
s@DeleteTableVersion' {} Maybe Text
a -> DeleteTableVersion
s {$sel:catalogId:DeleteTableVersion' :: Maybe Text
catalogId = Maybe Text
a} :: DeleteTableVersion)

-- | The database in the catalog in which the table resides. For Hive
-- compatibility, this name is entirely lowercase.
deleteTableVersion_databaseName :: Lens.Lens' DeleteTableVersion Prelude.Text
deleteTableVersion_databaseName :: Lens' DeleteTableVersion Text
deleteTableVersion_databaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTableVersion' {Text
databaseName :: Text
$sel:databaseName:DeleteTableVersion' :: DeleteTableVersion -> Text
databaseName} -> Text
databaseName) (\s :: DeleteTableVersion
s@DeleteTableVersion' {} Text
a -> DeleteTableVersion
s {$sel:databaseName:DeleteTableVersion' :: Text
databaseName = Text
a} :: DeleteTableVersion)

-- | The name of the table. For Hive compatibility, this name is entirely
-- lowercase.
deleteTableVersion_tableName :: Lens.Lens' DeleteTableVersion Prelude.Text
deleteTableVersion_tableName :: Lens' DeleteTableVersion Text
deleteTableVersion_tableName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTableVersion' {Text
tableName :: Text
$sel:tableName:DeleteTableVersion' :: DeleteTableVersion -> Text
tableName} -> Text
tableName) (\s :: DeleteTableVersion
s@DeleteTableVersion' {} Text
a -> DeleteTableVersion
s {$sel:tableName:DeleteTableVersion' :: Text
tableName = Text
a} :: DeleteTableVersion)

-- | The ID of the table version to be deleted. A @VersionID@ is a string
-- representation of an integer. Each version is incremented by 1.
deleteTableVersion_versionId :: Lens.Lens' DeleteTableVersion Prelude.Text
deleteTableVersion_versionId :: Lens' DeleteTableVersion Text
deleteTableVersion_versionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\DeleteTableVersion' {Text
versionId :: Text
$sel:versionId:DeleteTableVersion' :: DeleteTableVersion -> Text
versionId} -> Text
versionId) (\s :: DeleteTableVersion
s@DeleteTableVersion' {} Text
a -> DeleteTableVersion
s {$sel:versionId:DeleteTableVersion' :: Text
versionId = Text
a} :: DeleteTableVersion)

instance Core.AWSRequest DeleteTableVersion where
  type
    AWSResponse DeleteTableVersion =
      DeleteTableVersionResponse
  request :: (Service -> Service)
-> DeleteTableVersion -> Request DeleteTableVersion
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 DeleteTableVersion
-> ClientResponse ClientBody
-> m (Either
        Error (ClientResponse (AWSResponse DeleteTableVersion)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> () -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveEmpty
      ( \Int
s ResponseHeaders
h ()
x ->
          Int -> DeleteTableVersionResponse
DeleteTableVersionResponse'
            forall (f :: * -> *) a b. Functor 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 DeleteTableVersion where
  hashWithSalt :: Int -> DeleteTableVersion -> Int
hashWithSalt Int
_salt DeleteTableVersion' {Maybe Text
Text
versionId :: Text
tableName :: Text
databaseName :: Text
catalogId :: Maybe Text
$sel:versionId:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:tableName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:databaseName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:catalogId:DeleteTableVersion' :: DeleteTableVersion -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
catalogId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
databaseName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
tableName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
versionId

instance Prelude.NFData DeleteTableVersion where
  rnf :: DeleteTableVersion -> ()
rnf DeleteTableVersion' {Maybe Text
Text
versionId :: Text
tableName :: Text
databaseName :: Text
catalogId :: Maybe Text
$sel:versionId:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:tableName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:databaseName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:catalogId:DeleteTableVersion' :: DeleteTableVersion -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
catalogId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
databaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
tableName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
versionId

instance Data.ToHeaders DeleteTableVersion where
  toHeaders :: DeleteTableVersion -> 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
"AWSGlue.DeleteTableVersion" :: 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 DeleteTableVersion where
  toJSON :: DeleteTableVersion -> Value
toJSON DeleteTableVersion' {Maybe Text
Text
versionId :: Text
tableName :: Text
databaseName :: Text
catalogId :: Maybe Text
$sel:versionId:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:tableName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:databaseName:DeleteTableVersion' :: DeleteTableVersion -> Text
$sel:catalogId:DeleteTableVersion' :: DeleteTableVersion -> Maybe Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"CatalogId" 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
catalogId,
            forall a. a -> Maybe a
Prelude.Just (Key
"DatabaseName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
databaseName),
            forall a. a -> Maybe a
Prelude.Just (Key
"TableName" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
tableName),
            forall a. a -> Maybe a
Prelude.Just (Key
"VersionId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
versionId)
          ]
      )

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

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

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

-- |
-- Create a value of 'DeleteTableVersionResponse' 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:
--
-- 'httpStatus', 'deleteTableVersionResponse_httpStatus' - The response's http status code.
newDeleteTableVersionResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  DeleteTableVersionResponse
newDeleteTableVersionResponse :: Int -> DeleteTableVersionResponse
newDeleteTableVersionResponse Int
pHttpStatus_ =
  DeleteTableVersionResponse'
    { $sel:httpStatus:DeleteTableVersionResponse' :: Int
httpStatus =
        Int
pHttpStatus_
    }

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

instance Prelude.NFData DeleteTableVersionResponse where
  rnf :: DeleteTableVersionResponse -> ()
rnf DeleteTableVersionResponse' {Int
httpStatus :: Int
$sel:httpStatus:DeleteTableVersionResponse' :: DeleteTableVersionResponse -> Int
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus