{-# 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.DynamoDB.Scan
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- The @Scan@ operation returns one or more items and item attributes by
-- accessing every item in a table or a secondary index. To have DynamoDB
-- return fewer items, you can provide a @FilterExpression@ operation.
--
-- If the total number of scanned items exceeds the maximum dataset size
-- limit of 1 MB, the scan stops and results are returned to the user as a
-- @LastEvaluatedKey@ value to continue the scan in a subsequent operation.
-- The results also include the number of items exceeding the limit. A scan
-- can result in no table data meeting the filter criteria.
--
-- A single @Scan@ operation reads up to the maximum number of items set
-- (if using the @Limit@ parameter) or a maximum of 1 MB of data and then
-- apply any filtering to the results using @FilterExpression@. If
-- @LastEvaluatedKey@ is present in the response, you need to paginate the
-- result set. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination Paginating the Results>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- @Scan@ operations proceed sequentially; however, for faster performance
-- on a large table or secondary index, applications can request a parallel
-- @Scan@ operation by providing the @Segment@ and @TotalSegments@
-- parameters. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan Parallel Scan>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- @Scan@ uses eventually consistent reads when accessing the data in a
-- table; therefore, the result set might not include the changes to data
-- in the table immediately before the operation began. If you need a
-- consistent copy of the data, as of the time that the @Scan@ begins, you
-- can set the @ConsistentRead@ parameter to @true@.
--
-- This operation returns paginated results.
module Amazonka.DynamoDB.Scan
  ( -- * Creating a Request
    Scan (..),
    newScan,

    -- * Request Lenses
    scan_projectionExpression,
    scan_scanFilter,
    scan_attributesToGet,
    scan_totalSegments,
    scan_expressionAttributeNames,
    scan_filterExpression,
    scan_consistentRead,
    scan_expressionAttributeValues,
    scan_returnConsumedCapacity,
    scan_limit,
    scan_select,
    scan_segment,
    scan_conditionalOperator,
    scan_exclusiveStartKey,
    scan_indexName,
    scan_tableName,

    -- * Destructuring the Response
    ScanResponse (..),
    newScanResponse,

    -- * Response Lenses
    scanResponse_lastEvaluatedKey,
    scanResponse_count,
    scanResponse_scannedCount,
    scanResponse_items,
    scanResponse_consumedCapacity,
    scanResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import Amazonka.DynamoDB.Types
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | Represents the input of a @Scan@ operation.
--
-- /See:/ 'newScan' smart constructor.
data Scan = Scan'
  { -- | A string that identifies one or more attributes to retrieve from the
    -- specified table or index. These attributes can include scalars, sets, or
    -- elements of a JSON document. The attributes in the expression must be
    -- separated by commas.
    --
    -- If no attribute names are specified, then all attributes will be
    -- returned. If any of the requested attributes are not found, they will
    -- not appear in the result.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe Text
projectionExpression :: Prelude.Maybe Prelude.Text,
    -- | This is a legacy parameter. Use @FilterExpression@ instead. For more
    -- information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html ScanFilter>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe (HashMap Text Condition)
scanFilter :: Prelude.Maybe (Prelude.HashMap Prelude.Text Condition),
    -- | This is a legacy parameter. Use @ProjectionExpression@ instead. For more
    -- information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe (NonEmpty Text)
attributesToGet :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | For a parallel @Scan@ request, @TotalSegments@ represents the total
    -- number of segments into which the @Scan@ operation will be divided. The
    -- value of @TotalSegments@ corresponds to the number of application
    -- workers that will perform the parallel scan. For example, if you want to
    -- use four application threads to scan a table or an index, specify a
    -- @TotalSegments@ value of 4.
    --
    -- The value for @TotalSegments@ must be greater than or equal to 1, and
    -- less than or equal to 1000000. If you specify a @TotalSegments@ value of
    -- 1, the @Scan@ operation will be sequential rather than parallel.
    --
    -- If you specify @TotalSegments@, you must also specify @Segment@.
    Scan -> Maybe Natural
totalSegments :: Prelude.Maybe Prelude.Natural,
    -- | One or more substitution tokens for attribute names in an expression.
    -- The following are some use cases for using @ExpressionAttributeNames@:
    --
    -- -   To access an attribute whose name conflicts with a DynamoDB reserved
    --     word.
    --
    -- -   To create a placeholder for repeating occurrences of an attribute
    --     name in an expression.
    --
    -- -   To prevent special characters in an attribute name from being
    --     misinterpreted in an expression.
    --
    -- Use the __#__ character in an expression to dereference an attribute
    -- name. For example, consider the following attribute name:
    --
    -- -   @Percentile@
    --
    -- The name of this attribute conflicts with a reserved word, so it cannot
    -- be used directly in an expression. (For the complete list of reserved
    -- words, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
    -- in the /Amazon DynamoDB Developer Guide/). To work around this, you
    -- could specify the following for @ExpressionAttributeNames@:
    --
    -- -   @{\"#P\":\"Percentile\"}@
    --
    -- You could then use this substitution in an expression, as in this
    -- example:
    --
    -- -   @#P = :val@
    --
    -- Tokens that begin with the __:__ character are /expression attribute
    -- values/, which are placeholders for the actual value at runtime.
    --
    -- For more information on expression attribute names, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe (HashMap Text Text)
expressionAttributeNames :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A string that contains conditions that DynamoDB applies after the @Scan@
    -- operation, but before the data is returned to you. Items that do not
    -- satisfy the @FilterExpression@ criteria are not returned.
    --
    -- A @FilterExpression@ is applied after the items have already been read;
    -- the process of filtering does not consume any additional read capacity
    -- units.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults Filter Expressions>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe Text
filterExpression :: Prelude.Maybe Prelude.Text,
    -- | A Boolean value that determines the read consistency model during the
    -- scan:
    --
    -- -   If @ConsistentRead@ is @false@, then the data returned from @Scan@
    --     might not contain the results from other recently completed write
    --     operations (@PutItem@, @UpdateItem@, or @DeleteItem@).
    --
    -- -   If @ConsistentRead@ is @true@, then all of the write operations that
    --     completed before the @Scan@ began are guaranteed to be contained in
    --     the @Scan@ response.
    --
    -- The default setting for @ConsistentRead@ is @false@.
    --
    -- The @ConsistentRead@ parameter is not supported on global secondary
    -- indexes. If you scan a global secondary index with @ConsistentRead@ set
    -- to true, you will receive a @ValidationException@.
    Scan -> Maybe Bool
consistentRead :: Prelude.Maybe Prelude.Bool,
    -- | One or more values that can be substituted in an expression.
    --
    -- Use the __:__ (colon) character in an expression to dereference an
    -- attribute value. For example, suppose that you wanted to check whether
    -- the value of the @ProductStatus@ attribute was one of the following:
    --
    -- @Available | Backordered | Discontinued@
    --
    -- You would first need to specify @ExpressionAttributeValues@ as follows:
    --
    -- @{ \":avail\":{\"S\":\"Available\"}, \":back\":{\"S\":\"Backordered\"}, \":disc\":{\"S\":\"Discontinued\"} }@
    --
    -- You could then use these values in an expression, such as this:
    --
    -- @ProductStatus IN (:avail, :back, :disc)@
    --
    -- For more information on expression attribute values, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html Condition Expressions>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    Scan -> Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Prelude.Maybe ReturnConsumedCapacity,
    -- | The maximum number of items to evaluate (not necessarily the number of
    -- matching items). If DynamoDB processes the number of items up to the
    -- limit while processing the results, it stops the operation and returns
    -- the matching values up to that point, and a key in @LastEvaluatedKey@ to
    -- apply in a subsequent operation, so that you can pick up where you left
    -- off. Also, if the processed dataset size exceeds 1 MB before DynamoDB
    -- reaches this limit, it stops the operation and returns the matching
    -- values up to the limit, and a key in @LastEvaluatedKey@ to apply in a
    -- subsequent operation to continue the operation. For more information,
    -- see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html Working with Queries>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe Natural
limit :: Prelude.Maybe Prelude.Natural,
    -- | The attributes to be returned in the result. You can retrieve all item
    -- attributes, specific item attributes, the count of matching items, or in
    -- the case of an index, some or all of the attributes projected into the
    -- index.
    --
    -- -   @ALL_ATTRIBUTES@ - Returns all of the item attributes from the
    --     specified table or index. If you query a local secondary index, then
    --     for each matching item in the index, DynamoDB fetches the entire
    --     item from the parent table. If the index is configured to project
    --     all item attributes, then all of the data can be obtained from the
    --     local secondary index, and no fetching is required.
    --
    -- -   @ALL_PROJECTED_ATTRIBUTES@ - Allowed only when querying an index.
    --     Retrieves all attributes that have been projected into the index. If
    --     the index is configured to project all attributes, this return value
    --     is equivalent to specifying @ALL_ATTRIBUTES@.
    --
    -- -   @COUNT@ - Returns the number of matching items, rather than the
    --     matching items themselves.
    --
    -- -   @SPECIFIC_ATTRIBUTES@ - Returns only the attributes listed in
    --     @AttributesToGet@. This return value is equivalent to specifying
    --     @AttributesToGet@ without specifying any value for @Select@.
    --
    --     If you query or scan a local secondary index and request only
    --     attributes that are projected into that index, the operation reads
    --     only the index and not the table. If any of the requested attributes
    --     are not projected into the local secondary index, DynamoDB fetches
    --     each of these attributes from the parent table. This extra fetching
    --     incurs additional throughput cost and latency.
    --
    --     If you query or scan a global secondary index, you can only request
    --     attributes that are projected into the index. Global secondary index
    --     queries cannot fetch attributes from the parent table.
    --
    -- If neither @Select@ nor @AttributesToGet@ are specified, DynamoDB
    -- defaults to @ALL_ATTRIBUTES@ when accessing a table, and
    -- @ALL_PROJECTED_ATTRIBUTES@ when accessing an index. You cannot use both
    -- @Select@ and @AttributesToGet@ together in a single request, unless the
    -- value for @Select@ is @SPECIFIC_ATTRIBUTES@. (This usage is equivalent
    -- to specifying @AttributesToGet@ without any value for @Select@.)
    --
    -- If you use the @ProjectionExpression@ parameter, then the value for
    -- @Select@ can only be @SPECIFIC_ATTRIBUTES@. Any other value for @Select@
    -- will return an error.
    Scan -> Maybe Select
select :: Prelude.Maybe Select,
    -- | For a parallel @Scan@ request, @Segment@ identifies an individual
    -- segment to be scanned by an application worker.
    --
    -- Segment IDs are zero-based, so the first segment is always 0. For
    -- example, if you want to use four application threads to scan a table or
    -- an index, then the first thread specifies a @Segment@ value of 0, the
    -- second thread specifies 1, and so on.
    --
    -- The value of @LastEvaluatedKey@ returned from a parallel @Scan@ request
    -- must be used as @ExclusiveStartKey@ with the same segment ID in a
    -- subsequent @Scan@ operation.
    --
    -- The value for @Segment@ must be greater than or equal to 0, and less
    -- than the value provided for @TotalSegments@.
    --
    -- If you provide @Segment@, you must also provide @TotalSegments@.
    Scan -> Maybe Natural
segment :: Prelude.Maybe Prelude.Natural,
    -- | This is a legacy parameter. Use @FilterExpression@ instead. For more
    -- information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html ConditionalOperator>
    -- in the /Amazon DynamoDB Developer Guide/.
    Scan -> Maybe ConditionalOperator
conditionalOperator :: Prelude.Maybe ConditionalOperator,
    -- | The primary key of the first item that this operation will evaluate. Use
    -- the value that was returned for @LastEvaluatedKey@ in the previous
    -- operation.
    --
    -- The data type for @ExclusiveStartKey@ must be String, Number or Binary.
    -- No set data types are allowed.
    --
    -- In a parallel scan, a @Scan@ request that includes @ExclusiveStartKey@
    -- must specify the same segment whose previous @Scan@ returned the
    -- corresponding value of @LastEvaluatedKey@.
    Scan -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    -- | The name of a secondary index to scan. This index can be any local
    -- secondary index or global secondary index. Note that if you use the
    -- @IndexName@ parameter, you must also provide @TableName@.
    Scan -> Maybe Text
indexName :: Prelude.Maybe Prelude.Text,
    -- | The name of the table containing the requested items; or, if you provide
    -- @IndexName@, the name of the table to which that index belongs.
    Scan -> Text
tableName :: Prelude.Text
  }
  deriving (Scan -> Scan -> Bool
(Scan -> Scan -> Bool) -> (Scan -> Scan -> Bool) -> Eq Scan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Scan -> Scan -> Bool
$c/= :: Scan -> Scan -> Bool
== :: Scan -> Scan -> Bool
$c== :: Scan -> Scan -> Bool
Prelude.Eq, ReadPrec [Scan]
ReadPrec Scan
Int -> ReadS Scan
ReadS [Scan]
(Int -> ReadS Scan)
-> ReadS [Scan] -> ReadPrec Scan -> ReadPrec [Scan] -> Read Scan
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Scan]
$creadListPrec :: ReadPrec [Scan]
readPrec :: ReadPrec Scan
$creadPrec :: ReadPrec Scan
readList :: ReadS [Scan]
$creadList :: ReadS [Scan]
readsPrec :: Int -> ReadS Scan
$creadsPrec :: Int -> ReadS Scan
Prelude.Read, Int -> Scan -> ShowS
[Scan] -> ShowS
Scan -> String
(Int -> Scan -> ShowS)
-> (Scan -> String) -> ([Scan] -> ShowS) -> Show Scan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Scan] -> ShowS
$cshowList :: [Scan] -> ShowS
show :: Scan -> String
$cshow :: Scan -> String
showsPrec :: Int -> Scan -> ShowS
$cshowsPrec :: Int -> Scan -> ShowS
Prelude.Show, (forall x. Scan -> Rep Scan x)
-> (forall x. Rep Scan x -> Scan) -> Generic Scan
forall x. Rep Scan x -> Scan
forall x. Scan -> Rep Scan x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Scan x -> Scan
$cfrom :: forall x. Scan -> Rep Scan x
Prelude.Generic)

-- |
-- Create a value of 'Scan' 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:
--
-- 'projectionExpression', 'scan_projectionExpression' - A string that identifies one or more attributes to retrieve from the
-- specified table or index. These attributes can include scalars, sets, or
-- elements of a JSON document. The attributes in the expression must be
-- separated by commas.
--
-- If no attribute names are specified, then all attributes will be
-- returned. If any of the requested attributes are not found, they will
-- not appear in the result.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'scanFilter', 'scan_scanFilter' - This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html ScanFilter>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'attributesToGet', 'scan_attributesToGet' - This is a legacy parameter. Use @ProjectionExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'totalSegments', 'scan_totalSegments' - For a parallel @Scan@ request, @TotalSegments@ represents the total
-- number of segments into which the @Scan@ operation will be divided. The
-- value of @TotalSegments@ corresponds to the number of application
-- workers that will perform the parallel scan. For example, if you want to
-- use four application threads to scan a table or an index, specify a
-- @TotalSegments@ value of 4.
--
-- The value for @TotalSegments@ must be greater than or equal to 1, and
-- less than or equal to 1000000. If you specify a @TotalSegments@ value of
-- 1, the @Scan@ operation will be sequential rather than parallel.
--
-- If you specify @TotalSegments@, you must also specify @Segment@.
--
-- 'expressionAttributeNames', 'scan_expressionAttributeNames' - One or more substitution tokens for attribute names in an expression.
-- The following are some use cases for using @ExpressionAttributeNames@:
--
-- -   To access an attribute whose name conflicts with a DynamoDB reserved
--     word.
--
-- -   To create a placeholder for repeating occurrences of an attribute
--     name in an expression.
--
-- -   To prevent special characters in an attribute name from being
--     misinterpreted in an expression.
--
-- Use the __#__ character in an expression to dereference an attribute
-- name. For example, consider the following attribute name:
--
-- -   @Percentile@
--
-- The name of this attribute conflicts with a reserved word, so it cannot
-- be used directly in an expression. (For the complete list of reserved
-- words, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
-- in the /Amazon DynamoDB Developer Guide/). To work around this, you
-- could specify the following for @ExpressionAttributeNames@:
--
-- -   @{\"#P\":\"Percentile\"}@
--
-- You could then use this substitution in an expression, as in this
-- example:
--
-- -   @#P = :val@
--
-- Tokens that begin with the __:__ character are /expression attribute
-- values/, which are placeholders for the actual value at runtime.
--
-- For more information on expression attribute names, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'filterExpression', 'scan_filterExpression' - A string that contains conditions that DynamoDB applies after the @Scan@
-- operation, but before the data is returned to you. Items that do not
-- satisfy the @FilterExpression@ criteria are not returned.
--
-- A @FilterExpression@ is applied after the items have already been read;
-- the process of filtering does not consume any additional read capacity
-- units.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults Filter Expressions>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'consistentRead', 'scan_consistentRead' - A Boolean value that determines the read consistency model during the
-- scan:
--
-- -   If @ConsistentRead@ is @false@, then the data returned from @Scan@
--     might not contain the results from other recently completed write
--     operations (@PutItem@, @UpdateItem@, or @DeleteItem@).
--
-- -   If @ConsistentRead@ is @true@, then all of the write operations that
--     completed before the @Scan@ began are guaranteed to be contained in
--     the @Scan@ response.
--
-- The default setting for @ConsistentRead@ is @false@.
--
-- The @ConsistentRead@ parameter is not supported on global secondary
-- indexes. If you scan a global secondary index with @ConsistentRead@ set
-- to true, you will receive a @ValidationException@.
--
-- 'expressionAttributeValues', 'scan_expressionAttributeValues' - One or more values that can be substituted in an expression.
--
-- Use the __:__ (colon) character in an expression to dereference an
-- attribute value. For example, suppose that you wanted to check whether
-- the value of the @ProductStatus@ attribute was one of the following:
--
-- @Available | Backordered | Discontinued@
--
-- You would first need to specify @ExpressionAttributeValues@ as follows:
--
-- @{ \":avail\":{\"S\":\"Available\"}, \":back\":{\"S\":\"Backordered\"}, \":disc\":{\"S\":\"Discontinued\"} }@
--
-- You could then use these values in an expression, such as this:
--
-- @ProductStatus IN (:avail, :back, :disc)@
--
-- For more information on expression attribute values, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html Condition Expressions>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'returnConsumedCapacity', 'scan_returnConsumedCapacity' - Undocumented member.
--
-- 'limit', 'scan_limit' - The maximum number of items to evaluate (not necessarily the number of
-- matching items). If DynamoDB processes the number of items up to the
-- limit while processing the results, it stops the operation and returns
-- the matching values up to that point, and a key in @LastEvaluatedKey@ to
-- apply in a subsequent operation, so that you can pick up where you left
-- off. Also, if the processed dataset size exceeds 1 MB before DynamoDB
-- reaches this limit, it stops the operation and returns the matching
-- values up to the limit, and a key in @LastEvaluatedKey@ to apply in a
-- subsequent operation to continue the operation. For more information,
-- see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html Working with Queries>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'select', 'scan_select' - The attributes to be returned in the result. You can retrieve all item
-- attributes, specific item attributes, the count of matching items, or in
-- the case of an index, some or all of the attributes projected into the
-- index.
--
-- -   @ALL_ATTRIBUTES@ - Returns all of the item attributes from the
--     specified table or index. If you query a local secondary index, then
--     for each matching item in the index, DynamoDB fetches the entire
--     item from the parent table. If the index is configured to project
--     all item attributes, then all of the data can be obtained from the
--     local secondary index, and no fetching is required.
--
-- -   @ALL_PROJECTED_ATTRIBUTES@ - Allowed only when querying an index.
--     Retrieves all attributes that have been projected into the index. If
--     the index is configured to project all attributes, this return value
--     is equivalent to specifying @ALL_ATTRIBUTES@.
--
-- -   @COUNT@ - Returns the number of matching items, rather than the
--     matching items themselves.
--
-- -   @SPECIFIC_ATTRIBUTES@ - Returns only the attributes listed in
--     @AttributesToGet@. This return value is equivalent to specifying
--     @AttributesToGet@ without specifying any value for @Select@.
--
--     If you query or scan a local secondary index and request only
--     attributes that are projected into that index, the operation reads
--     only the index and not the table. If any of the requested attributes
--     are not projected into the local secondary index, DynamoDB fetches
--     each of these attributes from the parent table. This extra fetching
--     incurs additional throughput cost and latency.
--
--     If you query or scan a global secondary index, you can only request
--     attributes that are projected into the index. Global secondary index
--     queries cannot fetch attributes from the parent table.
--
-- If neither @Select@ nor @AttributesToGet@ are specified, DynamoDB
-- defaults to @ALL_ATTRIBUTES@ when accessing a table, and
-- @ALL_PROJECTED_ATTRIBUTES@ when accessing an index. You cannot use both
-- @Select@ and @AttributesToGet@ together in a single request, unless the
-- value for @Select@ is @SPECIFIC_ATTRIBUTES@. (This usage is equivalent
-- to specifying @AttributesToGet@ without any value for @Select@.)
--
-- If you use the @ProjectionExpression@ parameter, then the value for
-- @Select@ can only be @SPECIFIC_ATTRIBUTES@. Any other value for @Select@
-- will return an error.
--
-- 'segment', 'scan_segment' - For a parallel @Scan@ request, @Segment@ identifies an individual
-- segment to be scanned by an application worker.
--
-- Segment IDs are zero-based, so the first segment is always 0. For
-- example, if you want to use four application threads to scan a table or
-- an index, then the first thread specifies a @Segment@ value of 0, the
-- second thread specifies 1, and so on.
--
-- The value of @LastEvaluatedKey@ returned from a parallel @Scan@ request
-- must be used as @ExclusiveStartKey@ with the same segment ID in a
-- subsequent @Scan@ operation.
--
-- The value for @Segment@ must be greater than or equal to 0, and less
-- than the value provided for @TotalSegments@.
--
-- If you provide @Segment@, you must also provide @TotalSegments@.
--
-- 'conditionalOperator', 'scan_conditionalOperator' - This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html ConditionalOperator>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'exclusiveStartKey', 'scan_exclusiveStartKey' - The primary key of the first item that this operation will evaluate. Use
-- the value that was returned for @LastEvaluatedKey@ in the previous
-- operation.
--
-- The data type for @ExclusiveStartKey@ must be String, Number or Binary.
-- No set data types are allowed.
--
-- In a parallel scan, a @Scan@ request that includes @ExclusiveStartKey@
-- must specify the same segment whose previous @Scan@ returned the
-- corresponding value of @LastEvaluatedKey@.
--
-- 'indexName', 'scan_indexName' - The name of a secondary index to scan. This index can be any local
-- secondary index or global secondary index. Note that if you use the
-- @IndexName@ parameter, you must also provide @TableName@.
--
-- 'tableName', 'scan_tableName' - The name of the table containing the requested items; or, if you provide
-- @IndexName@, the name of the table to which that index belongs.
newScan ::
  -- | 'tableName'
  Prelude.Text ->
  Scan
newScan :: Text -> Scan
newScan Text
pTableName_ =
  Scan' :: Maybe Text
-> Maybe (HashMap Text Condition)
-> Maybe (NonEmpty Text)
-> Maybe Natural
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe Bool
-> Maybe (HashMap Text AttributeValue)
-> Maybe ReturnConsumedCapacity
-> Maybe Natural
-> Maybe Select
-> Maybe Natural
-> Maybe ConditionalOperator
-> Maybe (HashMap Text AttributeValue)
-> Maybe Text
-> Text
-> Scan
Scan'
    { $sel:projectionExpression:Scan' :: Maybe Text
projectionExpression = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:scanFilter:Scan' :: Maybe (HashMap Text Condition)
scanFilter = Maybe (HashMap Text Condition)
forall a. Maybe a
Prelude.Nothing,
      $sel:attributesToGet:Scan' :: Maybe (NonEmpty Text)
attributesToGet = Maybe (NonEmpty Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:totalSegments:Scan' :: Maybe Natural
totalSegments = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:expressionAttributeNames:Scan' :: Maybe (HashMap Text Text)
expressionAttributeNames = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:filterExpression:Scan' :: Maybe Text
filterExpression = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:consistentRead:Scan' :: Maybe Bool
consistentRead = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:expressionAttributeValues:Scan' :: Maybe (HashMap Text AttributeValue)
expressionAttributeValues = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:returnConsumedCapacity:Scan' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:limit:Scan' :: Maybe Natural
limit = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:select:Scan' :: Maybe Select
select = Maybe Select
forall a. Maybe a
Prelude.Nothing,
      $sel:segment:Scan' :: Maybe Natural
segment = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:conditionalOperator:Scan' :: Maybe ConditionalOperator
conditionalOperator = Maybe ConditionalOperator
forall a. Maybe a
Prelude.Nothing,
      $sel:exclusiveStartKey:Scan' :: Maybe (HashMap Text AttributeValue)
exclusiveStartKey = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:indexName:Scan' :: Maybe Text
indexName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tableName:Scan' :: Text
tableName = Text
pTableName_
    }

-- | A string that identifies one or more attributes to retrieve from the
-- specified table or index. These attributes can include scalars, sets, or
-- elements of a JSON document. The attributes in the expression must be
-- separated by commas.
--
-- If no attribute names are specified, then all attributes will be
-- returned. If any of the requested attributes are not found, they will
-- not appear in the result.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
scan_projectionExpression :: Lens.Lens' Scan (Prelude.Maybe Prelude.Text)
scan_projectionExpression :: (Maybe Text -> f (Maybe Text)) -> Scan -> f Scan
scan_projectionExpression = (Scan -> Maybe Text)
-> (Scan -> Maybe Text -> Scan)
-> Lens Scan Scan (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Text
projectionExpression :: Maybe Text
$sel:projectionExpression:Scan' :: Scan -> Maybe Text
projectionExpression} -> Maybe Text
projectionExpression) (\s :: Scan
s@Scan' {} Maybe Text
a -> Scan
s {$sel:projectionExpression:Scan' :: Maybe Text
projectionExpression = Maybe Text
a} :: Scan)

-- | This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html ScanFilter>
-- in the /Amazon DynamoDB Developer Guide/.
scan_scanFilter :: Lens.Lens' Scan (Prelude.Maybe (Prelude.HashMap Prelude.Text Condition))
scan_scanFilter :: (Maybe (HashMap Text Condition)
 -> f (Maybe (HashMap Text Condition)))
-> Scan -> f Scan
scan_scanFilter = (Scan -> Maybe (HashMap Text Condition))
-> (Scan -> Maybe (HashMap Text Condition) -> Scan)
-> Lens
     Scan
     Scan
     (Maybe (HashMap Text Condition))
     (Maybe (HashMap Text Condition))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe (HashMap Text Condition)
scanFilter :: Maybe (HashMap Text Condition)
$sel:scanFilter:Scan' :: Scan -> Maybe (HashMap Text Condition)
scanFilter} -> Maybe (HashMap Text Condition)
scanFilter) (\s :: Scan
s@Scan' {} Maybe (HashMap Text Condition)
a -> Scan
s {$sel:scanFilter:Scan' :: Maybe (HashMap Text Condition)
scanFilter = Maybe (HashMap Text Condition)
a} :: Scan) ((Maybe (HashMap Text Condition)
  -> f (Maybe (HashMap Text Condition)))
 -> Scan -> f Scan)
-> ((Maybe (HashMap Text Condition)
     -> f (Maybe (HashMap Text Condition)))
    -> Maybe (HashMap Text Condition)
    -> f (Maybe (HashMap Text Condition)))
-> (Maybe (HashMap Text Condition)
    -> f (Maybe (HashMap Text Condition)))
-> Scan
-> f Scan
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Condition)
  (HashMap Text Condition)
  (HashMap Text Condition)
  (HashMap Text Condition)
-> Iso
     (Maybe (HashMap Text Condition))
     (Maybe (HashMap Text Condition))
     (Maybe (HashMap Text Condition))
     (Maybe (HashMap Text Condition))
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 AnIso
  (HashMap Text Condition)
  (HashMap Text Condition)
  (HashMap Text Condition)
  (HashMap Text Condition)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | This is a legacy parameter. Use @ProjectionExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html AttributesToGet>
-- in the /Amazon DynamoDB Developer Guide/.
scan_attributesToGet :: Lens.Lens' Scan (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
scan_attributesToGet :: (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> Scan -> f Scan
scan_attributesToGet = (Scan -> Maybe (NonEmpty Text))
-> (Scan -> Maybe (NonEmpty Text) -> Scan)
-> Lens Scan Scan (Maybe (NonEmpty Text)) (Maybe (NonEmpty Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe (NonEmpty Text)
attributesToGet :: Maybe (NonEmpty Text)
$sel:attributesToGet:Scan' :: Scan -> Maybe (NonEmpty Text)
attributesToGet} -> Maybe (NonEmpty Text)
attributesToGet) (\s :: Scan
s@Scan' {} Maybe (NonEmpty Text)
a -> Scan
s {$sel:attributesToGet:Scan' :: Maybe (NonEmpty Text)
attributesToGet = Maybe (NonEmpty Text)
a} :: Scan) ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
 -> Scan -> f Scan)
-> ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
    -> Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> Scan
-> f Scan
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
-> Iso
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
     (Maybe (NonEmpty Text))
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 AnIso
  (NonEmpty Text) (NonEmpty Text) (NonEmpty Text) (NonEmpty Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | For a parallel @Scan@ request, @TotalSegments@ represents the total
-- number of segments into which the @Scan@ operation will be divided. The
-- value of @TotalSegments@ corresponds to the number of application
-- workers that will perform the parallel scan. For example, if you want to
-- use four application threads to scan a table or an index, specify a
-- @TotalSegments@ value of 4.
--
-- The value for @TotalSegments@ must be greater than or equal to 1, and
-- less than or equal to 1000000. If you specify a @TotalSegments@ value of
-- 1, the @Scan@ operation will be sequential rather than parallel.
--
-- If you specify @TotalSegments@, you must also specify @Segment@.
scan_totalSegments :: Lens.Lens' Scan (Prelude.Maybe Prelude.Natural)
scan_totalSegments :: (Maybe Natural -> f (Maybe Natural)) -> Scan -> f Scan
scan_totalSegments = (Scan -> Maybe Natural)
-> (Scan -> Maybe Natural -> Scan)
-> Lens Scan Scan (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Natural
totalSegments :: Maybe Natural
$sel:totalSegments:Scan' :: Scan -> Maybe Natural
totalSegments} -> Maybe Natural
totalSegments) (\s :: Scan
s@Scan' {} Maybe Natural
a -> Scan
s {$sel:totalSegments:Scan' :: Maybe Natural
totalSegments = Maybe Natural
a} :: Scan)

-- | One or more substitution tokens for attribute names in an expression.
-- The following are some use cases for using @ExpressionAttributeNames@:
--
-- -   To access an attribute whose name conflicts with a DynamoDB reserved
--     word.
--
-- -   To create a placeholder for repeating occurrences of an attribute
--     name in an expression.
--
-- -   To prevent special characters in an attribute name from being
--     misinterpreted in an expression.
--
-- Use the __#__ character in an expression to dereference an attribute
-- name. For example, consider the following attribute name:
--
-- -   @Percentile@
--
-- The name of this attribute conflicts with a reserved word, so it cannot
-- be used directly in an expression. (For the complete list of reserved
-- words, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
-- in the /Amazon DynamoDB Developer Guide/). To work around this, you
-- could specify the following for @ExpressionAttributeNames@:
--
-- -   @{\"#P\":\"Percentile\"}@
--
-- You could then use this substitution in an expression, as in this
-- example:
--
-- -   @#P = :val@
--
-- Tokens that begin with the __:__ character are /expression attribute
-- values/, which are placeholders for the actual value at runtime.
--
-- For more information on expression attribute names, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html Specifying Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
scan_expressionAttributeNames :: Lens.Lens' Scan (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
scan_expressionAttributeNames :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> Scan -> f Scan
scan_expressionAttributeNames = (Scan -> Maybe (HashMap Text Text))
-> (Scan -> Maybe (HashMap Text Text) -> Scan)
-> Lens
     Scan Scan (Maybe (HashMap Text Text)) (Maybe (HashMap Text Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe (HashMap Text Text)
expressionAttributeNames :: Maybe (HashMap Text Text)
$sel:expressionAttributeNames:Scan' :: Scan -> Maybe (HashMap Text Text)
expressionAttributeNames} -> Maybe (HashMap Text Text)
expressionAttributeNames) (\s :: Scan
s@Scan' {} Maybe (HashMap Text Text)
a -> Scan
s {$sel:expressionAttributeNames:Scan' :: Maybe (HashMap Text Text)
expressionAttributeNames = Maybe (HashMap Text Text)
a} :: Scan) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> Scan -> f Scan)
-> ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
    -> Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> Scan
-> f Scan
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
-> Iso
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
     (Maybe (HashMap Text Text))
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 AnIso
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
  (HashMap Text Text)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A string that contains conditions that DynamoDB applies after the @Scan@
-- operation, but before the data is returned to you. Items that do not
-- satisfy the @FilterExpression@ criteria are not returned.
--
-- A @FilterExpression@ is applied after the items have already been read;
-- the process of filtering does not consume any additional read capacity
-- units.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#FilteringResults Filter Expressions>
-- in the /Amazon DynamoDB Developer Guide/.
scan_filterExpression :: Lens.Lens' Scan (Prelude.Maybe Prelude.Text)
scan_filterExpression :: (Maybe Text -> f (Maybe Text)) -> Scan -> f Scan
scan_filterExpression = (Scan -> Maybe Text)
-> (Scan -> Maybe Text -> Scan)
-> Lens Scan Scan (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Text
filterExpression :: Maybe Text
$sel:filterExpression:Scan' :: Scan -> Maybe Text
filterExpression} -> Maybe Text
filterExpression) (\s :: Scan
s@Scan' {} Maybe Text
a -> Scan
s {$sel:filterExpression:Scan' :: Maybe Text
filterExpression = Maybe Text
a} :: Scan)

