{-# 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.AttributeValueUpdate
-- 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.AttributeValueUpdate where

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

-- | For the @UpdateItem@ operation, represents the attributes to be
-- modified, the action to perform on each, and the new value for each.
--
-- You cannot use @UpdateItem@ to update any primary key attributes.
-- Instead, you will need to delete the item, and then use @PutItem@ to
-- create a new item with new attributes.
--
-- Attribute values cannot be null; string and binary type attributes must
-- have lengths greater than zero; and set type attributes must not be
-- empty. Requests with empty values will be rejected with a
-- @ValidationException@ exception.
--
-- /See:/ 'newAttributeValueUpdate' smart constructor.
data AttributeValueUpdate = AttributeValueUpdate'
  { -- | Represents the data for an attribute.
    --
    -- Each attribute value is described as a name-value pair. The name is the
    -- data type, and the value is the data itself.
    --
    -- For more information, see
    -- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
    -- in the /Amazon DynamoDB Developer Guide/.
    AttributeValueUpdate -> Maybe AttributeValue
value :: Prelude.Maybe AttributeValue,
    -- | Specifies how to perform the update. Valid values are @PUT@ (default),
    -- @DELETE@, and @ADD@. The behavior depends on whether the specified
    -- primary key already exists in the table.
    --
    -- __If an item with the specified /Key/ is found in the table:__
    --
    -- -   @PUT@ - Adds the specified attribute to the item. If the attribute
    --     already exists, it is replaced by the new value.
    --
    -- -   @DELETE@ - If no value is specified, the attribute and its value are
    --     removed from the item. The data type of the specified value must
    --     match the existing value\'s data type.
    --
    --     If a /set/ of values is specified, then those values are subtracted
    --     from the old set. For example, if the attribute value was the set
    --     @[a,b,c]@ and the @DELETE@ action specified @[a,c]@, then the final
    --     attribute value would be @[b]@. Specifying an empty set is an error.
    --
    -- -   @ADD@ - If the attribute does not already exist, then the attribute
    --     and its values are added to the item. If the attribute does exist,
    --     then the behavior of @ADD@ depends on the data type of the
    --     attribute:
    --
    --     -   If the existing attribute is a number, and if @Value@ is also a
    --         number, then the @Value@ is mathematically added to the existing
    --         attribute. If @Value@ is a negative number, then it is
    --         subtracted from the existing attribute.
    --
    --         If you use @ADD@ to increment or decrement a number value for an
    --         item that doesn\'t exist before the update, DynamoDB uses 0 as
    --         the initial value.
    --
    --         In addition, if you use @ADD@ to update an existing item, and
    --         intend to increment or decrement an attribute value which does
    --         not yet exist, DynamoDB uses @0@ as the initial value. For
    --         example, suppose that the item you want to update does not yet
    --         have an attribute named /itemcount/, but you decide to @ADD@ the
    --         number @3@ to this attribute anyway, even though it currently
    --         does not exist. DynamoDB will create the /itemcount/ attribute,
    --         set its initial value to @0@, and finally add @3@ to it. The
    --         result will be a new /itemcount/ attribute in the item, with a
    --         value of @3@.
    --
    --     -   If the existing data type is a set, and if the @Value@ is also a
    --         set, then the @Value@ is added to the existing set. (This is a
    --         /set/ operation, not mathematical addition.) For example, if the
    --         attribute value was the set @[1,2]@, and the @ADD@ action
    --         specified @[3]@, then the final attribute value would be
    --         @[1,2,3]@. An error occurs if an Add action is specified for a
    --         set attribute and the attribute type specified does not match
    --         the existing set type.
    --
    --         Both sets must have the same primitive data type. For example,
    --         if the existing data type is a set of strings, the @Value@ must
    --         also be a set of strings. The same holds true for number sets
    --         and binary sets.
    --
    --     This action is only valid for an existing attribute whose data type
    --     is number or is a set. Do not use @ADD@ for any other data types.
    --
    -- __If no item with the specified /Key/ is found:__
    --
    -- -   @PUT@ - DynamoDB creates a new item with the specified primary key,
    --     and then adds the attribute.
    --
    -- -   @DELETE@ - Nothing happens; there is no attribute to delete.
    --
    -- -   @ADD@ - DynamoDB creates an item with the supplied primary key and
    --     number (or set of numbers) for the attribute value. The only data
    --     types allowed are number and number set; no other data types can be
    --     specified.
    AttributeValueUpdate -> Maybe AttributeAction
action :: Prelude.Maybe AttributeAction
  }
  deriving (AttributeValueUpdate -> AttributeValueUpdate -> Bool
(AttributeValueUpdate -> AttributeValueUpdate -> Bool)
-> (AttributeValueUpdate -> AttributeValueUpdate -> Bool)
-> Eq AttributeValueUpdate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AttributeValueUpdate -> AttributeValueUpdate -> Bool
$c/= :: AttributeValueUpdate -> AttributeValueUpdate -> Bool
== :: AttributeValueUpdate -> AttributeValueUpdate -> Bool
$c== :: AttributeValueUpdate -> AttributeValueUpdate -> Bool
Prelude.Eq, ReadPrec [AttributeValueUpdate]
ReadPrec AttributeValueUpdate
Int -> ReadS AttributeValueUpdate
ReadS [AttributeValueUpdate]
(Int -> ReadS AttributeValueUpdate)
-> ReadS [AttributeValueUpdate]
-> ReadPrec AttributeValueUpdate
-> ReadPrec [AttributeValueUpdate]
-> Read AttributeValueUpdate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AttributeValueUpdate]
$creadListPrec :: ReadPrec [AttributeValueUpdate]
readPrec :: ReadPrec AttributeValueUpdate
$creadPrec :: ReadPrec AttributeValueUpdate
readList :: ReadS [AttributeValueUpdate]
$creadList :: ReadS [AttributeValueUpdate]
readsPrec :: Int -> ReadS AttributeValueUpdate
$creadsPrec :: Int -> ReadS AttributeValueUpdate
Prelude.Read, Int -> AttributeValueUpdate -> ShowS
[AttributeValueUpdate] -> ShowS
AttributeValueUpdate -> String
(Int -> AttributeValueUpdate -> ShowS)
-> (AttributeValueUpdate -> String)
-> ([AttributeValueUpdate] -> ShowS)
-> Show AttributeValueUpdate
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AttributeValueUpdate] -> ShowS
$cshowList :: [AttributeValueUpdate] -> ShowS
show :: AttributeValueUpdate -> String
$cshow :: AttributeValueUpdate -> String
showsPrec :: Int -> AttributeValueUpdate -> ShowS
$cshowsPrec :: Int -> AttributeValueUpdate -> ShowS
Prelude.Show, (forall x. AttributeValueUpdate -> Rep AttributeValueUpdate x)
-> (forall x. Rep AttributeValueUpdate x -> AttributeValueUpdate)
-> Generic AttributeValueUpdate
forall x. Rep AttributeValueUpdate x -> AttributeValueUpdate
forall x. AttributeValueUpdate -> Rep AttributeValueUpdate x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep AttributeValueUpdate x -> AttributeValueUpdate
$cfrom :: forall x. AttributeValueUpdate -> Rep AttributeValueUpdate x
Prelude.Generic)

