{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# 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.Types.Table
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Glue.Types.Table 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.Column
import Amazonka.Glue.Types.StorageDescriptor
import Amazonka.Glue.Types.TableIdentifier
import qualified Amazonka.Prelude as Prelude

-- | Represents a collection of related data organized in columns and rows.
--
-- /See:/ 'newTable' smart constructor.
data Table = Table'
  { -- | The ID of the Data Catalog in which the table resides.
    Table -> Maybe Text
catalogId :: Prelude.Maybe Prelude.Text,
    -- | The time when the table definition was created in the Data Catalog.
    Table -> Maybe POSIX
createTime :: Prelude.Maybe Data.POSIX,
    -- | The person or entity who created the table.
    Table -> Maybe Text
createdBy :: Prelude.Maybe Prelude.Text,
    -- | The name of the database where the table metadata resides. For Hive
    -- compatibility, this must be all lowercase.
    Table -> Maybe Text
databaseName :: Prelude.Maybe Prelude.Text,
    -- | A description of the table.
    Table -> Maybe Text
description :: Prelude.Maybe Prelude.Text,
    -- | Indicates whether the table has been registered with Lake Formation.
    Table -> Maybe Bool
isRegisteredWithLakeFormation :: Prelude.Maybe Prelude.Bool,
    -- | The last time that the table was accessed. This is usually taken from
    -- HDFS, and might not be reliable.
    Table -> Maybe POSIX
lastAccessTime :: Prelude.Maybe Data.POSIX,
    -- | The last time that column statistics were computed for this table.
    Table -> Maybe POSIX
lastAnalyzedTime :: Prelude.Maybe Data.POSIX,
    -- | The owner of the table.
    Table -> Maybe Text
owner :: Prelude.Maybe Prelude.Text,
    -- | These key-value pairs define properties associated with the table.
    Table -> Maybe (HashMap Text Text)
parameters :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A list of columns by which the table is partitioned. Only primitive
    -- types are supported as partition keys.
    --
    -- When you create a table used by Amazon Athena, and you do not specify
    -- any @partitionKeys@, you must at least set the value of @partitionKeys@
    -- to an empty list. For example:
    --
    -- @\"PartitionKeys\": []@
    Table -> Maybe [Column]
partitionKeys :: Prelude.Maybe [Column],
    -- | The retention time for this table.
    Table -> Maybe Natural
retention :: Prelude.Maybe Prelude.Natural,
    -- | A storage descriptor containing information about the physical storage
    -- of this table.
    Table -> Maybe StorageDescriptor
storageDescriptor :: Prelude.Maybe StorageDescriptor,
    -- | The type of this table (@EXTERNAL_TABLE@, @VIRTUAL_VIEW@, etc.).
    Table -> Maybe Text
tableType :: Prelude.Maybe Prelude.Text,
    -- | A @TableIdentifier@ structure that describes a target table for resource
    -- linking.
    Table -> Maybe TableIdentifier
targetTable :: Prelude.Maybe TableIdentifier,
    -- | The last time that the table was updated.
    Table -> Maybe POSIX
updateTime :: Prelude.Maybe Data.POSIX,
    -- | The ID of the table version.
    Table -> Maybe Text
versionId :: Prelude.Maybe Prelude.Text,
    -- | If the table is a view, the expanded text of the view; otherwise @null@.
    Table -> Maybe Text
viewExpandedText :: Prelude.Maybe Prelude.Text,
    -- | If the table is a view, the original text of the view; otherwise @null@.
    Table -> Maybe Text
viewOriginalText :: Prelude.Maybe Prelude.Text,
    -- | The table name. For Hive compatibility, this must be entirely lowercase.
    Table -> Text
name :: Prelude.Text
  }
  deriving (Table -> Table -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Table -> Table -> Bool
$c/= :: Table -> Table -> Bool
== :: Table -> Table -> Bool
$c== :: Table -> Table -> Bool
Prelude.Eq, ReadPrec [Table]
ReadPrec Table
Int -> ReadS Table
ReadS [Table]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Table]
$creadListPrec :: ReadPrec [Table]
readPrec :: ReadPrec Table
$creadPrec :: ReadPrec Table
readList :: ReadS [Table]
$creadList :: ReadS [Table]
readsPrec :: Int -> ReadS Table
$creadsPrec :: Int -> ReadS Table
Prelude.Read, Int -> Table -> ShowS
[Table] -> ShowS
Table -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Table] -> ShowS
$cshowList :: [Table] -> ShowS
show :: Table -> String
$cshow :: Table -> String
showsPrec :: Int -> Table -> ShowS
$cshowsPrec :: Int -> Table -> ShowS
Prelude.Show, forall x. Rep Table x -> Table
forall x. Table -> Rep Table x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Table x -> Table
$cfrom :: forall x. Table -> Rep Table x
Prelude.Generic)

