{-# 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.StorageDescriptor
-- 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.StorageDescriptor 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.Order
import Amazonka.Glue.Types.SchemaReference
import Amazonka.Glue.Types.SerDeInfo
import Amazonka.Glue.Types.SkewedInfo
import qualified Amazonka.Prelude as Prelude

-- | Describes the physical storage of table data.
--
-- /See:/ 'newStorageDescriptor' smart constructor.
data StorageDescriptor = StorageDescriptor'
  { -- | A list of locations that point to the path where a Delta table is
    -- located.
    StorageDescriptor -> Maybe [Text]
additionalLocations :: Prelude.Maybe [Prelude.Text],
    -- | A list of reducer grouping columns, clustering columns, and bucketing
    -- columns in the table.
    StorageDescriptor -> Maybe [Text]
bucketColumns :: Prelude.Maybe [Prelude.Text],
    -- | A list of the @Columns@ in the table.
    StorageDescriptor -> Maybe [Column]
columns :: Prelude.Maybe [Column],
    -- | @True@ if the data in the table is compressed, or @False@ if not.
    StorageDescriptor -> Maybe Bool
compressed :: Prelude.Maybe Prelude.Bool,
    -- | The input format: @SequenceFileInputFormat@ (binary), or
    -- @TextInputFormat@, or a custom format.
    StorageDescriptor -> Maybe Text
inputFormat :: Prelude.Maybe Prelude.Text,
    -- | The physical location of the table. By default, this takes the form of
    -- the warehouse location, followed by the database location in the
    -- warehouse, followed by the table name.
    StorageDescriptor -> Maybe Text
location :: Prelude.Maybe Prelude.Text,
    -- | Must be specified if the table contains any dimension columns.
    StorageDescriptor -> Maybe Int
numberOfBuckets :: Prelude.Maybe Prelude.Int,
    -- | The output format: @SequenceFileOutputFormat@ (binary), or
    -- @IgnoreKeyTextOutputFormat@, or a custom format.
    StorageDescriptor -> Maybe Text
outputFormat :: Prelude.Maybe Prelude.Text,
    -- | The user-supplied properties in key-value form.
    StorageDescriptor -> Maybe (HashMap Text Text)
parameters :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | An object that references a schema stored in the Glue Schema Registry.
    --
    -- When creating a table, you can pass an empty list of columns for the
    -- schema, and instead use a schema reference.
    StorageDescriptor -> Maybe SchemaReference
schemaReference :: Prelude.Maybe SchemaReference,
    -- | The serialization\/deserialization (SerDe) information.
    StorageDescriptor -> Maybe SerDeInfo
serdeInfo :: Prelude.Maybe SerDeInfo,
    -- | The information about values that appear frequently in a column (skewed
    -- values).
    StorageDescriptor -> Maybe SkewedInfo
skewedInfo :: Prelude.Maybe SkewedInfo,
    -- | A list specifying the sort order of each bucket in the table.
    StorageDescriptor -> Maybe [Order]
sortColumns :: Prelude.Maybe [Order],
    -- | @True@ if the table data is stored in subdirectories, or @False@ if not.
    StorageDescriptor -> Maybe Bool
storedAsSubDirectories :: Prelude.Maybe Prelude.Bool
  }
  deriving (StorageDescriptor -> StorageDescriptor -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StorageDescriptor -> StorageDescriptor -> Bool
$c/= :: StorageDescriptor -> StorageDescriptor -> Bool
== :: StorageDescriptor -> StorageDescriptor -> Bool
$c== :: StorageDescriptor -> StorageDescriptor -> Bool
Prelude.Eq, ReadPrec [StorageDescriptor]
ReadPrec StorageDescriptor
Int -> ReadS StorageDescriptor
ReadS [StorageDescriptor]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [StorageDescriptor]
$creadListPrec :: ReadPrec [StorageDescriptor]
readPrec :: ReadPrec StorageDescriptor
$creadPrec :: ReadPrec StorageDescriptor
readList :: ReadS [StorageDescriptor]
$creadList :: ReadS [StorageDescriptor]
readsPrec :: Int -> ReadS StorageDescriptor
$creadsPrec :: Int -> ReadS StorageDescriptor
Prelude.Read, Int -> StorageDescriptor -> ShowS
[StorageDescriptor] -> ShowS
StorageDescriptor -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StorageDescriptor] -> ShowS
$cshowList :: [StorageDescriptor] -> ShowS
show :: StorageDescriptor -> String
$cshow :: StorageDescriptor -> String
showsPrec :: Int -> StorageDescriptor -> ShowS
$cshowsPrec :: Int -> StorageDescriptor -> ShowS
Prelude.Show, forall x. Rep StorageDescriptor x -> StorageDescriptor
forall x. StorageDescriptor -> Rep StorageDescriptor x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep StorageDescriptor x -> StorageDescriptor
$cfrom :: forall x. StorageDescriptor -> Rep StorageDescriptor x
Prelude.Generic)