-- |
-- Create a value of 'AttributeValueUpdate' 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:
--
-- 'value', 'attributeValueUpdate_value' - Represents the data for an attribute.
--
-- Each attribute value is described as a name-value pair. The name is the
-- data type, and the value is the data itself.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
-- in the /Amazon DynamoDB Developer Guide/.
--
-- 'action', 'attributeValueUpdate_action' - Specifies how to perform the update. Valid values are @PUT@ (default),
-- @DELETE@, and @ADD@. The behavior depends on whether the specified
-- primary key already exists in the table.
--
-- __If an item with the specified /Key/ is found in the table:__
--
-- -   @PUT@ - Adds the specified attribute to the item. If the attribute
--     already exists, it is replaced by the new value.
--
-- -   @DELETE@ - If no value is specified, the attribute and its value are
--     removed from the item. The data type of the specified value must
--     match the existing value\'s data type.
--
--     If a /set/ of values is specified, then those values are subtracted
--     from the old set. For example, if the attribute value was the set
--     @[a,b,c]@ and the @DELETE@ action specified @[a,c]@, then the final
--     attribute value would be @[b]@. Specifying an empty set is an error.
--
-- -   @ADD@ - If the attribute does not already exist, then the attribute
--     and its values are added to the item. If the attribute does exist,
--     then the behavior of @ADD@ depends on the data type of the
--     attribute:
--
--     -   If the existing attribute is a number, and if @Value@ is also a
--         number, then the @Value@ is mathematically added to the existing
--         attribute. If @Value@ is a negative number, then it is
--         subtracted from the existing attribute.
--
--         If you use @ADD@ to increment or decrement a number value for an
--         item that doesn\'t exist before the update, DynamoDB uses 0 as
--         the initial value.
--
--         In addition, if you use @ADD@ to update an existing item, and
--         intend to increment or decrement an attribute value which does
--         not yet exist, DynamoDB uses @0@ as the initial value. For
--         example, suppose that the item you want to update does not yet
--         have an attribute named /itemcount/, but you decide to @ADD@ the
--         number @3@ to this attribute anyway, even though it currently
--         does not exist. DynamoDB will create the /itemcount/ attribute,
--         set its initial value to @0@, and finally add @3@ to it. The
--         result will be a new /itemcount/ attribute in the item, with a
--         value of @3@.
--
--     -   If the existing data type is a set, and if the @Value@ is also a
--         set, then the @Value@ is added to the existing set. (This is a
--         /set/ operation, not mathematical addition.) For example, if the
--         attribute value was the set @[1,2]@, and the @ADD@ action
--         specified @[3]@, then the final attribute value would be
--         @[1,2,3]@. An error occurs if an Add action is specified for a
--         set attribute and the attribute type specified does not match
--         the existing set type.
--
--         Both sets must have the same primitive data type. For example,
--         if the existing data type is a set of strings, the @Value@ must
--         also be a set of strings. The same holds true for number sets
--         and binary sets.
--
--     This action is only valid for an existing attribute whose data type
--     is number or is a set. Do not use @ADD@ for any other data types.
--
-- __If no item with the specified /Key/ is found:__
--
-- -   @PUT@ - DynamoDB creates a new item with the specified primary key,
--     and then adds the attribute.
--
-- -   @DELETE@ - Nothing happens; there is no attribute to delete.
--
-- -   @ADD@ - DynamoDB creates an item with the supplied primary key and
--     number (or set of numbers) for the attribute value. The only data
--     types allowed are number and number set; no other data types can be
--     specified.
newAttributeValueUpdate ::
  AttributeValueUpdate
