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

Go to download
/*
 * Copyright 2010-2016 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#batchGetItem(BatchGetItemRequest) BatchGetItem operation}.
 * 
 * The BatchGetItem operation returns the attributes of one or
 * more items from one or more tables. You identify requested items by
 * primary key.
 * 
 * 
 * A single operation can retrieve up to 16 MB of data, which can contain
 * as many as 100 items. BatchGetItem will return a partial result
 * if the response size limit is exceeded, the table's provisioned
 * throughput is exceeded, or an internal processing failure occurs. If a
 * partial result is returned, the operation returns a value for
 * UnprocessedKeys . You can use this value to retry the operation
 * starting with the next item to get.
 * 
 * 
 * IMPORTANT: If you request more than 100 items BatchGetItem will
 * return a ValidationException with the message "Too many items
 * requested for the BatchGetItem call".
 * 
 * 
 * For example, if you ask to retrieve 100 items, but each individual
 * item is 300 KB in size, the system returns 52 items (so as not to
 * exceed the 16 MB limit). It also returns an appropriate
 * UnprocessedKeys value so you can get the next page of results.
 * If desired, your application can include its own logic to assemble the
 * pages of results into one data set.
 * 
 * 
 * If none of the items can be processed due to insufficient
 * provisioned throughput on all of the tables in the request, then
 * BatchGetItem will return a
 * ProvisionedThroughputExceededException . If at least one
 * of the items is successfully processed, then BatchGetItem
 * completes successfully, while returning the keys of the unread items
 * in UnprocessedKeys .
 * 
 * 
 * IMPORTANT: If DynamoDB returns any unprocessed items, you
 * should retry the batch operation on those items. However, we strongly
 * recommend that you use an exponential backoff algorithm. If you retry
 * the batch operation immediately, the underlying read or write requests
 * can still fail due to throttling on the individual tables. If you
 * delay the batch operation using exponential backoff, the individual
 * requests in the batch are much more likely to succeed. For more
 * information, see Batch Operations and Error Handling in the Amazon
 * DynamoDB Developer Guide.
 * 
 * 
 * By default, BatchGetItem performs eventually consistent reads
 * on every table in the request. If you want strongly consistent reads
 * instead, you can set ConsistentRead to true for
 * any or all tables.
 * 
 * 
 * In order to minimize response latency, BatchGetItem retrieves
 * items in parallel.
 * 
 * 
 * When designing your application, keep in mind that DynamoDB does not
 * return attributes in any particular order. To help parse the response
 * by item, include the primary key values for the items in your request
 * in the AttributesToGet parameter.
 * 
 * 
 * If a requested item does not exist, it is not returned in the result.
 * Requests for nonexistent items consume the minimum read capacity units
 * according to the type of read. For more information, see
 *  Capacity Units Calculations 
 * in the Amazon DynamoDB Developer Guide .
 * 
 *
 * @see com.amazonaws.services.dynamodbv2.AmazonDynamoDB#batchGetItem(BatchGetItemRequest)
 */
public class BatchGetItemRequest extends AmazonWebServiceRequest implements Serializable {

    /**
     * A map of one or more table names and, for each table, a map that
     * describes one or more items to retrieve from that table. Each table
     * name can be used only once per BatchGetItem request. Each
     * element in the map of items to retrieve consists of the following:
     * 
  ConsistentRead - If true, a strongly
     * consistent read is used; if false (the default), an
     * eventually consistent read is used. 
  
     * ExpressionAttributeNames - One or more substitution tokens for
     * attribute names in the ProjectionExpression parameter. The
     * following are some use cases for using
     * ExpressionAttributeNames: 
  To access an attribute
     * whose name conflicts with a DynamoDB reserved word. 
  To
     * create a placeholder for repeating occurrences of an attribute name in
     * an expression. 
  To prevent special characters in an
     * attribute name from being misinterpreted in an expression. 
 
     * Use the # character in an expression to dereference an
     * attribute name. For example, consider the following attribute name:
     * 
Percentile
 The name of this
     * attribute conflicts with a reserved word, so it cannot be used
     * directly in an expression. (For the complete list of reserved words,
     * see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * 
     * Constraints:

     * Length: 1 - 100

     */
    private java.util.Map requestItems;

    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 

     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     * 
     * Constraints:

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

    /**
     * Default constructor for a new BatchGetItemRequest object.  Callers should use the
     * setter or fluent setter (with...) methods to initialize this object after creating it.
     */
    public BatchGetItemRequest() {}
    
    /**
     * Constructs a new BatchGetItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param requestItems A map of one or more table names and, for each
     * table, a map that describes one or more items to retrieve from that
     * table. Each table name can be used only once per BatchGetItem
     * request. 
Each element in the map of items to retrieve consists of
     * the following: 
  ConsistentRead - If
     * true, a strongly consistent read is used; if
     * false (the default), an eventually consistent read is
     * used. 
   ExpressionAttributeNames - One or more
     * substitution tokens for attribute names in the
     * ProjectionExpression parameter. The following are some use
     * cases for using ExpressionAttributeNames: 
  To
     * access an attribute whose name conflicts with a DynamoDB reserved
     * word. 
  To create a placeholder for repeating occurrences
     * of an attribute name in an expression. 
  To prevent
     * special characters in an attribute name from being misinterpreted in
     * an expression. 
 
 Use the # character in an
     * expression to dereference an attribute name. For example, consider the
     * following attribute name: 
Percentile
     * The name of this attribute conflicts with a reserved word, so it
     * cannot be used directly in an expression. (For the complete list of
     * reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     */
    public BatchGetItemRequest(java.util.Map requestItems) {
        setRequestItems(requestItems);
    }

    /**
     * Constructs a new BatchGetItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param requestItems A map of one or more table names and, for each
     * table, a map that describes one or more items to retrieve from that
     * table. Each table name can be used only once per BatchGetItem
     * request. Each element in the map of items to retrieve consists of
     * the following: 
  ConsistentRead - If
     * true, a strongly consistent read is used; if
     * false (the default), an eventually consistent read is
     * used. 
   ExpressionAttributeNames - One or more
     * substitution tokens for attribute names in the
     * ProjectionExpression parameter. The following are some use
     * cases for using ExpressionAttributeNames: 
  To
     * access an attribute whose name conflicts with a DynamoDB reserved
     * word. 
  To create a placeholder for repeating occurrences
     * of an attribute name in an expression. 
  To prevent
     * special characters in an attribute name from being misinterpreted in
     * an expression. 
 
 Use the # character in an
     * expression to dereference an attribute name. For example, consider the
     * following attribute name: 
Percentile
     * The name of this attribute conflicts with a reserved word, so it
     * cannot be used directly in an expression. (For the complete list of
     * reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * @param returnConsumedCapacity Determines the level of detail about
     * provisioned throughput consumption that is returned in the response:
     *  INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     */
    public BatchGetItemRequest(java.util.Map requestItems, String returnConsumedCapacity) {
        setRequestItems(requestItems);
        setReturnConsumedCapacity(returnConsumedCapacity);
    }

    /**
     * Constructs a new BatchGetItemRequest object.
     * Callers should use the setter or fluent setter (with...) methods to
     * initialize any additional object members.
     * 
     * @param requestItems A map of one or more table names and, for each
     * table, a map that describes one or more items to retrieve from that
     * table. Each table name can be used only once per BatchGetItem
     * request. Each element in the map of items to retrieve consists of
     * the following: 
  ConsistentRead - If
     * true, a strongly consistent read is used; if
     * false (the default), an eventually consistent read is
     * used. 
   ExpressionAttributeNames - One or more
     * substitution tokens for attribute names in the
     * ProjectionExpression parameter. The following are some use
     * cases for using ExpressionAttributeNames: 
  To
     * access an attribute whose name conflicts with a DynamoDB reserved
     * word. 
  To create a placeholder for repeating occurrences
     * of an attribute name in an expression. 
  To prevent
     * special characters in an attribute name from being misinterpreted in
     * an expression. 
 
 Use the # character in an
     * expression to dereference an attribute name. For example, consider the
     * following attribute name: 
Percentile
     * The name of this attribute conflicts with a reserved word, so it
     * cannot be used directly in an expression. (For the complete list of
     * reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * @param returnConsumedCapacity Determines the level of detail about
     * provisioned throughput consumption that is returned in the response:
     *  INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     */
    public BatchGetItemRequest(java.util.Map requestItems, ReturnConsumedCapacity returnConsumedCapacity) {
        this.requestItems = requestItems;
        this.returnConsumedCapacity = returnConsumedCapacity.toString();
    }

    /**
     * A map of one or more table names and, for each table, a map that
     * describes one or more items to retrieve from that table. Each table
     * name can be used only once per BatchGetItem request. Each
     * element in the map of items to retrieve consists of the following:
     * 
  ConsistentRead - If true, a strongly
     * consistent read is used; if false (the default), an
     * eventually consistent read is used. 
  
     * ExpressionAttributeNames - One or more substitution tokens for
     * attribute names in the ProjectionExpression parameter. The
     * following are some use cases for using
     * ExpressionAttributeNames: 
  To access an attribute
     * whose name conflicts with a DynamoDB reserved word. 
  To
     * create a placeholder for repeating occurrences of an attribute name in
     * an expression. 
  To prevent special characters in an
     * attribute name from being misinterpreted in an expression. 
 
     * Use the # character in an expression to dereference an
     * attribute name. For example, consider the following attribute name:
     * 
Percentile
 The name of this
     * attribute conflicts with a reserved word, so it cannot be used
     * directly in an expression. (For the complete list of reserved words,
     * see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * 
     * Constraints:

     * Length: 1 - 100

     *
     * @return A map of one or more table names and, for each table, a map that
     *         describes one or more items to retrieve from that table. Each table
     *         name can be used only once per BatchGetItem request. 
Each
     *         element in the map of items to retrieve consists of the following:
     *         
  ConsistentRead - If true, a strongly
     *         consistent read is used; if false (the default), an
     *         eventually consistent read is used. 
  
     *         ExpressionAttributeNames - One or more substitution tokens for
     *         attribute names in the ProjectionExpression parameter. The
     *         following are some use cases for using
     *         ExpressionAttributeNames: 
  To access an attribute
     *         whose name conflicts with a DynamoDB reserved word. 
  To
     *         create a placeholder for repeating occurrences of an attribute name in
     *         an expression. 
  To prevent special characters in an
     *         attribute name from being misinterpreted in an expression. 
 
     *         Use the # character in an expression to dereference an
     *         attribute name. For example, consider the following attribute name:
     *         
Percentile
 The name of this
     *         attribute conflicts with a reserved word, so it cannot be used
     *         directly in an expression. (For the complete list of reserved words,
     *         see Reserved
     *         Words in the Amazon DynamoDB Developer Guide). To work
     *         around this, you could specify the following for
     *         ExpressionAttributeNames:
     *         
{"#P":"Percentile"}
 You could
     *         then use this substitution in an expression, as in this example:
     *         
#P = :val
 Tokens that begin
     *         with the : character are expression attribute values,
     *         which are placeholders for the actual value at runtime. 
For
     *         more information on expression attribute names, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
  Keys - An array of primary key attribute values
     *         that define specific items in the table. For each primary key, you
     *         must provide all of the key attributes. For example, with a
     *         simple primary key, you only need to provide the partition key value.
     *         For a composite key, you must provide both the partition key
     *         value and the sort key value. 
 
     *         ProjectionExpression - A string that identifies one or more
     *         attributes to retrieve from the table. These attributes can include
     *         scalars, sets, or elements of a JSON document. The attributes in the
     *         expression must be separated by commas. 
If no attribute names are
     *         specified, then all attributes will be returned. If any of the
     *         requested attributes are not found, they will not appear in the
     *         result. 
For more information, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
   AttributesToGet -  
This is a
     *         legacy parameter, for backward compatibility. New applications should
     *         use ProjectionExpression instead. Do not combine legacy
     *         parameters and expression parameters in a single API call; otherwise,
     *         DynamoDB will return a ValidationException exception. 
This
     *         parameter allows you to retrieve attributes of type List or Map;
     *         however, it cannot retrieve individual elements within a List or a
     *         Map. 
The names of one or more attributes to retrieve.
     *         If no attribute names are provided, then all attributes will be
     *         returned. If any of the requested attributes are not found, they will
     *         not appear in the result. 
Note that AttributesToGet has no
     *         effect on provisioned throughput consumption. DynamoDB determines
     *         capacity units consumed based on item size, not on the amount of data
     *         that is returned to an application. 
 
     */
    public java.util.Map getRequestItems() {
        
        return requestItems;
    }
    