-- | A Boolean value that determines the read consistency model during the
-- scan:
--
-- -   If @ConsistentRead@ is @false@, then the data returned from @Scan@
--     might not contain the results from other recently completed write
--     operations (@PutItem@, @UpdateItem@, or @DeleteItem@).
--
-- -   If @ConsistentRead@ is @true@, then all of the write operations that
--     completed before the @Scan@ began are guaranteed to be contained in
--     the @Scan@ response.
--
-- The default setting for @ConsistentRead@ is @false@.
--
-- The @ConsistentRead@ parameter is not supported on global secondary
-- indexes. If you scan a global secondary index with @ConsistentRead@ set
-- to true, you will receive a @ValidationException@.
scan_consistentRead :: Lens.Lens' Scan (Prelude.Maybe Prelude.Bool)
scan_consistentRead :: (Maybe Bool -> f (Maybe Bool)) -> Scan -> f Scan
scan_consistentRead = (Scan -> Maybe Bool)
-> (Scan -> Maybe Bool -> Scan)
-> Lens Scan Scan (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Bool
consistentRead :: Maybe Bool
$sel:consistentRead:Scan' :: Scan -> Maybe Bool
consistentRead} -> Maybe Bool
consistentRead) (\s :: Scan
s@Scan' {} Maybe Bool
a -> Scan
s {$sel:consistentRead:Scan' :: Maybe Bool
consistentRead = Maybe Bool
a} :: Scan)