-- |
-- Create a value of 'Table' 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', 'table_catalogId' - The ID of the Data Catalog in which the table resides.
--
-- 'createTime', 'table_createTime' - The time when the table definition was created in the Data Catalog.
--
-- 'createdBy', 'table_createdBy' - The person or entity who created the table.
--
-- 'databaseName', 'table_databaseName' - The name of the database where the table metadata resides. For Hive
-- compatibility, this must be all lowercase.
--
-- 'description', 'table_description' - A description of the table.
--
-- 'isRegisteredWithLakeFormation', 'table_isRegisteredWithLakeFormation' - Indicates whether the table has been registered with Lake Formation.
--
-- 'lastAccessTime', 'table_lastAccessTime' - The last time that the table was accessed. This is usually taken from
-- HDFS, and might not be reliable.
--
-- 'lastAnalyzedTime', 'table_lastAnalyzedTime' - The last time that column statistics were computed for this table.
--
-- 'owner', 'table_owner' - The owner of the table.
--
-- 'parameters', 'table_parameters' - These key-value pairs define properties associated with the table.
--
-- 'partitionKeys', 'table_partitionKeys' - A list of columns by which the table is partitioned. Only primitive
-- types are supported as partition keys.
--
-- When you create a table used by Amazon Athena, and you do not specify
-- any @partitionKeys@, you must at least set the value of @partitionKeys@
-- to an empty list. For example:
--
-- @\"PartitionKeys\": []@
--
-- 'retention', 'table_retention' - The retention time for this table.
--
-- 'storageDescriptor', 'table_storageDescriptor' - A storage descriptor containing information about the physical storage
-- of this table.
--
-- 'tableType', 'table_tableType' - The type of this table (@EXTERNAL_TABLE@, @VIRTUAL_VIEW@, etc.).
--
-- 'targetTable', 'table_targetTable' - A @TableIdentifier@ structure that describes a target table for resource
-- linking.
--
-- 'updateTime', 'table_updateTime' - The last time that the table was updated.
--
-- 'versionId', 'table_versionId' - The ID of the table version.
--
-- 'viewExpandedText', 'table_viewExpandedText' - If the table is a view, the expanded text of the view; otherwise @null@.
--
-- 'viewOriginalText', 'table_viewOriginalText' - If the table is a view, the original text of the view; otherwise @null@.
--
-- 'name', 'table_name' - The table name. For Hive compatibility, this must be entirely lowercase.
newTable ::
  -- | 'name'
  Prelude.Text ->
  Table