-- |
-- Create a value of 'StorageDescriptor' 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:
--
-- 'additionalLocations', 'storageDescriptor_additionalLocations' - A list of locations that point to the path where a Delta table is
-- located.
--
-- 'bucketColumns', 'storageDescriptor_bucketColumns' - A list of reducer grouping columns, clustering columns, and bucketing
-- columns in the table.
--
-- 'columns', 'storageDescriptor_columns' - A list of the @Columns@ in the table.
--
-- 'compressed', 'storageDescriptor_compressed' - @True@ if the data in the table is compressed, or @False@ if not.
--
-- 'inputFormat', 'storageDescriptor_inputFormat' - The input format: @SequenceFileInputFormat@ (binary), or
-- @TextInputFormat@, or a custom format.
--
-- 'location', 'storageDescriptor_location' - The physical location of the table. By default, this takes the form of
-- the warehouse location, followed by the database location in the
-- warehouse, followed by the table name.
--
-- 'numberOfBuckets', 'storageDescriptor_numberOfBuckets' - Must be specified if the table contains any dimension columns.
--
-- 'outputFormat', 'storageDescriptor_outputFormat' - The output format: @SequenceFileOutputFormat@ (binary), or
-- @IgnoreKeyTextOutputFormat@, or a custom format.
--
-- 'parameters', 'storageDescriptor_parameters' - The user-supplied properties in key-value form.
--
-- 'schemaReference', 'storageDescriptor_schemaReference' - An object that references a schema stored in the Glue Schema Registry.
--
-- When creating a table, you can pass an empty list of columns for the
-- schema, and instead use a schema reference.
--
-- 'serdeInfo', 'storageDescriptor_serdeInfo' - The serialization\/deserialization (SerDe) information.
--
-- 'skewedInfo', 'storageDescriptor_skewedInfo' - The information about values that appear frequently in a column (skewed
-- values).
--
-- 'sortColumns', 'storageDescriptor_sortColumns' - A list specifying the sort order of each bucket in the table.
--
-- 'storedAsSubDirectories', 'storageDescriptor_storedAsSubDirectories' - @True@ if the table data is stored in subdirectories, or @False@ if not.
newStorageDescriptor ::
  StorageDescriptor
newStorageDescriptor :: StorageDescriptor
newStorageDescriptor =
  StorageDescriptor'
    { $sel:additionalLocations:StorageDescriptor' :: Maybe [Text]
additionalLocations =
        forall a. Maybe a
Prelude.Nothing,
      $sel:bucketColumns:StorageDescriptor' :: Maybe [Text]
bucketColumns = forall a. Maybe a
Prelude.Nothing,
      $sel:columns:StorageDescriptor' :: Maybe [Column]
columns = forall a. Maybe a
Prelude.Nothing,
      $sel:compressed:StorageDescriptor' :: Maybe Bool
compressed = forall a. Maybe a
Prelude.Nothing,
      $sel:inputFormat:StorageDescriptor' :: Maybe Text
inputFormat = forall a. Maybe a
Prelude.Nothing,
      $sel:location:StorageDescriptor' :: Maybe Text
location = forall a. Maybe a
Prelude.Nothing,
      $sel:numberOfBuckets:StorageDescriptor' :: Maybe Int
numberOfBuckets = forall a. Maybe a
Prelude.Nothing,
      $sel:outputFormat:StorageDescriptor' :: Maybe Text
outputFormat = forall a. Maybe a
Prelude.Nothing,
      $sel:parameters:StorageDescriptor' :: Maybe (HashMap Text Text)
parameters = forall a. Maybe a
Prelude.Nothing,
      $sel:schemaReference:StorageDescriptor' :: Maybe SchemaReference
schemaReference = forall a. Maybe a
Prelude.Nothing,
      $sel:serdeInfo:StorageDescriptor' :: Maybe SerDeInfo
serdeInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:skewedInfo:StorageDescriptor' :: Maybe SkewedInfo
skewedInfo = forall a. Maybe a
Prelude.Nothing,
      $sel:sortColumns:StorageDescriptor' :: Maybe [Order]
sortColumns = forall a. Maybe a
Prelude.Nothing,
      $sel:storedAsSubDirectories:StorageDescriptor' :: Maybe Bool
storedAsSubDirectories = forall a. Maybe a
Prelude.Nothing
    }