-- | One or more values that can be substituted in an expression.
--
-- Use the __:__ (colon) character in an expression to dereference an
-- attribute value. For example, suppose that you wanted to check whether
-- the value of the @ProductStatus@ attribute was one of the following:
--
-- @Available | Backordered | Discontinued@
--
-- You would first need to specify @ExpressionAttributeValues@ as follows:
--
-- @{ \":avail\":{\"S\":\"Available\"}, \":back\":{\"S\":\"Backordered\"}, \":disc\":{\"S\":\"Discontinued\"} }@
--
-- You could then use these values in an expression, such as this:
--
-- @ProductStatus IN (:avail, :back, :disc)@
--
-- For more information on expression attribute values, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html Condition Expressions>
-- in the /Amazon DynamoDB Developer Guide/.
scan_expressionAttributeValues :: Lens.Lens' Scan (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
scan_expressionAttributeValues :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> Scan -> f Scan
scan_expressionAttributeValues = (Scan -> Maybe (HashMap Text AttributeValue))
-> (Scan -> Maybe (HashMap Text AttributeValue) -> Scan)
-> Lens
     Scan
     Scan
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe (HashMap Text AttributeValue)
expressionAttributeValues :: Maybe (HashMap Text AttributeValue)
$sel:expressionAttributeValues:Scan' :: Scan -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues} -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues) (\s :: Scan
s@Scan' {} Maybe (HashMap Text AttributeValue)
a -> Scan
s {$sel:expressionAttributeValues:Scan' :: Maybe (HashMap Text AttributeValue)
expressionAttributeValues = Maybe (HashMap Text AttributeValue)
a} :: Scan) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> Scan -> f Scan)
-> ((Maybe (HashMap Text AttributeValue)
     -> f (Maybe (HashMap Text AttributeValue)))
    -> Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> (Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> Scan
-> f Scan
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
-> Iso
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
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 AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Undocumented member.
scan_returnConsumedCapacity :: Lens.Lens' Scan (Prelude.Maybe ReturnConsumedCapacity)
scan_returnConsumedCapacity :: (Maybe ReturnConsumedCapacity -> f (Maybe ReturnConsumedCapacity))
-> Scan -> f Scan
scan_returnConsumedCapacity = (Scan -> Maybe ReturnConsumedCapacity)
-> (Scan -> Maybe ReturnConsumedCapacity -> Scan)
-> Lens
     Scan
     Scan
     (Maybe ReturnConsumedCapacity)
     (Maybe ReturnConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:returnConsumedCapacity:Scan' :: Scan -> Maybe ReturnConsumedCapacity
returnConsumedCapacity} -> Maybe ReturnConsumedCapacity
returnConsumedCapacity) (\s :: Scan
s@Scan' {} Maybe ReturnConsumedCapacity
a -> Scan
s {$sel:returnConsumedCapacity:Scan' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
a} :: Scan)

-- | The maximum number of items to evaluate (not necessarily the number of
-- matching items). If DynamoDB processes the number of items up to the
-- limit while processing the results, it stops the operation and returns
-- the matching values up to that point, and a key in @LastEvaluatedKey@ to
-- apply in a subsequent operation, so that you can pick up where you left
-- off. Also, if the processed dataset size exceeds 1 MB before DynamoDB
-- reaches this limit, it stops the operation and returns the matching
-- values up to the limit, and a key in @LastEvaluatedKey@ to apply in a
-- subsequent operation to continue the operation. For more information,
-- see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html Working with Queries>
-- in the /Amazon DynamoDB Developer Guide/.
scan_limit :: Lens.Lens' Scan (Prelude.Maybe Prelude.Natural)
scan_limit :: (Maybe Natural -> f (Maybe Natural)) -> Scan -> f Scan
scan_limit = (Scan -> Maybe Natural)
-> (Scan -> Maybe Natural -> Scan)
-> Lens Scan Scan (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Natural
limit :: Maybe Natural
$sel:limit:Scan' :: Scan -> Maybe Natural
limit} -> Maybe Natural
limit) (\s :: Scan
s@Scan' {} Maybe Natural
a -> Scan
s {$sel:limit:Scan' :: Maybe Natural
limit = Maybe Natural
a} :: Scan)

