com.amazonaws.services.dynamodbv2.model.UpdateItemRequest Maven / Gradle / Ivy
Show all versions of aws-java-sdk Show documentation
/*
* Copyright 2010-2014 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. All the conditions must be met for
* the operation to succeed. Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*/
private java.util.Map expected;
/**
* 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;
/**
* 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. All the conditions must be met for
* the operation to succeed.
Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*
* @return A map of attribute/condition pairs. This is the conditional block for
* the UpdateItem operation. All the conditions must be met for
* the operation to succeed.
Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*/
public java.util.Map getExpected() {
return expected;
}
/**
* A map of attribute/condition pairs. This is the conditional block for
* the UpdateItem operation. All the conditions must be met for
* the operation to succeed. Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*
* @param expected A map of attribute/condition pairs. This is the conditional block for
* the UpdateItem operation. All the conditions must be met for
* the operation to succeed.
Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*/
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. All the conditions must be met for
* the operation to succeed. Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*
* 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. All the conditions must be met for
* the operation to succeed.
Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*
* @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. All the conditions must be met for
* the operation to succeed. Expected allows you to provide an
* attribute name, and whether or not DynamoDB should check to see if the
* attribute value already exists; or if the attribute value exists and
* has a particular value before changing it.
Each item in
* Expected represents an attribute name for DynamoDB to check,
* along with the following:
-
Value - A value for
* DynamoDB to compare with an attribute. When performing the comparison,
* strongly consistent reads are used.
-
Exists -
* Causes DynamoDB to evaluate the value before attempting a 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 operation succeeds. If it is not
* found, the operation fails with a
* ConditionalCheckFailedException.
-
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 operation succeeds. If the value
* is found, despite the assumption that it does not exist, the operation
* fails with a ConditionalCheckFailedException.
* The default setting for Exists is true. If you
* supply a Value all by itself, DynamoDB assumes the attribute
* exists: You don't have to set Exists to true,
* because it is implied.
DynamoDB returns a
* ValidationException if:
-
Exists is
* true but there is no Value to check. (You expect a
* value to exist, but don't specify what that value is.)
-
*
Exists is false but you also specify a
* Value. (You cannot expect an attribute to have a value, while
* also expecting it not to exist.)
If you
* specify more than one condition for Exists, then all of the
* conditions must evaluate to true. (In other words, the conditions are
* ANDed together.) Otherwise, the conditional operation will fail.
*
* 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;
}
/**
* 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 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 (getReturnValues() != null) sb.append("ReturnValues: " + getReturnValues() + ",");
if (getReturnConsumedCapacity() != null) sb.append("ReturnConsumedCapacity: " + getReturnConsumedCapacity() + ",");
if (getReturnItemCollectionMetrics() != null) sb.append("ReturnItemCollectionMetrics: " + getReturnItemCollectionMetrics() );
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 + ((getReturnValues() == null) ? 0 : getReturnValues().hashCode());
hashCode = prime * hashCode + ((getReturnConsumedCapacity() == null) ? 0 : getReturnConsumedCapacity().hashCode());
hashCode = prime * hashCode + ((getReturnItemCollectionMetrics() == null) ? 0 : getReturnItemCollectionMetrics().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.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;
return true;
}
}