{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.DynamoDB.Types.Condition
-- 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)
module Amazonka.DynamoDB.Types.Condition where

import qualified Amazonka.Core as Core
import Amazonka.DynamoDB.Types.AttributeValue
import Amazonka.DynamoDB.Types.ComparisonOperator
import qualified Amazonka.Lens as Lens
import qualified Amazonka.Prelude as Prelude

-- | Represents the selection criteria for a @Query@ or @Scan@ operation:
--
-- -   For a @Query@ operation, @Condition@ is used for specifying the
--     @KeyConditions@ to use when querying a table or an index. For
--     @KeyConditions@, only the following comparison operators are
--     supported:
--
--     @EQ | LE | LT | GE | GT | BEGINS_WITH | BETWEEN@
--
--     @Condition@ is also used in a @QueryFilter@, which evaluates the
--     query results and returns only the desired values.
--
-- -   For a @Scan@ operation, @Condition@ is used in a @ScanFilter@, which
--     evaluates the scan results and returns only the desired values.
--
-- /See:/ 'newCondition' smart constructor.
data Condition = Condition'
  { -- | One or more values to evaluate against the supplied attribute. The
    -- number of values in the list depends on the @ComparisonOperator@ being
    -- used.
    --
    -- For type Number, value comparisons are numeric.
    --
    -- String value comparisons for greater than, equals, or less than are
    -- based on ASCII character code values. For example, @a@ is greater than
    -- @A@, and @a@ is greater than @B@. For a list of code values, see
    -- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
    --
    -- For Binary, DynamoDB treats each byte of the binary data as unsigned
    -- when it compares binary values.
    Condition -> Maybe [AttributeValue]
attributeValueList :: Prelude.Maybe [AttributeValue],
    -- | A comparator for evaluating attributes. For example, equals, greater
    -- than, less than, etc.
    --
    -- The following comparison operators are available:
    --
    -- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
    --
    -- The following are descriptions of each comparison operator.
    --
    -- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
    --     and maps.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, Binary, String Set, Number Set, or Binary
    --     Set. If an item contains an @AttributeValue@ element of a different
    --     type than the one provided in the request, the value does not match.
    --     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @NE@ : Not equal. @NE@ is supported for all data types, including
    --     lists and maps.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String, Number, Binary, String Set, Number Set, or Binary Set. If an
    --     item contains an @AttributeValue@ of a different type than the one
    --     provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @LE@ : Less than or equal.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @LT@ : Less than.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String, Number, or Binary (not a set type). If an item contains an
    --     @AttributeValue@ element of a different type than the one provided
    --     in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @GE@ : Greater than or equal.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @GT@ : Greater than.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If an item
    --     contains an @AttributeValue@ element of a different type than the
    --     one provided in the request, the value does not match. For example,
    --     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
    --     @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
    --
    -- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
    --     data types, including lists and maps.
    --
    --     This operator tests for the existence of an attribute, not its data
    --     type. If the data type of attribute \"@a@\" is null, and you
    --     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
    --     result is because the attribute \"@a@\" exists; its data type is not
    --     relevant to the @NOT_NULL@ comparison operator.
    --
    -- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
    --     data types, including lists and maps.
    --
    --     This operator tests for the nonexistence of an attribute, not its
    --     data type. If the data type of attribute \"@a@\" is null, and you
    --     evaluate it using @NULL@, the result is a Boolean @false@. This is
    --     because the attribute \"@a@\" exists; its data type is not relevant
    --     to the @NULL@ comparison operator.
    --
    -- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If the target
    --     attribute of the comparison is of type String, then the operator
    --     checks for a substring match. If the target attribute of the
    --     comparison is of type Binary, then the operator looks for a
    --     subsequence of the target that matches the input. If the target
    --     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
    --     \"@BS@\"), then the operator evaluates to true if it finds an exact
    --     match with any member of the set.
    --
    --     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
    --     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
    --     list.
    --
    -- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
    --     a value in a set.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ element
    --     of type String, Number, or Binary (not a set type). If the target
    --     attribute of the comparison is a String, then the operator checks
    --     for the absence of a substring match. If the target attribute of the
    --     comparison is Binary, then the operator checks for the absence of a
    --     subsequence of the target that matches the input. If the target
    --     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
    --     \"@BS@\"), then the operator evaluates to true if it /does not/ find
    --     an exact match with any member of the set.
    --
    --     NOT_CONTAINS is supported for lists: When evaluating
    --     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
    --     cannot be a set, a map, or a list.
    --
    -- -   @BEGINS_WITH@ : Checks for a prefix.
    --
    --     @AttributeValueList@ can contain only one @AttributeValue@ of type
    --     String or Binary (not a Number or a set type). The target attribute
    --     of the comparison must be of type String or Binary (not a Number or
    --     a set type).
    --
    -- -   @IN@ : Checks for matching elements in a list.
    --
    --     @AttributeValueList@ can contain one or more @AttributeValue@
    --     elements of type String, Number, or Binary. These attributes are
    --     compared against an existing attribute of an item. If any elements
    --     of the input are equal to the item attribute, the expression
    --     evaluates to true.
    --
    -- -   @BETWEEN@ : Greater than or equal to the first value, and less than
    --     or equal to the second value.
    --
    --     @AttributeValueList@ must contain two @AttributeValue@ elements of
    --     the same type, either String, Number, or Binary (not a set type). A
    --     target attribute matches if the target value is greater than, or
    --     equal to, the first element and less than, or equal to, the second
    --     element. If an item contains an @AttributeValue@ element of a
    --     different type than the one provided in the request, the value does
    --     not match. For example, @{\"S\":\"6\"}@ does not compare to
    --     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
    --     @{\"NS\":[\"6\", \"2\", \"1\"]}@
    --
    -- For usage examples of @AttributeValueList@ and @ComparisonOperator@, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html Legacy Conditional Parameters>
    -- in the /Amazon DynamoDB Developer Guide/.
    Condition -> ComparisonOperator
comparisonOperator :: ComparisonOperator
  }
  deriving (Condition -> Condition -> Bool
(Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool) -> Eq Condition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Condition -> Condition -> Bool
$c/= :: Condition -> Condition -> Bool
== :: Condition -> Condition -> Bool
$c== :: Condition -> Condition -> Bool
Prelude.Eq, ReadPrec [Condition]
ReadPrec Condition
Int -> ReadS Condition
ReadS [Condition]
(Int -> ReadS Condition)
-> ReadS [Condition]
-> ReadPrec Condition
-> ReadPrec [Condition]
-> Read Condition
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Condition]
$creadListPrec :: ReadPrec [Condition]
readPrec :: ReadPrec Condition
$creadPrec :: ReadPrec Condition
readList :: ReadS [Condition]
$creadList :: ReadS [Condition]
readsPrec :: Int -> ReadS Condition
$creadsPrec :: Int -> ReadS Condition
Prelude.Read, Int -> Condition -> ShowS
[Condition] -> ShowS
Condition -> String
(Int -> Condition -> ShowS)
-> (Condition -> String)
-> ([Condition] -> ShowS)
-> Show Condition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Condition] -> ShowS
$cshowList :: [Condition] -> ShowS
show :: Condition -> String
$cshow :: Condition -> String
showsPrec :: Int -> Condition -> ShowS
$cshowsPrec :: Int -> Condition -> ShowS
Prelude.Show, (forall x. Condition -> Rep Condition x)
-> (forall x. Rep Condition x -> Condition) -> Generic Condition
forall x. Rep Condition x -> Condition
forall x. Condition -> Rep Condition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Condition x -> Condition
$cfrom :: forall x. Condition -> Rep Condition x
Prelude.Generic)