-- | The attributes to be returned in the result. You can retrieve all item
-- attributes, specific item attributes, the count of matching items, or in
-- the case of an index, some or all of the attributes projected into the
-- index.
--
-- -   @ALL_ATTRIBUTES@ - Returns all of the item attributes from the
--     specified table or index. If you query a local secondary index, then
--     for each matching item in the index, DynamoDB fetches the entire
--     item from the parent table. If the index is configured to project
--     all item attributes, then all of the data can be obtained from the
--     local secondary index, and no fetching is required.
--
-- -   @ALL_PROJECTED_ATTRIBUTES@ - Allowed only when querying an index.
--     Retrieves all attributes that have been projected into the index. If
--     the index is configured to project all attributes, this return value
--     is equivalent to specifying @ALL_ATTRIBUTES@.
--
-- -   @COUNT@ - Returns the number of matching items, rather than the
--     matching items themselves.
--
-- -   @SPECIFIC_ATTRIBUTES@ - Returns only the attributes listed in
--     @AttributesToGet@. This return value is equivalent to specifying
--     @AttributesToGet@ without specifying any value for @Select@.
--
--     If you query or scan a local secondary index and request only
--     attributes that are projected into that index, the operation reads
--     only the index and not the table. If any of the requested attributes
--     are not projected into the local secondary index, DynamoDB fetches
--     each of these attributes from the parent table. This extra fetching
--     incurs additional throughput cost and latency.
--
--     If you query or scan a global secondary index, you can only request
--     attributes that are projected into the index. Global secondary index
--     queries cannot fetch attributes from the parent table.
--
-- If neither @Select@ nor @AttributesToGet@ are specified, DynamoDB
-- defaults to @ALL_ATTRIBUTES@ when accessing a table, and
-- @ALL_PROJECTED_ATTRIBUTES@ when accessing an index. You cannot use both
-- @Select@ and @AttributesToGet@ together in a single request, unless the
-- value for @Select@ is @SPECIFIC_ATTRIBUTES@. (This usage is equivalent
-- to specifying @AttributesToGet@ without any value for @Select@.)
--
-- If you use the @ProjectionExpression@ parameter, then the value for
-- @Select@ can only be @SPECIFIC_ATTRIBUTES@. Any other value for @Select@
-- will return an error.
scan_select :: Lens.Lens' Scan (Prelude.Maybe Select)
scan_select :: (Maybe Select -> f (Maybe Select)) -> Scan -> f Scan
scan_select = (Scan -> Maybe Select)
-> (Scan -> Maybe Select -> Scan)
-> Lens Scan Scan (Maybe Select) (Maybe Select)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Select
select :: Maybe Select
$sel:select:Scan' :: Scan -> Maybe Select
select} -> Maybe Select
select) (\s :: Scan
s@Scan' {} Maybe Select
a -> Scan
s {$sel:select:Scan' :: Maybe Select
select = Maybe Select
a} :: Scan)

-- | For a parallel @Scan@ request, @Segment@ identifies an individual
-- segment to be scanned by an application worker.
--
-- Segment IDs are zero-based, so the first segment is always 0. For
-- example, if you want to use four application threads to scan a table or
-- an index, then the first thread specifies a @Segment@ value of 0, the
-- second thread specifies 1, and so on.
--
-- The value of @LastEvaluatedKey@ returned from a parallel @Scan@ request
-- must be used as @ExclusiveStartKey@ with the same segment ID in a
-- subsequent @Scan@ operation.
--
-- The value for @Segment@ must be greater than or equal to 0, and less
-- than the value provided for @TotalSegments@.
--
-- If you provide @Segment@, you must also provide @TotalSegments@.
scan_segment :: Lens.Lens' Scan (Prelude.Maybe Prelude.Natural)
scan_segment :: (Maybe Natural -> f (Maybe Natural)) -> Scan -> f Scan
scan_segment = (Scan -> Maybe Natural)
-> (Scan -> Maybe Natural -> Scan)
-> Lens Scan Scan (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Natural
segment :: Maybe Natural
$sel:segment:Scan' :: Scan -> Maybe Natural
segment} -> Maybe Natural
segment) (\s :: Scan
s@Scan' {} Maybe Natural
a -> Scan
s {$sel:segment:Scan' :: Maybe Natural
segment = Maybe Natural
a} :: Scan)

-- | This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html ConditionalOperator>
-- in the /Amazon DynamoDB Developer Guide/.
scan_conditionalOperator :: Lens.Lens' Scan (Prelude.Maybe ConditionalOperator)
scan_conditionalOperator :: (Maybe ConditionalOperator -> f (Maybe ConditionalOperator))
-> Scan -> f Scan
scan_conditionalOperator = (Scan -> Maybe ConditionalOperator)
-> (Scan -> Maybe ConditionalOperator -> Scan)
-> Lens
     Scan Scan (Maybe ConditionalOperator) (Maybe ConditionalOperator)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe ConditionalOperator
conditionalOperator :: Maybe ConditionalOperator
$sel:conditionalOperator:Scan' :: Scan -> Maybe ConditionalOperator
conditionalOperator} -> Maybe ConditionalOperator
conditionalOperator) (\s :: Scan
s@Scan' {} Maybe ConditionalOperator
a -> Scan
s {$sel:conditionalOperator:Scan' :: Maybe ConditionalOperator
conditionalOperator = Maybe ConditionalOperator
a} :: Scan)

-- | The primary key of the first item that this operation will evaluate. Use
-- the value that was returned for @LastEvaluatedKey@ in the previous
-- operation.
--
-- The data type for @ExclusiveStartKey@ must be String, Number or Binary.
-- No set data types are allowed.
--
-- In a parallel scan, a @Scan@ request that includes @ExclusiveStartKey@
-- must specify the same segment whose previous @Scan@ returned the
-- corresponding value of @LastEvaluatedKey@.
scan_exclusiveStartKey :: Lens.Lens' Scan (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
scan_exclusiveStartKey :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> Scan -> f Scan
scan_exclusiveStartKey = (Scan -> Maybe (HashMap Text AttributeValue))
-> (Scan -> Maybe (HashMap Text AttributeValue) -> Scan)
-> Lens
     Scan
     Scan
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe (HashMap Text AttributeValue)
exclusiveStartKey :: Maybe (HashMap Text AttributeValue)
$sel:exclusiveStartKey:Scan' :: Scan -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey} -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey) (\s :: Scan
s@Scan' {} Maybe (HashMap Text AttributeValue)
a -> Scan
s {$sel:exclusiveStartKey:Scan' :: Maybe (HashMap Text AttributeValue)
exclusiveStartKey = Maybe (HashMap Text AttributeValue)
a} :: Scan) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> Scan -> f Scan)
-> ((Maybe (HashMap Text AttributeValue)
     -> f (Maybe (HashMap Text AttributeValue)))
    -> Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> (Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> Scan
-> f Scan
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
-> Iso
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
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 AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The name of a secondary index to scan. This index can be any local
-- secondary index or global secondary index. Note that if you use the
-- @IndexName@ parameter, you must also provide @TableName@.
scan_indexName :: Lens.Lens' Scan (Prelude.Maybe Prelude.Text)
scan_indexName :: (Maybe Text -> f (Maybe Text)) -> Scan -> f Scan
scan_indexName = (Scan -> Maybe Text)
-> (Scan -> Maybe Text -> Scan)
-> Lens Scan Scan (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Maybe Text
indexName :: Maybe Text
$sel:indexName:Scan' :: Scan -> Maybe Text
indexName} -> Maybe Text
indexName) (\s :: Scan
s@Scan' {} Maybe Text
a -> Scan
s {$sel:indexName:Scan' :: Maybe Text
indexName = Maybe Text
a} :: Scan)

-- | The name of the table containing the requested items; or, if you provide
-- @IndexName@, the name of the table to which that index belongs.
scan_tableName :: Lens.Lens' Scan Prelude.Text
scan_tableName :: (Text -> f Text) -> Scan -> f Scan
scan_tableName = (Scan -> Text)
-> (Scan -> Text -> Scan) -> Lens Scan Scan Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Scan' {Text
tableName :: Text
$sel:tableName:Scan' :: Scan -> Text
tableName} -> Text
tableName) (\s :: Scan
s@Scan' {} Text
a -> Scan
s {$sel:tableName:Scan' :: Text
tableName = Text
a} :: Scan)

instance Core.AWSPager Scan where
  page :: Scan -> AWSResponse Scan -> Maybe Scan
page Scan
rq AWSResponse Scan
rs
    | Maybe (HashMap Text AttributeValue) -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse Scan
ScanResponse
rs
            ScanResponse
-> Getting
     (First (HashMap Text AttributeValue))
     ScanResponse
     (HashMap Text AttributeValue)
-> Maybe (HashMap Text AttributeValue)
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe (HashMap Text AttributeValue)
 -> Const
      (First (HashMap Text AttributeValue))
      (Maybe (HashMap Text AttributeValue)))
-> ScanResponse
-> Const (First (HashMap Text AttributeValue)) ScanResponse
Lens' ScanResponse (Maybe (HashMap Text AttributeValue))
scanResponse_lastEvaluatedKey ((Maybe (HashMap Text AttributeValue)
  -> Const
       (First (HashMap Text AttributeValue))
       (Maybe (HashMap Text AttributeValue)))
 -> ScanResponse
 -> Const (First (HashMap Text AttributeValue)) ScanResponse)
-> ((HashMap Text AttributeValue
     -> Const
          (First (HashMap Text AttributeValue))
          (HashMap Text AttributeValue))
    -> Maybe (HashMap Text AttributeValue)
    -> Const
         (First (HashMap Text AttributeValue))
         (Maybe (HashMap Text AttributeValue)))
-> Getting
     (First (HashMap Text AttributeValue))
     ScanResponse
     (HashMap Text AttributeValue)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (HashMap Text AttributeValue
 -> Const
      (First (HashMap Text AttributeValue))
      (HashMap Text AttributeValue))
-> Maybe (HashMap Text AttributeValue)
-> Const
     (First (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just
        ) =
      Maybe Scan
forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
      Scan -> Maybe Scan
forall a. a -> Maybe a
Prelude.Just (Scan -> Maybe Scan) -> Scan -> Maybe Scan
forall a b. (a -> b) -> a -> b
Prelude.$
        Scan
rq
          Scan -> (Scan -> Scan) -> Scan
forall a b. a -> (a -> b) -> b
Prelude.& (Maybe (HashMap Text AttributeValue)
 -> Identity (Maybe (HashMap Text AttributeValue)))
-> Scan -> Identity Scan
Lens
  Scan
  Scan
  (Maybe (HashMap Text AttributeValue))
  (Maybe (HashMap Text AttributeValue))
scan_exclusiveStartKey
          ((Maybe (HashMap Text AttributeValue)
  -> Identity (Maybe (HashMap Text AttributeValue)))
 -> Scan -> Identity Scan)
-> Maybe (HashMap Text AttributeValue) -> Scan -> Scan
forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse Scan
ScanResponse
rs
          ScanResponse
-> Getting
     (First (HashMap Text AttributeValue))
     ScanResponse
     (HashMap Text AttributeValue)
-> Maybe (HashMap Text AttributeValue)
forall s a. s -> Getting (First a) s a -> Maybe a
Lens.^? (Maybe (HashMap Text AttributeValue)
 -> Const
      (First (HashMap Text AttributeValue))
      (Maybe (HashMap Text AttributeValue)))
-> ScanResponse
-> Const (First (HashMap Text AttributeValue)) ScanResponse
Lens' ScanResponse (Maybe (HashMap Text AttributeValue))
scanResponse_lastEvaluatedKey ((Maybe (HashMap Text AttributeValue)
  -> Const
       (First (HashMap Text AttributeValue))
       (Maybe (HashMap Text AttributeValue)))
 -> ScanResponse
 -> Const (First (HashMap Text AttributeValue)) ScanResponse)
-> ((HashMap Text AttributeValue
     -> Const
          (First (HashMap Text AttributeValue))
          (HashMap Text AttributeValue))
    -> Maybe (HashMap Text AttributeValue)
    -> Const
         (First (HashMap Text AttributeValue))
         (Maybe (HashMap Text AttributeValue)))
-> Getting
     (First (HashMap Text AttributeValue))
     ScanResponse
     (HashMap Text AttributeValue)
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. (HashMap Text AttributeValue
 -> Const
      (First (HashMap Text AttributeValue))
      (HashMap Text AttributeValue))
-> Maybe (HashMap Text AttributeValue)
-> Const
     (First (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
forall a b. Prism (Maybe a) (Maybe b) a b
Lens._Just

instance Core.AWSRequest Scan where
  type AWSResponse Scan = ScanResponse
  request :: Scan -> Request Scan
request = Service -> Scan -> Request Scan
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy Scan
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse Scan)))
response =
    (Int
 -> ResponseHeaders -> Object -> Either String (AWSResponse Scan))
-> Logger
-> Service
-> Proxy Scan
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse Scan)))
forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> Logger
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe (HashMap Text AttributeValue)
-> Maybe Int
-> Maybe Int
-> Maybe [HashMap Text AttributeValue]
-> Maybe ConsumedCapacity
-> Int
-> ScanResponse
ScanResponse'
            (Maybe (HashMap Text AttributeValue)
 -> Maybe Int
 -> Maybe Int
 -> Maybe [HashMap Text AttributeValue]
 -> Maybe ConsumedCapacity
 -> Int
 -> ScanResponse)
-> Either String (Maybe (HashMap Text AttributeValue))
-> Either
     String
     (Maybe Int
      -> Maybe Int
      -> Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity
      -> Int
      -> ScanResponse)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ( Object
x Object
-> Text
-> Either String (Maybe (Maybe (HashMap Text AttributeValue)))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"LastEvaluatedKey"
                            Either String (Maybe (Maybe (HashMap Text AttributeValue)))
-> Maybe (HashMap Text AttributeValue)
-> Either String (Maybe (HashMap Text AttributeValue))
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe (HashMap Text AttributeValue)
forall a. Monoid a => a
Prelude.mempty
                        )
            Either
  String
  (Maybe Int
   -> Maybe Int
   -> Maybe [HashMap Text AttributeValue]
   -> Maybe ConsumedCapacity
   -> Int
   -> ScanResponse)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe Int
      -> Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity
      -> Int
      -> ScanResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Int)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Count")
            Either
  String
  (Maybe Int
   -> Maybe [HashMap Text AttributeValue]
   -> Maybe ConsumedCapacity
   -> Int
   -> ScanResponse)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity -> Int -> ScanResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe Int)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"ScannedCount")
            Either
  String
  (Maybe [HashMap Text AttributeValue]
   -> Maybe ConsumedCapacity -> Int -> ScanResponse)
-> Either String (Maybe [HashMap Text AttributeValue])
-> Either String (Maybe ConsumedCapacity -> Int -> ScanResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object
-> Text
-> Either String (Maybe (Maybe [HashMap Text AttributeValue]))
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"Items" Either String (Maybe (Maybe [HashMap Text AttributeValue]))
-> Maybe [HashMap Text AttributeValue]
-> Either String (Maybe [HashMap Text AttributeValue])
forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ Maybe [HashMap Text AttributeValue]
forall a. Monoid a => a
Prelude.mempty)
            Either String (Maybe ConsumedCapacity -> Int -> ScanResponse)
-> Either String (Maybe ConsumedCapacity)
-> Either String (Int -> ScanResponse)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Either String (Maybe ConsumedCapacity)
forall a. FromJSON a => Object -> Text -> Either String (Maybe a)
Core..?> Text
"ConsumedCapacity")
            Either String (Int -> ScanResponse)
