main.java.com.amazonaws.services.dynamodbv2.model.UpdateItemRequest Maven / Gradle / Ivy
Show all versions of aws-android-sdk-s3 Show documentation
/*
* 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;
}
}