{-# 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.Query
-- 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 @Query@ operation finds items based on primary key values. You can
-- query any table or secondary index that has a composite primary key (a
-- partition key and a sort key).
--
-- Use the @KeyConditionExpression@ parameter to provide a specific value
-- for the partition key. The @Query@ operation will return all of the
-- items from the table or index with that partition key value. You can
-- optionally narrow the scope of the @Query@ operation by specifying a
-- sort key value and a comparison operator in @KeyConditionExpression@. To
-- further refine the @Query@ results, you can optionally provide a
-- @FilterExpression@. A @FilterExpression@ determines which items within
-- the results should be returned to you. All of the other results are
-- discarded.
--
-- A @Query@ operation always returns a result set. If no matching items
-- are found, the result set will be empty. Queries that do not return
-- results consume the minimum number of read capacity units for that type
-- of read operation.
--
-- DynamoDB calculates the number of read capacity units consumed based on
-- item size, not on the amount of data that is returned to an application.
-- The number of capacity units consumed will be the same whether you
-- request all of the attributes (the default behavior) or just some of
-- them (using a projection expression). The number will also be the same
-- whether or not you use a @FilterExpression@.
--
-- @Query@ results are always sorted by the sort key value. If the data
-- type of the sort key is Number, the results are returned in numeric
-- order; otherwise, the results are returned in order of UTF-8 bytes. By
-- default, the sort order is ascending. To reverse the order, set the
-- @ScanIndexForward@ parameter to false.
--
-- A single @Query@ operation will read 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 will need to paginate
-- the result set. For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination Paginating the Results>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- @FilterExpression@ is applied after a @Query@ finishes, but before the
-- results are returned. A @FilterExpression@ cannot contain partition key
-- or sort key attributes. You need to specify those attributes in the
-- @KeyConditionExpression@.
--
-- A @Query@ operation can return an empty result set and a
-- @LastEvaluatedKey@ if all the items read for the page of results are
-- filtered out.
--
-- You can query a table, a local secondary index, or a global secondary
-- index. For a query on a table or on a local secondary index, you can set
-- the @ConsistentRead@ parameter to @true@ and obtain a strongly
-- consistent result. Global secondary indexes support eventually
-- consistent reads only, so do not specify @ConsistentRead@ when querying
-- a global secondary index.
--
-- This operation returns paginated results.
module Amazonka.DynamoDB.Query
  ( -- * Creating a Request
    Query (..),
    newQuery,

    -- * Request Lenses
    query_keyConditions,
    query_projectionExpression,
    query_attributesToGet,
    query_expressionAttributeNames,
    query_filterExpression,
    query_queryFilter,
    query_consistentRead,
    query_expressionAttributeValues,
    query_returnConsumedCapacity,
    query_scanIndexForward,
    query_limit,
    query_select,
    query_keyConditionExpression,
    query_conditionalOperator,
    query_exclusiveStartKey,
    query_indexName,
    query_tableName,

    -- * Destructuring the Response
    QueryResponse (..),
    newQueryResponse,

    -- * Response Lenses
    queryResponse_lastEvaluatedKey,
    queryResponse_count,
    queryResponse_scannedCount,
    queryResponse_items,
    queryResponse_consumedCapacity,
    queryResponse_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 @Query@ operation.
--
-- /See:/ 'newQuery' smart constructor.
data Query = Query'
  { -- | This is a legacy parameter. Use @KeyConditionExpression@ instead. For
    -- more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html KeyConditions>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> Maybe (HashMap Text Condition)
keyConditions :: Prelude.Maybe (Prelude.HashMap Prelude.Text Condition),
    -- | A string that identifies one or more attributes to retrieve from the
    -- table. 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 Accessing Item Attributes>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> Maybe Text
projectionExpression :: Prelude.Maybe Prelude.Text,
    -- | 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/.
    Query -> Maybe (NonEmpty Text)
attributesToGet :: Prelude.Maybe (Prelude.NonEmpty Prelude.Text),
    -- | 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/.
    Query -> Maybe (HashMap Text Text)
expressionAttributeNames :: Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text),
    -- | A string that contains conditions that DynamoDB applies after the
    -- @Query@ operation, but before the data is returned to you. Items that do
    -- not satisfy the @FilterExpression@ criteria are not returned.
    --
    -- A @FilterExpression@ does not allow key attributes. You cannot define a
    -- filter expression based on a partition key or a sort key.
    --
    -- 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/.
    Query -> Maybe Text
filterExpression :: 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.QueryFilter.html QueryFilter>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> Maybe (HashMap Text Condition)
queryFilter :: Prelude.Maybe (Prelude.HashMap Prelude.Text Condition),
    -- | Determines the read consistency model: If set to @true@, then the
    -- operation uses strongly consistent reads; otherwise, the operation uses
    -- eventually consistent reads.
    --
    -- Strongly consistent reads are not supported on global secondary indexes.
    -- If you query a global secondary index with @ConsistentRead@ set to
    -- @true@, you will receive a @ValidationException@.
    Query -> 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 Specifying Conditions>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    Query -> Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Prelude.Maybe ReturnConsumedCapacity,
    -- | Specifies the order for index traversal: If @true@ (default), the
    -- traversal is performed in ascending order; if @false@, the traversal is
    -- performed in descending order.
    --
    -- Items with the same partition key value are stored in sorted order by
    -- sort key. If the sort key data type is Number, the results are stored in
    -- numeric order. For type String, the results are stored in order of UTF-8
    -- bytes. For type Binary, DynamoDB treats each byte of the binary data as
    -- unsigned.
    --
    -- If @ScanIndexForward@ is @true@, DynamoDB returns the results in the
    -- order in which they are stored (by sort key value). This is the default
    -- behavior. If @ScanIndexForward@ is @false@, DynamoDB reads the results
    -- in reverse order by sort key value, and then returns the results to the
    -- client.
    Query -> Maybe Bool
scanIndexForward :: Prelude.Maybe Prelude.Bool,
    -- | 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 Query and Scan>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> 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 will
    --     read 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.
    Query -> Maybe Select
select :: Prelude.Maybe Select,
    -- | The condition that specifies the key values for items to be retrieved by
    -- the @Query@ action.
    --
    -- The condition must perform an equality test on a single partition key
    -- value.
    --
    -- The condition can optionally perform one of several comparison tests on
    -- a single sort key value. This allows @Query@ to retrieve one item with a
    -- given partition key value and sort key value, or several items that have
    -- the same partition key value but different sort key values.
    --
    -- The partition key equality test is required, and must be specified in
    -- the following format:
    --
    -- @partitionKeyName@ /=/ @:partitionkeyval@
    --
    -- If you also want to provide a condition for the sort key, it must be
    -- combined using @AND@ with the condition for the sort key. Following is
    -- an example, using the __=__ comparison operator for the sort key:
    --
    -- @partitionKeyName@ @=@ @:partitionkeyval@ @AND@ @sortKeyName@ @=@
    -- @:sortkeyval@
    --
    -- Valid comparisons for the sort key condition are as follows:
    --
    -- -   @sortKeyName@ @=@ @:sortkeyval@ - true if the sort key value is
    --     equal to @:sortkeyval@.
    --
    -- -   @sortKeyName@ @\<@ @:sortkeyval@ - true if the sort key value is
    --     less than @:sortkeyval@.
    --
    -- -   @sortKeyName@ @\<=@ @:sortkeyval@ - true if the sort key value is
    --     less than or equal to @:sortkeyval@.
    --
    -- -   @sortKeyName@ @>@ @:sortkeyval@ - true if the sort key value is
    --     greater than @:sortkeyval@.
    --
    -- -   @sortKeyName@ @>= @ @:sortkeyval@ - true if the sort key value is
    --     greater than or equal to @:sortkeyval@.
    --
    -- -   @sortKeyName@ @BETWEEN@ @:sortkeyval1@ @AND@ @:sortkeyval2@ - true
    --     if the sort key value is greater than or equal to @:sortkeyval1@,
    --     and less than or equal to @:sortkeyval2@.
    --
    -- -   @begins_with (@ @sortKeyName@, @:sortkeyval@ @)@ - true if the sort
    --     key value begins with a particular operand. (You cannot use this
    --     function with a sort key that is of type Number.) Note that the
    --     function name @begins_with@ is case-sensitive.
    --
    -- Use the @ExpressionAttributeValues@ parameter to replace tokens such as
    -- @:partitionval@ and @:sortval@ with actual values at runtime.
    --
    -- You can optionally use the @ExpressionAttributeNames@ parameter to
    -- replace the names of the partition key and sort key with placeholder
    -- tokens. This option might be necessary if an attribute name conflicts
    -- with a DynamoDB reserved word. For example, the following
    -- @KeyConditionExpression@ parameter causes an error because /Size/ is a
    -- reserved word:
    --
    -- -   @Size = :myval@
    --
    -- To work around this, define a placeholder (such a @#S@) to represent the
    -- attribute name /Size/. @KeyConditionExpression@ then is as follows:
    --
    -- -   @#S = :myval@
    --
    -- For a list of reserved words, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
    -- in the /Amazon DynamoDB Developer Guide/.
    --
    -- For more information on @ExpressionAttributeNames@ and
    -- @ExpressionAttributeValues@, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html Using Placeholders for Attribute Names and Values>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> Maybe Text
keyConditionExpression :: 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.ConditionalOperator.html ConditionalOperator>
    -- in the /Amazon DynamoDB Developer Guide/.
    Query -> 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.
    Query -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    -- | The name of an index to query. This index can be any local secondary
    -- index or global secondary index on the table. Note that if you use the
    -- @IndexName@ parameter, you must also provide @TableName.@
    Query -> Maybe Text
indexName :: Prelude.Maybe Prelude.Text,
    -- | The name of the table containing the requested items.
    Query -> Text
tableName :: Prelude.Text
  }
  deriving (Query -> Query -> Bool
(Query -> Query -> Bool) -> (Query -> Query -> Bool) -> Eq Query
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Query -> Query -> Bool
$c/= :: Query -> Query -> Bool
== :: Query -> Query -> Bool
$c== :: Query -> Query -> Bool
Prelude.Eq, ReadPrec [Query]
ReadPrec Query
Int -> ReadS Query
ReadS [Query]
(Int -> ReadS Query)
-> ReadS [Query]
-> ReadPrec Query
-> ReadPrec [Query]
-> Read Query
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Query]
$creadListPrec :: ReadPrec [Query]
readPrec :: ReadPrec Query
$creadPrec :: ReadPrec Query
readList :: ReadS [Query]
$creadList :: ReadS [Query]
readsPrec :: Int -> ReadS Query
$creadsPrec :: Int -> ReadS Query
Prelude.Read, Int -> Query -> ShowS
[Query] -> ShowS
Query -> String
(Int -> Query -> ShowS)
-> (Query -> String) -> ([Query] -> ShowS) -> Show Query
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Query] -> ShowS
$cshowList :: [Query] -> ShowS
show :: Query -> String
$cshow :: Query -> String
showsPrec :: Int -> Query -> ShowS
$cshowsPrec :: Int -> Query -> ShowS
Prelude.Show, (forall x. Query -> Rep Query x)
-> (forall x. Rep Query x -> Query) -> Generic Query
forall x. Rep Query x -> Query
forall x. Query -> Rep Query x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Query x -> Query
$cfrom :: forall x. Query -> Rep Query x
Prelude.Generic)