-- |
-- Create a value of 'Condition' 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:
--
-- 'attributeValueList', 'condition_attributeValueList' - One or more values to evaluate against the supplied attribute. The
-- number of values in the list depends on the @ComparisonOperator@ being
-- used.
--
-- For type Number, value comparisons are numeric.
--
-- String value comparisons for greater than, equals, or less than are
-- based on ASCII character code values. For example, @a@ is greater than
-- @A@, and @a@ is greater than @B@. For a list of code values, see
-- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
--
-- For Binary, DynamoDB treats each byte of the binary data as unsigned
-- when it compares binary values.
--
-- 'comparisonOperator', 'condition_comparisonOperator' - A comparator for evaluating attributes. For example, equals, greater
-- than, less than, etc.
--
-- The following comparison operators are available:
--
-- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
--
-- The following are descriptions of each comparison operator.
--
-- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
--     and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, Binary, String Set, Number Set, or Binary
--     Set. If an item contains an @AttributeValue@ element of a different
--     type than the one provided in the request, the value does not match.
--     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NE@ : Not equal. @NE@ is supported for all data types, including
--     lists and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, Binary, String Set, Number Set, or Binary Set. If an
--     item contains an @AttributeValue@ of a different type than the one
--     provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LE@ : Less than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LT@ : Less than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, or Binary (not a set type). If an item contains an
--     @AttributeValue@ element of a different type than the one provided
--     in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GE@ : Greater than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GT@ : Greater than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the existence of an attribute, not its data
--     type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
--     result is because the attribute \"@a@\" exists; its data type is not
--     relevant to the @NOT_NULL@ comparison operator.
--
-- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the nonexistence of an attribute, not its
--     data type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NULL@, the result is a Boolean @false@. This is
--     because the attribute \"@a@\" exists; its data type is not relevant
--     to the @NULL@ comparison operator.
--
-- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is of type String, then the operator
--     checks for a substring match. If the target attribute of the
--     comparison is of type Binary, then the operator looks for a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it finds an exact
--     match with any member of the set.
--
--     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
--     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
--     list.
--
-- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
--     a value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is a String, then the operator checks
--     for the absence of a substring match. If the target attribute of the
--     comparison is Binary, then the operator checks for the absence of a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it /does not/ find
--     an exact match with any member of the set.
--
--     NOT_CONTAINS is supported for lists: When evaluating
--     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
--     cannot be a set, a map, or a list.
--
-- -   @BEGINS_WITH@ : Checks for a prefix.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String or Binary (not a Number or a set type). The target attribute
--     of the comparison must be of type String or Binary (not a Number or
--     a set type).
--
-- -   @IN@ : Checks for matching elements in a list.
--
--     @AttributeValueList@ can contain one or more @AttributeValue@
--     elements of type String, Number, or Binary. These attributes are
--     compared against an existing attribute of an item. If any elements
--     of the input are equal to the item attribute, the expression
--     evaluates to true.
--
-- -   @BETWEEN@ : Greater than or equal to the first value, and less than
--     or equal to the second value.
--
--     @AttributeValueList@ must contain two @AttributeValue@ elements of
--     the same type, either String, Number, or Binary (not a set type). A
--     target attribute matches if the target value is greater than, or
--     equal to, the first element and less than, or equal to, the second
--     element. If an item contains an @AttributeValue@ element of a
--     different type than the one provided in the request, the value does
--     not match. For example, @{\"S\":\"6\"}@ does not compare to
--     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@
--
-- For usage examples of @AttributeValueList@ and @ComparisonOperator@, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html Legacy Conditional Parameters>
-- in the /Amazon DynamoDB Developer Guide/.
newCondition ::
  -- | 'comparisonOperator'
  ComparisonOperator ->
  Condition
newCondition :: ComparisonOperator -> Condition
newCondition ComparisonOperator
pComparisonOperator_ =
  Condition' :: Maybe [AttributeValue] -> ComparisonOperator -> Condition
Condition'
    { $sel:attributeValueList:Condition' :: Maybe [AttributeValue]
attributeValueList = Maybe [AttributeValue]
forall a. Maybe a
Prelude.Nothing,
      $sel:comparisonOperator:Condition' :: ComparisonOperator
comparisonOperator = ComparisonOperator
pComparisonOperator_
    }

-- | One or more values to evaluate against the supplied attribute. The
-- number of values in the list depends on the @ComparisonOperator@ being
-- used.
--
-- For type Number, value comparisons are numeric.
--
-- String value comparisons for greater than, equals, or less than are
-- based on ASCII character code values. For example, @a@ is greater than
-- @A@, and @a@ is greater than @B@. For a list of code values, see
-- <http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters>.
--
-- For Binary, DynamoDB treats each byte of the binary data as unsigned
-- when it compares binary values.
condition_attributeValueList :: Lens.Lens' Condition (Prelude.Maybe [AttributeValue])
condition_attributeValueList :: (Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> Condition -> f Condition
condition_attributeValueList = (Condition -> Maybe [AttributeValue])
-> (Condition -> Maybe [AttributeValue] -> Condition)
-> Lens
     Condition
     Condition
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Condition' {Maybe [AttributeValue]
attributeValueList :: Maybe [AttributeValue]
$sel:attributeValueList:Condition' :: Condition -> Maybe [AttributeValue]
attributeValueList} -> Maybe [AttributeValue]
attributeValueList) (\s :: Condition
s@Condition' {} Maybe [AttributeValue]
a -> Condition
s {$sel:attributeValueList:Condition' :: Maybe [AttributeValue]
attributeValueList = Maybe [AttributeValue]
a} :: Condition) ((Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
 -> Condition -> f Condition)
-> ((Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
    -> Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> (Maybe [AttributeValue] -> f (Maybe [AttributeValue]))
-> Condition
-> f Condition
forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. AnIso
  [AttributeValue] [AttributeValue] [AttributeValue] [AttributeValue]
-> Iso
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
     (Maybe [AttributeValue])
     (Maybe [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
  [AttributeValue] [AttributeValue] [AttributeValue] [AttributeValue]
forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | A comparator for evaluating attributes. For example, equals, greater
-- than, less than, etc.
--
-- The following comparison operators are available:
--
-- @EQ | NE | LE | LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH | IN | BETWEEN@
--
-- The following are descriptions of each comparison operator.
--
-- -   @EQ@ : Equal. @EQ@ is supported for all data types, including lists
--     and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, Binary, String Set, Number Set, or Binary
--     Set. If an item contains an @AttributeValue@ element of a different
--     type than the one provided in the request, the value does not match.
--     For example, @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NE@ : Not equal. @NE@ is supported for all data types, including
--     lists and maps.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, Binary, String Set, Number Set, or Binary Set. If an
--     item contains an @AttributeValue@ of a different type than the one
--     provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not equal @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LE@ : Less than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @LT@ : Less than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String, Number, or Binary (not a set type). If an item contains an
--     @AttributeValue@ element of a different type than the one provided
--     in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GE@ : Greater than or equal.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @GT@ : Greater than.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If an item
--     contains an @AttributeValue@ element of a different type than the
--     one provided in the request, the value does not match. For example,
--     @{\"S\":\"6\"}@ does not equal @{\"N\":\"6\"}@. Also,
--     @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@.
--
-- -   @NOT_NULL@ : The attribute exists. @NOT_NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the existence of an attribute, not its data
--     type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NOT_NULL@, the result is a Boolean @true@. This
--     result is because the attribute \"@a@\" exists; its data type is not
--     relevant to the @NOT_NULL@ comparison operator.
--
-- -   @NULL@ : The attribute does not exist. @NULL@ is supported for all
--     data types, including lists and maps.
--
--     This operator tests for the nonexistence of an attribute, not its
--     data type. If the data type of attribute \"@a@\" is null, and you
--     evaluate it using @NULL@, the result is a Boolean @false@. This is
--     because the attribute \"@a@\" exists; its data type is not relevant
--     to the @NULL@ comparison operator.
--
-- -   @CONTAINS@ : Checks for a subsequence, or value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is of type String, then the operator
--     checks for a substring match. If the target attribute of the
--     comparison is of type Binary, then the operator looks for a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it finds an exact
--     match with any member of the set.
--
--     CONTAINS is supported for lists: When evaluating \"@a CONTAINS b@\",
--     \"@a@\" can be a list; however, \"@b@\" cannot be a set, a map, or a
--     list.
--
-- -   @NOT_CONTAINS@ : Checks for absence of a subsequence, or absence of
--     a value in a set.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ element
--     of type String, Number, or Binary (not a set type). If the target
--     attribute of the comparison is a String, then the operator checks
--     for the absence of a substring match. If the target attribute of the
--     comparison is Binary, then the operator checks for the absence of a
--     subsequence of the target that matches the input. If the target
--     attribute of the comparison is a set (\"@SS@\", \"@NS@\", or
--     \"@BS@\"), then the operator evaluates to true if it /does not/ find
--     an exact match with any member of the set.
--
--     NOT_CONTAINS is supported for lists: When evaluating
--     \"@a NOT CONTAINS b@\", \"@a@\" can be a list; however, \"@b@\"
--     cannot be a set, a map, or a list.
--
-- -   @BEGINS_WITH@ : Checks for a prefix.
--
--     @AttributeValueList@ can contain only one @AttributeValue@ of type
--     String or Binary (not a Number or a set type). The target attribute
--     of the comparison must be of type String or Binary (not a Number or
--     a set type).
--
-- -   @IN@ : Checks for matching elements in a list.
--
--     @AttributeValueList@ can contain one or more @AttributeValue@
--     elements of type String, Number, or Binary. These attributes are
--     compared against an existing attribute of an item. If any elements
--     of the input are equal to the item attribute, the expression
--     evaluates to true.
--
-- -   @BETWEEN@ : Greater than or equal to the first value, and less than
--     or equal to the second value.
--
--     @AttributeValueList@ must contain two @AttributeValue@ elements of
--     the same type, either String, Number, or Binary (not a set type). A
--     target attribute matches if the target value is greater than, or
--     equal to, the first element and less than, or equal to, the second
--     element. If an item contains an @AttributeValue@ element of a
--     different type than the one provided in the request, the value does
--     not match. For example, @{\"S\":\"6\"}@ does not compare to
--     @{\"N\":\"6\"}@. Also, @{\"N\":\"6\"}@ does not compare to
--     @{\"NS\":[\"6\", \"2\", \"1\"]}@
--
-- For usage examples of @AttributeValueList@ and @ComparisonOperator@, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.html Legacy Conditional Parameters>
-- in the /Amazon DynamoDB Developer Guide/.
condition_comparisonOperator :: Lens.Lens' Condition ComparisonOperator
condition_comparisonOperator :: (ComparisonOperator -> f ComparisonOperator)
-> Condition -> f Condition
condition_comparisonOperator = (Condition -> ComparisonOperator)
-> (Condition -> ComparisonOperator -> Condition)
-> Lens Condition Condition ComparisonOperator ComparisonOperator
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Condition' {ComparisonOperator
comparisonOperator :: ComparisonOperator
$sel:comparisonOperator:Condition' :: Condition -> ComparisonOperator
comparisonOperator} -> ComparisonOperator
comparisonOperator) (\s :: Condition
s@Condition' {} ComparisonOperator
a -> Condition
s {$sel:comparisonOperator:Condition' :: ComparisonOperator
comparisonOperator = ComparisonOperator
a} :: Condition)

instance Prelude.Hashable Condition

instance Prelude.NFData Condition

instance Core.ToJSON Condition where
  toJSON :: Condition -> Value
toJSON Condition' {Maybe [AttributeValue]
ComparisonOperator
comparisonOperator :: ComparisonOperator
attributeValueList :: Maybe [AttributeValue]
$sel:comparisonOperator:Condition' :: Condition -> ComparisonOperator
$sel:attributeValueList:Condition' :: Condition -> Maybe [AttributeValue]
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"AttributeValueList" Text -> [AttributeValue] -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              ([AttributeValue] -> Pair) -> Maybe [AttributeValue] -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe [AttributeValue]
attributeValueList,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"ComparisonOperator" Text -> ComparisonOperator -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= ComparisonOperator
comparisonOperator)
          ]
      )