newTable :: Text -> Table
newTable Text
pName_ =
  Table'
    { $sel:catalogId:Table' :: Maybe Text
catalogId = forall a. Maybe a
Prelude.Nothing,
      $sel:createTime:Table' :: Maybe POSIX
createTime = forall a. Maybe a
Prelude.Nothing,
      $sel:createdBy:Table' :: Maybe Text
createdBy = forall a. Maybe a
Prelude.Nothing,
      $sel:databaseName:Table' :: Maybe Text
databaseName = forall a. Maybe a
Prelude.Nothing,
      $sel:description:Table' :: Maybe Text
description = forall a. Maybe a
Prelude.Nothing,
      $sel:isRegisteredWithLakeFormation:Table' :: Maybe Bool
isRegisteredWithLakeFormation = forall a. Maybe a
Prelude.Nothing,
      $sel:lastAccessTime:Table' :: Maybe POSIX
lastAccessTime = forall a. Maybe a
Prelude.Nothing,
      $sel:lastAnalyzedTime:Table' :: Maybe POSIX
lastAnalyzedTime = forall a. Maybe a
Prelude.Nothing,
      $sel:owner:Table' :: Maybe Text
owner = forall a. Maybe a
Prelude.Nothing,
      $sel:parameters:Table' :: Maybe (HashMap Text Text)
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:partitionKeys:Table' :: Maybe [Column]
partitionKeys = forall a. Maybe a
Prelude.Nothing,
      $sel:retention:Table' :: Maybe Natural
retention = forall a. Maybe a
Prelude.Nothing,
      $sel:storageDescriptor:Table' :: Maybe StorageDescriptor
storageDescriptor = forall a. Maybe a
Prelude.Nothing,
      $sel:tableType:Table' :: Maybe Text
tableType = forall a. Maybe a
Prelude.Nothing,
      $sel:targetTable:Table' :: Maybe TableIdentifier
targetTable = forall a. Maybe a
Prelude.Nothing,
      $sel:updateTime:Table' :: Maybe POSIX
updateTime = forall a. Maybe a
Prelude.Nothing,
      $sel:versionId:Table' :: Maybe Text
versionId = forall a. Maybe a
Prelude.Nothing,
      $sel:viewExpandedText:Table' :: Maybe Text
viewExpandedText = forall a. Maybe a
Prelude.Nothing,
      $sel:viewOriginalText:Table' :: Maybe Text
viewOriginalText = forall a. Maybe a
Prelude.Nothing,
      $sel:name:Table' :: Text
name = Text
pName_
    }

-- | The ID of the Data Catalog in which the table resides.
table_catalogId :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_catalogId :: Lens' Table (Maybe Text)
table_catalogId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
catalogId :: Maybe Text
$sel:catalogId:Table' :: Table -> Maybe Text
catalogId} -> Maybe Text
catalogId) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:catalogId:Table' :: Maybe Text
catalogId = Maybe Text
a} :: Table)

-- | The time when the table definition was created in the Data Catalog.
table_createTime :: Lens.Lens' Table (Prelude.Maybe Prelude.UTCTime)
table_createTime :: Lens' Table (Maybe UTCTime)
table_createTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe POSIX
createTime :: Maybe POSIX
$sel:createTime:Table' :: Table -> Maybe POSIX
createTime} -> Maybe POSIX
createTime) (\s :: Table
s@Table' {} Maybe POSIX
a -> Table
s {$sel:createTime:Table' :: Maybe POSIX
createTime = Maybe POSIX
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The person or entity who created the table.
table_createdBy :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_createdBy :: Lens' Table (Maybe Text)
table_createdBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
createdBy :: Maybe Text
$sel:createdBy:Table' :: Table -> Maybe Text
createdBy} -> Maybe Text
createdBy) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:createdBy:Table' :: Maybe Text
createdBy = Maybe Text
a} :: Table)

-- | The name of the database where the table metadata resides. For Hive
-- compatibility, this must be all lowercase.
table_databaseName :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_databaseName :: Lens' Table (Maybe Text)
table_databaseName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
databaseName :: Maybe Text
$sel:databaseName:Table' :: Table -> Maybe Text
databaseName} -> Maybe Text
databaseName) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:databaseName:Table' :: Maybe Text
databaseName = Maybe Text
a} :: Table)