-- |
-- Create a value of 'Query' 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:
--
-- 'keyConditions', 'query_keyConditions' - This is a legacy parameter. Use @KeyConditionExpression@ instead. For
-- more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html KeyConditions>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'projectionExpression', 'query_projectionExpression' - A string that identifies one or more attributes to retrieve from the
-- table. 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 Accessing Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'attributesToGet', 'query_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/.
--
-- 'expressionAttributeNames', 'query_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', 'query_filterExpression' - A string that contains conditions that DynamoDB applies after the
-- @Query@ operation, but before the data is returned to you. Items that do
-- not satisfy the @FilterExpression@ criteria are not returned.
--
-- A @FilterExpression@ does not allow key attributes. You cannot define a
-- filter expression based on a partition key or a sort key.
--
-- 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/.
--
-- 'queryFilter', 'query_queryFilter' - This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html QueryFilter>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'consistentRead', 'query_consistentRead' - Determines the read consistency model: If set to @true@, then the
-- operation uses strongly consistent reads; otherwise, the operation uses
-- eventually consistent reads.
--
-- Strongly consistent reads are not supported on global secondary indexes.
-- If you query a global secondary index with @ConsistentRead@ set to
-- @true@, you will receive a @ValidationException@.
--
-- 'expressionAttributeValues', 'query_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 Specifying Conditions>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'returnConsumedCapacity', 'query_returnConsumedCapacity' - Undocumented member.
--
-- 'scanIndexForward', 'query_scanIndexForward' - Specifies the order for index traversal: If @true@ (default), the
-- traversal is performed in ascending order; if @false@, the traversal is
-- performed in descending order.
--
-- Items with the same partition key value are stored in sorted order by
-- sort key. If the sort key data type is Number, the results are stored in
-- numeric order. For type String, the results are stored in order of UTF-8
-- bytes. For type Binary, DynamoDB treats each byte of the binary data as
-- unsigned.
--
-- If @ScanIndexForward@ is @true@, DynamoDB returns the results in the
-- order in which they are stored (by sort key value). This is the default
-- behavior. If @ScanIndexForward@ is @false@, DynamoDB reads the results
-- in reverse order by sort key value, and then returns the results to the
-- client.
--
-- 'limit', 'query_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 Query and Scan>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'select', 'query_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 will
--     read 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.
--
-- 'keyConditionExpression', 'query_keyConditionExpression' - The condition that specifies the key values for items to be retrieved by
-- the @Query@ action.
--
-- The condition must perform an equality test on a single partition key
-- value.
--
-- The condition can optionally perform one of several comparison tests on
-- a single sort key value. This allows @Query@ to retrieve one item with a
-- given partition key value and sort key value, or several items that have
-- the same partition key value but different sort key values.
--
-- The partition key equality test is required, and must be specified in
-- the following format:
--
-- @partitionKeyName@ /=/ @:partitionkeyval@
--
-- If you also want to provide a condition for the sort key, it must be
-- combined using @AND@ with the condition for the sort key. Following is
-- an example, using the __=__ comparison operator for the sort key:
--
-- @partitionKeyName@ @=@ @:partitionkeyval@ @AND@ @sortKeyName@ @=@
-- @:sortkeyval@
--
-- Valid comparisons for the sort key condition are as follows:
--
-- -   @sortKeyName@ @=@ @:sortkeyval@ - true if the sort key value is
--     equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @\<@ @:sortkeyval@ - true if the sort key value is
--     less than @:sortkeyval@.
--
-- -   @sortKeyName@ @\<=@ @:sortkeyval@ - true if the sort key value is
--     less than or equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @>@ @:sortkeyval@ - true if the sort key value is
--     greater than @:sortkeyval@.
--
-- -   @sortKeyName@ @>= @ @:sortkeyval@ - true if the sort key value is
--     greater than or equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @BETWEEN@ @:sortkeyval1@ @AND@ @:sortkeyval2@ - true
--     if the sort key value is greater than or equal to @:sortkeyval1@,
--     and less than or equal to @:sortkeyval2@.
--
-- -   @begins_with (@ @sortKeyName@, @:sortkeyval@ @)@ - true if the sort
--     key value begins with a particular operand. (You cannot use this
--     function with a sort key that is of type Number.) Note that the
--     function name @begins_with@ is case-sensitive.
--
-- Use the @ExpressionAttributeValues@ parameter to replace tokens such as
-- @:partitionval@ and @:sortval@ with actual values at runtime.
--
-- You can optionally use the @ExpressionAttributeNames@ parameter to
-- replace the names of the partition key and sort key with placeholder
-- tokens. This option might be necessary if an attribute name conflicts
-- with a DynamoDB reserved word. For example, the following
-- @KeyConditionExpression@ parameter causes an error because /Size/ is a
-- reserved word:
--
-- -   @Size = :myval@
--
-- To work around this, define a placeholder (such a @#S@) to represent the
-- attribute name /Size/. @KeyConditionExpression@ then is as follows:
--
-- -   @#S = :myval@
--
-- For a list of reserved words, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- For more information on @ExpressionAttributeNames@ and
-- @ExpressionAttributeValues@, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html Using Placeholders for Attribute Names and Values>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'conditionalOperator', 'query_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', 'query_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.
--
-- 'indexName', 'query_indexName' - The name of an index to query. This index can be any local secondary
-- index or global secondary index on the table. Note that if you use the
-- @IndexName@ parameter, you must also provide @TableName.@
--
-- 'tableName', 'query_tableName' - The name of the table containing the requested items.
newQuery ::
  -- | 'tableName'
  Prelude.Text ->
  Query
newQuery :: Text -> Query
newQuery Text
pTableName_ =
  Query' :: Maybe (HashMap Text Condition)
-> Maybe Text
-> Maybe (NonEmpty Text)
-> Maybe (HashMap Text Text)
-> Maybe Text
-> Maybe (HashMap Text Condition)
-> Maybe Bool
-> Maybe (HashMap Text AttributeValue)
-> Maybe ReturnConsumedCapacity
-> Maybe Bool
-> Maybe Natural
-> Maybe Select
-> Maybe Text
-> Maybe ConditionalOperator
-> Maybe (HashMap Text AttributeValue)
-> Maybe Text
-> Text
-> Query
Query'
    { $sel:keyConditions:Query' :: Maybe (HashMap Text Condition)
keyConditions = Maybe (HashMap Text Condition)
forall a. Maybe a
Prelude.Nothing,
      $sel:projectionExpression:Query' :: Maybe Text
projectionExpression = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:attributesToGet:Query' :: Maybe (NonEmpty Text)
attributesToGet = Maybe (NonEmpty Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:expressionAttributeNames:Query' :: Maybe (HashMap Text Text)
expressionAttributeNames = Maybe (HashMap Text Text)
forall a. Maybe a
Prelude.Nothing,
      $sel:filterExpression:Query' :: Maybe Text
filterExpression = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:queryFilter:Query' :: Maybe (HashMap Text Condition)
queryFilter = Maybe (HashMap Text Condition)
forall a. Maybe a
Prelude.Nothing,
      $sel:consistentRead:Query' :: Maybe Bool
consistentRead = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:expressionAttributeValues:Query' :: Maybe (HashMap Text AttributeValue)
expressionAttributeValues = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:returnConsumedCapacity:Query' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:scanIndexForward:Query' :: Maybe Bool
scanIndexForward = Maybe Bool
forall a. Maybe a
Prelude.Nothing,
      $sel:limit:Query' :: Maybe Natural
limit = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:select:Query' :: Maybe Select
select = Maybe Select
forall a. Maybe a
Prelude.Nothing,
      $sel:keyConditionExpression:Query' :: Maybe Text
keyConditionExpression = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:conditionalOperator:Query' :: Maybe ConditionalOperator
conditionalOperator = Maybe ConditionalOperator
forall a. Maybe a
Prelude.Nothing,
      $sel:exclusiveStartKey:Query' :: Maybe (HashMap Text AttributeValue)
exclusiveStartKey = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:indexName:Query' :: Maybe Text
indexName = Maybe Text
forall a. Maybe a
Prelude.Nothing,
      $sel:tableName:Query' :: Text
tableName = Text
pTableName_
    }

-- | This is a legacy parameter. Use @KeyConditionExpression@ instead. For
-- more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html KeyConditions>
-- in the /Amazon DynamoDB Developer Guide/.
query_keyConditions :: Lens.Lens' Query (Prelude.Maybe (Prelude.HashMap Prelude.Text Condition))
query_keyConditions :: (Maybe (HashMap Text Condition)
 -> f (Maybe (HashMap Text Condition)))
-> Query -> f Query
query_keyConditions = (Query -> Maybe (HashMap Text Condition))
-> (Query -> Maybe (HashMap Text Condition) -> Query)
-> Lens
     Query
     Query
     (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 (\Query' {Maybe (HashMap Text Condition)
keyConditions :: Maybe (HashMap Text Condition)
$sel:keyConditions:Query' :: Query -> Maybe (HashMap Text Condition)
keyConditions} -> Maybe (HashMap Text Condition)
keyConditions) (\s :: Query
s@Query' {} Maybe (HashMap Text Condition)
a -> Query
s {$sel:keyConditions:Query' :: Maybe (HashMap Text Condition)
keyConditions = Maybe (HashMap Text Condition)
a} :: Query) ((Maybe (HashMap Text Condition)
  -> f (Maybe (HashMap Text Condition)))
 -> Query -> f Query)
-> ((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)))
-> Query
-> f Query
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

-- | A string that identifies one or more attributes to retrieve from the
-- table. 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 Accessing Item Attributes>
-- in the /Amazon DynamoDB Developer Guide/.
query_projectionExpression :: Lens.Lens' Query (Prelude.Maybe Prelude.Text)
query_projectionExpression :: (Maybe Text -> f (Maybe Text)) -> Query -> f Query
query_projectionExpression = (Query -> Maybe Text)
-> (Query -> Maybe Text -> Query)
-> Lens Query Query (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Text
projectionExpression :: Maybe Text
$sel:projectionExpression:Query' :: Query -> Maybe Text
projectionExpression} -> Maybe Text
projectionExpression) (\s :: Query
s@Query' {} Maybe Text
a -> Query
s {$sel:projectionExpression:Query' :: Maybe Text
projectionExpression = Maybe Text
a} :: Query)