-> Either String Int -> Either String ScanResponse
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Int -> Either String Int
forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (Int -> Int
forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable Scan

instance Prelude.NFData Scan

instance Core.ToHeaders Scan where
  toHeaders :: Scan -> ResponseHeaders
toHeaders =
    ResponseHeaders -> Scan -> ResponseHeaders
forall a b. a -> b -> a
Prelude.const
      ( [ResponseHeaders] -> ResponseHeaders
forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# (ByteString
"DynamoDB_20120810.Scan" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              HeaderName -> ByteString -> ResponseHeaders
forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Core.=# ( ByteString
"application/x-amz-json-1.0" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Core.ToJSON Scan where
  toJSON :: Scan -> Value
toJSON Scan' {Maybe Bool
Maybe Natural
Maybe (NonEmpty Text)
Maybe Text
Maybe (HashMap Text Text)
Maybe (HashMap Text AttributeValue)
Maybe (HashMap Text Condition)
Maybe ConditionalOperator
Maybe ReturnConsumedCapacity
Maybe Select
Text
tableName :: Text
indexName :: Maybe Text
exclusiveStartKey :: Maybe (HashMap Text AttributeValue)
conditionalOperator :: Maybe ConditionalOperator
segment :: Maybe Natural
select :: Maybe Select
limit :: Maybe Natural
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
expressionAttributeValues :: Maybe (HashMap Text AttributeValue)
consistentRead :: Maybe Bool
filterExpression :: Maybe Text
expressionAttributeNames :: Maybe (HashMap Text Text)
totalSegments :: Maybe Natural
attributesToGet :: Maybe (NonEmpty Text)
scanFilter :: Maybe (HashMap Text Condition)
projectionExpression :: Maybe Text
$sel:tableName:Scan' :: Scan -> Text
$sel:indexName:Scan' :: Scan -> Maybe Text
$sel:exclusiveStartKey:Scan' :: Scan -> Maybe (HashMap Text AttributeValue)
$sel:conditionalOperator:Scan' :: Scan -> Maybe ConditionalOperator
$sel:segment:Scan' :: Scan -> Maybe Natural
$sel:select:Scan' :: Scan -> Maybe Select
$sel:limit:Scan' :: Scan -> Maybe Natural
$sel:returnConsumedCapacity:Scan' :: Scan -> Maybe ReturnConsumedCapacity
$sel:expressionAttributeValues:Scan' :: Scan -> Maybe (HashMap Text AttributeValue)
$sel:consistentRead:Scan' :: Scan -> Maybe Bool
$sel:filterExpression:Scan' :: Scan -> Maybe Text
$sel:expressionAttributeNames:Scan' :: Scan -> Maybe (HashMap Text Text)
$sel:totalSegments:Scan' :: Scan -> Maybe Natural
$sel:attributesToGet:Scan' :: Scan -> Maybe (NonEmpty Text)
$sel:scanFilter:Scan' :: Scan -> Maybe (HashMap Text Condition)
$sel:projectionExpression:Scan' :: Scan -> Maybe Text
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"ProjectionExpression" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
projectionExpression,
            (Text
"ScanFilter" Text -> HashMap Text Condition -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (HashMap Text Condition -> Pair)
-> Maybe (HashMap Text Condition) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Condition)
scanFilter,
            (Text
"AttributesToGet" Text -> NonEmpty Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NonEmpty Text -> Pair) -> Maybe (NonEmpty Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty Text)
attributesToGet,
            (Text
"TotalSegments" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
totalSegments,
            (Text
"ExpressionAttributeNames" Text -> HashMap Text Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (HashMap Text Text -> Pair)
-> Maybe (HashMap Text Text) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text Text)
expressionAttributeNames,
            (Text
"FilterExpression" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
filterExpression,
            (Text
"ConsistentRead" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Bool -> Pair) -> Maybe Bool -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Bool
consistentRead,
            (Text
"ExpressionAttributeValues" Text -> HashMap Text AttributeValue -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (HashMap Text AttributeValue -> Pair)
-> Maybe (HashMap Text AttributeValue) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text AttributeValue)
expressionAttributeValues,
            (Text
"ReturnConsumedCapacity" Text -> ReturnConsumedCapacity -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ReturnConsumedCapacity -> Pair)
-> Maybe ReturnConsumedCapacity -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ReturnConsumedCapacity
returnConsumedCapacity,
            (Text
"Limit" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
limit,
            (Text
"Select" Text -> Select -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Select -> Pair) -> Maybe Select -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Select
select,
            (Text
"Segment" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
segment,
            (Text
"ConditionalOperator" Text -> ConditionalOperator -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (ConditionalOperator -> Pair)
-> Maybe ConditionalOperator -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe ConditionalOperator
conditionalOperator,
            (Text
"ExclusiveStartKey" Text -> HashMap Text AttributeValue -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (HashMap Text AttributeValue -> Pair)
-> Maybe (HashMap Text AttributeValue) -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (HashMap Text AttributeValue)
exclusiveStartKey,
            (Text
"IndexName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Text -> Pair) -> Maybe Text -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Text
indexName,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just (Text
"TableName" Text -> Text -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Text
tableName)
          ]
      )

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

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

-- | Represents the output of a @Scan@ operation.
--
-- /See:/ 'newScanResponse' smart constructor.
data ScanResponse = ScanResponse'
  { -- | The primary key of the item where the operation stopped, inclusive of
    -- the previous result set. Use this value to start a new operation,
    -- excluding this value in the new request.
    --
    -- If @LastEvaluatedKey@ is empty, then the \"last page\" of results has
    -- been processed and there is no more data to be retrieved.
    --
    -- If @LastEvaluatedKey@ is not empty, it does not necessarily mean that
    -- there is more data in the result set. The only way to know when you have
    -- reached the end of the result set is when @LastEvaluatedKey@ is empty.
    ScanResponse -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    -- | The number of items in the response.
    --
    -- If you set @ScanFilter@ in the request, then @Count@ is the number of
    -- items returned after the filter was applied, and @ScannedCount@ is the
    -- number of matching items before the filter was applied.
    --
    -- If you did not use a filter in the request, then @Count@ is the same as
    -- @ScannedCount@.
    ScanResponse -> Maybe Int
count :: Prelude.Maybe Prelude.Int,
    -- | The number of items evaluated, before any @ScanFilter@ is applied. A
    -- high @ScannedCount@ value with few, or no, @Count@ results indicates an
    -- inefficient @Scan@ operation. For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#Count Count and ScannedCount>
    -- in the /Amazon DynamoDB Developer Guide/.
    --
    -- If you did not use a filter in the request, then @ScannedCount@ is the
    -- same as @Count@.
    ScanResponse -> Maybe Int
scannedCount :: Prelude.Maybe Prelude.Int,
    -- | An array of item attributes that match the scan criteria. Each element
    -- in this array consists of an attribute name and the value for that
    -- attribute.
    ScanResponse -> Maybe [HashMap Text AttributeValue]
items :: Prelude.Maybe [Prelude.HashMap Prelude.Text AttributeValue],
    -- | The capacity units consumed by the @Scan@ operation. The data returned
    -- includes the total provisioned throughput consumed, along with
    -- statistics for the table and any indexes involved in the operation.
    -- @ConsumedCapacity@ is only returned if the @ReturnConsumedCapacity@
    -- parameter was specified. For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html Provisioned Throughput>
    -- in the /Amazon DynamoDB Developer Guide/.
    ScanResponse -> Maybe ConsumedCapacity
consumedCapacity :: Prelude.Maybe ConsumedCapacity,
    -- | The response's http status code.
    ScanResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (ScanResponse -> ScanResponse -> Bool
(ScanResponse -> ScanResponse -> Bool)
-> (ScanResponse -> ScanResponse -> Bool) -> Eq ScanResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScanResponse -> ScanResponse -> Bool
$c/= :: ScanResponse -> ScanResponse -> Bool
== :: ScanResponse -> ScanResponse -> Bool
$c== :: ScanResponse -> ScanResponse -> Bool
Prelude.Eq, ReadPrec [ScanResponse]
ReadPrec ScanResponse
Int -> ReadS ScanResponse
ReadS [ScanResponse]
(Int -> ReadS ScanResponse)
-> ReadS [ScanResponse]
-> ReadPrec ScanResponse
-> ReadPrec [ScanResponse]
-> Read ScanResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ScanResponse]
$creadListPrec :: ReadPrec [ScanResponse]
readPrec :: ReadPrec ScanResponse
$creadPrec :: ReadPrec ScanResponse
readList :: ReadS [ScanResponse]
$creadList :: ReadS [ScanResponse]
readsPrec :: Int -> ReadS ScanResponse
$creadsPrec :: Int -> ReadS ScanResponse
Prelude.Read, Int -> ScanResponse -> ShowS
[ScanResponse] -> ShowS
ScanResponse -> String
(Int -> ScanResponse -> ShowS)
-> (ScanResponse -> String)
-> ([ScanResponse] -> ShowS)
-> Show ScanResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScanResponse] -> ShowS
$cshowList :: [ScanResponse] -> ShowS
show :: ScanResponse -> String
$cshow :: ScanResponse -> String
showsPrec :: Int -> ScanResponse -> ShowS
$cshowsPrec :: Int -> ScanResponse -> ShowS
Prelude.Show, (forall x. ScanResponse -> Rep ScanResponse x)
-> (forall x. Rep ScanResponse x -> ScanResponse)
-> Generic ScanResponse
forall x. Rep ScanResponse x -> ScanResponse
forall x. ScanResponse -> Rep ScanResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep ScanResponse x -> ScanResponse
$cfrom :: forall x. ScanResponse -> Rep ScanResponse x
Prelude.Generic)

-- |
-- Create a value of 'ScanResponse' 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:
--
-- 'lastEvaluatedKey', 'scanResponse_lastEvaluatedKey' - The primary key of the item where the operation stopped, inclusive of
-- the previous result set. Use this value to start a new operation,
-- excluding this value in the new request.
--
-- If @LastEvaluatedKey@ is empty, then the \"last page\" of results has
-- been processed and there is no more data to be retrieved.
--
-- If @LastEvaluatedKey@ is not empty, it does not necessarily mean that
-- there is more data in the result set. The only way to know when you have
-- reached the end of the result set is when @LastEvaluatedKey@ is empty.
--
-- 'count', 'scanResponse_count' - The number of items in the response.
--
-- If you set @ScanFilter@ in the request, then @Count@ is the number of
-- items returned after the filter was applied, and @ScannedCount@ is the
-- number of matching items before the filter was applied.
--
-- If you did not use a filter in the request, then @Count@ is the same as
-- @ScannedCount@.
--
-- 'scannedCount', 'scanResponse_scannedCount' - The number of items evaluated, before any @ScanFilter@ is applied. A
-- high @ScannedCount@ value with few, or no, @Count@ results indicates an
-- inefficient @Scan@ operation. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#Count Count and ScannedCount>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- If you did not use a filter in the request, then @ScannedCount@ is the
-- same as @Count@.
--
-- 'items', 'scanResponse_items' - An array of item attributes that match the scan criteria. Each element
-- in this array consists of an attribute name and the value for that
-- attribute.
--
-- 'consumedCapacity', 'scanResponse_consumedCapacity' - The capacity units consumed by the @Scan@ operation. The data returned
-- includes the total provisioned throughput consumed, along with
-- statistics for the table and any indexes involved in the operation.
-- @ConsumedCapacity@ is only returned if the @ReturnConsumedCapacity@
-- parameter was specified. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html Provisioned Throughput>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'httpStatus', 'scanResponse_httpStatus' - The response's http status code.
newScanResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  ScanResponse
newScanResponse :: Int -> ScanResponse
newScanResponse Int
pHttpStatus_ =
  ScanResponse' :: Maybe (HashMap Text AttributeValue)
-> Maybe Int
-> Maybe Int
-> Maybe [HashMap Text AttributeValue]
-> Maybe ConsumedCapacity
-> Int
-> ScanResponse
ScanResponse'
    { $sel:lastEvaluatedKey:ScanResponse' :: Maybe (HashMap Text AttributeValue)
lastEvaluatedKey = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:count:ScanResponse' :: Maybe Int
count = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:scannedCount:ScanResponse' :: Maybe Int
scannedCount = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:items:ScanResponse' :: Maybe [HashMap Text AttributeValue]
items = Maybe [HashMap Text AttributeValue]
forall a. Maybe a
Prelude.Nothing,
      $sel:consumedCapacity:ScanResponse' :: Maybe ConsumedCapacity
consumedCapacity = Maybe ConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:ScanResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The primary key of the item where the operation stopped, inclusive of
-- the previous result set. Use this value to start a new operation,
-- excluding this value in the new request.
--
-- If @LastEvaluatedKey@ is empty, then the \"last page\" of results has
-- been processed and there is no more data to be retrieved.
--
-- If @LastEvaluatedKey@ is not empty, it does not necessarily mean that
-- there is more data in the result set. The only way to know when you have
-- reached the end of the result set is when @LastEvaluatedKey@ is empty.
scanResponse_lastEvaluatedKey :: Lens.Lens' ScanResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
scanResponse_lastEvaluatedKey :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> ScanResponse -> f ScanResponse
scanResponse_lastEvaluatedKey = (ScanResponse -> Maybe (HashMap Text AttributeValue))
-> (ScanResponse
    -> Maybe (HashMap Text AttributeValue) -> ScanResponse)
-> Lens' ScanResponse (Maybe (HashMap Text AttributeValue))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ScanResponse' {Maybe (HashMap Text AttributeValue)
lastEvaluatedKey :: Maybe (HashMap Text AttributeValue)
$sel:lastEvaluatedKey:ScanResponse' :: ScanResponse -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey} -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey) (\s :: ScanResponse
s@ScanResponse' {} Maybe (HashMap Text AttributeValue)
a -> ScanResponse
s {$sel:lastEvaluatedKey:ScanResponse' :: Maybe (HashMap Text AttributeValue)
lastEvaluatedKey = Maybe (HashMap Text AttributeValue)
a} :: ScanResponse) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> ScanResponse -> f ScanResponse)
-> ((Maybe (HashMap Text AttributeValue)
     -> f (Maybe (HashMap Text AttributeValue)))
    -> Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> (Maybe (HashMap Text AttributeValue)
    -> f (Maybe (HashMap Text AttributeValue)))
-> ScanResponse
-> f ScanResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
-> Iso
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
     (Maybe (HashMap Text AttributeValue))
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 AnIso
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
  (HashMap Text AttributeValue)
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The number of items in the response.
--
-- If you set @ScanFilter@ in the request, then @Count@ is the number of
-- items returned after the filter was applied, and @ScannedCount@ is the
-- number of matching items before the filter was applied.
--
-- If you did not use a filter in the request, then @Count@ is the same as
-- @ScannedCount@.
scanResponse_count :: Lens.Lens' ScanResponse (Prelude.Maybe Prelude.Int)
scanResponse_count :: (Maybe Int -> f (Maybe Int)) -> ScanResponse -> f ScanResponse
scanResponse_count = (ScanResponse -> Maybe Int)
-> (ScanResponse -> Maybe Int -> ScanResponse)
-> Lens ScanResponse ScanResponse (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ScanResponse' {Maybe Int
count :: Maybe Int
$sel:count:ScanResponse' :: ScanResponse -> Maybe Int
count} -> Maybe Int
count) (\s :: ScanResponse
s@ScanResponse' {} Maybe Int
a -> ScanResponse
s {$sel:count:ScanResponse' :: Maybe Int
count = Maybe Int
a} :: ScanResponse)

-- | The number of items evaluated, before any @ScanFilter@ is applied. A
-- high @ScannedCount@ value with few, or no, @Count@ results indicates an
-- inefficient @Scan@ operation. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/QueryAndScan.html#Count Count and ScannedCount>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- If you did not use a filter in the request, then @ScannedCount@ is the
-- same as @Count@.
scanResponse_scannedCount :: Lens.Lens' ScanResponse (Prelude.Maybe Prelude.Int)
scanResponse_scannedCount :: (Maybe Int -> f (Maybe Int)) -> ScanResponse -> f ScanResponse
scanResponse_scannedCount = (ScanResponse -> Maybe Int)
-> (ScanResponse -> Maybe Int -> ScanResponse)
-> Lens ScanResponse ScanResponse (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ScanResponse' {Maybe Int
scannedCount :: Maybe Int
$sel:scannedCount:ScanResponse' :: ScanResponse -> Maybe Int
scannedCount} -> Maybe Int
scannedCount) (\s :: ScanResponse
s@ScanResponse' {} Maybe Int
a -> ScanResponse
s {$sel:scannedCount:ScanResponse' :: Maybe Int
scannedCount = Maybe Int
a} :: ScanResponse)

-- | An array of item attributes that match the scan criteria. Each element
-- in this array consists of an attribute name and the value for that
-- attribute.
scanResponse_items :: Lens.Lens' ScanResponse (Prelude.Maybe [Prelude.HashMap Prelude.Text AttributeValue])
scanResponse_items :: (Maybe [HashMap Text AttributeValue]
 -> f (Maybe [HashMap Text AttributeValue]))
-> ScanResponse -> f ScanResponse
scanResponse_items = (ScanResponse -> Maybe [HashMap Text AttributeValue])
-> (ScanResponse
    -> Maybe [HashMap Text AttributeValue] -> ScanResponse)
-> Lens
     ScanResponse
     ScanResponse
     (Maybe [HashMap Text AttributeValue])
     (Maybe [HashMap Text AttributeValue])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ScanResponse' {Maybe [HashMap Text AttributeValue]
items :: Maybe [HashMap Text AttributeValue]
$sel:items:ScanResponse' :: ScanResponse -> Maybe [HashMap Text AttributeValue]
items} -> Maybe [HashMap Text AttributeValue]
items) (\s :: ScanResponse
s@ScanResponse' {} Maybe [HashMap Text AttributeValue]
a -> ScanResponse
s {$sel:items:ScanResponse' :: Maybe [HashMap Text AttributeValue]
items = Maybe [HashMap Text AttributeValue]
a} :: ScanResponse) ((Maybe [HashMap Text AttributeValue]
  -> f (Maybe [HashMap Text AttributeValue]))
 -> ScanResponse -> f ScanResponse)
-> ((Maybe [HashMap Text AttributeValue]
     -> f (Maybe [HashMap Text AttributeValue]))
    -> Maybe [HashMap Text AttributeValue]
    -> f (Maybe [HashMap Text AttributeValue]))
-> (Maybe [HashMap Text AttributeValue]
    -> f (Maybe [HashMap Text AttributeValue]))
-> ScanResponse
-> f ScanResponse
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
-> Iso
     (Maybe [HashMap Text AttributeValue])
     (Maybe [HashMap Text AttributeValue])
     (Maybe [HashMap Text AttributeValue])
     (Maybe [HashMap Text AttributeValue])
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 AnIso
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
  [HashMap Text AttributeValue]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The capacity units consumed by the @Scan@ operation. The data returned
-- includes the total provisioned throughput consumed, along with
-- statistics for the table and any indexes involved in the operation.
-- @ConsumedCapacity@ is only returned if the @ReturnConsumedCapacity@
-- parameter was specified. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ProvisionedThroughputIntro.html Provisioned Throughput>
-- in the /Amazon DynamoDB Developer Guide/.
scanResponse_consumedCapacity :: Lens.Lens' ScanResponse (Prelude.Maybe ConsumedCapacity)
scanResponse_consumedCapacity :: (Maybe ConsumedCapacity -> f (Maybe ConsumedCapacity))
-> ScanResponse -> f ScanResponse
scanResponse_consumedCapacity = (ScanResponse -> Maybe ConsumedCapacity)
-> (ScanResponse -> Maybe ConsumedCapacity -> ScanResponse)
-> Lens
     ScanResponse
     ScanResponse
     (Maybe ConsumedCapacity)
     (Maybe ConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\ScanResponse' {Maybe ConsumedCapacity
consumedCapacity :: Maybe ConsumedCapacity
$sel:consumedCapacity:ScanResponse' :: ScanResponse -> Maybe ConsumedCapacity
consumedCapacity} -> Maybe ConsumedCapacity
consumedCapacity) (\s :: ScanResponse
s@ScanResponse' {} Maybe ConsumedCapacity
a -> ScanResponse
s {$sel:consumedCapacity:ScanResponse' :: Maybe ConsumedCapacity
consumedCapacity = Maybe ConsumedCapacity
a} :: ScanResponse)

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

instance Prelude.NFData ScanResponse