newAttributeValueUpdate :: AttributeValueUpdate
newAttributeValueUpdate =
  AttributeValueUpdate' :: Maybe AttributeValue
-> Maybe AttributeAction -> AttributeValueUpdate
AttributeValueUpdate'
    { $sel:value:AttributeValueUpdate' :: Maybe AttributeValue
value = Maybe AttributeValue
forall a. Maybe a
Prelude.Nothing,
      $sel:action:AttributeValueUpdate' :: Maybe AttributeAction
action = Maybe AttributeAction
forall a. Maybe a
Prelude.Nothing
    }

-- | Represents the data for an attribute.
--
-- Each attribute value is described as a name-value pair. The name is the
-- data type, and the value is the data itself.
--
-- For more information, see
-- <https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes Data Types>
-- in the /Amazon DynamoDB Developer Guide/.
attributeValueUpdate_value :: Lens.Lens' AttributeValueUpdate (Prelude.Maybe AttributeValue)
attributeValueUpdate_value :: (Maybe AttributeValue -> f (Maybe AttributeValue))
-> AttributeValueUpdate -> f AttributeValueUpdate
attributeValueUpdate_value = (AttributeValueUpdate -> Maybe AttributeValue)
-> (AttributeValueUpdate
    -> Maybe AttributeValue -> AttributeValueUpdate)
-> Lens
     AttributeValueUpdate
     AttributeValueUpdate
     (Maybe AttributeValue)
     (Maybe AttributeValue)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AttributeValueUpdate' {Maybe AttributeValue
value :: Maybe AttributeValue
$sel:value:AttributeValueUpdate' :: AttributeValueUpdate -> Maybe AttributeValue
value} -> Maybe AttributeValue
value) (\s :: AttributeValueUpdate
s@AttributeValueUpdate' {} Maybe AttributeValue
a -> AttributeValueUpdate
s {$sel:value:AttributeValueUpdate' :: Maybe AttributeValue
value = Maybe AttributeValue
a} :: AttributeValueUpdate)

-- | Specifies how to perform the update. Valid values are @PUT@ (default),
-- @DELETE@, and @ADD@. The behavior depends on whether the specified
-- primary key already exists in the table.
--
-- __If an item with the specified /Key/ is found in the table:__
--
-- -   @PUT@ - Adds the specified attribute to the item. If the attribute
--     already exists, it is replaced by the new value.
--
-- -   @DELETE@ - If no value is specified, the attribute and its value are
--     removed from the item. The data type of the specified value must
--     match the existing value\'s data type.
--
--     If a /set/ of values is specified, then those values are subtracted
--     from the old set. For example, if the attribute value was the set
--     @[a,b,c]@ and the @DELETE@ action specified @[a,c]@, then the final
--     attribute value would be @[b]@. Specifying an empty set is an error.
--
-- -   @ADD@ - If the attribute does not already exist, then the attribute
--     and its values are added to the item. If the attribute does exist,
--     then the behavior of @ADD@ depends on the data type of the
--     attribute:
--
--     -   If the existing attribute is a number, and if @Value@ is also a
--         number, then the @Value@ is mathematically added to the existing
--         attribute. If @Value@ is a negative number, then it is
--         subtracted from the existing attribute.
--
--         If you use @ADD@ to increment or decrement a number value for an
--         item that doesn\'t exist before the update, DynamoDB uses 0 as
--         the initial value.
--
--         In addition, if you use @ADD@ to update an existing item, and
--         intend to increment or decrement an attribute value which does
--         not yet exist, DynamoDB uses @0@ as the initial value. For
--         example, suppose that the item you want to update does not yet
--         have an attribute named /itemcount/, but you decide to @ADD@ the
--         number @3@ to this attribute anyway, even though it currently
--         does not exist. DynamoDB will create the /itemcount/ attribute,
--         set its initial value to @0@, and finally add @3@ to it. The
--         result will be a new /itemcount/ attribute in the item, with a
--         value of @3@.
--
--     -   If the existing data type is a set, and if the @Value@ is also a
--         set, then the @Value@ is added to the existing set. (This is a
--         /set/ operation, not mathematical addition.) For example, if the
--         attribute value was the set @[1,2]@, and the @ADD@ action
--         specified @[3]@, then the final attribute value would be
--         @[1,2,3]@. An error occurs if an Add action is specified for a
--         set attribute and the attribute type specified does not match
--         the existing set type.
--
--         Both sets must have the same primitive data type. For example,
--         if the existing data type is a set of strings, the @Value@ must
--         also be a set of strings. The same holds true for number sets
--         and binary sets.
--
--     This action is only valid for an existing attribute whose data type
--     is number or is a set. Do not use @ADD@ for any other data types.
--
-- __If no item with the specified /Key/ is found:__
--
-- -   @PUT@ - DynamoDB creates a new item with the specified primary key,
--     and then adds the attribute.
--
-- -   @DELETE@ - Nothing happens; there is no attribute to delete.
--
-- -   @ADD@ - DynamoDB creates an item with the supplied primary key and
--     number (or set of numbers) for the attribute value. The only data
--     types allowed are number and number set; no other data types can be
--     specified.
attributeValueUpdate_action :: Lens.Lens' AttributeValueUpdate (Prelude.Maybe AttributeAction)
attributeValueUpdate_action :: (Maybe AttributeAction -> f (Maybe AttributeAction))
-> AttributeValueUpdate -> f AttributeValueUpdate
attributeValueUpdate_action = (AttributeValueUpdate -> Maybe AttributeAction)
-> (AttributeValueUpdate
    -> Maybe AttributeAction -> AttributeValueUpdate)
-> Lens
     AttributeValueUpdate
     AttributeValueUpdate
     (Maybe AttributeAction)
     (Maybe AttributeAction)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AttributeValueUpdate' {Maybe AttributeAction
action :: Maybe AttributeAction
$sel:action:AttributeValueUpdate' :: AttributeValueUpdate -> Maybe AttributeAction
action} -> Maybe AttributeAction
action) (\s :: AttributeValueUpdate
s@AttributeValueUpdate' {} Maybe AttributeAction
a -> AttributeValueUpdate
s {$sel:action:AttributeValueUpdate' :: Maybe AttributeAction
action = Maybe AttributeAction
a} :: AttributeValueUpdate)

instance Prelude.Hashable AttributeValueUpdate

instance Prelude.NFData AttributeValueUpdate

instance Core.ToJSON AttributeValueUpdate where
  toJSON :: AttributeValueUpdate -> Value
toJSON AttributeValueUpdate' {Maybe AttributeAction
Maybe AttributeValue
action :: Maybe AttributeAction
value :: Maybe AttributeValue
$sel:action:AttributeValueUpdate' :: AttributeValueUpdate -> Maybe AttributeAction
$sel:value:AttributeValueUpdate' :: AttributeValueUpdate -> Maybe AttributeValue
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"Value" 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
value,
            (Text
"Action" Text -> AttributeAction -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (AttributeAction -> Pair) -> Maybe AttributeAction -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AttributeAction
action
          ]
      )