-- | 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/.
query_attributesToGet :: Lens.Lens' Query (Prelude.Maybe (Prelude.NonEmpty Prelude.Text))
query_attributesToGet :: (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> Query -> f Query
query_attributesToGet = (Query -> Maybe (NonEmpty Text))
-> (Query -> Maybe (NonEmpty Text) -> Query)
-> Lens Query Query (Maybe (NonEmpty Text)) (Maybe (NonEmpty Text))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe (NonEmpty Text)
attributesToGet :: Maybe (NonEmpty Text)
$sel:attributesToGet:Query' :: Query -> Maybe (NonEmpty Text)
attributesToGet} -> Maybe (NonEmpty Text)
attributesToGet) (\s :: Query
s@Query' {} Maybe (NonEmpty Text)
a -> Query
s {$sel:attributesToGet:Query' :: Maybe (NonEmpty Text)
attributesToGet = Maybe (NonEmpty Text)
a} :: Query) ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
 -> Query -> f Query)
-> ((Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
    -> Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> (Maybe (NonEmpty Text) -> f (Maybe (NonEmpty Text)))
-> Query
-> f Query
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

-- | 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/.
query_expressionAttributeNames :: Lens.Lens' Query (Prelude.Maybe (Prelude.HashMap Prelude.Text Prelude.Text))
query_expressionAttributeNames :: (Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
-> Query -> f Query
query_expressionAttributeNames = (Query -> Maybe (HashMap Text Text))
-> (Query -> Maybe (HashMap Text Text) -> Query)
-> Lens
     Query Query (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 (\Query' {Maybe (HashMap Text Text)
expressionAttributeNames :: Maybe (HashMap Text Text)
$sel:expressionAttributeNames:Query' :: Query -> Maybe (HashMap Text Text)
expressionAttributeNames} -> Maybe (HashMap Text Text)
expressionAttributeNames) (\s :: Query
s@Query' {} Maybe (HashMap Text Text)
a -> Query
s {$sel:expressionAttributeNames:Query' :: Maybe (HashMap Text Text)
expressionAttributeNames = Maybe (HashMap Text Text)
a} :: Query) ((Maybe (HashMap Text Text) -> f (Maybe (HashMap Text Text)))
 -> Query -> f Query)
-> ((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)))
-> Query
-> f Query
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
-- @Query@ operation, but before the data is returned to you. Items that do
-- not satisfy the @FilterExpression@ criteria are not returned.
--
-- A @FilterExpression@ does not allow key attributes. You cannot define a
-- filter expression based on a partition key or a sort key.
--
-- 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/.
query_filterExpression :: Lens.Lens' Query (Prelude.Maybe Prelude.Text)
query_filterExpression :: (Maybe Text -> f (Maybe Text)) -> Query -> f Query
query_filterExpression = (Query -> Maybe Text)
-> (Query -> Maybe Text -> Query)
-> Lens Query Query (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Text
filterExpression :: Maybe Text
$sel:filterExpression:Query' :: Query -> Maybe Text
filterExpression} -> Maybe Text
filterExpression) (\s :: Query
s@Query' {} Maybe Text
a -> Query
s {$sel:filterExpression:Query' :: Maybe Text
filterExpression = Maybe Text
a} :: Query)

-- | This is a legacy parameter. Use @FilterExpression@ instead. For more
-- information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html QueryFilter>
-- in the /Amazon DynamoDB Developer Guide/.
query_queryFilter :: Lens.Lens' Query (Prelude.Maybe (Prelude.HashMap Prelude.Text Condition))
query_queryFilter :: (Maybe (HashMap Text Condition)
 -> f (Maybe (HashMap Text Condition)))
-> Query -> f Query
query_queryFilter = (Query -> Maybe (HashMap Text Condition))
-> (Query -> Maybe (HashMap Text Condition) -> Query)
-> Lens
     Query
     Query
     (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 (\Query' {Maybe (HashMap Text Condition)
queryFilter :: Maybe (HashMap Text Condition)
$sel:queryFilter:Query' :: Query -> Maybe (HashMap Text Condition)
queryFilter} -> Maybe (HashMap Text Condition)
queryFilter) (\s :: Query
s@Query' {} Maybe (HashMap Text Condition)
a -> Query
s {$sel:queryFilter:Query' :: Maybe (HashMap Text Condition)
queryFilter = Maybe (HashMap Text Condition)
a} :: Query) ((Maybe (HashMap Text Condition)
  -> f (Maybe (HashMap Text Condition)))
 -> Query -> f Query)
-> ((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)))
-> Query
-> f Query
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