    /**
     * A map of one or more table names and, for each table, a map that
     * describes one or more items to retrieve from that table. Each table
     * name can be used only once per BatchGetItem request. Each
     * element in the map of items to retrieve consists of the following:
     * 
  ConsistentRead - If true, a strongly
     * consistent read is used; if false (the default), an
     * eventually consistent read is used. 
  
     * ExpressionAttributeNames - One or more substitution tokens for
     * attribute names in the ProjectionExpression parameter. The
     * following are some use cases for using
     * ExpressionAttributeNames: 
  To access an attribute
     * whose name conflicts with a DynamoDB reserved word. 
  To
     * create a placeholder for repeating occurrences of an attribute name in
     * an expression. 
  To prevent special characters in an
     * attribute name from being misinterpreted in an expression. 
 
     * Use the # character in an expression to dereference an
     * attribute name. For example, consider the following attribute name:
     * 
Percentile
 The name of this
     * attribute conflicts with a reserved word, so it cannot be used
     * directly in an expression. (For the complete list of reserved words,
     * see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * 
     * Constraints:

     * Length: 1 - 100

     *
     * @param requestItems A map of one or more table names and, for each table, a map that
     *         describes one or more items to retrieve from that table. Each table
     *         name can be used only once per BatchGetItem request. 
Each
     *         element in the map of items to retrieve consists of the following:
     *         
  ConsistentRead - If true, a strongly
     *         consistent read is used; if false (the default), an
     *         eventually consistent read is used. 
  
     *         ExpressionAttributeNames - One or more substitution tokens for
     *         attribute names in the ProjectionExpression parameter. The
     *         following are some use cases for using
     *         ExpressionAttributeNames: 
  To access an attribute
     *         whose name conflicts with a DynamoDB reserved word. 
  To
     *         create a placeholder for repeating occurrences of an attribute name in
     *         an expression. 
  To prevent special characters in an
     *         attribute name from being misinterpreted in an expression. 
 
     *         Use the # character in an expression to dereference an
     *         attribute name. For example, consider the following attribute name:
     *         
Percentile
 The name of this
     *         attribute conflicts with a reserved word, so it cannot be used
     *         directly in an expression. (For the complete list of reserved words,
     *         see Reserved
     *         Words in the Amazon DynamoDB Developer Guide). To work
     *         around this, you could specify the following for
     *         ExpressionAttributeNames:
     *         
{"#P":"Percentile"}
 You could
     *         then use this substitution in an expression, as in this example:
     *         
#P = :val
 Tokens that begin
     *         with the : character are expression attribute values,
     *         which are placeholders for the actual value at runtime. 
For
     *         more information on expression attribute names, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
  Keys - An array of primary key attribute values
     *         that define specific items in the table. For each primary key, you
     *         must provide all of the key attributes. For example, with a
     *         simple primary key, you only need to provide the partition key value.
     *         For a composite key, you must provide both the partition key
     *         value and the sort key value. 
 
     *         ProjectionExpression - A string that identifies one or more
     *         attributes to retrieve from the table. These attributes can include
     *         scalars, sets, or elements of a JSON document. The attributes in the
     *         expression must be separated by commas. 
If no attribute names are
     *         specified, then all attributes will be returned. If any of the
     *         requested attributes are not found, they will not appear in the
     *         result. 
For more information, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
   AttributesToGet -  
This is a
     *         legacy parameter, for backward compatibility. New applications should
     *         use ProjectionExpression instead. Do not combine legacy
     *         parameters and expression parameters in a single API call; otherwise,
     *         DynamoDB will return a ValidationException exception. 
This
     *         parameter allows you to retrieve attributes of type List or Map;
     *         however, it cannot retrieve individual elements within a List or a
     *         Map. 
The names of one or more attributes to retrieve.
     *         If no attribute names are provided, then all attributes will be
     *         returned. If any of the requested attributes are not found, they will
     *         not appear in the result. 
Note that AttributesToGet has no
     *         effect on provisioned throughput consumption. DynamoDB determines
     *         capacity units consumed based on item size, not on the amount of data
     *         that is returned to an application. 
 
     */
    public void setRequestItems(java.util.Map requestItems) {
        this.requestItems = requestItems;
    }
    
    /**
     * A map of one or more table names and, for each table, a map that
     * describes one or more items to retrieve from that table. Each table
     * name can be used only once per BatchGetItem request. Each
     * element in the map of items to retrieve consists of the following:
     * 
  ConsistentRead - If true, a strongly
     * consistent read is used; if false (the default), an
     * eventually consistent read is used. 
  
     * ExpressionAttributeNames - One or more substitution tokens for
     * attribute names in the ProjectionExpression parameter. The
     * following are some use cases for using
     * ExpressionAttributeNames: 
  To access an attribute
     * whose name conflicts with a DynamoDB reserved word. 
  To
     * create a placeholder for repeating occurrences of an attribute name in
     * an expression. 
  To prevent special characters in an
     * attribute name from being misinterpreted in an expression. 
 
     * Use the # character in an expression to dereference an
     * attribute name. For example, consider the following attribute name:
     * 
Percentile
 The name of this
     * attribute conflicts with a reserved word, so it cannot be used
     * directly in an expression. (For the complete list of reserved words,
     * see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * 
     * Returns a reference to this object so that method calls can be chained together.
     * 

     * Constraints:

     * Length: 1 - 100

     *
     * @param requestItems A map of one or more table names and, for each table, a map that
     *         describes one or more items to retrieve from that table. Each table
     *         name can be used only once per BatchGetItem request. 
Each
     *         element in the map of items to retrieve consists of the following:
     *         
  ConsistentRead - If true, a strongly
     *         consistent read is used; if false (the default), an
     *         eventually consistent read is used. 
  
     *         ExpressionAttributeNames - One or more substitution tokens for
     *         attribute names in the ProjectionExpression parameter. The
     *         following are some use cases for using
     *         ExpressionAttributeNames: 
  To access an attribute
     *         whose name conflicts with a DynamoDB reserved word. 
  To
     *         create a placeholder for repeating occurrences of an attribute name in
     *         an expression. 
  To prevent special characters in an
     *         attribute name from being misinterpreted in an expression. 
 
     *         Use the # character in an expression to dereference an
     *         attribute name. For example, consider the following attribute name:
     *         
Percentile
 The name of this
     *         attribute conflicts with a reserved word, so it cannot be used
     *         directly in an expression. (For the complete list of reserved words,
     *         see Reserved
     *         Words in the Amazon DynamoDB Developer Guide). To work
     *         around this, you could specify the following for
     *         ExpressionAttributeNames:
     *         
{"#P":"Percentile"}
 You could
     *         then use this substitution in an expression, as in this example:
     *         
#P = :val
 Tokens that begin
     *         with the : character are expression attribute values,
     *         which are placeholders for the actual value at runtime. 
For
     *         more information on expression attribute names, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
  Keys - An array of primary key attribute values
     *         that define specific items in the table. For each primary key, you
     *         must provide all of the key attributes. For example, with a
     *         simple primary key, you only need to provide the partition key value.
     *         For a composite key, you must provide both the partition key
     *         value and the sort key value. 
 
     *         ProjectionExpression - A string that identifies one or more
     *         attributes to retrieve from the table. These attributes can include
     *         scalars, sets, or elements of a JSON document. The attributes in the
     *         expression must be separated by commas. 
If no attribute names are
     *         specified, then all attributes will be returned. If any of the
     *         requested attributes are not found, they will not appear in the
     *         result. 
For more information, see Accessing
     *         Item Attributes in the Amazon DynamoDB Developer Guide.
     *         
   AttributesToGet -  
This is a
     *         legacy parameter, for backward compatibility. New applications should
     *         use ProjectionExpression instead. Do not combine legacy
     *         parameters and expression parameters in a single API call; otherwise,
     *         DynamoDB will return a ValidationException exception. 
This
     *         parameter allows you to retrieve attributes of type List or Map;
     *         however, it cannot retrieve individual elements within a List or a
     *         Map. 
The names of one or more attributes to retrieve.
     *         If no attribute names are provided, then all attributes will be
     *         returned. If any of the requested attributes are not found, they will
     *         not appear in the result. 
Note that AttributesToGet has no
     *         effect on provisioned throughput consumption. DynamoDB determines
     *         capacity units consumed based on item size, not on the amount of data
     *         that is returned to an application. 
 
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public BatchGetItemRequest withRequestItems(java.util.Map requestItems) {
        setRequestItems(requestItems);
        return this;
    }

    /**
     * A map of one or more table names and, for each table, a map that
     * describes one or more items to retrieve from that table. Each table
     * name can be used only once per BatchGetItem request. Each
     * element in the map of items to retrieve consists of the following:
     * 
  ConsistentRead - If true, a strongly
     * consistent read is used; if false (the default), an
     * eventually consistent read is used. 
  
     * ExpressionAttributeNames - One or more substitution tokens for
     * attribute names in the ProjectionExpression parameter. The
     * following are some use cases for using
     * ExpressionAttributeNames: 
  To access an attribute
     * whose name conflicts with a DynamoDB reserved word. 
  To
     * create a placeholder for repeating occurrences of an attribute name in
     * an expression. 
  To prevent special characters in an
     * attribute name from being misinterpreted in an expression. 
 
     * Use the # character in an expression to dereference an
     * attribute name. For example, consider the following attribute name:
     * 
Percentile
 The name of this
     * attribute conflicts with a reserved word, so it cannot be used
     * directly in an expression. (For the complete list of reserved words,
     * see Reserved
     * Words in the Amazon DynamoDB Developer Guide). To work
     * around this, you could specify the following for
     * ExpressionAttributeNames:
     * 
{"#P":"Percentile"}
 You could
     * then use this substitution in an expression, as in this example:
     * 
#P = :val
 Tokens that begin
     * with the : character are expression attribute values,
     * which are placeholders for the actual value at runtime. 
For
     * more information on expression attribute names, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
  Keys - An array of primary key attribute values
     * that define specific items in the table. For each primary key, you
     * must provide all of the key attributes. For example, with a
     * simple primary key, you only need to provide the partition key value.
     * For a composite key, you must provide both the partition key
     * value and the sort key value. 
 
     * ProjectionExpression - A string that identifies one or more
     * attributes to retrieve from the table. These attributes can include
     * scalars, sets, or elements of a JSON document. The attributes in the
     * expression must be separated by commas. 
If no attribute names are
     * specified, then all attributes will be returned. If any of the
     * requested attributes are not found, they will not appear in the
     * result. 
For more information, see Accessing
     * Item Attributes in the Amazon DynamoDB Developer Guide.
     * 
   AttributesToGet -  
This is a
     * legacy parameter, for backward compatibility. New applications should
     * use ProjectionExpression instead. Do not combine legacy
     * parameters and expression parameters in a single API call; otherwise,
     * DynamoDB will return a ValidationException exception. 
This
     * parameter allows you to retrieve attributes of type List or Map;
     * however, it cannot retrieve individual elements within a List or a
     * Map. 
The names of one or more attributes to retrieve.
     * If no attribute names are provided, then all attributes will be
     * returned. If any of the requested attributes are not found, they will
     * not appear in the result. 
Note that AttributesToGet has no
     * effect on provisioned throughput consumption. DynamoDB determines
     * capacity units consumed based on item size, not on the amount of data
     * that is returned to an application. 
 
     * 
     * The method adds a new key-value pair into RequestItems parameter, and
     * returns a reference to this object so that method calls can be chained
     * together.
     * 

     * Constraints:

     * Length: 1 - 100

     *
     * @param key The key of the entry to be added into RequestItems.
     * @param value The corresponding value of the entry to be added into RequestItems.
     */
    public BatchGetItemRequest addRequestItemsEntry(String key, KeysAndAttributes value) {
        if (null == this.requestItems) {
            this.requestItems = new java.util.HashMap();
        }
        if (this.requestItems.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.requestItems.put(key, value);
        return this;
    }

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

     * Returns a reference to this object so that method calls can be chained together.
     */
    public BatchGetItemRequest clearRequestItemsEntries() {
        this.requestItems = null;
        return this;
    }
    
    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 

     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     * 
     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @return Determines the level of detail about provisioned throughput
     *         consumption that is returned in the response: 

     *         INDEXES - The response includes the aggregate
     *         ConsumedCapacity for the operation, together with
     *         ConsumedCapacity for each table and secondary index that was
     *         accessed. 
Note that some operations, such as GetItem and
     *         BatchGetItem, do not access any indexes at all. In these cases,
     *         specifying INDEXES will only return ConsumedCapacity
     *         information for table(s).
 TOTAL - The response
     *         includes only the aggregate ConsumedCapacity for the
     *         operation.
 NONE - No ConsumedCapacity
     *         details are included in the response.
 
     *
     * @see ReturnConsumedCapacity
     */
    public String getReturnConsumedCapacity() {
        return returnConsumedCapacity;
    }
    
    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 
     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     * 
     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity Determines the level of detail about provisioned throughput
     *         consumption that is returned in the response: 

     *         INDEXES - The response includes the aggregate
     *         ConsumedCapacity for the operation, together with
     *         ConsumedCapacity for each table and secondary index that was
     *         accessed. 
Note that some operations, such as GetItem and
     *         BatchGetItem, do not access any indexes at all. In these cases,
     *         specifying INDEXES will only return ConsumedCapacity
     *         information for table(s).
 TOTAL - The response
     *         includes only the aggregate ConsumedCapacity for the
     *         operation.
 NONE - No ConsumedCapacity
     *         details are included in the response.
 
     *
     * @see ReturnConsumedCapacity
     */
    public void setReturnConsumedCapacity(String returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity;
    }
    
    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 
     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are 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 Determines the level of detail about provisioned throughput
     *         consumption that is returned in the response: 

     *         INDEXES - The response includes the aggregate
     *         ConsumedCapacity for the operation, together with
     *         ConsumedCapacity for each table and secondary index that was
     *         accessed. 
Note that some operations, such as GetItem and
     *         BatchGetItem, do not access any indexes at all. In these cases,
     *         specifying INDEXES will only return ConsumedCapacity
     *         information for table(s).
 TOTAL - The response
     *         includes only the aggregate ConsumedCapacity for the
     *         operation.
 NONE - No ConsumedCapacity
     *         details are included in the response.
 
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnConsumedCapacity
     */
    public BatchGetItemRequest withReturnConsumedCapacity(String returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity;
        return this;
    }

    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 
     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are included in the response.
 
     * 
     * Constraints:

     * Allowed Values: INDEXES, TOTAL, NONE
     *
     * @param returnConsumedCapacity Determines the level of detail about provisioned throughput
     *         consumption that is returned in the response: 

     *         INDEXES - The response includes the aggregate
     *         ConsumedCapacity for the operation, together with
     *         ConsumedCapacity for each table and secondary index that was
     *         accessed. 
Note that some operations, such as GetItem and
     *         BatchGetItem, do not access any indexes at all. In these cases,
     *         specifying INDEXES will only return ConsumedCapacity
     *         information for table(s).
 TOTAL - The response
     *         includes only the aggregate ConsumedCapacity for the
     *         operation.
 NONE - No ConsumedCapacity
     *         details are included in the response.
 
     *
     * @see ReturnConsumedCapacity
     */
    public void setReturnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity.toString();
    }
    