-- | A description of the table.
table_description :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_description :: Lens' Table (Maybe Text)
table_description = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
description :: Maybe Text
$sel:description:Table' :: Table -> Maybe Text
description} -> Maybe Text
description) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:description:Table' :: Maybe Text
description = Maybe Text
a} :: Table)

-- | Indicates whether the table has been registered with Lake Formation.
table_isRegisteredWithLakeFormation :: Lens.Lens' Table (Prelude.Maybe Prelude.Bool)
table_isRegisteredWithLakeFormation :: Lens' Table (Maybe Bool)
table_isRegisteredWithLakeFormation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Bool
isRegisteredWithLakeFormation :: Maybe Bool
$sel:isRegisteredWithLakeFormation:Table' :: Table -> Maybe Bool
isRegisteredWithLakeFormation} -> Maybe Bool
isRegisteredWithLakeFormation) (\s :: Table
s@Table' {} Maybe Bool
a -> Table
s {$sel:isRegisteredWithLakeFormation:Table' :: Maybe Bool
isRegisteredWithLakeFormation = Maybe Bool
a} :: Table)

-- | The last time that the table was accessed. This is usually taken from
-- HDFS, and might not be reliable.
table_lastAccessTime :: Lens.Lens' Table (Prelude.Maybe Prelude.UTCTime)
table_lastAccessTime :: Lens' Table (Maybe UTCTime)
table_lastAccessTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe POSIX
lastAccessTime :: Maybe POSIX
$sel:lastAccessTime:Table' :: Table -> Maybe POSIX
lastAccessTime} -> Maybe POSIX
lastAccessTime) (\s :: Table
s@Table' {} Maybe POSIX
a -> Table
s {$sel:lastAccessTime:Table' :: Maybe POSIX
lastAccessTime = Maybe POSIX
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The last time that column statistics were computed for this table.
table_lastAnalyzedTime :: Lens.Lens' Table (Prelude.Maybe Prelude.UTCTime)
table_lastAnalyzedTime :: Lens' Table (Maybe UTCTime)
table_lastAnalyzedTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe POSIX
lastAnalyzedTime :: Maybe POSIX
$sel:lastAnalyzedTime:Table' :: Table -> Maybe POSIX
lastAnalyzedTime} -> Maybe POSIX
lastAnalyzedTime) (\s :: Table
s@Table' {} Maybe POSIX
a -> Table
s {$sel:lastAnalyzedTime:Table' :: Maybe POSIX
lastAnalyzedTime = Maybe POSIX
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The owner of the table.
table_owner :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_owner :: Lens' Table (Maybe Text)
table_owner = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
owner :: Maybe Text
$sel:owner:Table' :: Table -> Maybe Text
owner} -> Maybe Text
owner) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:owner:Table' :: Maybe Text
owner = Maybe Text
a} :: Table)

-- | These key-value pairs define properties associated with the table.
table_parameters :: Lens.Lens' Table (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
table_parameters :: Lens' Table (Maybe (HashMap Text Text))
table_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe (HashMap Text Text)
parameters :: Maybe (HashMap Text Text)
$sel:parameters:Table' :: Table -> Maybe (HashMap Text Text)
parameters} -> Maybe (HashMap Text Text)
parameters) (\s :: Table
s@Table' {} Maybe (HashMap Text Text)
a -> Table
s {$sel:parameters:Table' :: Maybe (HashMap Text Text)
parameters = Maybe (HashMap Text Text)
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A list of columns by which the table is partitioned. Only primitive
-- types are supported as partition keys.
--
-- When you create a table used by Amazon Athena, and you do not specify
-- any @partitionKeys@, you must at least set the value of @partitionKeys@
-- to an empty list. For example:
--
-- @\"PartitionKeys\": []@
table_partitionKeys :: Lens.Lens' Table (Prelude.Maybe [Column])
table_partitionKeys :: Lens' Table (Maybe [Column])
table_partitionKeys = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe [Column]
partitionKeys :: Maybe [Column]
$sel:partitionKeys:Table' :: Table -> Maybe [Column]
partitionKeys} -> Maybe [Column]
partitionKeys) (\s :: Table
s@Table' {} Maybe [Column]
a -> Table
s {$sel:partitionKeys:Table' :: Maybe [Column]
partitionKeys = Maybe [Column]
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The retention time for this table.
table_retention :: Lens.Lens' Table (Prelude.Maybe Prelude.Natural)
table_retention :: Lens' Table (Maybe Natural)
table_retention = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Natural
retention :: Maybe Natural
$sel:retention:Table' :: Table -> Maybe Natural
retention} -> Maybe Natural
retention) (\s :: Table
s@Table' {} Maybe Natural
a -> Table
s {$sel:retention:Table' :: Maybe Natural
retention = Maybe Natural
a} :: Table)