-- | A list of locations that point to the path where a Delta table is
-- located.
storageDescriptor_additionalLocations :: Lens.Lens' StorageDescriptor (Prelude.Maybe [Prelude.Text])
storageDescriptor_additionalLocations :: Lens' StorageDescriptor (Maybe [Text])
storageDescriptor_additionalLocations = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe [Text]
additionalLocations :: Maybe [Text]
$sel:additionalLocations:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
additionalLocations} -> Maybe [Text]
additionalLocations) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe [Text]
a -> StorageDescriptor
s {$sel:additionalLocations:StorageDescriptor' :: Maybe [Text]
additionalLocations = Maybe [Text]
a} :: StorageDescriptor) 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 reducer grouping columns, clustering columns, and bucketing
-- columns in the table.
storageDescriptor_bucketColumns :: Lens.Lens' StorageDescriptor (Prelude.Maybe [Prelude.Text])
storageDescriptor_bucketColumns :: Lens' StorageDescriptor (Maybe [Text])
storageDescriptor_bucketColumns = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe [Text]
bucketColumns :: Maybe [Text]
$sel:bucketColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
bucketColumns} -> Maybe [Text]
bucketColumns) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe [Text]
a -> StorageDescriptor
s {$sel:bucketColumns:StorageDescriptor' :: Maybe [Text]
bucketColumns = Maybe [Text]
a} :: StorageDescriptor) 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 the @Columns@ in the table.
storageDescriptor_columns :: Lens.Lens' StorageDescriptor (Prelude.Maybe [Column])
storageDescriptor_columns :: Lens' StorageDescriptor (Maybe [Column])
storageDescriptor_columns = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe [Column]
columns :: Maybe [Column]
$sel:columns:StorageDescriptor' :: StorageDescriptor -> Maybe [Column]
columns} -> Maybe [Column]
columns) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe [Column]
a -> StorageDescriptor
s {$sel:columns:StorageDescriptor' :: Maybe [Column]
columns = Maybe [Column]
a} :: StorageDescriptor) 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

-- | @True@ if the data in the table is compressed, or @False@ if not.
storageDescriptor_compressed :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Bool)
storageDescriptor_compressed :: Lens' StorageDescriptor (Maybe Bool)
storageDescriptor_compressed = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Bool
compressed :: Maybe Bool
$sel:compressed:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
compressed} -> Maybe Bool
compressed) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Bool
a -> StorageDescriptor
s {$sel:compressed:StorageDescriptor' :: Maybe Bool
compressed = Maybe Bool
a} :: StorageDescriptor)

-- | The input format: @SequenceFileInputFormat@ (binary), or
-- @TextInputFormat@, or a custom format.
storageDescriptor_inputFormat :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Text)
storageDescriptor_inputFormat :: Lens' StorageDescriptor (Maybe Text)
storageDescriptor_inputFormat = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Text
inputFormat :: Maybe Text
$sel:inputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
inputFormat} -> Maybe Text
inputFormat) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Text
a -> StorageDescriptor
s {$sel:inputFormat:StorageDescriptor' :: Maybe Text
inputFormat = Maybe Text
a} :: StorageDescriptor)

-- | The physical location of the table. By default, this takes the form of
-- the warehouse location, followed by the database location in the
-- warehouse, followed by the table name.
storageDescriptor_location :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Text)
storageDescriptor_location :: Lens' StorageDescriptor (Maybe Text)
storageDescriptor_location = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Text
location :: Maybe Text
$sel:location:StorageDescriptor' :: StorageDescriptor -> Maybe Text
location} -> Maybe Text
location) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Text
a -> StorageDescriptor
s {$sel:location:StorageDescriptor' :: Maybe Text
location = Maybe Text
a} :: StorageDescriptor)