    /**
     * Determines the level of detail about provisioned throughput
     * consumption that is returned in the response: 
     * INDEXES - The response includes the aggregate
     * ConsumedCapacity for the operation, together with
     * ConsumedCapacity for each table and secondary index that was
     * accessed. 
Note that some operations, such as GetItem and
     * BatchGetItem, do not access any indexes at all. In these cases,
     * specifying INDEXES will only return ConsumedCapacity
     * information for table(s).
 TOTAL - The response
     * includes only the aggregate ConsumedCapacity for the
     * operation.
 NONE - No ConsumedCapacity
     * details are 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 Determines the level of detail about provisioned throughput
     *         consumption that is returned in the response: 

     *         INDEXES - The response includes the aggregate
     *         ConsumedCapacity for the operation, together with
     *         ConsumedCapacity for each table and secondary index that was
     *         accessed. 
Note that some operations, such as GetItem and
     *         BatchGetItem, do not access any indexes at all. In these cases,
     *         specifying INDEXES will only return ConsumedCapacity
     *         information for table(s).
 TOTAL - The response
     *         includes only the aggregate ConsumedCapacity for the
     *         operation.
 NONE - No ConsumedCapacity
     *         details are included in the response.
 
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ReturnConsumedCapacity
     */
    public BatchGetItemRequest withReturnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity.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 (getRequestItems() != null) sb.append("RequestItems: " + getRequestItems() + ",");
        if (getReturnConsumedCapacity() != null) sb.append("ReturnConsumedCapacity: " + getReturnConsumedCapacity() );
        sb.append("}");
        return sb.toString();
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;
        
        hashCode = prime * hashCode + ((getRequestItems() == null) ? 0 : getRequestItems().hashCode()); 
        hashCode = prime * hashCode + ((getReturnConsumedCapacity() == null) ? 0 : getReturnConsumedCapacity().hashCode()); 
        return hashCode;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        if (obj instanceof BatchGetItemRequest == false) return false;
        BatchGetItemRequest other = (BatchGetItemRequest)obj;
        
        if (other.getRequestItems() == null ^ this.getRequestItems() == null) return false;
        if (other.getRequestItems() != null && other.getRequestItems().equals(this.getRequestItems()) == false) return false; 
        if (other.getReturnConsumedCapacity() == null ^ this.getReturnConsumedCapacity() == null) return false;
        if (other.getReturnConsumedCapacity() != null && other.getReturnConsumedCapacity().equals(this.getReturnConsumedCapacity()) == false) return false; 
        return true;
    }
    
}