All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.amazonaws.services.dynamodbv2.model.UpdateItemRequest Maven / Gradle / Ivy

Go to download

Gradle project for AWS SDK Android

The newest version!
/*
 * Copyright 2010-2015 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 * 
 *  http://aws.amazon.com/apache2.0
 * 
 * or in the "license" file accompanying this file. This file is distributed
 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */
package com.amazonaws.services.dynamodbv2.model;

import java.io.Serializable;

import com.amazonaws.AmazonWebServiceRequest;

/**
 * Container for the parameters to the {@link com.amazonaws.services.dynamodbv2.AmazonDynamoDB#updateItem(UpdateItemRequest) UpdateItem operation}.
 * 

 * Edits an existing item's attributes, or inserts a new item if it does
 * not already exist. You can put, delete, or add attribute values. You
 * can also perform a conditional update (insert a new attribute
 * name-value pair if it doesn't exist, or replace an existing name-value
 * pair if it has certain expected attribute values).
 * 

 * 

 * In addition to updating an item, you can also return the item's
 * attribute values in the same operation, using the ReturnValues
 * parameter.
 * 

 *
 * @see com.amazonaws.services.dynamodbv2.AmazonDynamoDB#updateItem(UpdateItemRequest)
 */
public class UpdateItemRequest extends AmazonWebServiceRequest implements Serializable {

    /**
     * The name of the table containing the item to update.
     * 

     * Constraints:

     * Length: 3 - 255

     * Pattern: [a-zA-Z0-9_.-]+

     */
    private String tableName;

    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     */
    private java.util.Map key;

    /**
     * The names of attributes to be modified, the action to perform on each,
     * and the new value for each. If you are updating an attribute that is
     * an index key attribute for any indexes on that table, the attribute
     * type must match the index key type defined in the
     * AttributesDefinition of the table description. You can use
     * UpdateItem to update any non-key attributes. 
Attribute
     * values cannot be null. String and binary type attributes must have
     * lengths greater than zero. Set type attributes must not be empty.
     * Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     */
    private java.util.Map attributeUpdates;

    /**
     * A map of attribute/condition pairs. This is the conditional block for
     * the UpdateItem operation. 
Each element of Expected
     * consists of an attribute name, a comparison operator, and one or more
     * values. DynamoDB compares the attribute with the value(s) you
     * supplied, using the comparison operator. For each Expected
     * element, the result of the evaluation is either true or false. 
If
     * you specify more than one element in the Expected map, then by
     * default all of the conditions must evaluate to true. In other words,
     * the conditions are ANDed together. (You can use the
     * ConditionalOperator parameter to OR the conditions instead. If
     * you do this, then at least one of the conditions must evaluate to
     * true, rather than all of them.) 
If the Expected map
     * evaluates to true, then the conditional operation succeeds; otherwise,
     * it fails. 
Each item in Expected represents an attribute name
     * for DynamoDB to check, along with an AttributeValueList and a
     * ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     * query expressions. 
    •  
  •  
    ComparisonOperator - A
     * comparator for evaluating attributes in the AttributeValueList.
     * When performing the comparison, DynamoDB uses strongly consistent
     * reads. 
    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. 
      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 specified 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.
     * 
      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 specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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. 
      •  
    •  
      NULL : The attribute does
     * not exist. 
      •  
    •  
      CONTAINS : checks for a
     * subsequence, or value in a set. 
      AttributeValueList can
     * contain only one AttributeValue of type String, Number, or
     * Binary (not a set). If the target attribute of the comparison is a
     * String, then the operation checks for a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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
     * operation checks for a member of the set (not as a substring). 
      • 
     * 
    •  
      NOT_CONTAINS : checks for absence of a
     * subsequence, or absence of a value in a set.
     * 
      AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set).
     * If the target attribute of the comparison is a String, then the
     * operation checks for the absence of a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     * as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     * prefix. 
      AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a
     * set). The target attribute of the comparison must be a String or
     * Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     * checks for exact matches. 
      AttributeValueList can contain
     * more than one AttributeValue of type String, Number, or Binary
     * (not a set). The target attribute of the comparison must be of the
     * same type and exact value to match. A String never matches a String
     * set. 
      •  
    •  
      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). 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 of a different
     * type than the one specified 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 Conditional
     * Expressions in the Amazon DynamoDB Developer Guide.  
For
     * backward compatibility with previous DynamoDB releases, the following
     * parameters can be used instead of AttributeValueList and
     * ComparisonOperator: 
     
  • Value - A value for
     * DynamoDB to compare with an attribute.
    •  
  • Exists -
     * Causes DynamoDB to evaluate the value vefore attempting the
     * conditional operation: 
       
    • If Exists is
     * true, DynamoDB will check to see if that attribute???
     * value already exists in the table. If it is found, then the condition
     * evaluates to true; otherwise the condition evaluate to false.
      • 
     * 
    • If Exists is false, DynamoDB assumes that
     * the attribute value does??? not exist in the table. If in fact
     * the value does not exist, then the??? assumption is valid and the
     * condition evaluates to true. If the value is found, despite the
     * assumption that it does not exist, the condition evaluates to
     * false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     * accept the Value and Exists parameters, they are now
     * deprecated. We recommend that you use AttributeValueList and
     * ComparisonOperator instead, since they allow you to constuct a
     * much wider range of conditions. 
The Value and Exists
     * parameters are incompatible with AttributeValueList and
     * ComparisonOperator. If you attempt to use both sets of
     * parameters at once, DynamoDB will throw a ValidationException.
     * 
     */
    private java.util.Map expected;

    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     */
    private String conditionalOperator;

    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     */
    private String returnValues;

    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     */
    private String returnConsumedCapacity;

    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     */
    private String returnItemCollectionMetrics;

    private String updateExpression;

    private String conditionExpression;

    private java.util.Map expressionAttributeNames;

    private java.util.Map expressionAttributeValues;

    /**
     * Default constructor for a new UpdateItemRequest object.  Callers should use the
     * setter or fluent setter (with...) methods to initialize this object after creating it.
     */
    public UpdateItemRequest() {}
    
    /**
     * Constructs a new UpdateItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param tableName The name of the table containing the item to update.
     * @param key The primary key that defines the item. Each element
     * consists of an attribute name and a value for that attribute.
     * @param attributeUpdates The names of attributes to be modified, the
     * action to perform on each, and the new value for each. If you are
     * updating an attribute that is an index key attribute for any indexes
     * on that table, the attribute type must match the index key type
     * defined in the AttributesDefinition of the table description.
     * You can use UpdateItem to update any non-key attributes.
     * 
Attribute values cannot be null. String and binary type attributes
     * must have lengths greater than zero. Set type attributes must not be
     * empty. Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     */
    public UpdateItemRequest(String tableName, java.util.Map key, java.util.Map attributeUpdates) {
        setTableName(tableName);
        setKey(key);
        setAttributeUpdates(attributeUpdates);
    }

    /**
     * Constructs a new UpdateItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param tableName The name of the table containing the item to update.
     * @param key The primary key that defines the item. Each element
     * consists of an attribute name and a value for that attribute.
     * @param attributeUpdates The names of attributes to be modified, the
     * action to perform on each, and the new value for each. If you are
     * updating an attribute that is an index key attribute for any indexes
     * on that table, the attribute type must match the index key type
     * defined in the AttributesDefinition of the table description.
     * You can use UpdateItem to update any non-key attributes.
     * 
Attribute values cannot be null. String and binary type attributes
     * must have lengths greater than zero. Set type attributes must not be
     * empty. Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     * @param returnValues Use ReturnValues if you want to get the
     * item attributes as they appeared either before or after they were
     * updated. For UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     */
    public UpdateItemRequest(String tableName, java.util.Map key, java.util.Map attributeUpdates, String returnValues) {
        setTableName(tableName);
        setKey(key);
        setAttributeUpdates(attributeUpdates);
        setReturnValues(returnValues);
    }

    /**
     * Constructs a new UpdateItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param tableName The name of the table containing the item to update.
     * @param key The primary key that defines the item. Each element
     * consists of an attribute name and a value for that attribute.
     * @param attributeUpdates The names of attributes to be modified, the
     * action to perform on each, and the new value for each. If you are
     * updating an attribute that is an index key attribute for any indexes
     * on that table, the attribute type must match the index key type
     * defined in the AttributesDefinition of the table description.
     * You can use UpdateItem to update any non-key attributes.
     * 
Attribute values cannot be null. String and binary type attributes
     * must have lengths greater than zero. Set type attributes must not be
     * empty. Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     * @param returnValues Use ReturnValues if you want to get the
     * item attributes as they appeared either before or after they were
     * updated. For UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     */
    public UpdateItemRequest(String tableName, java.util.Map key, java.util.Map attributeUpdates, ReturnValue returnValues) {
        this.tableName = tableName;
        this.key = key;
        this.attributeUpdates = attributeUpdates;
        this.returnValues = returnValues.toString();
    }