-- | Must be specified if the table contains any dimension columns.
storageDescriptor_numberOfBuckets :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Int)
storageDescriptor_numberOfBuckets :: Lens' StorageDescriptor (Maybe Int)
storageDescriptor_numberOfBuckets = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Int
numberOfBuckets :: Maybe Int
$sel:numberOfBuckets:StorageDescriptor' :: StorageDescriptor -> Maybe Int
numberOfBuckets} -> Maybe Int
numberOfBuckets) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Int
a -> StorageDescriptor
s {$sel:numberOfBuckets:StorageDescriptor' :: Maybe Int
numberOfBuckets = Maybe Int
a} :: StorageDescriptor)

-- | The output format: @SequenceFileOutputFormat@ (binary), or
-- @IgnoreKeyTextOutputFormat@, or a custom format.
storageDescriptor_outputFormat :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Text)
storageDescriptor_outputFormat :: Lens' StorageDescriptor (Maybe Text)
storageDescriptor_outputFormat = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Text
outputFormat :: Maybe Text
$sel:outputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
outputFormat} -> Maybe Text
outputFormat) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Text
a -> StorageDescriptor
s {$sel:outputFormat:StorageDescriptor' :: Maybe Text
outputFormat = Maybe Text
a} :: StorageDescriptor)

-- | The user-supplied properties in key-value form.
storageDescriptor_parameters :: Lens.Lens' StorageDescriptor (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
storageDescriptor_parameters :: Lens' StorageDescriptor (Maybe (HashMap Text Text))
storageDescriptor_parameters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe (HashMap Text Text)
parameters :: Maybe (HashMap Text Text)
$sel:parameters:StorageDescriptor' :: StorageDescriptor -> Maybe (HashMap Text Text)
parameters} -> Maybe (HashMap Text Text)
parameters) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe (HashMap Text Text)
a -> StorageDescriptor
s {$sel:parameters:StorageDescriptor' :: Maybe (HashMap Text Text)
parameters = Maybe (HashMap Text Text)
a} :: StorageDescriptor) 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

-- | An object that references a schema stored in the Glue Schema Registry.
--
-- When creating a table, you can pass an empty list of columns for the
-- schema, and instead use a schema reference.
storageDescriptor_schemaReference :: Lens.Lens' StorageDescriptor (Prelude.Maybe SchemaReference)
storageDescriptor_schemaReference :: Lens' StorageDescriptor (Maybe SchemaReference)
storageDescriptor_schemaReference = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe SchemaReference
schemaReference :: Maybe SchemaReference
$sel:schemaReference:StorageDescriptor' :: StorageDescriptor -> Maybe SchemaReference
schemaReference} -> Maybe SchemaReference
schemaReference) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe SchemaReference
a -> StorageDescriptor
s {$sel:schemaReference:StorageDescriptor' :: Maybe SchemaReference
schemaReference = Maybe SchemaReference
a} :: StorageDescriptor)

-- | The serialization\/deserialization (SerDe) information.
storageDescriptor_serdeInfo :: Lens.Lens' StorageDescriptor (Prelude.Maybe SerDeInfo)
storageDescriptor_serdeInfo :: Lens' StorageDescriptor (Maybe SerDeInfo)
storageDescriptor_serdeInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe SerDeInfo
serdeInfo :: Maybe SerDeInfo
$sel:serdeInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SerDeInfo
serdeInfo} -> Maybe SerDeInfo
serdeInfo) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe SerDeInfo
a -> StorageDescriptor
s {$sel:serdeInfo:StorageDescriptor' :: Maybe SerDeInfo
serdeInfo = Maybe SerDeInfo
a} :: StorageDescriptor)

-- | The information about values that appear frequently in a column (skewed
-- values).
storageDescriptor_skewedInfo :: Lens.Lens' StorageDescriptor (Prelude.Maybe SkewedInfo)
storageDescriptor_skewedInfo :: Lens' StorageDescriptor (Maybe SkewedInfo)
storageDescriptor_skewedInfo = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe SkewedInfo
skewedInfo :: Maybe SkewedInfo
$sel:skewedInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SkewedInfo
skewedInfo} -> Maybe SkewedInfo
skewedInfo) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe SkewedInfo
a -> StorageDescriptor
s {$sel:skewedInfo:StorageDescriptor' :: Maybe SkewedInfo
skewedInfo = Maybe SkewedInfo
a} :: StorageDescriptor)

-- | A list specifying the sort order of each bucket in the table.
storageDescriptor_sortColumns :: Lens.Lens' StorageDescriptor (Prelude.Maybe [Order])
storageDescriptor_sortColumns :: Lens' StorageDescriptor (Maybe [Order])
storageDescriptor_sortColumns = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe [Order]
sortColumns :: Maybe [Order]
$sel:sortColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Order]
sortColumns} -> Maybe [Order]
sortColumns) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe [Order]
a -> StorageDescriptor
s {$sel:sortColumns:StorageDescriptor' :: Maybe [Order]
sortColumns = Maybe [Order]
a} :: StorageDescriptor) 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