-- | Determines the read consistency model: If set to @true@, then the
-- operation uses strongly consistent reads; otherwise, the operation uses
-- eventually consistent reads.
--
-- Strongly consistent reads are not supported on global secondary indexes.
-- If you query a global secondary index with @ConsistentRead@ set to
-- @true@, you will receive a @ValidationException@.
query_consistentRead :: Lens.Lens' Query (Prelude.Maybe Prelude.Bool)
query_consistentRead :: (Maybe Bool -> f (Maybe Bool)) -> Query -> f Query
query_consistentRead = (Query -> Maybe Bool)
-> (Query -> Maybe Bool -> Query)
-> Lens Query Query (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Bool
consistentRead :: Maybe Bool
$sel:consistentRead:Query' :: Query -> Maybe Bool
consistentRead} -> Maybe Bool
consistentRead) (\s :: Query
s@Query' {} Maybe Bool
a -> Query
s {$sel:consistentRead:Query' :: Maybe Bool
consistentRead = Maybe Bool
a} :: Query)

-- | 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 Specifying Conditions>
-- in the /Amazon DynamoDB Developer Guide/.
query_expressionAttributeValues :: Lens.Lens' Query (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
query_expressionAttributeValues :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> Query -> f Query
query_expressionAttributeValues = (Query -> Maybe (HashMap Text AttributeValue))
-> (Query -> Maybe (HashMap Text AttributeValue) -> Query)
-> Lens
     Query
     Query
     (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 (\Query' {Maybe (HashMap Text AttributeValue)
expressionAttributeValues :: Maybe (HashMap Text AttributeValue)
$sel:expressionAttributeValues:Query' :: Query -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues} -> Maybe (HashMap Text AttributeValue)
expressionAttributeValues) (\s :: Query
s@Query' {} Maybe (HashMap Text AttributeValue)
a -> Query
s {$sel:expressionAttributeValues:Query' :: Maybe (HashMap Text AttributeValue)
expressionAttributeValues = Maybe (HashMap Text AttributeValue)
a} :: Query) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> Query -> f Query)
-> ((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)))
-> Query
-> f Query
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.
query_returnConsumedCapacity :: Lens.Lens' Query (Prelude.Maybe ReturnConsumedCapacity)
query_returnConsumedCapacity :: (Maybe ReturnConsumedCapacity -> f (Maybe ReturnConsumedCapacity))
-> Query -> f Query
query_returnConsumedCapacity = (Query -> Maybe ReturnConsumedCapacity)
-> (Query -> Maybe ReturnConsumedCapacity -> Query)
-> Lens
     Query
     Query
     (Maybe ReturnConsumedCapacity)
     (Maybe ReturnConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe ReturnConsumedCapacity
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
$sel:returnConsumedCapacity:Query' :: Query -> Maybe ReturnConsumedCapacity
returnConsumedCapacity} -> Maybe ReturnConsumedCapacity
returnConsumedCapacity) (\s :: Query
s@Query' {} Maybe ReturnConsumedCapacity
a -> Query
s {$sel:returnConsumedCapacity:Query' :: Maybe ReturnConsumedCapacity
returnConsumedCapacity = Maybe ReturnConsumedCapacity
a} :: Query)

-- | Specifies the order for index traversal: If @true@ (default), the
-- traversal is performed in ascending order; if @false@, the traversal is
-- performed in descending order.
--
-- Items with the same partition key value are stored in sorted order by
-- sort key. If the sort key data type is Number, the results are stored in
-- numeric order. For type String, the results are stored in order of UTF-8
-- bytes. For type Binary, DynamoDB treats each byte of the binary data as
-- unsigned.
--
-- If @ScanIndexForward@ is @true@, DynamoDB returns the results in the
-- order in which they are stored (by sort key value). This is the default
-- behavior. If @ScanIndexForward@ is @false@, DynamoDB reads the results
-- in reverse order by sort key value, and then returns the results to the
-- client.
query_scanIndexForward :: Lens.Lens' Query (Prelude.Maybe Prelude.Bool)
query_scanIndexForward :: (Maybe Bool -> f (Maybe Bool)) -> Query -> f Query
query_scanIndexForward = (Query -> Maybe Bool)
-> (Query -> Maybe Bool -> Query)
-> Lens Query Query (Maybe Bool) (Maybe Bool)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Bool
scanIndexForward :: Maybe Bool
$sel:scanIndexForward:Query' :: Query -> Maybe Bool
scanIndexForward} -> Maybe Bool
scanIndexForward) (\s :: Query
s@Query' {} Maybe Bool
a -> Query
s {$sel:scanIndexForward:Query' :: Maybe Bool
scanIndexForward = Maybe Bool
a} :: Query)

-- | 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 Query and Scan>
-- in the /Amazon DynamoDB Developer Guide/.
query_limit :: Lens.Lens' Query (Prelude.Maybe Prelude.Natural)
query_limit :: (Maybe Natural -> f (Maybe Natural)) -> Query -> f Query
query_limit = (Query -> Maybe Natural)
-> (Query -> Maybe Natural -> Query)
-> Lens Query Query (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Natural
limit :: Maybe Natural
$sel:limit:Query' :: Query -> Maybe Natural
limit} -> Maybe Natural
limit) (\s :: Query
s@Query' {} Maybe Natural
a -> Query
s {$sel:limit:Query' :: Maybe Natural
limit = Maybe Natural
a} :: Query)

-- | 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 will
--     read 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.
query_select :: Lens.Lens' Query (Prelude.Maybe Select)
query_select :: (Maybe Select -> f (Maybe Select)) -> Query -> f Query
query_select = (Query -> Maybe Select)
-> (Query -> Maybe Select -> Query)
-> Lens Query Query (Maybe Select) (Maybe Select)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Select
select :: Maybe Select
$sel:select:Query' :: Query -> Maybe Select
select} -> Maybe Select
select) (\s :: Query
s@Query' {} Maybe Select
a -> Query
s {$sel:select:Query' :: Maybe Select
select = Maybe Select
a} :: Query)

-- | The condition that specifies the key values for items to be retrieved by
-- the @Query@ action.
--
-- The condition must perform an equality test on a single partition key
-- value.
--
-- The condition can optionally perform one of several comparison tests on
-- a single sort key value. This allows @Query@ to retrieve one item with a
-- given partition key value and sort key value, or several items that have
-- the same partition key value but different sort key values.
--
-- The partition key equality test is required, and must be specified in
-- the following format:
--
-- @partitionKeyName@ /=/ @:partitionkeyval@
--
-- If you also want to provide a condition for the sort key, it must be
-- combined using @AND@ with the condition for the sort key. Following is
-- an example, using the __=__ comparison operator for the sort key:
--
-- @partitionKeyName@ @=@ @:partitionkeyval@ @AND@ @sortKeyName@ @=@
-- @:sortkeyval@
--
-- Valid comparisons for the sort key condition are as follows:
--
-- -   @sortKeyName@ @=@ @:sortkeyval@ - true if the sort key value is
--     equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @\<@ @:sortkeyval@ - true if the sort key value is
--     less than @:sortkeyval@.
--
-- -   @sortKeyName@ @\<=@ @:sortkeyval@ - true if the sort key value is
--     less than or equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @>@ @:sortkeyval@ - true if the sort key value is
--     greater than @:sortkeyval@.
--
-- -   @sortKeyName@ @>= @ @:sortkeyval@ - true if the sort key value is
--     greater than or equal to @:sortkeyval@.
--
-- -   @sortKeyName@ @BETWEEN@ @:sortkeyval1@ @AND@ @:sortkeyval2@ - true
--     if the sort key value is greater than or equal to @:sortkeyval1@,
--     and less than or equal to @:sortkeyval2@.
--
-- -   @begins_with (@ @sortKeyName@, @:sortkeyval@ @)@ - true if the sort
--     key value begins with a particular operand. (You cannot use this
--     function with a sort key that is of type Number.) Note that the
--     function name @begins_with@ is case-sensitive.
--
-- Use the @ExpressionAttributeValues@ parameter to replace tokens such as
-- @:partitionval@ and @:sortval@ with actual values at runtime.
--
-- You can optionally use the @ExpressionAttributeNames@ parameter to
-- replace the names of the partition key and sort key with placeholder
-- tokens. This option might be necessary if an attribute name conflicts
-- with a DynamoDB reserved word. For example, the following
-- @KeyConditionExpression@ parameter causes an error because /Size/ is a
-- reserved word:
--
-- -   @Size = :myval@
--
-- To work around this, define a placeholder (such a @#S@) to represent the
-- attribute name /Size/. @KeyConditionExpression@ then is as follows:
--
-- -   @#S = :myval@
--
-- For a list of reserved words, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html Reserved Words>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- For more information on @ExpressionAttributeNames@ and
-- @ExpressionAttributeValues@, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ExpressionPlaceholders.html Using Placeholders for Attribute Names and Values>
-- in the /Amazon DynamoDB Developer Guide/.
query_keyConditionExpression :: Lens.Lens' Query (Prelude.Maybe Prelude.Text)
query_keyConditionExpression :: (Maybe Text -> f (Maybe Text)) -> Query -> f Query
query_keyConditionExpression = (Query -> Maybe Text)
-> (Query -> Maybe Text -> Query)
-> Lens Query Query (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Text
keyConditionExpression :: Maybe Text
$sel:keyConditionExpression:Query' :: Query -> Maybe Text
keyConditionExpression} -> Maybe Text
keyConditionExpression) (\s :: Query
s@Query' {} Maybe Text
a -> Query
s {$sel:keyConditionExpression:Query' :: Maybe Text
keyConditionExpression = Maybe Text
a} :: Query)

-- | 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/.
query_conditionalOperator :: Lens.Lens' Query (Prelude.Maybe ConditionalOperator)
query_conditionalOperator :: (Maybe ConditionalOperator -> f (Maybe ConditionalOperator))
-> Query -> f Query
query_conditionalOperator = (Query -> Maybe ConditionalOperator)
-> (Query -> Maybe ConditionalOperator -> Query)
-> Lens
     Query Query (Maybe ConditionalOperator) (Maybe ConditionalOperator)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe ConditionalOperator
conditionalOperator :: Maybe ConditionalOperator
$sel:conditionalOperator:Query' :: Query -> Maybe ConditionalOperator
conditionalOperator} -> Maybe ConditionalOperator
conditionalOperator) (\s :: Query
s@Query' {} Maybe ConditionalOperator
a -> Query
s {$sel:conditionalOperator:Query' :: Maybe ConditionalOperator
conditionalOperator = Maybe ConditionalOperator
a} :: Query)

-- | 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.
query_exclusiveStartKey :: Lens.Lens' Query (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
query_exclusiveStartKey :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> Query -> f Query
query_exclusiveStartKey = (Query -> Maybe (HashMap Text AttributeValue))
-> (Query -> Maybe (HashMap Text AttributeValue) -> Query)
-> Lens
     Query
     Query
     (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 (\Query' {Maybe (HashMap Text AttributeValue)
exclusiveStartKey :: Maybe (HashMap Text AttributeValue)
$sel:exclusiveStartKey:Query' :: Query -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey} -> Maybe (HashMap Text AttributeValue)
exclusiveStartKey) (\s :: Query
s@Query' {} Maybe (HashMap Text AttributeValue)
a -> Query
s {$sel:exclusiveStartKey:Query' :: Maybe (HashMap Text AttributeValue)
exclusiveStartKey = Maybe (HashMap Text AttributeValue)
a} :: Query) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> Query -> f Query)
-> ((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)))
-> Query
-> f Query
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 an index to query. This index can be any local secondary
-- index or global secondary index on the table. Note that if you use the
-- @IndexName@ parameter, you must also provide @TableName.@
query_indexName :: Lens.Lens' Query (Prelude.Maybe Prelude.Text)
query_indexName :: (Maybe Text -> f (Maybe Text)) -> Query -> f Query
query_indexName = (Query -> Maybe Text)
-> (Query -> Maybe Text -> Query)
-> Lens Query Query (Maybe Text) (Maybe Text)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Maybe Text
indexName :: Maybe Text
$sel:indexName:Query' :: Query -> Maybe Text
indexName} -> Maybe Text
indexName) (\s :: Query
s@Query' {} Maybe Text
a -> Query
s {$sel:indexName:Query' :: Maybe Text
indexName = Maybe Text
a} :: Query)

-- | The name of the table containing the requested items.
query_tableName :: Lens.Lens' Query Prelude.Text
query_tableName :: (Text -> f Text) -> Query -> f Query
query_tableName = (Query -> Text)
-> (Query -> Text -> Query) -> Lens Query Query Text Text
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Query' {Text
tableName :: Text
$sel:tableName:Query' :: Query -> Text
tableName} -> Text
tableName) (\s :: Query
s@Query' {} Text
a -> Query
s {$sel:tableName:Query' :: Text
tableName = Text
a} :: Query)

instance Core.AWSPager Query where
  page :: Query -> AWSResponse Query -> Maybe Query
page Query
rq AWSResponse Query
rs
    | Maybe (HashMap Text AttributeValue) -> Bool
forall a. AWSTruncated a => a -> Bool
Core.stop
        ( AWSResponse Query
QueryResponse
rs
            QueryResponse
-> Getting
     (First (HashMap Text AttributeValue))
     QueryResponse
     (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)))
-> QueryResponse
-> Const (First (HashMap Text AttributeValue)) QueryResponse
Lens' QueryResponse (Maybe (HashMap Text AttributeValue))
queryResponse_lastEvaluatedKey ((Maybe (HashMap Text AttributeValue)
  -> Const
       (First (HashMap Text AttributeValue))
       (Maybe (HashMap Text AttributeValue)))
 -> QueryResponse
 -> Const (First (HashMap Text AttributeValue)) QueryResponse)
-> ((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))
     QueryResponse
     (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 Query
forall a. Maybe a
Prelude.Nothing
    | Bool
Prelude.otherwise =
      Query -> Maybe Query
forall a. a -> Maybe a
Prelude.Just (Query -> Maybe Query) -> Query -> Maybe Query
forall a b. (a -> b) -> a -> b
Prelude.$
        Query
rq
          Query -> (Query -> Query) -> Query
forall a b. a -> (a -> b) -> b
Prelude.& (Maybe (HashMap Text AttributeValue)
 -> Identity (Maybe (HashMap Text AttributeValue)))
-> Query -> Identity Query
Lens
  Query
  Query
  (Maybe (HashMap Text AttributeValue))
  (Maybe (HashMap Text AttributeValue))
query_exclusiveStartKey
          ((Maybe (HashMap Text AttributeValue)
  -> Identity (Maybe (HashMap Text AttributeValue)))
 -> Query -> Identity Query)
-> Maybe (HashMap Text AttributeValue) -> Query -> Query
forall s t a b. ASetter s t a b -> b -> s -> t
Lens..~ AWSResponse Query
QueryResponse
rs
          QueryResponse
-> Getting
     (First (HashMap Text AttributeValue))
     QueryResponse
     (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)))
-> QueryResponse
-> Const (First (HashMap Text AttributeValue)) QueryResponse
Lens' QueryResponse (Maybe (HashMap Text AttributeValue))
queryResponse_lastEvaluatedKey ((Maybe (HashMap Text AttributeValue)
  -> Const
       (First (HashMap Text AttributeValue))
       (Maybe (HashMap Text AttributeValue)))
 -> QueryResponse
 -> Const (First (HashMap Text AttributeValue)) QueryResponse)
-> ((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))
     QueryResponse
     (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 Query where
  type AWSResponse Query = QueryResponse
  request :: Query -> Request Query
request = Service -> Query -> Request Query
forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON Service
defaultService
  response :: Logger
-> Service
-> Proxy Query
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse Query)))
response =
    (Int
 -> ResponseHeaders -> Object -> Either String (AWSResponse Query))
-> Logger
-> Service
-> Proxy Query
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse Query)))
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
-> QueryResponse
QueryResponse'
            (Maybe (HashMap Text AttributeValue)
 -> Maybe Int
 -> Maybe Int
 -> Maybe [HashMap Text AttributeValue]
 -> Maybe ConsumedCapacity
 -> Int
 -> QueryResponse)
-> Either String (Maybe (HashMap Text AttributeValue))
-> Either
     String
     (Maybe Int
      -> Maybe Int
      -> Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity
      -> Int
      -> QueryResponse)
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
   -> QueryResponse)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe Int
      -> Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity
      -> Int
      -> QueryResponse)
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
   -> QueryResponse)
-> Either String (Maybe Int)
-> Either
     String
     (Maybe [HashMap Text AttributeValue]
      -> Maybe ConsumedCapacity -> Int -> QueryResponse)
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 -> QueryResponse)
-> Either String (Maybe [HashMap Text AttributeValue])
-> Either String (Maybe ConsumedCapacity -> Int -> QueryResponse)
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 -> QueryResponse)
-> Either String (Maybe ConsumedCapacity)
-> Either String (Int -> QueryResponse)
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 -> QueryResponse)
-> Either String Int -> Either String QueryResponse
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 Query

instance Prelude.NFData Query

instance Core.ToHeaders Query where
  toHeaders :: Query -> ResponseHeaders
toHeaders =
    ResponseHeaders -> Query -> 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.Query" :: 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 Query where
  toJSON :: Query -> Value
toJSON Query' {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
keyConditionExpression :: Maybe Text
select :: Maybe Select
limit :: Maybe Natural
scanIndexForward :: Maybe Bool
returnConsumedCapacity :: Maybe ReturnConsumedCapacity
expressionAttributeValues :: Maybe (HashMap Text AttributeValue)
consistentRead :: Maybe Bool
queryFilter :: Maybe (HashMap Text Condition)
filterExpression :: Maybe Text
expressionAttributeNames :: Maybe (HashMap Text Text)
attributesToGet :: Maybe (NonEmpty Text)
projectionExpression :: Maybe Text
keyConditions :: Maybe (HashMap Text Condition)
$sel:tableName:Query' :: Query -> Text
$sel:indexName:Query' :: Query -> Maybe Text
$sel:exclusiveStartKey:Query' :: Query -> Maybe (HashMap Text AttributeValue)
$sel:conditionalOperator:Query' :: Query -> Maybe ConditionalOperator
$sel:keyConditionExpression:Query' :: Query -> Maybe Text
$sel:select:Query' :: Query -> Maybe Select
$sel:limit:Query' :: Query -> Maybe Natural
$sel:scanIndexForward:Query' :: Query -> Maybe Bool
$sel:returnConsumedCapacity:Query' :: Query -> Maybe ReturnConsumedCapacity
$sel:expressionAttributeValues:Query' :: Query -> Maybe (HashMap Text AttributeValue)
$sel:consistentRead:Query' :: Query -> Maybe Bool
$sel:queryFilter:Query' :: Query -> Maybe (HashMap Text Condition)
$sel:filterExpression:Query' :: Query -> Maybe Text
$sel:expressionAttributeNames:Query' :: Query -> Maybe (HashMap Text Text)
$sel:attributesToGet:Query' :: Query -> Maybe (NonEmpty Text)
$sel:projectionExpression:Query' :: Query -> Maybe Text
$sel:keyConditions:Query' :: Query -> Maybe (HashMap Text Condition)
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"KeyConditions" 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)
keyConditions,
            (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
"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
"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
"QueryFilter" 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)
queryFilter,
            (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
"ScanIndexForward" 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
scanIndexForward,
            (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
"KeyConditionExpression" 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
keyConditionExpression,
            (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 Query where
  toPath :: Query -> ByteString
toPath = ByteString -> Query -> ByteString
forall a b. a -> b -> a
Prelude.const ByteString
"/"

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

-- | Represents the output of a @Query@ operation.
--
-- /See:/ 'newQueryResponse' smart constructor.
data QueryResponse = QueryResponse'
  { -- | 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.
    QueryResponse -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey :: Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue),
    -- | The number of items in the response.
    --
    -- If you used a @QueryFilter@ 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@ and
    -- @ScannedCount@ are the same.
    QueryResponse -> Maybe Int
count :: Prelude.Maybe Prelude.Int,
    -- | The number of items evaluated, before any @QueryFilter@ is applied. A
    -- high @ScannedCount@ value with few, or no, @Count@ results indicates an
    -- inefficient @Query@ 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@.
    QueryResponse -> Maybe Int
scannedCount :: Prelude.Maybe Prelude.Int,
    -- | An array of item attributes that match the query criteria. Each element
    -- in this array consists of an attribute name and the value for that
    -- attribute.
    QueryResponse -> Maybe [HashMap Text AttributeValue]
items :: Prelude.Maybe [Prelude.HashMap Prelude.Text AttributeValue],
    -- | The capacity units consumed by the @Query@ 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/.
    QueryResponse -> Maybe ConsumedCapacity
consumedCapacity :: Prelude.Maybe ConsumedCapacity,
    -- | The response's http status code.
    QueryResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (QueryResponse -> QueryResponse -> Bool
(QueryResponse -> QueryResponse -> Bool)
-> (QueryResponse -> QueryResponse -> Bool) -> Eq QueryResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: QueryResponse -> QueryResponse -> Bool
$c/= :: QueryResponse -> QueryResponse -> Bool
== :: QueryResponse -> QueryResponse -> Bool
$c== :: QueryResponse -> QueryResponse -> Bool
Prelude.Eq, ReadPrec [QueryResponse]
ReadPrec QueryResponse
Int -> ReadS QueryResponse
ReadS [QueryResponse]
(Int -> ReadS QueryResponse)
-> ReadS [QueryResponse]
-> ReadPrec QueryResponse
-> ReadPrec [QueryResponse]
-> Read QueryResponse
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [QueryResponse]
$creadListPrec :: ReadPrec [QueryResponse]
readPrec :: ReadPrec QueryResponse
$creadPrec :: ReadPrec QueryResponse
readList :: ReadS [QueryResponse]
$creadList :: ReadS [QueryResponse]
readsPrec :: Int -> ReadS QueryResponse
$creadsPrec :: Int -> ReadS QueryResponse
Prelude.Read, Int -> QueryResponse -> ShowS
[QueryResponse] -> ShowS
QueryResponse -> String
(Int -> QueryResponse -> ShowS)
-> (QueryResponse -> String)
-> ([QueryResponse] -> ShowS)
-> Show QueryResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [QueryResponse] -> ShowS
$cshowList :: [QueryResponse] -> ShowS
show :: QueryResponse -> String
$cshow :: QueryResponse -> String
showsPrec :: Int -> QueryResponse -> ShowS
$cshowsPrec :: Int -> QueryResponse -> ShowS
Prelude.Show, (forall x. QueryResponse -> Rep QueryResponse x)
-> (forall x. Rep QueryResponse x -> QueryResponse)
-> Generic QueryResponse
forall x. Rep QueryResponse x -> QueryResponse
forall x. QueryResponse -> Rep QueryResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep QueryResponse x -> QueryResponse
$cfrom :: forall x. QueryResponse -> Rep QueryResponse x
Prelude.Generic)

-- |
-- Create a value of 'QueryResponse' 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', 'queryResponse_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', 'queryResponse_count' - The number of items in the response.
--
-- If you used a @QueryFilter@ 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@ and
-- @ScannedCount@ are the same.
--
-- 'scannedCount', 'queryResponse_scannedCount' - The number of items evaluated, before any @QueryFilter@ is applied. A
-- high @ScannedCount@ value with few, or no, @Count@ results indicates an
-- inefficient @Query@ 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', 'queryResponse_items' - An array of item attributes that match the query criteria. Each element
-- in this array consists of an attribute name and the value for that
-- attribute.
--
-- 'consumedCapacity', 'queryResponse_consumedCapacity' - The capacity units consumed by the @Query@ 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', 'queryResponse_httpStatus' - The response's http status code.
newQueryResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  QueryResponse
newQueryResponse :: Int -> QueryResponse
newQueryResponse Int
pHttpStatus_ =
  QueryResponse' :: Maybe (HashMap Text AttributeValue)
-> Maybe Int
-> Maybe Int
-> Maybe [HashMap Text AttributeValue]
-> Maybe ConsumedCapacity
-> Int
-> QueryResponse
QueryResponse'
    { $sel:lastEvaluatedKey:QueryResponse' :: Maybe (HashMap Text AttributeValue)
lastEvaluatedKey = Maybe (HashMap Text AttributeValue)
forall a. Maybe a
Prelude.Nothing,
      $sel:count:QueryResponse' :: Maybe Int
count = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:scannedCount:QueryResponse' :: Maybe Int
scannedCount = Maybe Int
forall a. Maybe a
Prelude.Nothing,
      $sel:items:QueryResponse' :: Maybe [HashMap Text AttributeValue]
items = Maybe [HashMap Text AttributeValue]
forall a. Maybe a
Prelude.Nothing,
      $sel:consumedCapacity:QueryResponse' :: Maybe ConsumedCapacity
consumedCapacity = Maybe ConsumedCapacity
forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:QueryResponse' :: 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.
queryResponse_lastEvaluatedKey :: Lens.Lens' QueryResponse (Prelude.Maybe (Prelude.HashMap Prelude.Text AttributeValue))
queryResponse_lastEvaluatedKey :: (Maybe (HashMap Text AttributeValue)
 -> f (Maybe (HashMap Text AttributeValue)))
-> QueryResponse -> f QueryResponse
queryResponse_lastEvaluatedKey = (QueryResponse -> Maybe (HashMap Text AttributeValue))
-> (QueryResponse
    -> Maybe (HashMap Text AttributeValue) -> QueryResponse)
-> Lens' QueryResponse (Maybe (HashMap Text AttributeValue))
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QueryResponse' {Maybe (HashMap Text AttributeValue)
lastEvaluatedKey :: Maybe (HashMap Text AttributeValue)
$sel:lastEvaluatedKey:QueryResponse' :: QueryResponse -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey} -> Maybe (HashMap Text AttributeValue)
lastEvaluatedKey) (\s :: QueryResponse
s@QueryResponse' {} Maybe (HashMap Text AttributeValue)
a -> QueryResponse
s {$sel:lastEvaluatedKey:QueryResponse' :: Maybe (HashMap Text AttributeValue)
lastEvaluatedKey = Maybe (HashMap Text AttributeValue)
a} :: QueryResponse) ((Maybe (HashMap Text AttributeValue)
  -> f (Maybe (HashMap Text AttributeValue)))
 -> QueryResponse -> f QueryResponse)
-> ((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)))
-> QueryResponse
-> f QueryResponse
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 used a @QueryFilter@ 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@ and
-- @ScannedCount@ are the same.
queryResponse_count :: Lens.Lens' QueryResponse (Prelude.Maybe Prelude.Int)
queryResponse_count :: (Maybe Int -> f (Maybe Int)) -> QueryResponse -> f QueryResponse
queryResponse_count = (QueryResponse -> Maybe Int)
-> (QueryResponse -> Maybe Int -> QueryResponse)
-> Lens QueryResponse QueryResponse (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QueryResponse' {Maybe Int
count :: Maybe Int
$sel:count:QueryResponse' :: QueryResponse -> Maybe Int
count} -> Maybe Int
count) (\s :: QueryResponse
s@QueryResponse' {} Maybe Int
a -> QueryResponse
s {$sel:count:QueryResponse' :: Maybe Int
count = Maybe Int
a} :: QueryResponse)

-- | The number of items evaluated, before any @QueryFilter@ is applied. A
-- high @ScannedCount@ value with few, or no, @Count@ results indicates an
-- inefficient @Query@ 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@.
queryResponse_scannedCount :: Lens.Lens' QueryResponse (Prelude.Maybe Prelude.Int)
queryResponse_scannedCount :: (Maybe Int -> f (Maybe Int)) -> QueryResponse -> f QueryResponse
queryResponse_scannedCount = (QueryResponse -> Maybe Int)
-> (QueryResponse -> Maybe Int -> QueryResponse)
-> Lens QueryResponse QueryResponse (Maybe Int) (Maybe Int)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QueryResponse' {Maybe Int
scannedCount :: Maybe Int
$sel:scannedCount:QueryResponse' :: QueryResponse -> Maybe Int
scannedCount} -> Maybe Int
scannedCount) (\s :: QueryResponse
s@QueryResponse' {} Maybe Int
a -> QueryResponse
s {$sel:scannedCount:QueryResponse' :: Maybe Int
scannedCount = Maybe Int
a} :: QueryResponse)

-- | An array of item attributes that match the query criteria. Each element
-- in this array consists of an attribute name and the value for that
-- attribute.
queryResponse_items :: Lens.Lens' QueryResponse (Prelude.Maybe [Prelude.HashMap Prelude.Text AttributeValue])
queryResponse_items :: (Maybe [HashMap Text AttributeValue]
 -> f (Maybe [HashMap Text AttributeValue]))
-> QueryResponse -> f QueryResponse
queryResponse_items = (QueryResponse -> Maybe [HashMap Text AttributeValue])
-> (QueryResponse
    -> Maybe [HashMap Text AttributeValue] -> QueryResponse)
-> Lens
     QueryResponse
     QueryResponse
     (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 (\QueryResponse' {Maybe [HashMap Text AttributeValue]
items :: Maybe [HashMap Text AttributeValue]
$sel:items:QueryResponse' :: QueryResponse -> Maybe [HashMap Text AttributeValue]
items} -> Maybe [HashMap Text AttributeValue]
items) (\s :: QueryResponse
s@QueryResponse' {} Maybe [HashMap Text AttributeValue]
a -> QueryResponse
s {$sel:items:QueryResponse' :: Maybe [HashMap Text AttributeValue]
items = Maybe [HashMap Text AttributeValue]
a} :: QueryResponse) ((Maybe [HashMap Text AttributeValue]
  -> f (Maybe [HashMap Text AttributeValue]))
 -> QueryResponse -> f QueryResponse)
-> ((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]))
-> QueryResponse
-> f QueryResponse
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 @Query@ 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/.
queryResponse_consumedCapacity :: Lens.Lens' QueryResponse (Prelude.Maybe ConsumedCapacity)
queryResponse_consumedCapacity :: (Maybe ConsumedCapacity -> f (Maybe ConsumedCapacity))
-> QueryResponse -> f QueryResponse
queryResponse_consumedCapacity = (QueryResponse -> Maybe ConsumedCapacity)
-> (QueryResponse -> Maybe ConsumedCapacity -> QueryResponse)
-> Lens
     QueryResponse
     QueryResponse
     (Maybe ConsumedCapacity)
     (Maybe ConsumedCapacity)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\QueryResponse' {Maybe ConsumedCapacity
consumedCapacity :: Maybe ConsumedCapacity
$sel:consumedCapacity:QueryResponse' :: QueryResponse -> Maybe ConsumedCapacity
consumedCapacity} -> Maybe ConsumedCapacity
consumedCapacity) (\s :: QueryResponse
s@QueryResponse' {} Maybe ConsumedCapacity
a -> QueryResponse
s {$sel:consumedCapacity:QueryResponse' :: Maybe ConsumedCapacity
consumedCapacity = Maybe ConsumedCapacity
a} :: QueryResponse)

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

instance Prelude.NFData QueryResponse