    /**
     * The name of the table containing the item to update.
     * 

     * Constraints:

     * Length: 3 - 255

     * Pattern: [a-zA-Z0-9_.-]+

     *
     * @return The name of the table containing the item to update.
     */
    public String getTableName() {
        return tableName;
    }
    
    /**
     * The name of the table containing the item to update.
     * 

     * Constraints:

     * Length: 3 - 255

     * Pattern: [a-zA-Z0-9_.-]+

     *
     * @param tableName The name of the table containing the item to update.
     */
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
    
    /**
     * The name of the table containing the item to update.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Length: 3 - 255

     * Pattern: [a-zA-Z0-9_.-]+

     *
     * @param tableName The name of the table containing the item to update.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withTableName(String tableName) {
        this.tableName = tableName;
        return this;
    }

    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     *
     * @return The primary key that defines the item. Each element consists of an
     *         attribute name and a value for that attribute.
     */
    public java.util.Map getKey() {
        
        return key;
    }
    
    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     *
     * @param key The primary key that defines the item. Each element consists of an
     *         attribute name and a value for that attribute.
     */
    public void setKey(java.util.Map key) {
        this.key = key;
    }
    
    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param key The primary key that defines the item. Each element consists of an
     *         attribute name and a value for that attribute.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withKey(java.util.Map key) {
        setKey(key);
        return this;
    }

    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     * 

     * This method accepts the hashKey, rangeKey of Key as
     * java.util.Map.Entry objects.
     *
     * @param hashKey Primary hash key.
     * @param rangeKey Primary range key. (null if it a hash-only table)
     */
    public void setKey(java.util.Map.Entry hashKey, java.util.Map.Entry rangeKey) throws IllegalArgumentException {
        java.util.HashMap key = new java.util.HashMap();
        
        if (hashKey != null) {
            key.put(hashKey.getKey(), hashKey.getValue());
        } else
            throw new IllegalArgumentException("hashKey must be non-null object.");
        if (rangeKey != null) {
            key.put(rangeKey.getKey(), rangeKey.getValue());
        } 
        setKey(key);
    }
    
    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     * 

     * This method accepts the hashKey, rangeKey of Key as
     * java.util.Map.Entry objects.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param hashKey Primary hash key.
     * @param rangeKey Primary range key. (null if it a hash-only table)
     */
    public UpdateItemRequest withKey(java.util.Map.Entry hashKey, java.util.Map.Entry rangeKey) throws IllegalArgumentException {
        setKey(hashKey, rangeKey);
        return this;
    }