-- | @True@ if the table data is stored in subdirectories, or @False@ if not.
storageDescriptor_storedAsSubDirectories :: Lens.Lens' StorageDescriptor (Prelude.Maybe Prelude.Bool)
storageDescriptor_storedAsSubDirectories :: Lens' StorageDescriptor (Maybe Bool)
storageDescriptor_storedAsSubDirectories = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\StorageDescriptor' {Maybe Bool
storedAsSubDirectories :: Maybe Bool
$sel:storedAsSubDirectories:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
storedAsSubDirectories} -> Maybe Bool
storedAsSubDirectories) (\s :: StorageDescriptor
s@StorageDescriptor' {} Maybe Bool
a -> StorageDescriptor
s {$sel:storedAsSubDirectories:StorageDescriptor' :: Maybe Bool
storedAsSubDirectories = Maybe Bool
a} :: StorageDescriptor)

instance Data.FromJSON StorageDescriptor where
  parseJSON :: Value -> Parser StorageDescriptor
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"StorageDescriptor"
      ( \Object
x ->
          Maybe [Text]
-> Maybe [Text]
-> Maybe [Column]
-> Maybe Bool
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe Text
-> Maybe (HashMap Text Text)
-> Maybe SchemaReference
-> Maybe SerDeInfo
-> Maybe SkewedInfo
-> Maybe [Order]
-> Maybe Bool
-> StorageDescriptor
StorageDescriptor'
            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
"AdditionalLocations"
                            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
"BucketColumns" 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
"Columns" 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
"Compressed")
            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
"InputFormat")
            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
"Location")
            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
"NumberOfBuckets")
            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
"OutputFormat")
            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
"SchemaReference")
            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
"SerdeInfo")
            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
"SkewedInfo")
            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
"SortColumns" 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
"StoredAsSubDirectories")
      )

instance Prelude.Hashable StorageDescriptor where
  hashWithSalt :: Int -> StorageDescriptor -> Int
hashWithSalt Int
_salt StorageDescriptor' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [Column]
Maybe [Order]
Maybe Text
Maybe (HashMap Text Text)
Maybe SchemaReference
Maybe SerDeInfo
Maybe SkewedInfo
storedAsSubDirectories :: Maybe Bool
sortColumns :: Maybe [Order]
skewedInfo :: Maybe SkewedInfo
serdeInfo :: Maybe SerDeInfo
schemaReference :: Maybe SchemaReference
parameters :: Maybe (HashMap Text Text)
outputFormat :: Maybe Text
numberOfBuckets :: Maybe Int
location :: Maybe Text
inputFormat :: Maybe Text
compressed :: Maybe Bool
columns :: Maybe [Column]
bucketColumns :: Maybe [Text]
additionalLocations :: Maybe [Text]
$sel:storedAsSubDirectories:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:sortColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Order]
$sel:skewedInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SkewedInfo
$sel:serdeInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SerDeInfo
$sel:schemaReference:StorageDescriptor' :: StorageDescriptor -> Maybe SchemaReference
$sel:parameters:StorageDescriptor' :: StorageDescriptor -> Maybe (HashMap Text Text)
$sel:outputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:numberOfBuckets:StorageDescriptor' :: StorageDescriptor -> Maybe Int
$sel:location:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:inputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:compressed:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:columns:StorageDescriptor' :: StorageDescriptor -> Maybe [Column]
$sel:bucketColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
$sel:additionalLocations:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
additionalLocations
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Text]
bucketColumns
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Column]
columns
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
compressed
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
inputFormat
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
location
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
numberOfBuckets
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
outputFormat
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (HashMap Text Text)
parameters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SchemaReference
schemaReference
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SerDeInfo
serdeInfo
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SkewedInfo
skewedInfo
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Order]
sortColumns
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Bool
storedAsSubDirectories

instance Prelude.NFData StorageDescriptor where
  rnf :: StorageDescriptor -> ()
rnf StorageDescriptor' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [Column]
Maybe [Order]
Maybe Text
Maybe (HashMap Text Text)
Maybe SchemaReference
Maybe SerDeInfo
Maybe SkewedInfo
storedAsSubDirectories :: Maybe Bool
sortColumns :: Maybe [Order]
skewedInfo :: Maybe SkewedInfo
serdeInfo :: Maybe SerDeInfo
schemaReference :: Maybe SchemaReference
parameters :: Maybe (HashMap Text Text)
outputFormat :: Maybe Text
numberOfBuckets :: Maybe Int
location :: Maybe Text
inputFormat :: Maybe Text
compressed :: Maybe Bool
columns :: Maybe [Column]
bucketColumns :: Maybe [Text]
additionalLocations :: Maybe [Text]
$sel:storedAsSubDirectories:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:sortColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Order]
$sel:skewedInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SkewedInfo
$sel:serdeInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SerDeInfo
$sel:schemaReference:StorageDescriptor' :: StorageDescriptor -> Maybe SchemaReference
$sel:parameters:StorageDescriptor' :: StorageDescriptor -> Maybe (HashMap Text Text)
$sel:outputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:numberOfBuckets:StorageDescriptor' :: StorageDescriptor -> Maybe Int
$sel:location:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:inputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:compressed:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:columns:StorageDescriptor' :: StorageDescriptor -> Maybe [Column]
$sel:bucketColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
$sel:additionalLocations:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
additionalLocations
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Text]
bucketColumns
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Column]
columns
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
compressed
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
inputFormat
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
location
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
numberOfBuckets
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
outputFormat
      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 SchemaReference
schemaReference
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SerDeInfo
serdeInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SkewedInfo
skewedInfo
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Order]
sortColumns
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Bool
storedAsSubDirectories

instance Data.ToJSON StorageDescriptor where
  toJSON :: StorageDescriptor -> Value
toJSON StorageDescriptor' {Maybe Bool
Maybe Int
Maybe [Text]
Maybe [Column]
Maybe [Order]
Maybe Text
Maybe (HashMap Text Text)
Maybe SchemaReference
Maybe SerDeInfo
Maybe SkewedInfo
storedAsSubDirectories :: Maybe Bool
sortColumns :: Maybe [Order]
skewedInfo :: Maybe SkewedInfo
serdeInfo :: Maybe SerDeInfo
schemaReference :: Maybe SchemaReference
parameters :: Maybe (HashMap Text Text)
outputFormat :: Maybe Text
numberOfBuckets :: Maybe Int
location :: Maybe Text
inputFormat :: Maybe Text
compressed :: Maybe Bool
columns :: Maybe [Column]
bucketColumns :: Maybe [Text]
additionalLocations :: Maybe [Text]
$sel:storedAsSubDirectories:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:sortColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Order]
$sel:skewedInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SkewedInfo
$sel:serdeInfo:StorageDescriptor' :: StorageDescriptor -> Maybe SerDeInfo
$sel:schemaReference:StorageDescriptor' :: StorageDescriptor -> Maybe SchemaReference
$sel:parameters:StorageDescriptor' :: StorageDescriptor -> Maybe (HashMap Text Text)
$sel:outputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:numberOfBuckets:StorageDescriptor' :: StorageDescriptor -> Maybe Int
$sel:location:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:inputFormat:StorageDescriptor' :: StorageDescriptor -> Maybe Text
$sel:compressed:StorageDescriptor' :: StorageDescriptor -> Maybe Bool
$sel:columns:StorageDescriptor' :: StorageDescriptor -> Maybe [Column]
$sel:bucketColumns:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
$sel:additionalLocations:StorageDescriptor' :: StorageDescriptor -> Maybe [Text]
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"AdditionalLocations" 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]
additionalLocations,
            (Key
"BucketColumns" 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]
bucketColumns,
            (Key
"Columns" 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 [Column]
columns,
            (Key
"Compressed" 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
compressed,
            (Key
"InputFormat" 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
inputFormat,
            (Key
"Location" 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
location,
            (Key
"NumberOfBuckets" 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 Int
numberOfBuckets,
            (Key
"OutputFormat" 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
outputFormat,
            (Key
"Parameters" 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 (HashMap Text Text)
parameters,
            (Key
"SchemaReference" 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 SchemaReference
schemaReference,
            (Key
"SerdeInfo" 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 SerDeInfo
serdeInfo,
            (Key
"SkewedInfo" 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 SkewedInfo
skewedInfo,
            (Key
"SortColumns" 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 [Order]
sortColumns,
            (Key
"StoredAsSubDirectories" 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
storedAsSubDirectories
          ]
      )