-- | A storage descriptor containing information about the physical storage
-- of this table.
table_storageDescriptor :: Lens.Lens' Table (Prelude.Maybe StorageDescriptor)
table_storageDescriptor :: Lens' Table (Maybe StorageDescriptor)
table_storageDescriptor = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe StorageDescriptor
storageDescriptor :: Maybe StorageDescriptor
$sel:storageDescriptor:Table' :: Table -> Maybe StorageDescriptor
storageDescriptor} -> Maybe StorageDescriptor
storageDescriptor) (\s :: Table
s@Table' {} Maybe StorageDescriptor
a -> Table
s {$sel:storageDescriptor:Table' :: Maybe StorageDescriptor
storageDescriptor = Maybe StorageDescriptor
a} :: Table)

-- | The type of this table (@EXTERNAL_TABLE@, @VIRTUAL_VIEW@, etc.).
table_tableType :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_tableType :: Lens' Table (Maybe Text)
table_tableType = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
tableType :: Maybe Text
$sel:tableType:Table' :: Table -> Maybe Text
tableType} -> Maybe Text
tableType) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:tableType:Table' :: Maybe Text
tableType = Maybe Text
a} :: Table)

-- | A @TableIdentifier@ structure that describes a target table for resource
-- linking.
table_targetTable :: Lens.Lens' Table (Prelude.Maybe TableIdentifier)
table_targetTable :: Lens' Table (Maybe TableIdentifier)
table_targetTable = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe TableIdentifier
targetTable :: Maybe TableIdentifier
$sel:targetTable:Table' :: Table -> Maybe TableIdentifier
targetTable} -> Maybe TableIdentifier
targetTable) (\s :: Table
s@Table' {} Maybe TableIdentifier
a -> Table
s {$sel:targetTable:Table' :: Maybe TableIdentifier
targetTable = Maybe TableIdentifier
a} :: Table)

-- | The last time that the table was updated.
table_updateTime :: Lens.Lens' Table (Prelude.Maybe Prelude.UTCTime)
table_updateTime :: Lens' Table (Maybe UTCTime)
table_updateTime = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe POSIX
updateTime :: Maybe POSIX
$sel:updateTime:Table' :: Table -> Maybe POSIX
updateTime} -> Maybe POSIX
updateTime) (\s :: Table
s@Table' {} Maybe POSIX
a -> Table
s {$sel:updateTime:Table' :: Maybe POSIX
updateTime = Maybe POSIX
a} :: Table) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall (a :: Format). Iso' (Time a) UTCTime
Data._Time

-- | The ID of the table version.
table_versionId :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_versionId :: Lens' Table (Maybe Text)
table_versionId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
versionId :: Maybe Text
$sel:versionId:Table' :: Table -> Maybe Text
versionId} -> Maybe Text
versionId) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:versionId:Table' :: Maybe Text
versionId = Maybe Text
a} :: Table)

-- | If the table is a view, the expanded text of the view; otherwise @null@.
table_viewExpandedText :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_viewExpandedText :: Lens' Table (Maybe Text)
table_viewExpandedText = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
viewExpandedText :: Maybe Text
$sel:viewExpandedText:Table' :: Table -> Maybe Text
viewExpandedText} -> Maybe Text
viewExpandedText) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:viewExpandedText:Table' :: Maybe Text
viewExpandedText = Maybe Text
a} :: Table)

-- | If the table is a view, the original text of the view; otherwise @null@.
table_viewOriginalText :: Lens.Lens' Table (Prelude.Maybe Prelude.Text)
table_viewOriginalText :: Lens' Table (Maybe Text)
table_viewOriginalText = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Maybe Text
viewOriginalText :: Maybe Text
$sel:viewOriginalText:Table' :: Table -> Maybe Text
viewOriginalText} -> Maybe Text
viewOriginalText) (\s :: Table
s@Table' {} Maybe Text
a -> Table
s {$sel:viewOriginalText:Table' :: Maybe Text
viewOriginalText = Maybe Text
a} :: Table)

-- | The table name. For Hive compatibility, this must be entirely lowercase.
table_name :: Lens.Lens' Table Prelude.Text
table_name :: Lens' Table Text
table_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Table' {Text
name :: Text
$sel:name:Table' :: Table -> Text
name} -> Text
name) (\s :: Table
s@Table' {} Text
a -> Table
s {$sel:name:Table' :: Text
name = Text
a} :: Table)

instance Data.FromJSON Table where
  parseJSON :: Value -> Parser Table
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Table"
      ( \Object
x ->
          Maybe Text
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Bool
-> Maybe POSIX
-> Maybe POSIX
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe [Column]
-> Maybe Natural
-> Maybe StorageDescriptor
-> Maybe Text
-> Maybe TableIdentifier
-> Maybe POSIX
-> Maybe Text
-> Maybe Text
-> Maybe Text
-> Text
-> Table
Table'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CatalogId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreateTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CreatedBy")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"DatabaseName")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Description")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"IsRegisteredWithLakeFormation")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastAccessTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"LastAnalyzedTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Owner")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Parameters" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"PartitionKeys" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"Retention")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"StorageDescriptor")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"TableType")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"TargetTable")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"UpdateTime")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"VersionId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ViewExpandedText")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"ViewOriginalText")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"Name")
      )

instance Prelude.Hashable Table where
  hashWithSalt :: Int -> Table -> Int
hashWithSalt Int
_salt Table' {Maybe Bool
Maybe Natural
Maybe [Column]
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe StorageDescriptor
Maybe TableIdentifier
Text
name :: Text
viewOriginalText :: Maybe Text
viewExpandedText :: Maybe Text
versionId :: Maybe Text
updateTime :: Maybe POSIX
targetTable :: Maybe TableIdentifier
tableType :: Maybe Text
storageDescriptor :: Maybe StorageDescriptor
retention :: Maybe Natural
partitionKeys :: Maybe [Column]
parameters :: Maybe (HashMap Text Text)
owner :: Maybe Text
lastAnalyzedTime :: Maybe POSIX
lastAccessTime :: Maybe POSIX
isRegisteredWithLakeFormation :: Maybe Bool
description :: Maybe Text
databaseName :: Maybe Text
createdBy :: Maybe Text
createTime :: Maybe POSIX
catalogId :: Maybe Text
$sel:name:Table' :: Table -> Text
$sel:viewOriginalText:Table' :: Table -> Maybe Text
$sel:viewExpandedText:Table' :: Table -> Maybe Text
$sel:versionId:Table' :: Table -> Maybe Text
$sel:updateTime:Table' :: Table -> Maybe POSIX
$sel:targetTable:Table' :: Table -> Maybe TableIdentifier
$sel:tableType:Table' :: Table -> Maybe Text
$sel:storageDescriptor:Table' :: Table -> Maybe StorageDescriptor
$sel:retention:Table' :: Table -> Maybe Natural
$sel:partitionKeys:Table' :: Table -> Maybe [Column]
$sel:parameters:Table' :: Table -> Maybe (HashMap Text Text)
$sel:owner:Table' :: Table -> Maybe Text
$sel:lastAnalyzedTime:Table' :: Table -> Maybe POSIX
$sel:lastAccessTime:Table' :: Table -> Maybe POSIX
$sel:isRegisteredWithLakeFormation:Table' :: Table -> Maybe Bool
$sel:description:Table' :: Table -> Maybe Text
$sel:databaseName:Table' :: Table -> Maybe Text
$sel:createdBy:Table' :: Table -> Maybe Text
$sel:createTime:Table' :: Table -> Maybe POSIX
$sel:catalogId:Table' :: Table -> 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` Maybe POSIX
createTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
createdBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
databaseName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
description
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
isRegisteredWithLakeFormation
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastAccessTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
lastAnalyzedTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
owner
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
parameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Column]
partitionKeys
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
retention
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StorageDescriptor
storageDescriptor
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
tableType
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe TableIdentifier
targetTable
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe POSIX
updateTime
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
versionId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
viewExpandedText
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
viewOriginalText
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData Table where
  rnf :: Table -> ()
rnf Table' {Maybe Bool
Maybe Natural
Maybe [Column]
Maybe Text
Maybe (HashMap Text Text)
Maybe POSIX
Maybe StorageDescriptor
Maybe TableIdentifier
Text
name :: Text
viewOriginalText :: Maybe Text
viewExpandedText :: Maybe Text
versionId :: Maybe Text
updateTime :: Maybe POSIX
targetTable :: Maybe TableIdentifier
tableType :: Maybe Text
storageDescriptor :: Maybe StorageDescriptor
retention :: Maybe Natural
partitionKeys :: Maybe [Column]
parameters :: Maybe (HashMap Text Text)
owner :: Maybe Text
lastAnalyzedTime :: Maybe POSIX
lastAccessTime :: Maybe POSIX
isRegisteredWithLakeFormation :: Maybe Bool
description :: Maybe Text
databaseName :: Maybe Text
createdBy :: Maybe Text
createTime :: Maybe POSIX
catalogId :: Maybe Text
$sel:name:Table' :: Table -> Text
$sel:viewOriginalText:Table' :: Table -> Maybe Text
$sel:viewExpandedText:Table' :: Table -> Maybe Text
$sel:versionId:Table' :: Table -> Maybe Text
$sel:updateTime:Table' :: Table -> Maybe POSIX
$sel:targetTable:Table' :: Table -> Maybe TableIdentifier
$sel:tableType:Table' :: Table -> Maybe Text
$sel:storageDescriptor:Table' :: Table -> Maybe StorageDescriptor
$sel:retention:Table' :: Table -> Maybe Natural
$sel:partitionKeys:Table' :: Table -> Maybe [Column]
$sel:parameters:Table' :: Table -> Maybe (HashMap Text Text)
$sel:owner:Table' :: Table -> Maybe Text
$sel:lastAnalyzedTime:Table' :: Table -> Maybe POSIX
$sel:lastAccessTime:Table' :: Table -> Maybe POSIX
$sel:isRegisteredWithLakeFormation:Table' :: Table -> Maybe Bool
$sel:description:Table' :: Table -> Maybe Text
$sel:databaseName:Table' :: Table -> Maybe Text
$sel:createdBy:Table' :: Table -> Maybe Text
$sel:createTime:Table' :: Table -> Maybe POSIX
$sel:catalogId:Table' :: Table -> 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 Maybe POSIX
createTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
createdBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
databaseName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
description
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
isRegisteredWithLakeFormation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastAccessTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
lastAnalyzedTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
owner
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (HashMap Text Text)
parameters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Column]
partitionKeys
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
retention
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StorageDescriptor
storageDescriptor
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
tableType
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe TableIdentifier
targetTable
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe POSIX
updateTime
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
versionId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
viewExpandedText
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
viewOriginalText
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
name