    /**
     * The primary key that defines the item. Each element consists of an
     * attribute name and a value for that attribute.
     * 

     * The method adds a new key-value pair into Key parameter, and returns a
     * reference to this object so that method calls can be chained together.
     *
     * @param key The key of the entry to be added into Key.
     * @param value The corresponding value of the entry to be added into Key.
     */
    public UpdateItemRequest addKeyEntry(String key, AttributeValue value) {
        if (null == this.key) {
            this.key = new java.util.HashMap();
        }
        if (this.key.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.key.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into Key.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     */
    public UpdateItemRequest clearKeyEntries() {
        this.key = null;
        return this;
    }
    
    /**
     * The names of attributes to be modified, the action to perform on each,
     * and the new value for each. If you are updating an attribute that is
     * an index key attribute for any indexes on that table, the attribute
     * type must match the index key type defined in the
     * AttributesDefinition of the table description. You can use
     * UpdateItem to update any non-key attributes. 
Attribute
     * values cannot be null. String and binary type attributes must have
     * lengths greater than zero. Set type attributes must not be empty.
     * Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     *
     * @return The names of attributes to be modified, the action to perform on each,
     *         and the new value for each. If you are updating an attribute that is
     *         an index key attribute for any indexes on that table, the attribute
     *         type must match the index key type defined in the
     *         AttributesDefinition of the table description. You can use
     *         UpdateItem to update any non-key attributes. 
Attribute
     *         values cannot be null. String and binary type attributes must have
     *         lengths greater than zero. Set type attributes must not be empty.
     *         Requests with empty values will be rejected with a
     *         ValidationException. 
Each AttributeUpdates element
     *         consists of an attribute name to modify, along with the following:
     *         
     
  •  
    Value - The new value, if applicable, for this
     *         attribute. 
    •  
  •  
    Action - Specifies how to perform the
     *         update. Valid values for Action are PUT,
     *         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. 
      •  
     
    •  

     *         
If you specify any attributes that are part of an index key, then
     *         the data types for those attributes must match those of the schema in
     *         the table's attribute definition.
     */
    public java.util.Map getAttributeUpdates() {
        
        return attributeUpdates;
    }
    
    /**
     * The names of attributes to be modified, the action to perform on each,
     * and the new value for each. If you are updating an attribute that is
     * an index key attribute for any indexes on that table, the attribute
     * type must match the index key type defined in the
     * AttributesDefinition of the table description. You can use
     * UpdateItem to update any non-key attributes. 
Attribute
     * values cannot be null. String and binary type attributes must have
     * lengths greater than zero. Set type attributes must not be empty.
     * Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     *
     * @param attributeUpdates The names of attributes to be modified, the action to perform on each,
     *         and the new value for each. If you are updating an attribute that is
     *         an index key attribute for any indexes on that table, the attribute
     *         type must match the index key type defined in the
     *         AttributesDefinition of the table description. You can use
     *         UpdateItem to update any non-key attributes. 
Attribute
     *         values cannot be null. String and binary type attributes must have
     *         lengths greater than zero. Set type attributes must not be empty.
     *         Requests with empty values will be rejected with a
     *         ValidationException. 
Each AttributeUpdates element
     *         consists of an attribute name to modify, along with the following:
     *         
     
  •  
    Value - The new value, if applicable, for this
     *         attribute. 
    •  
  •  
    Action - Specifies how to perform the
     *         update. Valid values for Action are PUT,
     *         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. 
      •  
     
    •  

     *         
If you specify any attributes that are part of an index key, then
     *         the data types for those attributes must match those of the schema in
     *         the table's attribute definition.
     */
    public void setAttributeUpdates(java.util.Map attributeUpdates) {
        this.attributeUpdates = attributeUpdates;
    }
    
    /**
     * The names of attributes to be modified, the action to perform on each,
     * and the new value for each. If you are updating an attribute that is
     * an index key attribute for any indexes on that table, the attribute
     * type must match the index key type defined in the
     * AttributesDefinition of the table description. You can use
     * UpdateItem to update any non-key attributes. 
Attribute
     * values cannot be null. String and binary type attributes must have
     * lengths greater than zero. Set type attributes must not be empty.
     * Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param attributeUpdates The names of attributes to be modified, the action to perform on each,
     *         and the new value for each. If you are updating an attribute that is
     *         an index key attribute for any indexes on that table, the attribute
     *         type must match the index key type defined in the
     *         AttributesDefinition of the table description. You can use
     *         UpdateItem to update any non-key attributes. 
Attribute
     *         values cannot be null. String and binary type attributes must have
     *         lengths greater than zero. Set type attributes must not be empty.
     *         Requests with empty values will be rejected with a
     *         ValidationException. 
Each AttributeUpdates element
     *         consists of an attribute name to modify, along with the following:
     *         
     
  •  
    Value - The new value, if applicable, for this
     *         attribute. 
    •  
  •  
    Action - Specifies how to perform the
     *         update. Valid values for Action are PUT,
     *         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. 
      •  
     
    •  

     *         
If you specify any attributes that are part of an index key, then
     *         the data types for those attributes must match those of the schema in
     *         the table's attribute definition.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withAttributeUpdates(java.util.Map attributeUpdates) {
        setAttributeUpdates(attributeUpdates);
        return this;
    }

    /**
     * The names of attributes to be modified, the action to perform on each,
     * and the new value for each. If you are updating an attribute that is
     * an index key attribute for any indexes on that table, the attribute
     * type must match the index key type defined in the
     * AttributesDefinition of the table description. You can use
     * UpdateItem to update any non-key attributes. 
Attribute
     * values cannot be null. String and binary type attributes must have
     * lengths greater than zero. Set type attributes must not be empty.
     * Requests with empty values will be rejected with a
     * ValidationException. 
Each AttributeUpdates element
     * consists of an attribute name to modify, along with the following:
     * 
     
  •  
    Value - The new value, if applicable, for this
     * attribute. 
    •  
  •  
    Action - Specifies how to perform the
     * update. Valid values for Action are PUT,
     * 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. 
      •  
     
    •  

     * 
If you specify any attributes that are part of an index key, then
     * the data types for those attributes must match those of the schema in
     * the table's attribute definition.
     * 

     * The method adds a new key-value pair into AttributeUpdates parameter,
     * and returns a reference to this object so that method calls can be
     * chained together.
     *
     * @param key The key of the entry to be added into AttributeUpdates.
     * @param value The corresponding value of the entry to be added into AttributeUpdates.
     */
    public UpdateItemRequest addAttributeUpdatesEntry(String key, AttributeValueUpdate value) {
        if (null == this.attributeUpdates) {
            this.attributeUpdates = new java.util.HashMap();
        }
        if (this.attributeUpdates.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.attributeUpdates.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into AttributeUpdates.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     */
    public UpdateItemRequest clearAttributeUpdatesEntries() {
        this.attributeUpdates = null;
        return this;
    }
    
    /**
     * A map of attribute/condition pairs. This is the conditional block for
     * the UpdateItem operation. 
Each element of Expected
     * consists of an attribute name, a comparison operator, and one or more
     * values. DynamoDB compares the attribute with the value(s) you
     * supplied, using the comparison operator. For each Expected
     * element, the result of the evaluation is either true or false. 
If
     * you specify more than one element in the Expected map, then by
     * default all of the conditions must evaluate to true. In other words,
     * the conditions are ANDed together. (You can use the
     * ConditionalOperator parameter to OR the conditions instead. If
     * you do this, then at least one of the conditions must evaluate to
     * true, rather than all of them.) 
If the Expected map
     * evaluates to true, then the conditional operation succeeds; otherwise,
     * it fails. 
Each item in Expected represents an attribute name
     * for DynamoDB to check, along with an AttributeValueList and a
     * ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     * query expressions. 
    •  
  •  
    ComparisonOperator - A
     * comparator for evaluating attributes in the AttributeValueList.
     * When performing the comparison, DynamoDB uses strongly consistent
     * reads. 
    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. 
      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 specified 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.
     * 
      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 specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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. 
      •  
    •  
      NULL : The attribute does
     * not exist. 
      •  
    •  
      CONTAINS : checks for a
     * subsequence, or value in a set. 
      AttributeValueList can
     * contain only one AttributeValue of type String, Number, or
     * Binary (not a set). If the target attribute of the comparison is a
     * String, then the operation checks for a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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
     * operation checks for a member of the set (not as a substring). 
      • 
     * 
    •  
      NOT_CONTAINS : checks for absence of a
     * subsequence, or absence of a value in a set.
     * 
      AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set).
     * If the target attribute of the comparison is a String, then the
     * operation checks for the absence of a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     * as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     * prefix. 
      AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a
     * set). The target attribute of the comparison must be a String or
     * Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     * checks for exact matches. 
      AttributeValueList can contain
     * more than one AttributeValue of type String, Number, or Binary
     * (not a set). The target attribute of the comparison must be of the
     * same type and exact value to match. A String never matches a String
     * set. 
      •  
    •  
      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). 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 of a different
     * type than the one specified 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 Conditional
     * Expressions in the Amazon DynamoDB Developer Guide.  
For
     * backward compatibility with previous DynamoDB releases, the following
     * parameters can be used instead of AttributeValueList and
     * ComparisonOperator: 
     
  • Value - A value for
     * DynamoDB to compare with an attribute.
    •  
  • Exists -
     * Causes DynamoDB to evaluate the value vefore attempting the
     * conditional operation: 
       
    • If Exists is
     * true, DynamoDB will check to see if that attribute???
     * value already exists in the table. If it is found, then the condition
     * evaluates to true; otherwise the condition evaluate to false.
      • 
     * 
    • If Exists is false, DynamoDB assumes that
     * the attribute value does??? not exist in the table. If in fact
     * the value does not exist, then the??? assumption is valid and the
     * condition evaluates to true. If the value is found, despite the
     * assumption that it does not exist, the condition evaluates to
     * false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     * accept the Value and Exists parameters, they are now
     * deprecated. We recommend that you use AttributeValueList and
     * ComparisonOperator instead, since they allow you to constuct a
     * much wider range of conditions. 
The Value and Exists
     * parameters are incompatible with AttributeValueList and
     * ComparisonOperator. If you attempt to use both sets of
     * parameters at once, DynamoDB will throw a ValidationException.
     * 
     *
     * @return A map of attribute/condition pairs. This is the conditional block for
     *         the UpdateItem operation. 
Each element of Expected
     *         consists of an attribute name, a comparison operator, and one or more
     *         values. DynamoDB compares the attribute with the value(s) you
     *         supplied, using the comparison operator. For each Expected
     *         element, the result of the evaluation is either true or false. 
If
     *         you specify more than one element in the Expected map, then by
     *         default all of the conditions must evaluate to true. In other words,
     *         the conditions are ANDed together. (You can use the
     *         ConditionalOperator parameter to OR the conditions instead. If
     *         you do this, then at least one of the conditions must evaluate to
     *         true, rather than all of them.) 
If the Expected map
     *         evaluates to true, then the conditional operation succeeds; otherwise,
     *         it fails. 
Each item in Expected represents an attribute name
     *         for DynamoDB to check, along with an AttributeValueList and a
     *         ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     *         query expressions. 
    •  
  •  
    ComparisonOperator - A
     *         comparator for evaluating attributes in the AttributeValueList.
     *         When performing the comparison, DynamoDB uses strongly consistent
     *         reads. 
    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. 
      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 specified 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.
     *         
      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 specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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. 
      •  
    •  
      NULL : The attribute does
     *         not exist. 
      •  
    •  
      CONTAINS : checks for a
     *         subsequence, or value in a set. 
      AttributeValueList can
     *         contain only one AttributeValue of type String, Number, or
     *         Binary (not a set). If the target attribute of the comparison is a
     *         String, then the operation checks for a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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
     *         operation checks for a member of the set (not as a substring). 
      • 
     *         
    •  
      NOT_CONTAINS : checks for absence of a
     *         subsequence, or absence of a value in a set.
     *         
      AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set).
     *         If the target attribute of the comparison is a String, then the
     *         operation checks for the absence of a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     *         as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     *         prefix. 
      AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a
     *         set). The target attribute of the comparison must be a String or
     *         Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     *         checks for exact matches. 
      AttributeValueList can contain
     *         more than one AttributeValue of type String, Number, or Binary
     *         (not a set). The target attribute of the comparison must be of the
     *         same type and exact value to match. A String never matches a String
     *         set. 
      •  
    •  
      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). 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 of a different
     *         type than the one specified 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 Conditional
     *         Expressions in the Amazon DynamoDB Developer Guide.  
For
     *         backward compatibility with previous DynamoDB releases, the following
     *         parameters can be used instead of AttributeValueList and
     *         ComparisonOperator: 
     
  • Value - A value for
     *         DynamoDB to compare with an attribute.
    •  
  • Exists -
     *         Causes DynamoDB to evaluate the value vefore attempting the
     *         conditional operation: 
       
    • If Exists is
     *         true, DynamoDB will check to see if that attribute???
     *         value already exists in the table. If it is found, then the condition
     *         evaluates to true; otherwise the condition evaluate to false.
      • 
     *         
    • If Exists is false, DynamoDB assumes that
     *         the attribute value does??? not exist in the table. If in fact
     *         the value does not exist, then the??? assumption is valid and the
     *         condition evaluates to true. If the value is found, despite the
     *         assumption that it does not exist, the condition evaluates to
     *         false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     *         accept the Value and Exists parameters, they are now
     *         deprecated. We recommend that you use AttributeValueList and
     *         ComparisonOperator instead, since they allow you to constuct a
     *         much wider range of conditions. 
The Value and Exists
     *         parameters are incompatible with AttributeValueList and
     *         ComparisonOperator. If you attempt to use both sets of
     *         parameters at once, DynamoDB will throw a ValidationException.
     *         
     */
    public java.util.Map getExpected() {
        
        return expected;
    }
    
    /**
     * A map of attribute/condition pairs. This is the conditional block for
     * the UpdateItem operation. 
Each element of Expected
     * consists of an attribute name, a comparison operator, and one or more
     * values. DynamoDB compares the attribute with the value(s) you
     * supplied, using the comparison operator. For each Expected
     * element, the result of the evaluation is either true or false. 
If
     * you specify more than one element in the Expected map, then by
     * default all of the conditions must evaluate to true. In other words,
     * the conditions are ANDed together. (You can use the
     * ConditionalOperator parameter to OR the conditions instead. If
     * you do this, then at least one of the conditions must evaluate to
     * true, rather than all of them.) 
If the Expected map
     * evaluates to true, then the conditional operation succeeds; otherwise,
     * it fails. 
Each item in Expected represents an attribute name
     * for DynamoDB to check, along with an AttributeValueList and a
     * ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     * query expressions. 
    •  
  •  
    ComparisonOperator - A
     * comparator for evaluating attributes in the AttributeValueList.
     * When performing the comparison, DynamoDB uses strongly consistent
     * reads. 
    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. 
      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 specified 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.
     * 
      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 specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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. 
      •  
    •  
      NULL : The attribute does
     * not exist. 
      •  
    •  
      CONTAINS : checks for a
     * subsequence, or value in a set. 
      AttributeValueList can
     * contain only one AttributeValue of type String, Number, or
     * Binary (not a set). If the target attribute of the comparison is a
     * String, then the operation checks for a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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
     * operation checks for a member of the set (not as a substring). 
      • 
     * 
    •  
      NOT_CONTAINS : checks for absence of a
     * subsequence, or absence of a value in a set.
     * 
      AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set).
     * If the target attribute of the comparison is a String, then the
     * operation checks for the absence of a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     * as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     * prefix. 
      AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a
     * set). The target attribute of the comparison must be a String or
     * Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     * checks for exact matches. 
      AttributeValueList can contain
     * more than one AttributeValue of type String, Number, or Binary
     * (not a set). The target attribute of the comparison must be of the
     * same type and exact value to match. A String never matches a String
     * set. 
      •  
    •  
      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). 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 of a different
     * type than the one specified 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 Conditional
     * Expressions in the Amazon DynamoDB Developer Guide.  
For
     * backward compatibility with previous DynamoDB releases, the following
     * parameters can be used instead of AttributeValueList and
     * ComparisonOperator: 
     
  • Value - A value for
     * DynamoDB to compare with an attribute.
    •  
  • Exists -
     * Causes DynamoDB to evaluate the value vefore attempting the
     * conditional operation: 
       
    • If Exists is
     * true, DynamoDB will check to see if that attribute???
     * value already exists in the table. If it is found, then the condition
     * evaluates to true; otherwise the condition evaluate to false.
      • 
     * 
    • If Exists is false, DynamoDB assumes that
     * the attribute value does??? not exist in the table. If in fact
     * the value does not exist, then the??? assumption is valid and the
     * condition evaluates to true. If the value is found, despite the
     * assumption that it does not exist, the condition evaluates to
     * false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     * accept the Value and Exists parameters, they are now
     * deprecated. We recommend that you use AttributeValueList and
     * ComparisonOperator instead, since they allow you to constuct a
     * much wider range of conditions. 
The Value and Exists
     * parameters are incompatible with AttributeValueList and
     * ComparisonOperator. If you attempt to use both sets of
     * parameters at once, DynamoDB will throw a ValidationException.
     * 
     *
     * @param expected A map of attribute/condition pairs. This is the conditional block for
     *         the UpdateItem operation. 
Each element of Expected
     *         consists of an attribute name, a comparison operator, and one or more
     *         values. DynamoDB compares the attribute with the value(s) you
     *         supplied, using the comparison operator. For each Expected
     *         element, the result of the evaluation is either true or false. 
If
     *         you specify more than one element in the Expected map, then by
     *         default all of the conditions must evaluate to true. In other words,
     *         the conditions are ANDed together. (You can use the
     *         ConditionalOperator parameter to OR the conditions instead. If
     *         you do this, then at least one of the conditions must evaluate to
     *         true, rather than all of them.) 
If the Expected map
     *         evaluates to true, then the conditional operation succeeds; otherwise,
     *         it fails. 
Each item in Expected represents an attribute name
     *         for DynamoDB to check, along with an AttributeValueList and a
     *         ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     *         query expressions. 
    •  
  •  
    ComparisonOperator - A
     *         comparator for evaluating attributes in the AttributeValueList.
     *         When performing the comparison, DynamoDB uses strongly consistent
     *         reads. 
    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. 
      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 specified 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.
     *         
      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 specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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. 
      •  
    •  
      NULL : The attribute does
     *         not exist. 
      •  
    •  
      CONTAINS : checks for a
     *         subsequence, or value in a set. 
      AttributeValueList can
     *         contain only one AttributeValue of type String, Number, or
     *         Binary (not a set). If the target attribute of the comparison is a
     *         String, then the operation checks for a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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
     *         operation checks for a member of the set (not as a substring). 
      • 
     *         
    •  
      NOT_CONTAINS : checks for absence of a
     *         subsequence, or absence of a value in a set.
     *         
      AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set).
     *         If the target attribute of the comparison is a String, then the
     *         operation checks for the absence of a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     *         as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     *         prefix. 
      AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a
     *         set). The target attribute of the comparison must be a String or
     *         Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     *         checks for exact matches. 
      AttributeValueList can contain
     *         more than one AttributeValue of type String, Number, or Binary
     *         (not a set). The target attribute of the comparison must be of the
     *         same type and exact value to match. A String never matches a String
     *         set. 
      •  
    •  
      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). 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 of a different
     *         type than the one specified 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 Conditional
     *         Expressions in the Amazon DynamoDB Developer Guide.  
For
     *         backward compatibility with previous DynamoDB releases, the following
     *         parameters can be used instead of AttributeValueList and
     *         ComparisonOperator: 
     
  • Value - A value for
     *         DynamoDB to compare with an attribute.
    •  
  • Exists -
     *         Causes DynamoDB to evaluate the value vefore attempting the
     *         conditional operation: 
       
    • If Exists is
     *         true, DynamoDB will check to see if that attribute???
     *         value already exists in the table. If it is found, then the condition
     *         evaluates to true; otherwise the condition evaluate to false.
      • 
     *         
    • If Exists is false, DynamoDB assumes that
     *         the attribute value does??? not exist in the table. If in fact
     *         the value does not exist, then the??? assumption is valid and the
     *         condition evaluates to true. If the value is found, despite the
     *         assumption that it does not exist, the condition evaluates to
     *         false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     *         accept the Value and Exists parameters, they are now
     *         deprecated. We recommend that you use AttributeValueList and
     *         ComparisonOperator instead, since they allow you to constuct a
     *         much wider range of conditions. 
The Value and Exists
     *         parameters are incompatible with AttributeValueList and
     *         ComparisonOperator. If you attempt to use both sets of
     *         parameters at once, DynamoDB will throw a ValidationException.
     *         
     */
    public void setExpected(java.util.Map expected) {
        this.expected = expected;
    }
    
    /**
     * A map of attribute/condition pairs. This is the conditional block for
     * the UpdateItem operation. 
Each element of Expected
     * consists of an attribute name, a comparison operator, and one or more
     * values. DynamoDB compares the attribute with the value(s) you
     * supplied, using the comparison operator. For each Expected
     * element, the result of the evaluation is either true or false. 
If
     * you specify more than one element in the Expected map, then by
     * default all of the conditions must evaluate to true. In other words,
     * the conditions are ANDed together. (You can use the
     * ConditionalOperator parameter to OR the conditions instead. If
     * you do this, then at least one of the conditions must evaluate to
     * true, rather than all of them.) 
If the Expected map
     * evaluates to true, then the conditional operation succeeds; otherwise,
     * it fails. 
Each item in Expected represents an attribute name
     * for DynamoDB to check, along with an AttributeValueList and a
     * ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     * query expressions. 
    •  
  •  
    ComparisonOperator - A
     * comparator for evaluating attributes in the AttributeValueList.
     * When performing the comparison, DynamoDB uses strongly consistent
     * reads. 
    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. 
      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 specified 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.
     * 
      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 specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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. 
      •  
    •  
      NULL : The attribute does
     * not exist. 
      •  
    •  
      CONTAINS : checks for a
     * subsequence, or value in a set. 
      AttributeValueList can
     * contain only one AttributeValue of type String, Number, or
     * Binary (not a set). If the target attribute of the comparison is a
     * String, then the operation checks for a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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
     * operation checks for a member of the set (not as a substring). 
      • 
     * 
    •  
      NOT_CONTAINS : checks for absence of a
     * subsequence, or absence of a value in a set.
     * 
      AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set).
     * If the target attribute of the comparison is a String, then the
     * operation checks for the absence of a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     * as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     * prefix. 
      AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a
     * set). The target attribute of the comparison must be a String or
     * Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     * checks for exact matches. 
      AttributeValueList can contain
     * more than one AttributeValue of type String, Number, or Binary
     * (not a set). The target attribute of the comparison must be of the
     * same type and exact value to match. A String never matches a String
     * set. 
      •  
    •  
      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). 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 of a different
     * type than the one specified 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 Conditional
     * Expressions in the Amazon DynamoDB Developer Guide.  
For
     * backward compatibility with previous DynamoDB releases, the following
     * parameters can be used instead of AttributeValueList and
     * ComparisonOperator: 
     
  • Value - A value for
     * DynamoDB to compare with an attribute.
    •  
  • Exists -
     * Causes DynamoDB to evaluate the value vefore attempting the
     * conditional operation: 
       
    • If Exists is
     * true, DynamoDB will check to see if that attribute???
     * value already exists in the table. If it is found, then the condition
     * evaluates to true; otherwise the condition evaluate to false.
      • 
     * 
    • If Exists is false, DynamoDB assumes that
     * the attribute value does??? not exist in the table. If in fact
     * the value does not exist, then the??? assumption is valid and the
     * condition evaluates to true. If the value is found, despite the
     * assumption that it does not exist, the condition evaluates to
     * false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     * accept the Value and Exists parameters, they are now
     * deprecated. We recommend that you use AttributeValueList and
     * ComparisonOperator instead, since they allow you to constuct a
     * much wider range of conditions. 
The Value and Exists
     * parameters are incompatible with AttributeValueList and
     * ComparisonOperator. If you attempt to use both sets of
     * parameters at once, DynamoDB will throw a ValidationException.
     * 
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param expected A map of attribute/condition pairs. This is the conditional block for
     *         the UpdateItem operation. 
Each element of Expected
     *         consists of an attribute name, a comparison operator, and one or more
     *         values. DynamoDB compares the attribute with the value(s) you
     *         supplied, using the comparison operator. For each Expected
     *         element, the result of the evaluation is either true or false. 
If
     *         you specify more than one element in the Expected map, then by
     *         default all of the conditions must evaluate to true. In other words,
     *         the conditions are ANDed together. (You can use the
     *         ConditionalOperator parameter to OR the conditions instead. If
     *         you do this, then at least one of the conditions must evaluate to
     *         true, rather than all of them.) 
If the Expected map
     *         evaluates to true, then the conditional operation succeeds; otherwise,
     *         it fails. 
Each item in Expected represents an attribute name
     *         for DynamoDB to check, along with an AttributeValueList and a
     *         ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     *         query expressions. 
    •  
  •  
    ComparisonOperator - A
     *         comparator for evaluating attributes in the AttributeValueList.
     *         When performing the comparison, DynamoDB uses strongly consistent
     *         reads. 
    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. 
      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 specified 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.
     *         
      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 specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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 of type String, Number, or Binary (not a set).
     *         If an item contains an AttributeValue of a different type than
     *         the one specified 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. 
      •  
    •  
      NULL : The attribute does
     *         not exist. 
      •  
    •  
      CONTAINS : checks for a
     *         subsequence, or value in a set. 
      AttributeValueList can
     *         contain only one AttributeValue of type String, Number, or
     *         Binary (not a set). If the target attribute of the comparison is a
     *         String, then the operation checks for a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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
     *         operation checks for a member of the set (not as a substring). 
      • 
     *         
    •  
      NOT_CONTAINS : checks for absence of a
     *         subsequence, or absence of a value in a set.
     *         
      AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set).
     *         If the target attribute of the comparison is a String, then the
     *         operation checks for the absence of a substring match. If the target
     *         attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     *         as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     *         prefix. 
      AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a
     *         set). The target attribute of the comparison must be a String or
     *         Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     *         checks for exact matches. 
      AttributeValueList can contain
     *         more than one AttributeValue of type String, Number, or Binary
     *         (not a set). The target attribute of the comparison must be of the
     *         same type and exact value to match. A String never matches a String
     *         set. 
      •  
    •  
      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). 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 of a different
     *         type than the one specified 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 Conditional
     *         Expressions in the Amazon DynamoDB Developer Guide.  
For
     *         backward compatibility with previous DynamoDB releases, the following
     *         parameters can be used instead of AttributeValueList and
     *         ComparisonOperator: 
     
  • Value - A value for
     *         DynamoDB to compare with an attribute.
    •  
  • Exists -
     *         Causes DynamoDB to evaluate the value vefore attempting the
     *         conditional operation: 
       
    • If Exists is
     *         true, DynamoDB will check to see if that attribute???
     *         value already exists in the table. If it is found, then the condition
     *         evaluates to true; otherwise the condition evaluate to false.
      • 
     *         
    • If Exists is false, DynamoDB assumes that
     *         the attribute value does??? not exist in the table. If in fact
     *         the value does not exist, then the??? assumption is valid and the
     *         condition evaluates to true. If the value is found, despite the
     *         assumption that it does not exist, the condition evaluates to
     *         false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     *         accept the Value and Exists parameters, they are now
     *         deprecated. We recommend that you use AttributeValueList and
     *         ComparisonOperator instead, since they allow you to constuct a
     *         much wider range of conditions. 
The Value and Exists
     *         parameters are incompatible with AttributeValueList and
     *         ComparisonOperator. If you attempt to use both sets of
     *         parameters at once, DynamoDB will throw a ValidationException.
     *         
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withExpected(java.util.Map expected) {
        setExpected(expected);
        return this;
    }

    /**
     * A map of attribute/condition pairs. This is the conditional block for
     * the UpdateItem operation. 
Each element of Expected
     * consists of an attribute name, a comparison operator, and one or more
     * values. DynamoDB compares the attribute with the value(s) you
     * supplied, using the comparison operator. For each Expected
     * element, the result of the evaluation is either true or false. 
If
     * you specify more than one element in the Expected map, then by
     * default all of the conditions must evaluate to true. In other words,
     * the conditions are ANDed together. (You can use the
     * ConditionalOperator parameter to OR the conditions instead. If
     * you do this, then at least one of the conditions must evaluate to
     * true, rather than all of them.) 
If the Expected map
     * evaluates to true, then the conditional operation succeeds; otherwise,
     * it fails. 
Each item in Expected represents an attribute name
     * for DynamoDB to check, along with an AttributeValueList and a
     * ComparisonOperator: 
     
  •  
    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 aa 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, for example when evaluating
     * query expressions. 
    •  
  •  
    ComparisonOperator - A
     * comparator for evaluating attributes in the AttributeValueList.
     * When performing the comparison, DynamoDB uses strongly consistent
     * reads. 
    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. 
      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 specified 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.
     * 
      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 specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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 of type String, Number, or Binary (not a set).
     * If an item contains an AttributeValue of a different type than
     * the one specified 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. 
      •  
    •  
      NULL : The attribute does
     * not exist. 
      •  
    •  
      CONTAINS : checks for a
     * subsequence, or value in a set. 
      AttributeValueList can
     * contain only one AttributeValue of type String, Number, or
     * Binary (not a set). If the target attribute of the comparison is a
     * String, then the operation checks for a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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
     * operation checks for a member of the set (not as a substring). 
      • 
     * 
    •  
      NOT_CONTAINS : checks for absence of a
     * subsequence, or absence of a value in a set.
     * 
      AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set).
     * If the target attribute of the comparison is a String, then the
     * operation checks for the absence of a substring match. If the target
     * attribute of the comparison is Binary, then the operation 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 operation checks for the absence of a member of the set (not
     * as a substring).
      •  
    •  
      BEGINS_WITH : checks for a
     * prefix. 
      AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a
     * set). The target attribute of the comparison must be a String or
     * Binary (not a Number or a set). 
       
      •  
    •  
      IN :
     * checks for exact matches. 
      AttributeValueList can contain
     * more than one AttributeValue of type String, Number, or Binary
     * (not a set). The target attribute of the comparison must be of the
     * same type and exact value to match. A String never matches a String
     * set. 
      •  
    •  
      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). 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 of a different
     * type than the one specified 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 Conditional
     * Expressions in the Amazon DynamoDB Developer Guide.  
For
     * backward compatibility with previous DynamoDB releases, the following
     * parameters can be used instead of AttributeValueList and
     * ComparisonOperator: 
     
  • Value - A value for
     * DynamoDB to compare with an attribute.
    •  
  • Exists -
     * Causes DynamoDB to evaluate the value vefore attempting the
     * conditional operation: 
       
    • If Exists is
     * true, DynamoDB will check to see if that attribute???
     * value already exists in the table. If it is found, then the condition
     * evaluates to true; otherwise the condition evaluate to false.
      • 
     * 
    • If Exists is false, DynamoDB assumes that
     * the attribute value does??? not exist in the table. If in fact
     * the value does not exist, then the??? assumption is valid and the
     * condition evaluates to true. If the value is found, despite the
     * assumption that it does not exist, the condition evaluates to
     * false.???
      •  
     
    •  
 
Even though DynamoDB continues to
     * accept the Value and Exists parameters, they are now
     * deprecated. We recommend that you use AttributeValueList and
     * ComparisonOperator instead, since they allow you to constuct a
     * much wider range of conditions. 
The Value and Exists
     * parameters are incompatible with AttributeValueList and
     * ComparisonOperator. If you attempt to use both sets of
     * parameters at once, DynamoDB will throw a ValidationException.
     * 
     * 

     * The method adds a new key-value pair into Expected parameter, and
     * returns a reference to this object so that method calls can be chained
     * together.
     *
     * @param key The key of the entry to be added into Expected.
     * @param value The corresponding value of the entry to be added into Expected.
     */
    public UpdateItemRequest addExpectedEntry(String key, ExpectedAttributeValue value) {
        if (null == this.expected) {
            this.expected = new java.util.HashMap();
        }
        if (this.expected.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.expected.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into Expected.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     */
    public UpdateItemRequest clearExpectedEntries() {
        this.expected = null;
        return this;
    }
    
    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     *
     * @return A logical operator to apply to the conditions in the Expected
     *         map: 
     
  • AND - If all of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    • 
     *         
  • OR - If at least one of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    •  

     *         
If you omit ConditionalOperator, then AND is
     *         the default. 
The operation will succeed only if the entire map
     *         evaluates to true.
     *
     * @see ConditionalOperator
     */
    public String getConditionalOperator() {
        return conditionalOperator;
    }
    
    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     *
     * @param conditionalOperator A logical operator to apply to the conditions in the Expected
     *         map: 
     
  • AND - If all of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    • 
     *         
  • OR - If at least one of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    •  

     *         
If you omit ConditionalOperator, then AND is
     *         the default. 
The operation will succeed only if the entire map
     *         evaluates to true.
     *
     * @see ConditionalOperator
     */
    public void setConditionalOperator(String conditionalOperator) {
        this.conditionalOperator = conditionalOperator;
    }
    
    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     *
     * @param conditionalOperator A logical operator to apply to the conditions in the Expected
     *         map: 
     
  • AND - If all of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    • 
     *         
  • OR - If at least one of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    •  

     *         
If you omit ConditionalOperator, then AND is
     *         the default. 
The operation will succeed only if the entire map
     *         evaluates to true.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ConditionalOperator
     */
    public UpdateItemRequest withConditionalOperator(String conditionalOperator) {
        this.conditionalOperator = conditionalOperator;
        return this;
    }

    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     *
     * @param conditionalOperator A logical operator to apply to the conditions in the Expected
     *         map: 
     
  • AND - If all of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    • 
     *         
  • OR - If at least one of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    •  

     *         
If you omit ConditionalOperator, then AND is
     *         the default. 
The operation will succeed only if the entire map
     *         evaluates to true.
     *
     * @see ConditionalOperator
     */
    public void setConditionalOperator(ConditionalOperator conditionalOperator) {
        this.conditionalOperator = conditionalOperator.toString();
    }
    
    /**
     * A logical operator to apply to the conditions in the Expected
     * map: 
     
  • AND - If all of the conditions
     * evaluate to true, then the entire map evaluates to true.
    • 
     * 
  • OR - If at least one of the conditions
     * evaluate to true, then the entire map evaluates to true.
    •  

     * 
If you omit ConditionalOperator, then AND is
     * the default. 
The operation will succeed only if the entire map
     * evaluates to true.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: AND, OR
     *
     * @param conditionalOperator A logical operator to apply to the conditions in the Expected
     *         map: 
     
  • AND - If all of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    • 
     *         
  • OR - If at least one of the conditions
     *         evaluate to true, then the entire map evaluates to true.
    •  

     *         
If you omit ConditionalOperator, then AND is
     *         the default. 
The operation will succeed only if the entire map
     *         evaluates to true.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ConditionalOperator
     */
    public UpdateItemRequest withConditionalOperator(ConditionalOperator conditionalOperator) {
        this.conditionalOperator = conditionalOperator.toString();
        return this;
    }

    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     *
     * @return Use ReturnValues if you want to get the item attributes as they
     *         appeared either before or after they were updated. For
     *         UpdateItem, the valid values are: 
     
  • 
     *         
    NONE - If ReturnValues is not specified, or if
     *         its value is NONE, then nothing is returned. (This is the
     *         default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     *         If UpdateItem overwrote an attribute name-value pair, then the
     *         content of the old item is returned. 
    •  
  • 
     *         
    UPDATED_OLD - The old versions of only the updated
     *         attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     *         the attributes of the new version of the item are returned. 
    •  
  • 
     *         
    UPDATED_NEW - The new versions of only the updated
     *         attributes are returned. 
    •  

     *
     * @see ReturnValue
     */
    public String getReturnValues() {
        return returnValues;
    }
    
    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     *
     * @param returnValues Use ReturnValues if you want to get the item attributes as they
     *         appeared either before or after they were updated. For
     *         UpdateItem, the valid values are: 
     
  • 
     *         
    NONE - If ReturnValues is not specified, or if
     *         its value is NONE, then nothing is returned. (This is the
     *         default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     *         If UpdateItem overwrote an attribute name-value pair, then the
     *         content of the old item is returned. 
    •  
  • 
     *         
    UPDATED_OLD - The old versions of only the updated
     *         attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     *         the attributes of the new version of the item are returned. 
    •  
  • 
     *         
    UPDATED_NEW - The new versions of only the updated
     *         attributes are returned. 
    •  

     *
     * @see ReturnValue
     */
    public void setReturnValues(String returnValues) {
        this.returnValues = returnValues;
    }
    
    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     *
     * @param returnValues Use ReturnValues if you want to get the item attributes as they
     *         appeared either before or after they were updated. For
     *         UpdateItem, the valid values are: 
     
  • 
     *         
    NONE - If ReturnValues is not specified, or if
     *         its value is NONE, then nothing is returned. (This is the
     *         default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     *         If UpdateItem overwrote an attribute name-value pair, then the
     *         content of the old item is returned. 
    •  
  • 
     *         
    UPDATED_OLD - The old versions of only the updated
     *         attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     *         the attributes of the new version of the item are returned. 
    •  
  • 
     *         
    UPDATED_NEW - The new versions of only the updated
     *         attributes are returned. 
    •  

     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnValue
     */
    public UpdateItemRequest withReturnValues(String returnValues) {
        this.returnValues = returnValues;
        return this;
    }

    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     *
     * @param returnValues Use ReturnValues if you want to get the item attributes as they
     *         appeared either before or after they were updated. For
     *         UpdateItem, the valid values are: 
     
  • 
     *         
    NONE - If ReturnValues is not specified, or if
     *         its value is NONE, then nothing is returned. (This is the
     *         default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     *         If UpdateItem overwrote an attribute name-value pair, then the
     *         content of the old item is returned. 
    •  
  • 
     *         
    UPDATED_OLD - The old versions of only the updated
     *         attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     *         the attributes of the new version of the item are returned. 
    •  
  • 
     *         
    UPDATED_NEW - The new versions of only the updated
     *         attributes are returned. 
    •  

     *
     * @see ReturnValue
     */
    public void setReturnValues(ReturnValue returnValues) {
        this.returnValues = returnValues.toString();
    }
    
    /**
     * Use ReturnValues if you want to get the item attributes as they
     * appeared either before or after they were updated. For
     * UpdateItem, the valid values are: 
     
  • 
     * 
    NONE - If ReturnValues is not specified, or if
     * its value is NONE, then nothing is returned. (This is the
     * default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     * If UpdateItem overwrote an attribute name-value pair, then the
     * content of the old item is returned. 
    •  
  • 
     * 
    UPDATED_OLD - The old versions of only the updated
     * attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     * the attributes of the new version of the item are returned. 
    •  
  • 
     * 
    UPDATED_NEW - The new versions of only the updated
     * attributes are returned. 
    •  

     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
     *
     * @param returnValues Use ReturnValues if you want to get the item attributes as they
     *         appeared either before or after they were updated. For
     *         UpdateItem, the valid values are: 
     
  • 
     *         
    NONE - If ReturnValues is not specified, or if
     *         its value is NONE, then nothing is returned. (This is the
     *         default for ReturnValues.) 
    •  
  •  
    ALL_OLD -
     *         If UpdateItem overwrote an attribute name-value pair, then the
     *         content of the old item is returned. 
    •  
  • 
     *         
    UPDATED_OLD - The old versions of only the updated
     *         attributes are returned. 
    •  
  •  
    ALL_NEW - All of
     *         the attributes of the new version of the item are returned. 
    •  
  • 
     *         
    UPDATED_NEW - The new versions of only the updated
     *         attributes are returned. 
    •  

     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnValue
     */
    public UpdateItemRequest withReturnValues(ReturnValue returnValues) {
        this.returnValues = returnValues.toString();
        return this;
    }

    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @return If set to TOTAL, the response includes
     *         ConsumedCapacity data for tables and indexes. If set to
     *         INDEXES, the response includes ConsumedCapacity
     *         for indexes. If set to NONE (the default),
     *         ConsumedCapacity is not included in the response.
     *
     * @see ReturnConsumedCapacity
     */
    public String getReturnConsumedCapacity() {
        return returnConsumedCapacity;
    }
    
    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity If set to TOTAL, the response includes
     *         ConsumedCapacity data for tables and indexes. If set to
     *         INDEXES, the response includes ConsumedCapacity
     *         for indexes. If set to NONE (the default),
     *         ConsumedCapacity is not included in the response.
     *
     * @see ReturnConsumedCapacity
     */
    public void setReturnConsumedCapacity(String returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity;
    }
    
    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity If set to TOTAL, the response includes
     *         ConsumedCapacity data for tables and indexes. If set to
     *         INDEXES, the response includes ConsumedCapacity
     *         for indexes. If set to NONE (the default),
     *         ConsumedCapacity is not included in the response.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnConsumedCapacity
     */
    public UpdateItemRequest withReturnConsumedCapacity(String returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity;
        return this;
    }

    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity If set to TOTAL, the response includes
     *         ConsumedCapacity data for tables and indexes. If set to
     *         INDEXES, the response includes ConsumedCapacity
     *         for indexes. If set to NONE (the default),
     *         ConsumedCapacity is not included in the response.
     *
     * @see ReturnConsumedCapacity
     */
    public void setReturnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity.toString();
    }
    
    /**
     * If set to TOTAL, the response includes
     * ConsumedCapacity data for tables and indexes. If set to
     * INDEXES, the response includes ConsumedCapacity
     * for indexes. If set to NONE (the default),
     * ConsumedCapacity is not included in the response.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity If set to TOTAL, the response includes
     *         ConsumedCapacity data for tables and indexes. If set to
     *         INDEXES, the response includes ConsumedCapacity
     *         for indexes. If set to NONE (the default),
     *         ConsumedCapacity is not included in the response.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnConsumedCapacity
     */
    public UpdateItemRequest withReturnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity.toString();
        return this;
    }

    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     *
     * @return If set to SIZE, statistics about item collections, if
     *         any, that were modified during the operation are returned in the
     *         response. If set to NONE (the default), no statistics are
     *         returned.
     *
     * @see ReturnItemCollectionMetrics
     */
    public String getReturnItemCollectionMetrics() {
        return returnItemCollectionMetrics;
    }
    
    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     *
     * @param returnItemCollectionMetrics If set to SIZE, statistics about item collections, if
     *         any, that were modified during the operation are returned in the
     *         response. If set to NONE (the default), no statistics are
     *         returned.
     *
     * @see ReturnItemCollectionMetrics
     */
    public void setReturnItemCollectionMetrics(String returnItemCollectionMetrics) {
        this.returnItemCollectionMetrics = returnItemCollectionMetrics;
    }
    
    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     *
     * @param returnItemCollectionMetrics If set to SIZE, statistics about item collections, if
     *         any, that were modified during the operation are returned in the
     *         response. If set to NONE (the default), no statistics are
     *         returned.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnItemCollectionMetrics
     */
    public UpdateItemRequest withReturnItemCollectionMetrics(String returnItemCollectionMetrics) {
        this.returnItemCollectionMetrics = returnItemCollectionMetrics;
        return this;
    }

    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     *
     * @param returnItemCollectionMetrics If set to SIZE, statistics about item collections, if
     *         any, that were modified during the operation are returned in the
     *         response. If set to NONE (the default), no statistics are
     *         returned.
     *
     * @see ReturnItemCollectionMetrics
     */
    public void setReturnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics) {
        this.returnItemCollectionMetrics = returnItemCollectionMetrics.toString();
    }
    
    /**
     * If set to SIZE, statistics about item collections, if
     * any, that were modified during the operation are returned in the
     * response. If set to NONE (the default), no statistics are
     * returned.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Allowed Values: SIZE, NONE
     *
     * @param returnItemCollectionMetrics If set to SIZE, statistics about item collections, if
     *         any, that were modified during the operation are returned in the
     *         response. If set to NONE (the default), no statistics are
     *         returned.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnItemCollectionMetrics
     */
    public UpdateItemRequest withReturnItemCollectionMetrics(ReturnItemCollectionMetrics returnItemCollectionMetrics) {
        this.returnItemCollectionMetrics = returnItemCollectionMetrics.toString();
        return this;
    }

    /**
     * Returns the value of the UpdateExpression property for this object.
     *
     * @return The value of the UpdateExpression property for this object.
     */
    public String getUpdateExpression() {
        return updateExpression;
    }
    
    /**
     * Sets the value of the UpdateExpression property for this object.
     *
     * @param updateExpression The new value for the UpdateExpression property for this object.
     */
    public void setUpdateExpression(String updateExpression) {
        this.updateExpression = updateExpression;
    }
    
    /**
     * Sets the value of the UpdateExpression property for this object.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param updateExpression The new value for the UpdateExpression property for this object.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withUpdateExpression(String updateExpression) {
        this.updateExpression = updateExpression;
        return this;
    }

    /**
     * Returns the value of the ConditionExpression property for this object.
     *
     * @return The value of the ConditionExpression property for this object.
     */
    public String getConditionExpression() {
        return conditionExpression;
    }
    
    /**
     * Sets the value of the ConditionExpression property for this object.
     *
     * @param conditionExpression The new value for the ConditionExpression property for this object.
     */
    public void setConditionExpression(String conditionExpression) {
        this.conditionExpression = conditionExpression;
    }
    
    /**
     * Sets the value of the ConditionExpression property for this object.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param conditionExpression The new value for the ConditionExpression property for this object.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withConditionExpression(String conditionExpression) {
        this.conditionExpression = conditionExpression;
        return this;
    }

    /**
     * Returns the value of the ExpressionAttributeNames property for this
     * object.
     *
     * @return The value of the ExpressionAttributeNames property for this object.
     */
    public java.util.Map getExpressionAttributeNames() {
        
        return expressionAttributeNames;
    }
    
    /**
     * Sets the value of the ExpressionAttributeNames property for this
     * object.
     *
     * @param expressionAttributeNames The new value for the ExpressionAttributeNames property for this
     *         object.
     */
    public void setExpressionAttributeNames(java.util.Map expressionAttributeNames) {
        this.expressionAttributeNames = expressionAttributeNames;
    }
    
    /**
     * Sets the value of the ExpressionAttributeNames property for this
     * object.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param expressionAttributeNames The new value for the ExpressionAttributeNames property for this
     *         object.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withExpressionAttributeNames(java.util.Map expressionAttributeNames) {
        setExpressionAttributeNames(expressionAttributeNames);
        return this;
    }

    /**
     * Sets the value of the ExpressionAttributeNames property for this
     * object.
     * 

     * The method adds a new key-value pair into ExpressionAttributeNames
     * parameter, and returns a reference to this object so that method calls
     * can be chained together.
     *
     * @param key The key of the entry to be added into ExpressionAttributeNames.
     * @param value The corresponding value of the entry to be added into ExpressionAttributeNames.
     */
    public UpdateItemRequest addExpressionAttributeNamesEntry(String key, String value) {
        if (null == this.expressionAttributeNames) {
            this.expressionAttributeNames = new java.util.HashMap();
        }
        if (this.expressionAttributeNames.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.expressionAttributeNames.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into ExpressionAttributeNames.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     */
    public UpdateItemRequest clearExpressionAttributeNamesEntries() {
        this.expressionAttributeNames = null;
        return this;
    }
    
    /**
     * Returns the value of the ExpressionAttributeValues property for this
     * object.
     *
     * @return The value of the ExpressionAttributeValues property for this object.
     */
    public java.util.Map getExpressionAttributeValues() {
        
        return expressionAttributeValues;
    }
    
    /**
     * Sets the value of the ExpressionAttributeValues property for this
     * object.
     *
     * @param expressionAttributeValues The new value for the ExpressionAttributeValues property for this
     *         object.
     */
    public void setExpressionAttributeValues(java.util.Map expressionAttributeValues) {
        this.expressionAttributeValues = expressionAttributeValues;
    }
    
    /**
     * Sets the value of the ExpressionAttributeValues property for this
     * object.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param expressionAttributeValues The new value for the ExpressionAttributeValues property for this
     *         object.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public UpdateItemRequest withExpressionAttributeValues(java.util.Map expressionAttributeValues) {
        setExpressionAttributeValues(expressionAttributeValues);
        return this;
    }

    /**
     * Sets the value of the ExpressionAttributeValues property for this
     * object.
     * 

     * The method adds a new key-value pair into ExpressionAttributeValues
     * parameter, and returns a reference to this object so that method calls
     * can be chained together.
     *
     * @param key The key of the entry to be added into ExpressionAttributeValues.
     * @param value The corresponding value of the entry to be added into ExpressionAttributeValues.
     */
    public UpdateItemRequest addExpressionAttributeValuesEntry(String key, AttributeValue value) {
        if (null == this.expressionAttributeValues) {
            this.expressionAttributeValues = new java.util.HashMap();
        }
        if (this.expressionAttributeValues.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.expressionAttributeValues.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into ExpressionAttributeValues.
     * 

     * Returns a reference to this object so that method calls can be chained together.
     */
    public UpdateItemRequest clearExpressionAttributeValuesEntries() {
        this.expressionAttributeValues = null;
        return this;
    }
    
    /**
     * Returns a string representation of this object; useful for testing and
     * debugging.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getTableName() != null) sb.append("TableName: " + getTableName() + ",");
        if (getKey() != null) sb.append("Key: " + getKey() + ",");
        if (getAttributeUpdates() != null) sb.append("AttributeUpdates: " + getAttributeUpdates() + ",");
        if (getExpected() != null) sb.append("Expected: " + getExpected() + ",");
        if (getConditionalOperator() != null) sb.append("ConditionalOperator: " + getConditionalOperator() + ",");
        if (getReturnValues() != null) sb.append("ReturnValues: " + getReturnValues() + ",");
        if (getReturnConsumedCapacity() != null) sb.append("ReturnConsumedCapacity: " + getReturnConsumedCapacity() + ",");
        if (getReturnItemCollectionMetrics() != null) sb.append("ReturnItemCollectionMetrics: " + getReturnItemCollectionMetrics() + ",");
        if (getUpdateExpression() != null) sb.append("UpdateExpression: " + getUpdateExpression() + ",");
        if (getConditionExpression() != null) sb.append("ConditionExpression: " + getConditionExpression() + ",");
        if (getExpressionAttributeNames() != null) sb.append("ExpressionAttributeNames: " + getExpressionAttributeNames() + ",");
        if (getExpressionAttributeValues() != null) sb.append("ExpressionAttributeValues: " + getExpressionAttributeValues() );
        sb.append("}");
        return sb.toString();
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;
        
        hashCode = prime * hashCode + ((getTableName() == null) ? 0 : getTableName().hashCode()); 
        hashCode = prime * hashCode + ((getKey() == null) ? 0 : getKey().hashCode()); 
        hashCode = prime * hashCode + ((getAttributeUpdates() == null) ? 0 : getAttributeUpdates().hashCode()); 
        hashCode = prime * hashCode + ((getExpected() == null) ? 0 : getExpected().hashCode()); 
        hashCode = prime * hashCode + ((getConditionalOperator() == null) ? 0 : getConditionalOperator().hashCode()); 
        hashCode = prime * hashCode + ((getReturnValues() == null) ? 0 : getReturnValues().hashCode()); 
        hashCode = prime * hashCode + ((getReturnConsumedCapacity() == null) ? 0 : getReturnConsumedCapacity().hashCode()); 
        hashCode = prime * hashCode + ((getReturnItemCollectionMetrics() == null) ? 0 : getReturnItemCollectionMetrics().hashCode()); 
        hashCode = prime * hashCode + ((getUpdateExpression() == null) ? 0 : getUpdateExpression().hashCode()); 
        hashCode = prime * hashCode + ((getConditionExpression() == null) ? 0 : getConditionExpression().hashCode()); 
        hashCode = prime * hashCode + ((getExpressionAttributeNames() == null) ? 0 : getExpressionAttributeNames().hashCode()); 
        hashCode = prime * hashCode + ((getExpressionAttributeValues() == null) ? 0 : getExpressionAttributeValues().hashCode()); 
        return hashCode;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        if (obj instanceof UpdateItemRequest == false) return false;
        UpdateItemRequest other = (UpdateItemRequest)obj;
        
        if (other.getTableName() == null ^ this.getTableName() == null) return false;
        if (other.getTableName() != null && other.getTableName().equals(this.getTableName()) == false) return false; 
        if (other.getKey() == null ^ this.getKey() == null) return false;
        if (other.getKey() != null && other.getKey().equals(this.getKey()) == false) return false; 
        if (other.getAttributeUpdates() == null ^ this.getAttributeUpdates() == null) return false;
        if (other.getAttributeUpdates() != null && other.getAttributeUpdates().equals(this.getAttributeUpdates()) == false) return false; 
        if (other.getExpected() == null ^ this.getExpected() == null) return false;
        if (other.getExpected() != null && other.getExpected().equals(this.getExpected()) == false) return false; 
        if (other.getConditionalOperator() == null ^ this.getConditionalOperator() == null) return false;
        if (other.getConditionalOperator() != null && other.getConditionalOperator().equals(this.getConditionalOperator()) == false) return false; 
        if (other.getReturnValues() == null ^ this.getReturnValues() == null) return false;
        if (other.getReturnValues() != null && other.getReturnValues().equals(this.getReturnValues()) == false) return false; 
        if (other.getReturnConsumedCapacity() == null ^ this.getReturnConsumedCapacity() == null) return false;
        if (other.getReturnConsumedCapacity() != null && other.getReturnConsumedCapacity().equals(this.getReturnConsumedCapacity()) == false) return false; 
        if (other.getReturnItemCollectionMetrics() == null ^ this.getReturnItemCollectionMetrics() == null) return false;
        if (other.getReturnItemCollectionMetrics() != null && other.getReturnItemCollectionMetrics().equals(this.getReturnItemCollectionMetrics()) == false) return false; 
        if (other.getUpdateExpression() == null ^ this.getUpdateExpression() == null) return false;
        if (other.getUpdateExpression() != null && other.getUpdateExpression().equals(this.getUpdateExpression()) == false) return false; 
        if (other.getConditionExpression() == null ^ this.getConditionExpression() == null) return false;
        if (other.getConditionExpression() != null && other.getConditionExpression().equals(this.getConditionExpression()) == false) return false; 
        if (other.getExpressionAttributeNames() == null ^ this.getExpressionAttributeNames() == null) return false;
        if (other.getExpressionAttributeNames() != null && other.getExpressionAttributeNames().equals(this.getExpressionAttributeNames()) == false) return false; 
        if (other.getExpressionAttributeValues() == null ^ this.getExpressionAttributeValues() == null) return false;
        if (other.getExpressionAttributeValues() != null && other.getExpressionAttributeValues().equals(this.getExpressionAttributeValues()) == false) return false; 
        return true;
    }
    
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy