All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.amazonaws.services.dynamodbv2.model.QueryRequest Maven / Gradle / Ivy

    /*
 * 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#query(QueryRequest) Query operation}.
 * 
    
 * A Query operation uses the primary key of a table or a
 * secondary index to directly access items from that table or index.
 * 
    
 * 
    
 * Use the KeyConditionExpression parameter to provide a specific
 * value for the partition key. The Query operation will return
 * all of the items from the table or index with that partition key
 * value. You can optionally narrow the scope of the Query
 * operation by specifying a sort key value and a comparison operator in
 * KeyConditionExpression . You can use the
 * ScanIndexForward parameter to get results in forward or reverse
 * order, by sort key.
 * 
    
 * 
    
 * Queries that do not return results consume the minimum number of read
 * capacity units for that type of read operation.
 * 
    
 * 
    
 * If the total number of items meeting the query criteria exceeds the
 * result set size limit of 1 MB, the query stops and results are
 * returned to the user with the LastEvaluatedKey element to
 * continue the query in a subsequent operation. Unlike a Scan
 * operation, a Query operation never returns both an empty result
 * set and a LastEvaluatedKey value. LastEvaluatedKey is
 * only provided if the results exceed 1 MB, or if you have used the
 * Limit parameter.
 * 
    
 * 
    
 * You can query a table, a local secondary index, or a global secondary
 * index. For a query on a table or on a local secondary index, you can
 * set the ConsistentRead parameter to true and
 * obtain a strongly consistent result. Global secondary indexes support
 * eventually consistent reads only, so do not specify
 * ConsistentRead when querying a global secondary index.
 * 
    
 *
 * @see com.amazonaws.services.dynamodbv2.AmazonDynamoDB#query(QueryRequest)
 */
public class QueryRequest extends AmazonWebServiceRequest implements Serializable {

    /**
     * The name of the table containing the requested items.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     */
    private String tableName;

    /**
     * The name of an index to query. This index can be any local secondary
     * index or global secondary index on the table. Note that if you use the
     * IndexName parameter, you must also provide TableName.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     */
    private String indexName;

    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     */
    private String select;

    /**
     * 
    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. 
    You cannot use both
     * AttributesToGet and Select together in a Query
     * request, unless the value for Select is
     * SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     * specifying AttributesToGet without any value for
     * Select.) 
    If you query a local secondary index and request
     * only attributes that are projected into that index, the operation will
     * read only the index and not the table. If any of the requested
     * attributes are not projected into the local secondary index, DynamoDB
     * will fetch each of these attributes from the parent table. This extra
     * fetching incurs additional throughput cost and latency. 
    If you
     * query a global secondary index, you can only request attributes that
     * are projected into the index. Global secondary index queries cannot
     * fetch attributes from the parent table.
     * 
    
     * Constraints:
    
     * Length: 1 - 
    
     */
    private com.amazonaws.internal.ListWithAutoConstructFlag attributesToGet;

    /**
     * The maximum number of items to evaluate (not necessarily the number of
     * matching items). If DynamoDB processes the number of items up to the
     * limit while processing the results, it stops the operation and returns
     * the matching values up to that point, and a key in
     * LastEvaluatedKey to apply in a subsequent operation, so that
     * you can pick up where you left off. Also, if the processed data set
     * size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     * operation and returns the matching values up to the limit, and a key
     * in LastEvaluatedKey to apply in a subsequent operation to
     * continue the operation. For more information, see Query
     * and Scan in the Amazon DynamoDB Developer Guide.
     * 
    
     * Constraints:
    
     * Range: 1 - 
    
     */
    private Integer limit;

    /**
     * Determines the read consistency model: If set to true,
     * then the operation uses strongly consistent reads; otherwise, the
     * operation uses eventually consistent reads. 
    Strongly consistent
     * reads are not supported on global secondary indexes. If you query a
     * global secondary index with ConsistentRead set to
     * true, you will receive a ValidationException.
     */
    private Boolean consistentRead;

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use KeyConditionExpression instead. Do
     * not combine legacy parameters and expression parameters in a single
     * API call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    The selection criteria for the query. For a
     * query on a table, you can have conditions only on the table primary
     * key attributes. You must provide the partition key name and value as
     * an EQ condition. You can optionally provide a second
     * condition, referring to the sort key.  
    If you don't provide a
     * sort key condition, all of the items that match the partition key will
     * be retrieved. If a FilterExpression or QueryFilter is
     * present, it will be applied after the items are retrieved.
     * 
    For a query on an index, you can have conditions only on the index
     * key attributes. You must provide the index partition key name and
     * value as an EQ condition. You can optionally provide a
     * second condition, referring to the index sort key. 
    Each
     * KeyConditions element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the ComparisonOperator being
     * used. 
      For type Number, value comparisons are numeric. 
      String
     * value comparisons for greater than, equals, or less than are based on
     * ASCII character code values. For example, a is greater
     * than A, and a is greater than
     * B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      •  
    • 
     * 
      ComparisonOperator - A comparator for evaluating attributes,
     * for example, equals, greater than, less than, and so on. 
      For
     * KeyConditions, only the following comparison operators are
     * supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     * BETWEEN 
      The following are descriptions of these comparison
     * operators. 
         
      •  
        EQ : Equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one specified in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        LE : Less than or equal. 
        AttributeValueList
     * can contain only one AttributeValue element of type String,
     * Number, or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        LT : Less than.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GE : Greater than or equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue element of type String, Number, or Binary (not a
     * set type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GT : Greater than. 
        AttributeValueList can
     * contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     * a prefix. 
        AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a set
     * type). The target attribute of the comparison must be of type String
     * or Binary (not a Number or a set type). 
         
        •  
      • 
     * 
        BETWEEN : Greater than or equal to the first value,
     * and less than or equal to the second value.
     * 
        AttributeValueList must contain two AttributeValue
     * elements of the same type, either String, Number, or Binary (not a set
     * type). A target attribute matches if the target value is greater than,
     * or equal to, the first element and less than, or equal to, the second
     * element. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not compare to
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     * usage examples of AttributeValueList and
     * ComparisonOperator, see Legacy
     * Conditional Parameters in the Amazon DynamoDB Developer
     * Guide.
     */
    private java.util.Map keyConditions;

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A condition that evaluates the query
     * results after the items are read and returns only the desired values.
     * 
    This parameter does not support attributes of type List or Map.
     * 
    A QueryFilter is applied after the items have already
     * been read; the process of filtering does not consume any additional
     * read capacity units. 
    If you provide more than one condition
     * in the QueryFilter map, then by default all of the conditions
     * must evaluate to true. In other words, the conditions are ANDed
     * together. (You can use the ConditionalOperator parameter to OR
     * the conditions instead. If you do this, then at least one of the
     * conditions must evaluate to true, rather than all of them.) 
    Note
     * that QueryFilter does not allow key attributes. You cannot
     * define a filter condition on a partition key or a sort key. 
    Each
     * QueryFilter element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the operator specified in
     * ComparisonOperator. 
      For type Number, value comparisons are
     * numeric. 
      String value comparisons for greater than, equals, or less
     * than are based on ASCII character code values. For example,
     * a is greater than A, and a is
     * greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For type Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      For information on
     * specifying data types in JSON, see JSON
     * Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     * 
    • ComparisonOperator - A comparator for evaluating
     * attributes. For example, equals, greater than, less than, etc. 
      The
     * following comparison operators are available: 
      EQ | NE | LE |
     * LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     * | IN | BETWEEN 
      For complete descriptions of all comparison
     * operators, see the Condition
     * data type. 
      •  
    
     */
    private java.util.Map queryFilter;

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     */
    private String conditionalOperator;

    /**
     * Specifies the order for index traversal: If true
     * (default), the traversal is performed in ascending order; if
     * false, the traversal is performed in descending order.
     * 
    Items with the same partition key value are stored in sorted order
     * by sort key. If the sort key data type is Number, the results are
     * stored in numeric order. For type String, the results are stored in
     * order of ASCII character code values. For type Binary, DynamoDB treats
     * each byte of the binary data as unsigned. 
    If
     * ScanIndexForward is true, DynamoDB returns the
     * results in the order in which they are stored (by sort key value).
     * This is the default behavior. If ScanIndexForward is
     * false, DynamoDB reads the results in reverse order by
     * sort key value, and then returns the results to the client.
     */
    private Boolean scanIndexForward;

    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     */
    private java.util.Map exclusiveStartKey;

    /**
     * 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;

    /**
     * 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.
     * 
    ProjectionExpression replaces the legacy
     * AttributesToGet parameter.
     */
    private String projectionExpression;

    /**
     * A string that contains conditions that DynamoDB applies after the
     * Query operation, but before the data is returned to you. Items
     * that do not satisfy the FilterExpression criteria are not
     * returned.  
    A FilterExpression is applied after the
     * items have already been read; the process of filtering does not
     * consume any additional read capacity units.  
    For more
     * information, see Filter
     * Expressions in the Amazon DynamoDB Developer Guide.
     * 
    FilterExpression replaces the legacy
     * QueryFilter and ConditionalOperator parameters.
     */
    private String filterExpression;

    /**
     * The condition that specifies the key value(s) for items to be
     * retrieved by the Query action. 
    The condition must perform an
     * equality test on a single partition key value. The condition can also
     * perform one of several comparison tests on a single sort key value.
     * Query can use KeyConditionExpression to retrieve one
     * item with a given partition key value and sort key value, or several
     * items that have the same partition key value but different sort key
     * values. 
    The partition key equality test is required, and must be
     * specified in the following format: 
     partitionKeyName
     * = :partitionkeyval 
    If you also want to provide
     * a condition for the sort key, it must be combined using AND
     * with the condition for the sort key. Following is an example, using
     * the = comparison operator for the sort key: 
    
     * partitionKeyName = :partitionkeyval
     * AND sortKeyName = :sortkeyval
     * 
    Valid comparisons for the sort key condition are as follows: 
      
     * 
    •  
      sortKeyName = :sortkeyval -
     * true if the sort key value is equal to :sortkeyval. 
      • 
     * 
    •  
      sortKeyName < :sortkeyval -
     * true if the sort key value is less than :sortkeyval.
     * 
      •  
    •  
      sortKeyName <=
     * :sortkeyval - true if the sort key value is less than or
     * equal to :sortkeyval. 
      •  
    • 
     * 
      sortKeyName > :sortkeyval - true
     * if the sort key value is greater than :sortkeyval. 
      • 
     * 
    •  
      sortKeyName >= :sortkeyval -
     * true if the sort key value is greater than or equal to
     * :sortkeyval. 
      •  
    •  
      sortKeyName
     * BETWEEN :sortkeyval1 AND
     * :sortkeyval2 - true if the sort key value is greater than
     * or equal to :sortkeyval1, and less than or equal to
     * :sortkeyval2. 
      •  
    •  
      begins_with
     * (sortKeyName, :sortkeyval) - true
     * if the sort key value begins with a particular operand. (You cannot
     * use this function with a sort key that is of type Number.) Note that
     * the function name begins_with is case-sensitive. 
      • 
     * 
     
    Use the ExpressionAttributeValues parameter to replace
     * tokens such as :partitionval and :sortval
     * with actual values at runtime. 
    You can optionally use the
     * ExpressionAttributeNames parameter to replace the names of the
     * partition key and sort key with placeholder tokens. This option might
     * be necessary if an attribute name conflicts with a DynamoDB reserved
     * word. For example, the following KeyConditionExpression
     * parameter causes an error because Size is a reserved word: 
      
     * 
    •  Size = :myval 
      •  
     
    To work around this,
     * define a placeholder (such a #S) to represent the
     * attribute name Size. KeyConditionExpression then is as
     * follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     * of reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide. 
    For more
     * information on ExpressionAttributeNames and
     * ExpressionAttributeValues, see Using
     * Placeholders for Attribute Names and Values in the Amazon
     * DynamoDB Developer Guide.  
    KeyConditionExpression
     * replaces the legacy KeyConditions parameter. 
     */
    private String keyConditionExpression;

    /**
     * One or more substitution tokens for attribute names in an expression.
     * 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.
     */
    private java.util.Map expressionAttributeNames;

    /**
     * One or more values that can be substituted in an expression. 
    Use
     * the : (colon) character in an expression to dereference an
     * attribute value. For example, suppose that you wanted to check whether
     * the value of the ProductStatus attribute was one of the
     * following: 
    Available | Backordered | Discontinued
     * 
    You would first need to specify ExpressionAttributeValues as
     * follows: 
    { ":avail":{"S":"Available"},
     * ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     * 
    You could then use these values in an expression, such as this:
     * 
    ProductStatus IN (:avail, :back, :disc) 
    For more
     * information on expression attribute values, see Specifying
     * Conditions in the Amazon DynamoDB Developer Guide.
     */
    private java.util.Map expressionAttributeValues;

    /**
     * Default constructor for a new QueryRequest object.  Callers should use the
     * setter or fluent setter (with...) methods to initialize this object after creating it.
     */
    public QueryRequest() {}
    
    /**
     * Constructs a new QueryRequest 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 requested items.
     */
    public QueryRequest(String tableName) {
        setTableName(tableName);
    }

    /**
     * The name of the table containing the requested items.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     *
     * @return The name of the table containing the requested items.
     */
    public String getTableName() {
        return tableName;
    }
    
    /**
     * The name of the table containing the requested items.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     *
     * @param tableName The name of the table containing the requested items.
     */
    public void setTableName(String tableName) {
        this.tableName = tableName;
    }
    
    /**
     * The name of the table containing the requested items.
     * 
    
     * 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 requested items.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withTableName(String tableName) {
        this.tableName = tableName;
        return this;
    }

    /**
     * The name of an index to query. This index can be any local secondary
     * index or global secondary index on the table. Note that if you use the
     * IndexName parameter, you must also provide TableName.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     *
     * @return The name of an index to query. This index can be any local secondary
     *         index or global secondary index on the table. Note that if you use the
     *         IndexName parameter, you must also provide TableName.
     */
    public String getIndexName() {
        return indexName;
    }
    
    /**
     * The name of an index to query. This index can be any local secondary
     * index or global secondary index on the table. Note that if you use the
     * IndexName parameter, you must also provide TableName.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     *
     * @param indexName The name of an index to query. This index can be any local secondary
     *         index or global secondary index on the table. Note that if you use the
     *         IndexName parameter, you must also provide TableName.
     */
    public void setIndexName(String indexName) {
        this.indexName = indexName;
    }
    
    /**
     * The name of an index to query. This index can be any local secondary
     * index or global secondary index on the table. Note that if you use the
     * IndexName parameter, you must also provide TableName.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Length: 3 - 255
    
     * Pattern: [a-zA-Z0-9_.-]+
    
     *
     * @param indexName The name of an index to query. This index can be any local secondary
     *         index or global secondary index on the table. Note that if you use the
     *         IndexName parameter, you must also provide TableName.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withIndexName(String indexName) {
        this.indexName = indexName;
        return this;
    }

    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     *
     * @return The attributes to be returned in the result. You can retrieve all item
     *         attributes, specific item attributes, the count of matching items, or
     *         in the case of an index, some or all of the attributes projected into
     *         the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     *         the item attributes from the specified table or index. If you query a
     *         local secondary index, then for each matching item in the index
     *         DynamoDB will fetch the entire item from the parent table. If the
     *         index is configured to project all item attributes, then all of the
     *         data can be obtained from the local secondary index, and no fetching
     *         is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     *         Allowed only when querying an index. Retrieves all attributes that
     *         have been projected into the index. If the index is configured to
     *         project all attributes, this return value is equivalent to specifying
     *         ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     *         Returns the number of matching items, rather than the matching items
     *         themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     *         only the attributes listed in AttributesToGet. This return
     *         value is equivalent to specifying AttributesToGet without
     *         specifying any value for Select. 
      If you query a local
     *         secondary index and request only attributes that are projected into
     *         that index, the operation will read only the index and not the table.
     *         If any of the requested attributes are not projected into the local
     *         secondary index, DynamoDB will fetch each of these attributes from the
     *         parent table. This extra fetching incurs additional throughput cost
     *         and latency. 
      If you query a global secondary index, you can only
     *         request attributes that are projected into the index. Global secondary
     *         index queries cannot fetch attributes from the parent table. 
      • 
     *         
     
    If neither Select nor AttributesToGet are
     *         specified, DynamoDB defaults to ALL_ATTRIBUTES when
     *         accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     *         accessing an index. You cannot use both Select and
     *         AttributesToGet together in a single request, unless the value
     *         for Select is SPECIFIC_ATTRIBUTES. (This usage is
     *         equivalent to specifying AttributesToGet without any value for
     *         Select.) 
    If you use the ProjectionExpression
     *         parameter, then the value for Select can only be
     *         SPECIFIC_ATTRIBUTES. Any other value for Select
     *         will return an error.
     *
     * @see Select
     */
    public String getSelect() {
        return select;
    }
    
    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     *
     * @param select The attributes to be returned in the result. You can retrieve all item
     *         attributes, specific item attributes, the count of matching items, or
     *         in the case of an index, some or all of the attributes projected into
     *         the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     *         the item attributes from the specified table or index. If you query a
     *         local secondary index, then for each matching item in the index
     *         DynamoDB will fetch the entire item from the parent table. If the
     *         index is configured to project all item attributes, then all of the
     *         data can be obtained from the local secondary index, and no fetching
     *         is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     *         Allowed only when querying an index. Retrieves all attributes that
     *         have been projected into the index. If the index is configured to
     *         project all attributes, this return value is equivalent to specifying
     *         ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     *         Returns the number of matching items, rather than the matching items
     *         themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     *         only the attributes listed in AttributesToGet. This return
     *         value is equivalent to specifying AttributesToGet without
     *         specifying any value for Select. 
      If you query a local
     *         secondary index and request only attributes that are projected into
     *         that index, the operation will read only the index and not the table.
     *         If any of the requested attributes are not projected into the local
     *         secondary index, DynamoDB will fetch each of these attributes from the
     *         parent table. This extra fetching incurs additional throughput cost
     *         and latency. 
      If you query a global secondary index, you can only
     *         request attributes that are projected into the index. Global secondary
     *         index queries cannot fetch attributes from the parent table. 
      • 
     *         
     
    If neither Select nor AttributesToGet are
     *         specified, DynamoDB defaults to ALL_ATTRIBUTES when
     *         accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     *         accessing an index. You cannot use both Select and
     *         AttributesToGet together in a single request, unless the value
     *         for Select is SPECIFIC_ATTRIBUTES. (This usage is
     *         equivalent to specifying AttributesToGet without any value for
     *         Select.) 
    If you use the ProjectionExpression
     *         parameter, then the value for Select can only be
     *         SPECIFIC_ATTRIBUTES. Any other value for Select
     *         will return an error.
     *
     * @see Select
     */
    public void setSelect(String select) {
        this.select = select;
    }
    
    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     *
     * @param select The attributes to be returned in the result. You can retrieve all item
     *         attributes, specific item attributes, the count of matching items, or
     *         in the case of an index, some or all of the attributes projected into
     *         the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     *         the item attributes from the specified table or index. If you query a
     *         local secondary index, then for each matching item in the index
     *         DynamoDB will fetch the entire item from the parent table. If the
     *         index is configured to project all item attributes, then all of the
     *         data can be obtained from the local secondary index, and no fetching
     *         is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     *         Allowed only when querying an index. Retrieves all attributes that
     *         have been projected into the index. If the index is configured to
     *         project all attributes, this return value is equivalent to specifying
     *         ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     *         Returns the number of matching items, rather than the matching items
     *         themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     *         only the attributes listed in AttributesToGet. This return
     *         value is equivalent to specifying AttributesToGet without
     *         specifying any value for Select. 
      If you query a local
     *         secondary index and request only attributes that are projected into
     *         that index, the operation will read only the index and not the table.
     *         If any of the requested attributes are not projected into the local
     *         secondary index, DynamoDB will fetch each of these attributes from the
     *         parent table. This extra fetching incurs additional throughput cost
     *         and latency. 
      If you query a global secondary index, you can only
     *         request attributes that are projected into the index. Global secondary
     *         index queries cannot fetch attributes from the parent table. 
      • 
     *         
     
    If neither Select nor AttributesToGet are
     *         specified, DynamoDB defaults to ALL_ATTRIBUTES when
     *         accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     *         accessing an index. You cannot use both Select and
     *         AttributesToGet together in a single request, unless the value
     *         for Select is SPECIFIC_ATTRIBUTES. (This usage is
     *         equivalent to specifying AttributesToGet without any value for
     *         Select.) 
    If you use the ProjectionExpression
     *         parameter, then the value for Select can only be
     *         SPECIFIC_ATTRIBUTES. Any other value for Select
     *         will return an error.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see Select
     */
    public QueryRequest withSelect(String select) {
        this.select = select;
        return this;
    }

    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     *
     * @param select The attributes to be returned in the result. You can retrieve all item
     *         attributes, specific item attributes, the count of matching items, or
     *         in the case of an index, some or all of the attributes projected into
     *         the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     *         the item attributes from the specified table or index. If you query a
     *         local secondary index, then for each matching item in the index
     *         DynamoDB will fetch the entire item from the parent table. If the
     *         index is configured to project all item attributes, then all of the
     *         data can be obtained from the local secondary index, and no fetching
     *         is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     *         Allowed only when querying an index. Retrieves all attributes that
     *         have been projected into the index. If the index is configured to
     *         project all attributes, this return value is equivalent to specifying
     *         ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     *         Returns the number of matching items, rather than the matching items
     *         themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     *         only the attributes listed in AttributesToGet. This return
     *         value is equivalent to specifying AttributesToGet without
     *         specifying any value for Select. 
      If you query a local
     *         secondary index and request only attributes that are projected into
     *         that index, the operation will read only the index and not the table.
     *         If any of the requested attributes are not projected into the local
     *         secondary index, DynamoDB will fetch each of these attributes from the
     *         parent table. This extra fetching incurs additional throughput cost
     *         and latency. 
      If you query a global secondary index, you can only
     *         request attributes that are projected into the index. Global secondary
     *         index queries cannot fetch attributes from the parent table. 
      • 
     *         
     
    If neither Select nor AttributesToGet are
     *         specified, DynamoDB defaults to ALL_ATTRIBUTES when
     *         accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     *         accessing an index. You cannot use both Select and
     *         AttributesToGet together in a single request, unless the value
     *         for Select is SPECIFIC_ATTRIBUTES. (This usage is
     *         equivalent to specifying AttributesToGet without any value for
     *         Select.) 
    If you use the ProjectionExpression
     *         parameter, then the value for Select can only be
     *         SPECIFIC_ATTRIBUTES. Any other value for Select
     *         will return an error.
     *
     * @see Select
     */
    public void setSelect(Select select) {
        this.select = select.toString();
    }
    
    /**
     * The attributes to be returned in the result. You can retrieve all item
     * attributes, specific item attributes, the count of matching items, or
     * in the case of an index, some or all of the attributes projected into
     * the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     * the item attributes from the specified table or index. If you query a
     * local secondary index, then for each matching item in the index
     * DynamoDB will fetch the entire item from the parent table. If the
     * index is configured to project all item attributes, then all of the
     * data can be obtained from the local secondary index, and no fetching
     * is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     * Allowed only when querying an index. Retrieves all attributes that
     * have been projected into the index. If the index is configured to
     * project all attributes, this return value is equivalent to specifying
     * ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     * Returns the number of matching items, rather than the matching items
     * themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     * only the attributes listed in AttributesToGet. This return
     * value is equivalent to specifying AttributesToGet without
     * specifying any value for Select. 
      If you query a local
     * secondary index and request only attributes that are projected into
     * that index, the operation will read only the index and not the table.
     * If any of the requested attributes are not projected into the local
     * secondary index, DynamoDB will fetch each of these attributes from the
     * parent table. This extra fetching incurs additional throughput cost
     * and latency. 
      If you query a global secondary index, you can only
     * request attributes that are projected into the index. Global secondary
     * index queries cannot fetch attributes from the parent table. 
      • 
     * 
     
    If neither Select nor AttributesToGet are
     * specified, DynamoDB defaults to ALL_ATTRIBUTES when
     * accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     * accessing an index. You cannot use both Select and
     * AttributesToGet together in a single request, unless the value
     * for Select is SPECIFIC_ATTRIBUTES. (This usage is
     * equivalent to specifying AttributesToGet without any value for
     * Select.) 
    If you use the ProjectionExpression
     * parameter, then the value for Select can only be
     * SPECIFIC_ATTRIBUTES. Any other value for Select
     * will return an error.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Allowed Values: ALL_ATTRIBUTES, ALL_PROJECTED_ATTRIBUTES, SPECIFIC_ATTRIBUTES, COUNT
     *
     * @param select The attributes to be returned in the result. You can retrieve all item
     *         attributes, specific item attributes, the count of matching items, or
     *         in the case of an index, some or all of the attributes projected into
     *         the index. 
       
    •  
      ALL_ATTRIBUTES - Returns all of
     *         the item attributes from the specified table or index. If you query a
     *         local secondary index, then for each matching item in the index
     *         DynamoDB will fetch the entire item from the parent table. If the
     *         index is configured to project all item attributes, then all of the
     *         data can be obtained from the local secondary index, and no fetching
     *         is required. 
      •  
    •  
      ALL_PROJECTED_ATTRIBUTES -
     *         Allowed only when querying an index. Retrieves all attributes that
     *         have been projected into the index. If the index is configured to
     *         project all attributes, this return value is equivalent to specifying
     *         ALL_ATTRIBUTES. 
      •  
    •  
      COUNT -
     *         Returns the number of matching items, rather than the matching items
     *         themselves. 
      •  
    •  
       SPECIFIC_ATTRIBUTES - Returns
     *         only the attributes listed in AttributesToGet. This return
     *         value is equivalent to specifying AttributesToGet without
     *         specifying any value for Select. 
      If you query a local
     *         secondary index and request only attributes that are projected into
     *         that index, the operation will read only the index and not the table.
     *         If any of the requested attributes are not projected into the local
     *         secondary index, DynamoDB will fetch each of these attributes from the
     *         parent table. This extra fetching incurs additional throughput cost
     *         and latency. 
      If you query a global secondary index, you can only
     *         request attributes that are projected into the index. Global secondary
     *         index queries cannot fetch attributes from the parent table. 
      • 
     *         
     
    If neither Select nor AttributesToGet are
     *         specified, DynamoDB defaults to ALL_ATTRIBUTES when
     *         accessing a table, and ALL_PROJECTED_ATTRIBUTES when
     *         accessing an index. You cannot use both Select and
     *         AttributesToGet together in a single request, unless the value
     *         for Select is SPECIFIC_ATTRIBUTES. (This usage is
     *         equivalent to specifying AttributesToGet without any value for
     *         Select.) 
    If you use the ProjectionExpression
     *         parameter, then the value for Select can only be
     *         SPECIFIC_ATTRIBUTES. Any other value for Select
     *         will return an error.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see Select
     */
    public QueryRequest withSelect(Select select) {
        this.select = select.toString();
        return this;
    }

    /**
     * 
    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. 
    You cannot use both
     * AttributesToGet and Select together in a Query
     * request, unless the value for Select is
     * SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     * specifying AttributesToGet without any value for
     * Select.) 
    If you query a local secondary index and request
     * only attributes that are projected into that index, the operation will
     * read only the index and not the table. If any of the requested
     * attributes are not projected into the local secondary index, DynamoDB
     * will fetch each of these attributes from the parent table. This extra
     * fetching incurs additional throughput cost and latency. 
    If you
     * query a global secondary index, you can only request attributes that
     * are projected into the index. Global secondary index queries cannot
     * fetch attributes from the parent table.
     * 
    
     * Constraints:
    
     * Length: 1 - 
    
     *
     * @return 
    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. 
    You cannot use both
     *         AttributesToGet and Select together in a Query
     *         request, unless the value for Select is
     *         SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     *         specifying AttributesToGet without any value for
     *         Select.) 
    If you query a local secondary index and request
     *         only attributes that are projected into that index, the operation will
     *         read only the index and not the table. If any of the requested
     *         attributes are not projected into the local secondary index, DynamoDB
     *         will fetch each of these attributes from the parent table. This extra
     *         fetching incurs additional throughput cost and latency. 
    If you
     *         query a global secondary index, you can only request attributes that
     *         are projected into the index. Global secondary index queries cannot
     *         fetch attributes from the parent table.
     */
    public java.util.List getAttributesToGet() {
        return 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. 
    You cannot use both
     * AttributesToGet and Select together in a Query
     * request, unless the value for Select is
     * SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     * specifying AttributesToGet without any value for
     * Select.) 
    If you query a local secondary index and request
     * only attributes that are projected into that index, the operation will
     * read only the index and not the table. If any of the requested
     * attributes are not projected into the local secondary index, DynamoDB
     * will fetch each of these attributes from the parent table. This extra
     * fetching incurs additional throughput cost and latency. 
    If you
     * query a global secondary index, you can only request attributes that
     * are projected into the index. Global secondary index queries cannot
     * fetch attributes from the parent table.
     * 
    
     * Constraints:
    
     * Length: 1 - 
    
     *
     * @param 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. 
    You cannot use both
     *         AttributesToGet and Select together in a Query
     *         request, unless the value for Select is
     *         SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     *         specifying AttributesToGet without any value for
     *         Select.) 
    If you query a local secondary index and request
     *         only attributes that are projected into that index, the operation will
     *         read only the index and not the table. If any of the requested
     *         attributes are not projected into the local secondary index, DynamoDB
     *         will fetch each of these attributes from the parent table. This extra
     *         fetching incurs additional throughput cost and latency. 
    If you
     *         query a global secondary index, you can only request attributes that
     *         are projected into the index. Global secondary index queries cannot
     *         fetch attributes from the parent table.
     */
    public void setAttributesToGet(java.util.Collection attributesToGet) {
        if (attributesToGet == null) {
            this.attributesToGet = null;
            return;
        }
        com.amazonaws.internal.ListWithAutoConstructFlag attributesToGetCopy = new com.amazonaws.internal.ListWithAutoConstructFlag(attributesToGet.size());
        attributesToGetCopy.addAll(attributesToGet);
        this.attributesToGet = attributesToGetCopy;
    }
    
    /**
     * 
    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. 
    You cannot use both
     * AttributesToGet and Select together in a Query
     * request, unless the value for Select is
     * SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     * specifying AttributesToGet without any value for
     * Select.) 
    If you query a local secondary index and request
     * only attributes that are projected into that index, the operation will
     * read only the index and not the table. If any of the requested
     * attributes are not projected into the local secondary index, DynamoDB
     * will fetch each of these attributes from the parent table. This extra
     * fetching incurs additional throughput cost and latency. 
    If you
     * query a global secondary index, you can only request attributes that
     * are projected into the index. Global secondary index queries cannot
     * fetch attributes from the parent table.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Length: 1 - 
    
     *
     * @param 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. 
    You cannot use both
     *         AttributesToGet and Select together in a Query
     *         request, unless the value for Select is
     *         SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     *         specifying AttributesToGet without any value for
     *         Select.) 
    If you query a local secondary index and request
     *         only attributes that are projected into that index, the operation will
     *         read only the index and not the table. If any of the requested
     *         attributes are not projected into the local secondary index, DynamoDB
     *         will fetch each of these attributes from the parent table. This extra
     *         fetching incurs additional throughput cost and latency. 
    If you
     *         query a global secondary index, you can only request attributes that
     *         are projected into the index. Global secondary index queries cannot
     *         fetch attributes from the parent table.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withAttributesToGet(String... attributesToGet) {
        if (getAttributesToGet() == null) setAttributesToGet(new java.util.ArrayList(attributesToGet.length));
        for (String value : attributesToGet) {
            getAttributesToGet().add(value);
        }
        return this;
    }
    
    /**
     * 
    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. 
    You cannot use both
     * AttributesToGet and Select together in a Query
     * request, unless the value for Select is
     * SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     * specifying AttributesToGet without any value for
     * Select.) 
    If you query a local secondary index and request
     * only attributes that are projected into that index, the operation will
     * read only the index and not the table. If any of the requested
     * attributes are not projected into the local secondary index, DynamoDB
     * will fetch each of these attributes from the parent table. This extra
     * fetching incurs additional throughput cost and latency. 
    If you
     * query a global secondary index, you can only request attributes that
     * are projected into the index. Global secondary index queries cannot
     * fetch attributes from the parent table.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Length: 1 - 
    
     *
     * @param 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. 
    You cannot use both
     *         AttributesToGet and Select together in a Query
     *         request, unless the value for Select is
     *         SPECIFIC_ATTRIBUTES. (This usage is equivalent to
     *         specifying AttributesToGet without any value for
     *         Select.) 
    If you query a local secondary index and request
     *         only attributes that are projected into that index, the operation will
     *         read only the index and not the table. If any of the requested
     *         attributes are not projected into the local secondary index, DynamoDB
     *         will fetch each of these attributes from the parent table. This extra
     *         fetching incurs additional throughput cost and latency. 
    If you
     *         query a global secondary index, you can only request attributes that
     *         are projected into the index. Global secondary index queries cannot
     *         fetch attributes from the parent table.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withAttributesToGet(java.util.Collection attributesToGet) {
        if (attributesToGet == null) {
            this.attributesToGet = null;
        } else {
            com.amazonaws.internal.ListWithAutoConstructFlag attributesToGetCopy = new com.amazonaws.internal.ListWithAutoConstructFlag(attributesToGet.size());
            attributesToGetCopy.addAll(attributesToGet);
            this.attributesToGet = attributesToGetCopy;
        }

        return this;
    }

    /**
     * The maximum number of items to evaluate (not necessarily the number of
     * matching items). If DynamoDB processes the number of items up to the
     * limit while processing the results, it stops the operation and returns
     * the matching values up to that point, and a key in
     * LastEvaluatedKey to apply in a subsequent operation, so that
     * you can pick up where you left off. Also, if the processed data set
     * size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     * operation and returns the matching values up to the limit, and a key
     * in LastEvaluatedKey to apply in a subsequent operation to
     * continue the operation. For more information, see Query
     * and Scan in the Amazon DynamoDB Developer Guide.
     * 
    
     * Constraints:
    
     * Range: 1 - 
    
     *
     * @return The maximum number of items to evaluate (not necessarily the number of
     *         matching items). If DynamoDB processes the number of items up to the
     *         limit while processing the results, it stops the operation and returns
     *         the matching values up to that point, and a key in
     *         LastEvaluatedKey to apply in a subsequent operation, so that
     *         you can pick up where you left off. Also, if the processed data set
     *         size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     *         operation and returns the matching values up to the limit, and a key
     *         in LastEvaluatedKey to apply in a subsequent operation to
     *         continue the operation. For more information, see Query
     *         and Scan in the Amazon DynamoDB Developer Guide.
     */
    public Integer getLimit() {
        return limit;
    }
    
    /**
     * The maximum number of items to evaluate (not necessarily the number of
     * matching items). If DynamoDB processes the number of items up to the
     * limit while processing the results, it stops the operation and returns
     * the matching values up to that point, and a key in
     * LastEvaluatedKey to apply in a subsequent operation, so that
     * you can pick up where you left off. Also, if the processed data set
     * size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     * operation and returns the matching values up to the limit, and a key
     * in LastEvaluatedKey to apply in a subsequent operation to
     * continue the operation. For more information, see Query
     * and Scan in the Amazon DynamoDB Developer Guide.
     * 
    
     * Constraints:
    
     * Range: 1 - 
    
     *
     * @param limit The maximum number of items to evaluate (not necessarily the number of
     *         matching items). If DynamoDB processes the number of items up to the
     *         limit while processing the results, it stops the operation and returns
     *         the matching values up to that point, and a key in
     *         LastEvaluatedKey to apply in a subsequent operation, so that
     *         you can pick up where you left off. Also, if the processed data set
     *         size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     *         operation and returns the matching values up to the limit, and a key
     *         in LastEvaluatedKey to apply in a subsequent operation to
     *         continue the operation. For more information, see Query
     *         and Scan in the Amazon DynamoDB Developer Guide.
     */
    public void setLimit(Integer limit) {
        this.limit = limit;
    }
    
    /**
     * The maximum number of items to evaluate (not necessarily the number of
     * matching items). If DynamoDB processes the number of items up to the
     * limit while processing the results, it stops the operation and returns
     * the matching values up to that point, and a key in
     * LastEvaluatedKey to apply in a subsequent operation, so that
     * you can pick up where you left off. Also, if the processed data set
     * size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     * operation and returns the matching values up to the limit, and a key
     * in LastEvaluatedKey to apply in a subsequent operation to
     * continue the operation. For more information, see Query
     * and Scan in the Amazon DynamoDB Developer Guide.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Range: 1 - 
    
     *
     * @param limit The maximum number of items to evaluate (not necessarily the number of
     *         matching items). If DynamoDB processes the number of items up to the
     *         limit while processing the results, it stops the operation and returns
     *         the matching values up to that point, and a key in
     *         LastEvaluatedKey to apply in a subsequent operation, so that
     *         you can pick up where you left off. Also, if the processed data set
     *         size exceeds 1 MB before DynamoDB reaches this limit, it stops the
     *         operation and returns the matching values up to the limit, and a key
     *         in LastEvaluatedKey to apply in a subsequent operation to
     *         continue the operation. For more information, see Query
     *         and Scan in the Amazon DynamoDB Developer Guide.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withLimit(Integer limit) {
        this.limit = limit;
        return this;
    }

    /**
     * Determines the read consistency model: If set to true,
     * then the operation uses strongly consistent reads; otherwise, the
     * operation uses eventually consistent reads. 
    Strongly consistent
     * reads are not supported on global secondary indexes. If you query a
     * global secondary index with ConsistentRead set to
     * true, you will receive a ValidationException.
     *
     * @return Determines the read consistency model: If set to true,
     *         then the operation uses strongly consistent reads; otherwise, the
     *         operation uses eventually consistent reads. 
    Strongly consistent
     *         reads are not supported on global secondary indexes. If you query a
     *         global secondary index with ConsistentRead set to
     *         true, you will receive a ValidationException.
     */
    public Boolean isConsistentRead() {
        return consistentRead;
    }
    
    /**
     * Determines the read consistency model: If set to true,
     * then the operation uses strongly consistent reads; otherwise, the
     * operation uses eventually consistent reads. 
    Strongly consistent
     * reads are not supported on global secondary indexes. If you query a
     * global secondary index with ConsistentRead set to
     * true, you will receive a ValidationException.
     *
     * @param consistentRead Determines the read consistency model: If set to true,
     *         then the operation uses strongly consistent reads; otherwise, the
     *         operation uses eventually consistent reads. 
    Strongly consistent
     *         reads are not supported on global secondary indexes. If you query a
     *         global secondary index with ConsistentRead set to
     *         true, you will receive a ValidationException.
     */
    public void setConsistentRead(Boolean consistentRead) {
        this.consistentRead = consistentRead;
    }
    
    /**
     * Determines the read consistency model: If set to true,
     * then the operation uses strongly consistent reads; otherwise, the
     * operation uses eventually consistent reads. 
    Strongly consistent
     * reads are not supported on global secondary indexes. If you query a
     * global secondary index with ConsistentRead set to
     * true, you will receive a ValidationException.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param consistentRead Determines the read consistency model: If set to true,
     *         then the operation uses strongly consistent reads; otherwise, the
     *         operation uses eventually consistent reads. 
    Strongly consistent
     *         reads are not supported on global secondary indexes. If you query a
     *         global secondary index with ConsistentRead set to
     *         true, you will receive a ValidationException.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withConsistentRead(Boolean consistentRead) {
        this.consistentRead = consistentRead;
        return this;
    }

    /**
     * Determines the read consistency model: If set to true,
     * then the operation uses strongly consistent reads; otherwise, the
     * operation uses eventually consistent reads. 
    Strongly consistent
     * reads are not supported on global secondary indexes. If you query a
     * global secondary index with ConsistentRead set to
     * true, you will receive a ValidationException.
     *
     * @return Determines the read consistency model: If set to true,
     *         then the operation uses strongly consistent reads; otherwise, the
     *         operation uses eventually consistent reads. 
    Strongly consistent
     *         reads are not supported on global secondary indexes. If you query a
     *         global secondary index with ConsistentRead set to
     *         true, you will receive a ValidationException.
     */
    public Boolean getConsistentRead() {
        return consistentRead;
    }

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use KeyConditionExpression instead. Do
     * not combine legacy parameters and expression parameters in a single
     * API call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    The selection criteria for the query. For a
     * query on a table, you can have conditions only on the table primary
     * key attributes. You must provide the partition key name and value as
     * an EQ condition. You can optionally provide a second
     * condition, referring to the sort key.  
    If you don't provide a
     * sort key condition, all of the items that match the partition key will
     * be retrieved. If a FilterExpression or QueryFilter is
     * present, it will be applied after the items are retrieved.
     * 
    For a query on an index, you can have conditions only on the index
     * key attributes. You must provide the index partition key name and
     * value as an EQ condition. You can optionally provide a
     * second condition, referring to the index sort key. 
    Each
     * KeyConditions element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the ComparisonOperator being
     * used. 
      For type Number, value comparisons are numeric. 
      String
     * value comparisons for greater than, equals, or less than are based on
     * ASCII character code values. For example, a is greater
     * than A, and a is greater than
     * B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      •  
    • 
     * 
      ComparisonOperator - A comparator for evaluating attributes,
     * for example, equals, greater than, less than, and so on. 
      For
     * KeyConditions, only the following comparison operators are
     * supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     * BETWEEN 
      The following are descriptions of these comparison
     * operators. 
         
      •  
        EQ : Equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one specified in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        LE : Less than or equal. 
        AttributeValueList
     * can contain only one AttributeValue element of type String,
     * Number, or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        LT : Less than.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GE : Greater than or equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue element of type String, Number, or Binary (not a
     * set type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GT : Greater than. 
        AttributeValueList can
     * contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     * a prefix. 
        AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a set
     * type). The target attribute of the comparison must be of type String
     * or Binary (not a Number or a set type). 
         
        •  
      • 
     * 
        BETWEEN : Greater than or equal to the first value,
     * and less than or equal to the second value.
     * 
        AttributeValueList must contain two AttributeValue
     * elements of the same type, either String, Number, or Binary (not a set
     * type). A target attribute matches if the target value is greater than,
     * or equal to, the first element and less than, or equal to, the second
     * element. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not compare to
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     * usage examples of AttributeValueList and
     * ComparisonOperator, see Legacy
     * Conditional Parameters in the Amazon DynamoDB Developer
     * Guide.
     *
     * @return  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use KeyConditionExpression instead. Do
     *         not combine legacy parameters and expression parameters in a single
     *         API call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    The selection criteria for the query. For a
     *         query on a table, you can have conditions only on the table primary
     *         key attributes. You must provide the partition key name and value as
     *         an EQ condition. You can optionally provide a second
     *         condition, referring to the sort key.  
    If you don't provide a
     *         sort key condition, all of the items that match the partition key will
     *         be retrieved. If a FilterExpression or QueryFilter is
     *         present, it will be applied after the items are retrieved.
     *         
    For a query on an index, you can have conditions only on the index
     *         key attributes. You must provide the index partition key name and
     *         value as an EQ condition. You can optionally provide a
     *         second condition, referring to the index sort key. 
    Each
     *         KeyConditions element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the ComparisonOperator being
     *         used. 
      For type Number, value comparisons are numeric. 
      String
     *         value comparisons for greater than, equals, or less than are based on
     *         ASCII character code values. For example, a is greater
     *         than A, and a is greater than
     *         B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      •  
    • 
     *         
      ComparisonOperator - A comparator for evaluating attributes,
     *         for example, equals, greater than, less than, and so on. 
      For
     *         KeyConditions, only the following comparison operators are
     *         supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     *         BETWEEN 
      The following are descriptions of these comparison
     *         operators. 
         
      •  
        EQ : Equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one specified in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not equal
     *         {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        LE : Less than or equal. 
        AttributeValueList
     *         can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        LT : Less than.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GE : Greater than or equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue element of type String, Number, or Binary (not a
     *         set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GT : Greater than. 
        AttributeValueList can
     *         contain only one AttributeValue element of type String, Number,
     *         or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     *         a prefix. 
        AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a set
     *         type). The target attribute of the comparison must be of type String
     *         or Binary (not a Number or a set type). 
         
        •  
      • 
     *         
        BETWEEN : Greater than or equal to the first value,
     *         and less than or equal to the second value.
     *         
        AttributeValueList must contain two AttributeValue
     *         elements of the same type, either String, Number, or Binary (not a set
     *         type). A target attribute matches if the target value is greater than,
     *         or equal to, the first element and less than, or equal to, the second
     *         element. If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not compare to
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     *         usage examples of AttributeValueList and
     *         ComparisonOperator, see Legacy
     *         Conditional Parameters in the Amazon DynamoDB Developer
     *         Guide.
     */
    public java.util.Map getKeyConditions() {
        
        return keyConditions;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use KeyConditionExpression instead. Do
     * not combine legacy parameters and expression parameters in a single
     * API call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    The selection criteria for the query. For a
     * query on a table, you can have conditions only on the table primary
     * key attributes. You must provide the partition key name and value as
     * an EQ condition. You can optionally provide a second
     * condition, referring to the sort key.  
    If you don't provide a
     * sort key condition, all of the items that match the partition key will
     * be retrieved. If a FilterExpression or QueryFilter is
     * present, it will be applied after the items are retrieved.
     * 
    For a query on an index, you can have conditions only on the index
     * key attributes. You must provide the index partition key name and
     * value as an EQ condition. You can optionally provide a
     * second condition, referring to the index sort key. 
    Each
     * KeyConditions element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the ComparisonOperator being
     * used. 
      For type Number, value comparisons are numeric. 
      String
     * value comparisons for greater than, equals, or less than are based on
     * ASCII character code values. For example, a is greater
     * than A, and a is greater than
     * B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      •  
    • 
     * 
      ComparisonOperator - A comparator for evaluating attributes,
     * for example, equals, greater than, less than, and so on. 
      For
     * KeyConditions, only the following comparison operators are
     * supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     * BETWEEN 
      The following are descriptions of these comparison
     * operators. 
         
      •  
        EQ : Equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one specified in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        LE : Less than or equal. 
        AttributeValueList
     * can contain only one AttributeValue element of type String,
     * Number, or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        LT : Less than.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GE : Greater than or equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue element of type String, Number, or Binary (not a
     * set type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GT : Greater than. 
        AttributeValueList can
     * contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     * a prefix. 
        AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a set
     * type). The target attribute of the comparison must be of type String
     * or Binary (not a Number or a set type). 
         
        •  
      • 
     * 
        BETWEEN : Greater than or equal to the first value,
     * and less than or equal to the second value.
     * 
        AttributeValueList must contain two AttributeValue
     * elements of the same type, either String, Number, or Binary (not a set
     * type). A target attribute matches if the target value is greater than,
     * or equal to, the first element and less than, or equal to, the second
     * element. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not compare to
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     * usage examples of AttributeValueList and
     * ComparisonOperator, see Legacy
     * Conditional Parameters in the Amazon DynamoDB Developer
     * Guide.
     *
     * @param keyConditions  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use KeyConditionExpression instead. Do
     *         not combine legacy parameters and expression parameters in a single
     *         API call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    The selection criteria for the query. For a
     *         query on a table, you can have conditions only on the table primary
     *         key attributes. You must provide the partition key name and value as
     *         an EQ condition. You can optionally provide a second
     *         condition, referring to the sort key.  
    If you don't provide a
     *         sort key condition, all of the items that match the partition key will
     *         be retrieved. If a FilterExpression or QueryFilter is
     *         present, it will be applied after the items are retrieved.
     *         
    For a query on an index, you can have conditions only on the index
     *         key attributes. You must provide the index partition key name and
     *         value as an EQ condition. You can optionally provide a
     *         second condition, referring to the index sort key. 
    Each
     *         KeyConditions element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the ComparisonOperator being
     *         used. 
      For type Number, value comparisons are numeric. 
      String
     *         value comparisons for greater than, equals, or less than are based on
     *         ASCII character code values. For example, a is greater
     *         than A, and a is greater than
     *         B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      •  
    • 
     *         
      ComparisonOperator - A comparator for evaluating attributes,
     *         for example, equals, greater than, less than, and so on. 
      For
     *         KeyConditions, only the following comparison operators are
     *         supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     *         BETWEEN 
      The following are descriptions of these comparison
     *         operators. 
         
      •  
        EQ : Equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one specified in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not equal
     *         {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        LE : Less than or equal. 
        AttributeValueList
     *         can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        LT : Less than.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GE : Greater than or equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue element of type String, Number, or Binary (not a
     *         set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GT : Greater than. 
        AttributeValueList can
     *         contain only one AttributeValue element of type String, Number,
     *         or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     *         a prefix. 
        AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a set
     *         type). The target attribute of the comparison must be of type String
     *         or Binary (not a Number or a set type). 
         
        •  
      • 
     *         
        BETWEEN : Greater than or equal to the first value,
     *         and less than or equal to the second value.
     *         
        AttributeValueList must contain two AttributeValue
     *         elements of the same type, either String, Number, or Binary (not a set
     *         type). A target attribute matches if the target value is greater than,
     *         or equal to, the first element and less than, or equal to, the second
     *         element. If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not compare to
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     *         usage examples of AttributeValueList and
     *         ComparisonOperator, see Legacy
     *         Conditional Parameters in the Amazon DynamoDB Developer
     *         Guide.
     */
    public void setKeyConditions(java.util.Map keyConditions) {
        this.keyConditions = keyConditions;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use KeyConditionExpression instead. Do
     * not combine legacy parameters and expression parameters in a single
     * API call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    The selection criteria for the query. For a
     * query on a table, you can have conditions only on the table primary
     * key attributes. You must provide the partition key name and value as
     * an EQ condition. You can optionally provide a second
     * condition, referring to the sort key.  
    If you don't provide a
     * sort key condition, all of the items that match the partition key will
     * be retrieved. If a FilterExpression or QueryFilter is
     * present, it will be applied after the items are retrieved.
     * 
    For a query on an index, you can have conditions only on the index
     * key attributes. You must provide the index partition key name and
     * value as an EQ condition. You can optionally provide a
     * second condition, referring to the index sort key. 
    Each
     * KeyConditions element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the ComparisonOperator being
     * used. 
      For type Number, value comparisons are numeric. 
      String
     * value comparisons for greater than, equals, or less than are based on
     * ASCII character code values. For example, a is greater
     * than A, and a is greater than
     * B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      •  
    • 
     * 
      ComparisonOperator - A comparator for evaluating attributes,
     * for example, equals, greater than, less than, and so on. 
      For
     * KeyConditions, only the following comparison operators are
     * supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     * BETWEEN 
      The following are descriptions of these comparison
     * operators. 
         
      •  
        EQ : Equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one specified in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        LE : Less than or equal. 
        AttributeValueList
     * can contain only one AttributeValue element of type String,
     * Number, or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        LT : Less than.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GE : Greater than or equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue element of type String, Number, or Binary (not a
     * set type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GT : Greater than. 
        AttributeValueList can
     * contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     * a prefix. 
        AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a set
     * type). The target attribute of the comparison must be of type String
     * or Binary (not a Number or a set type). 
         
        •  
      • 
     * 
        BETWEEN : Greater than or equal to the first value,
     * and less than or equal to the second value.
     * 
        AttributeValueList must contain two AttributeValue
     * elements of the same type, either String, Number, or Binary (not a set
     * type). A target attribute matches if the target value is greater than,
     * or equal to, the first element and less than, or equal to, the second
     * element. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not compare to
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     * usage examples of AttributeValueList and
     * ComparisonOperator, see Legacy
     * Conditional Parameters in the Amazon DynamoDB Developer
     * Guide.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param keyConditions  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use KeyConditionExpression instead. Do
     *         not combine legacy parameters and expression parameters in a single
     *         API call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    The selection criteria for the query. For a
     *         query on a table, you can have conditions only on the table primary
     *         key attributes. You must provide the partition key name and value as
     *         an EQ condition. You can optionally provide a second
     *         condition, referring to the sort key.  
    If you don't provide a
     *         sort key condition, all of the items that match the partition key will
     *         be retrieved. If a FilterExpression or QueryFilter is
     *         present, it will be applied after the items are retrieved.
     *         
    For a query on an index, you can have conditions only on the index
     *         key attributes. You must provide the index partition key name and
     *         value as an EQ condition. You can optionally provide a
     *         second condition, referring to the index sort key. 
    Each
     *         KeyConditions element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the ComparisonOperator being
     *         used. 
      For type Number, value comparisons are numeric. 
      String
     *         value comparisons for greater than, equals, or less than are based on
     *         ASCII character code values. For example, a is greater
     *         than A, and a is greater than
     *         B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      •  
    • 
     *         
      ComparisonOperator - A comparator for evaluating attributes,
     *         for example, equals, greater than, less than, and so on. 
      For
     *         KeyConditions, only the following comparison operators are
     *         supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     *         BETWEEN 
      The following are descriptions of these comparison
     *         operators. 
         
      •  
        EQ : Equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one specified in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not equal
     *         {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        LE : Less than or equal. 
        AttributeValueList
     *         can contain only one AttributeValue element of type String,
     *         Number, or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        LT : Less than.
     *         
        AttributeValueList can contain only one
     *         AttributeValue of type String, Number, or Binary (not a set
     *         type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GE : Greater than or equal.
     *         
        AttributeValueList can contain only one
     *         AttributeValue element of type String, Number, or Binary (not a
     *         set type). If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not equal
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     *         
        GT : Greater than. 
        AttributeValueList can
     *         contain only one AttributeValue element of type String, Number,
     *         or Binary (not a set type). If an item contains an
     *         AttributeValue element of a different type than the one
     *         provided in the request, the value does not match. For example,
     *         {"S":"6"} does not equal {"N":"6"}. Also,
     *         {"N":"6"} does not compare to {"NS":["6", "2",
     *         "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     *         a prefix. 
        AttributeValueList can contain only one
     *         AttributeValue of type String or Binary (not a Number or a set
     *         type). The target attribute of the comparison must be of type String
     *         or Binary (not a Number or a set type). 
         
        •  
      • 
     *         
        BETWEEN : Greater than or equal to the first value,
     *         and less than or equal to the second value.
     *         
        AttributeValueList must contain two AttributeValue
     *         elements of the same type, either String, Number, or Binary (not a set
     *         type). A target attribute matches if the target value is greater than,
     *         or equal to, the first element and less than, or equal to, the second
     *         element. If an item contains an AttributeValue element of a
     *         different type than the one provided in the request, the value does
     *         not match. For example, {"S":"6"} does not compare to
     *         {"N":"6"}. Also, {"N":"6"} does not compare
     *         to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     *         usage examples of AttributeValueList and
     *         ComparisonOperator, see Legacy
     *         Conditional Parameters in the Amazon DynamoDB Developer
     *         Guide.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withKeyConditions(java.util.Map keyConditions) {
        setKeyConditions(keyConditions);
        return this;
    }

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use KeyConditionExpression instead. Do
     * not combine legacy parameters and expression parameters in a single
     * API call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    The selection criteria for the query. For a
     * query on a table, you can have conditions only on the table primary
     * key attributes. You must provide the partition key name and value as
     * an EQ condition. You can optionally provide a second
     * condition, referring to the sort key.  
    If you don't provide a
     * sort key condition, all of the items that match the partition key will
     * be retrieved. If a FilterExpression or QueryFilter is
     * present, it will be applied after the items are retrieved.
     * 
    For a query on an index, you can have conditions only on the index
     * key attributes. You must provide the index partition key name and
     * value as an EQ condition. You can optionally provide a
     * second condition, referring to the index sort key. 
    Each
     * KeyConditions element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the ComparisonOperator being
     * used. 
      For type Number, value comparisons are numeric. 
      String
     * value comparisons for greater than, equals, or less than are based on
     * ASCII character code values. For example, a is greater
     * than A, and a is greater than
     * B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      •  
    • 
     * 
      ComparisonOperator - A comparator for evaluating attributes,
     * for example, equals, greater than, less than, and so on. 
      For
     * KeyConditions, only the following comparison operators are
     * supported: 
       EQ | LE | LT | GE | GT | BEGINS_WITH |
     * BETWEEN 
      The following are descriptions of these comparison
     * operators. 
         
      •  
        EQ : Equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one specified in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not equal
     * {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        LE : Less than or equal. 
        AttributeValueList
     * can contain only one AttributeValue element of type String,
     * Number, or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        LT : Less than.
     * 
        AttributeValueList can contain only one
     * AttributeValue of type String, Number, or Binary (not a set
     * type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GE : Greater than or equal.
     * 
        AttributeValueList can contain only one
     * AttributeValue element of type String, Number, or Binary (not a
     * set type). If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not equal
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]}. 
         
        •  
      • 
     * 
        GT : Greater than. 
        AttributeValueList can
     * contain only one AttributeValue element of type String, Number,
     * or Binary (not a set type). If an item contains an
     * AttributeValue element of a different type than the one
     * provided in the request, the value does not match. For example,
     * {"S":"6"} does not equal {"N":"6"}. Also,
     * {"N":"6"} does not compare to {"NS":["6", "2",
     * "1"]}. 
         
        •  
      •  
        BEGINS_WITH : Checks for
     * a prefix. 
        AttributeValueList can contain only one
     * AttributeValue of type String or Binary (not a Number or a set
     * type). The target attribute of the comparison must be of type String
     * or Binary (not a Number or a set type). 
         
        •  
      • 
     * 
        BETWEEN : Greater than or equal to the first value,
     * and less than or equal to the second value.
     * 
        AttributeValueList must contain two AttributeValue
     * elements of the same type, either String, Number, or Binary (not a set
     * type). A target attribute matches if the target value is greater than,
     * or equal to, the first element and less than, or equal to, the second
     * element. If an item contains an AttributeValue element of a
     * different type than the one provided in the request, the value does
     * not match. For example, {"S":"6"} does not compare to
     * {"N":"6"}. Also, {"N":"6"} does not compare
     * to {"NS":["6", "2", "1"]} 
        •  
       
      •  
     
    For
     * usage examples of AttributeValueList and
     * ComparisonOperator, see Legacy
     * Conditional Parameters in the Amazon DynamoDB Developer
     * Guide.
     * 
    
     * The method adds a new key-value pair into KeyConditions 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 KeyConditions.
     * @param value The corresponding value of the entry to be added into KeyConditions.
     */
    public QueryRequest addKeyConditionsEntry(String key, Condition value) {
        if (null == this.keyConditions) {
            this.keyConditions = new java.util.HashMap();
        }
        if (this.keyConditions.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.keyConditions.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into KeyConditions.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     */
    public QueryRequest clearKeyConditionsEntries() {
        this.keyConditions = null;
        return this;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A condition that evaluates the query
     * results after the items are read and returns only the desired values.
     * 
    This parameter does not support attributes of type List or Map.
     * 
    A QueryFilter is applied after the items have already
     * been read; the process of filtering does not consume any additional
     * read capacity units. 
    If you provide more than one condition
     * in the QueryFilter map, then by default all of the conditions
     * must evaluate to true. In other words, the conditions are ANDed
     * together. (You can use the ConditionalOperator parameter to OR
     * the conditions instead. If you do this, then at least one of the
     * conditions must evaluate to true, rather than all of them.) 
    Note
     * that QueryFilter does not allow key attributes. You cannot
     * define a filter condition on a partition key or a sort key. 
    Each
     * QueryFilter element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the operator specified in
     * ComparisonOperator. 
      For type Number, value comparisons are
     * numeric. 
      String value comparisons for greater than, equals, or less
     * than are based on ASCII character code values. For example,
     * a is greater than A, and a is
     * greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For type Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      For information on
     * specifying data types in JSON, see JSON
     * Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     * 
    • ComparisonOperator - A comparator for evaluating
     * attributes. For example, equals, greater than, less than, etc. 
      The
     * following comparison operators are available: 
      EQ | NE | LE |
     * LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     * | IN | BETWEEN 
      For complete descriptions of all comparison
     * operators, see the Condition
     * data type. 
      •  
    
     *
     * @return  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A condition that evaluates the query
     *         results after the items are read and returns only the desired values.
     *         
    This parameter does not support attributes of type List or Map.
     *         
    A QueryFilter is applied after the items have already
     *         been read; the process of filtering does not consume any additional
     *         read capacity units. 
    If you provide more than one condition
     *         in the QueryFilter map, then by default all of the conditions
     *         must evaluate to true. In other words, the conditions are ANDed
     *         together. (You can use the ConditionalOperator parameter to OR
     *         the conditions instead. If you do this, then at least one of the
     *         conditions must evaluate to true, rather than all of them.) 
    Note
     *         that QueryFilter does not allow key attributes. You cannot
     *         define a filter condition on a partition key or a sort key. 
    Each
     *         QueryFilter element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the operator specified in
     *         ComparisonOperator. 
      For type Number, value comparisons are
     *         numeric. 
      String value comparisons for greater than, equals, or less
     *         than are based on ASCII character code values. For example,
     *         a is greater than A, and a is
     *         greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For type Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      For information on
     *         specifying data types in JSON, see JSON
     *         Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     *         
    • ComparisonOperator - A comparator for evaluating
     *         attributes. For example, equals, greater than, less than, etc. 
      The
     *         following comparison operators are available: 
      EQ | NE | LE |
     *         LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     *         | IN | BETWEEN 
      For complete descriptions of all comparison
     *         operators, see the Condition
     *         data type. 
      •  
    
     */
    public java.util.Map getQueryFilter() {
        
        return queryFilter;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A condition that evaluates the query
     * results after the items are read and returns only the desired values.
     * 
    This parameter does not support attributes of type List or Map.
     * 
    A QueryFilter is applied after the items have already
     * been read; the process of filtering does not consume any additional
     * read capacity units. 
    If you provide more than one condition
     * in the QueryFilter map, then by default all of the conditions
     * must evaluate to true. In other words, the conditions are ANDed
     * together. (You can use the ConditionalOperator parameter to OR
     * the conditions instead. If you do this, then at least one of the
     * conditions must evaluate to true, rather than all of them.) 
    Note
     * that QueryFilter does not allow key attributes. You cannot
     * define a filter condition on a partition key or a sort key. 
    Each
     * QueryFilter element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the operator specified in
     * ComparisonOperator. 
      For type Number, value comparisons are
     * numeric. 
      String value comparisons for greater than, equals, or less
     * than are based on ASCII character code values. For example,
     * a is greater than A, and a is
     * greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For type Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      For information on
     * specifying data types in JSON, see JSON
     * Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     * 
    • ComparisonOperator - A comparator for evaluating
     * attributes. For example, equals, greater than, less than, etc. 
      The
     * following comparison operators are available: 
      EQ | NE | LE |
     * LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     * | IN | BETWEEN 
      For complete descriptions of all comparison
     * operators, see the Condition
     * data type. 
      •  
    
     *
     * @param queryFilter  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A condition that evaluates the query
     *         results after the items are read and returns only the desired values.
     *         
    This parameter does not support attributes of type List or Map.
     *         
    A QueryFilter is applied after the items have already
     *         been read; the process of filtering does not consume any additional
     *         read capacity units. 
    If you provide more than one condition
     *         in the QueryFilter map, then by default all of the conditions
     *         must evaluate to true. In other words, the conditions are ANDed
     *         together. (You can use the ConditionalOperator parameter to OR
     *         the conditions instead. If you do this, then at least one of the
     *         conditions must evaluate to true, rather than all of them.) 
    Note
     *         that QueryFilter does not allow key attributes. You cannot
     *         define a filter condition on a partition key or a sort key. 
    Each
     *         QueryFilter element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the operator specified in
     *         ComparisonOperator. 
      For type Number, value comparisons are
     *         numeric. 
      String value comparisons for greater than, equals, or less
     *         than are based on ASCII character code values. For example,
     *         a is greater than A, and a is
     *         greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For type Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      For information on
     *         specifying data types in JSON, see JSON
     *         Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     *         
    • ComparisonOperator - A comparator for evaluating
     *         attributes. For example, equals, greater than, less than, etc. 
      The
     *         following comparison operators are available: 
      EQ | NE | LE |
     *         LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     *         | IN | BETWEEN 
      For complete descriptions of all comparison
     *         operators, see the Condition
     *         data type. 
      •  
    
     */
    public void setQueryFilter(java.util.Map queryFilter) {
        this.queryFilter = queryFilter;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A condition that evaluates the query
     * results after the items are read and returns only the desired values.
     * 
    This parameter does not support attributes of type List or Map.
     * 
    A QueryFilter is applied after the items have already
     * been read; the process of filtering does not consume any additional
     * read capacity units. 
    If you provide more than one condition
     * in the QueryFilter map, then by default all of the conditions
     * must evaluate to true. In other words, the conditions are ANDed
     * together. (You can use the ConditionalOperator parameter to OR
     * the conditions instead. If you do this, then at least one of the
     * conditions must evaluate to true, rather than all of them.) 
    Note
     * that QueryFilter does not allow key attributes. You cannot
     * define a filter condition on a partition key or a sort key. 
    Each
     * QueryFilter element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the operator specified in
     * ComparisonOperator. 
      For type Number, value comparisons are
     * numeric. 
      String value comparisons for greater than, equals, or less
     * than are based on ASCII character code values. For example,
     * a is greater than A, and a is
     * greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For type Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      For information on
     * specifying data types in JSON, see JSON
     * Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     * 
    • ComparisonOperator - A comparator for evaluating
     * attributes. For example, equals, greater than, less than, etc. 
      The
     * following comparison operators are available: 
      EQ | NE | LE |
     * LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     * | IN | BETWEEN 
      For complete descriptions of all comparison
     * operators, see the Condition
     * data type. 
      •  
    
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param queryFilter  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A condition that evaluates the query
     *         results after the items are read and returns only the desired values.
     *         
    This parameter does not support attributes of type List or Map.
     *         
    A QueryFilter is applied after the items have already
     *         been read; the process of filtering does not consume any additional
     *         read capacity units. 
    If you provide more than one condition
     *         in the QueryFilter map, then by default all of the conditions
     *         must evaluate to true. In other words, the conditions are ANDed
     *         together. (You can use the ConditionalOperator parameter to OR
     *         the conditions instead. If you do this, then at least one of the
     *         conditions must evaluate to true, rather than all of them.) 
    Note
     *         that QueryFilter does not allow key attributes. You cannot
     *         define a filter condition on a partition key or a sort key. 
    Each
     *         QueryFilter element consists of an attribute name to compare,
     *         along with the following: 
       
    •  
      AttributeValueList - One
     *         or more values to evaluate against the supplied attribute. The number
     *         of values in the list depends on the operator specified in
     *         ComparisonOperator. 
      For type Number, value comparisons are
     *         numeric. 
      String value comparisons for greater than, equals, or less
     *         than are based on ASCII character code values. For example,
     *         a is greater than A, and a is
     *         greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     *         
      For type Binary, DynamoDB treats each byte of the binary data as
     *         unsigned when it compares binary values. 
      For information on
     *         specifying data types in JSON, see JSON
     *         Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     *         
    • ComparisonOperator - A comparator for evaluating
     *         attributes. For example, equals, greater than, less than, etc. 
      The
     *         following comparison operators are available: 
      EQ | NE | LE |
     *         LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     *         | IN | BETWEEN 
      For complete descriptions of all comparison
     *         operators, see the Condition
     *         data type. 
      •  
    
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withQueryFilter(java.util.Map queryFilter) {
        setQueryFilter(queryFilter);
        return this;
    }

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A condition that evaluates the query
     * results after the items are read and returns only the desired values.
     * 
    This parameter does not support attributes of type List or Map.
     * 
    A QueryFilter is applied after the items have already
     * been read; the process of filtering does not consume any additional
     * read capacity units. 
    If you provide more than one condition
     * in the QueryFilter map, then by default all of the conditions
     * must evaluate to true. In other words, the conditions are ANDed
     * together. (You can use the ConditionalOperator parameter to OR
     * the conditions instead. If you do this, then at least one of the
     * conditions must evaluate to true, rather than all of them.) 
    Note
     * that QueryFilter does not allow key attributes. You cannot
     * define a filter condition on a partition key or a sort key. 
    Each
     * QueryFilter element consists of an attribute name to compare,
     * along with the following: 
       
    •  
      AttributeValueList - One
     * or more values to evaluate against the supplied attribute. The number
     * of values in the list depends on the operator specified in
     * ComparisonOperator. 
      For type Number, value comparisons are
     * numeric. 
      String value comparisons for greater than, equals, or less
     * than are based on ASCII character code values. For example,
     * a is greater than A, and a is
     * greater than B. For a list of code values, see http://en.wikipedia.org/wiki/ASCII#ASCII_printable_characters.
     * 
      For type Binary, DynamoDB treats each byte of the binary data as
     * unsigned when it compares binary values. 
      For information on
     * specifying data types in JSON, see JSON
     * Data Format in the Amazon DynamoDB Developer Guide. 
      • 
     * 
    • ComparisonOperator - A comparator for evaluating
     * attributes. For example, equals, greater than, less than, etc. 
      The
     * following comparison operators are available: 
      EQ | NE | LE |
     * LT | GE | GT | NOT_NULL | NULL | CONTAINS | NOT_CONTAINS | BEGINS_WITH
     * | IN | BETWEEN 
      For complete descriptions of all comparison
     * operators, see the Condition
     * data type. 
      •  
    
     * 
    
     * The method adds a new key-value pair into QueryFilter 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 QueryFilter.
     * @param value The corresponding value of the entry to be added into QueryFilter.
     */
    public QueryRequest addQueryFilterEntry(String key, Condition value) {
        if (null == this.queryFilter) {
            this.queryFilter = new java.util.HashMap();
        }
        if (this.queryFilter.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.queryFilter.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into QueryFilter.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     */
    public QueryRequest clearQueryFilterEntries() {
        this.queryFilter = null;
        return this;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     *
     * @return  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A logical operator to apply to the
     *         conditions in a QueryFilter map: 
       
    • AND -
     *         If all of the conditions evaluate to true, then the entire map
     *         evaluates to true.
      •  
    • OR - If at least one of
     *         the conditions evaluate to true, then the entire map evaluates to
     *         true.
      •  
     
    If you omit ConditionalOperator, then
     *         AND is the default. 
    The operation will succeed only if
     *         the entire map evaluates to true. 
    This parameter does not
     *         support attributes of type List or Map.
     *
     * @see ConditionalOperator
     */
    public String getConditionalOperator() {
        return conditionalOperator;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     *
     * @param conditionalOperator  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A logical operator to apply to the
     *         conditions in a QueryFilter map: 
       
    • AND -
     *         If all of the conditions evaluate to true, then the entire map
     *         evaluates to true.
      •  
    • OR - If at least one of
     *         the conditions evaluate to true, then the entire map evaluates to
     *         true.
      •  
     
    If you omit ConditionalOperator, then
     *         AND is the default. 
    The operation will succeed only if
     *         the entire map evaluates to true. 
    This parameter does not
     *         support attributes of type List or Map.
     *
     * @see ConditionalOperator
     */
    public void setConditionalOperator(String conditionalOperator) {
        this.conditionalOperator = conditionalOperator;
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     *
     * @param conditionalOperator  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A logical operator to apply to the
     *         conditions in a QueryFilter map: 
       
    • AND -
     *         If all of the conditions evaluate to true, then the entire map
     *         evaluates to true.
      •  
    • OR - If at least one of
     *         the conditions evaluate to true, then the entire map evaluates to
     *         true.
      •  
     
    If you omit ConditionalOperator, then
     *         AND is the default. 
    The operation will succeed only if
     *         the entire map evaluates to true. 
    This parameter does not
     *         support attributes of type List or Map.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ConditionalOperator
     */
    public QueryRequest withConditionalOperator(String conditionalOperator) {
        this.conditionalOperator = conditionalOperator;
        return this;
    }

    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     *
     * @param conditionalOperator  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A logical operator to apply to the
     *         conditions in a QueryFilter map: 
       
    • AND -
     *         If all of the conditions evaluate to true, then the entire map
     *         evaluates to true.
      •  
    • OR - If at least one of
     *         the conditions evaluate to true, then the entire map evaluates to
     *         true.
      •  
     
    If you omit ConditionalOperator, then
     *         AND is the default. 
    The operation will succeed only if
     *         the entire map evaluates to true. 
    This parameter does not
     *         support attributes of type List or Map.
     *
     * @see ConditionalOperator
     */
    public void setConditionalOperator(ConditionalOperator conditionalOperator) {
        this.conditionalOperator = conditionalOperator.toString();
    }
    
    /**
     *  
    This is a legacy parameter, for backward compatibility.
     * New applications should use FilterExpression instead. Do not
     * combine legacy parameters and expression parameters in a single API
     * call; otherwise, DynamoDB will return a ValidationException
     * exception.  
    A logical operator to apply to the
     * conditions in a QueryFilter map: 
       
    • AND -
     * If all of the conditions evaluate to true, then the entire map
     * evaluates to true.
      •  
    • OR - If at least one of
     * the conditions evaluate to true, then the entire map evaluates to
     * true.
      •  
     
    If you omit ConditionalOperator, then
     * AND is the default. 
    The operation will succeed only if
     * the entire map evaluates to true. 
    This parameter does not
     * support attributes of type List or Map.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     * 
    
     * Constraints:
    
     * Allowed Values: AND, OR
     *
     * @param conditionalOperator  
    This is a legacy parameter, for backward compatibility.
     *         New applications should use FilterExpression instead. Do not
     *         combine legacy parameters and expression parameters in a single API
     *         call; otherwise, DynamoDB will return a ValidationException
     *         exception.  
    A logical operator to apply to the
     *         conditions in a QueryFilter map: 
       
    • AND -
     *         If all of the conditions evaluate to true, then the entire map
     *         evaluates to true.
      •  
    • OR - If at least one of
     *         the conditions evaluate to true, then the entire map evaluates to
     *         true.
      •  
     
    If you omit ConditionalOperator, then
     *         AND is the default. 
    The operation will succeed only if
     *         the entire map evaluates to true. 
    This parameter does not
     *         support attributes of type List or Map.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     *
     * @see ConditionalOperator
     */
    public QueryRequest withConditionalOperator(ConditionalOperator conditionalOperator) {
        this.conditionalOperator = conditionalOperator.toString();
        return this;
    }

    /**
     * Specifies the order for index traversal: If true
     * (default), the traversal is performed in ascending order; if
     * false, the traversal is performed in descending order.
     * 
    Items with the same partition key value are stored in sorted order
     * by sort key. If the sort key data type is Number, the results are
     * stored in numeric order. For type String, the results are stored in
     * order of ASCII character code values. For type Binary, DynamoDB treats
     * each byte of the binary data as unsigned. 
    If
     * ScanIndexForward is true, DynamoDB returns the
     * results in the order in which they are stored (by sort key value).
     * This is the default behavior. If ScanIndexForward is
     * false, DynamoDB reads the results in reverse order by
     * sort key value, and then returns the results to the client.
     *
     * @return Specifies the order for index traversal: If true
     *         (default), the traversal is performed in ascending order; if
     *         false, the traversal is performed in descending order.
     *         
    Items with the same partition key value are stored in sorted order
     *         by sort key. If the sort key data type is Number, the results are
     *         stored in numeric order. For type String, the results are stored in
     *         order of ASCII character code values. For type Binary, DynamoDB treats
     *         each byte of the binary data as unsigned. 
    If
     *         ScanIndexForward is true, DynamoDB returns the
     *         results in the order in which they are stored (by sort key value).
     *         This is the default behavior. If ScanIndexForward is
     *         false, DynamoDB reads the results in reverse order by
     *         sort key value, and then returns the results to the client.
     */
    public Boolean isScanIndexForward() {
        return scanIndexForward;
    }
    
    /**
     * Specifies the order for index traversal: If true
     * (default), the traversal is performed in ascending order; if
     * false, the traversal is performed in descending order.
     * 
    Items with the same partition key value are stored in sorted order
     * by sort key. If the sort key data type is Number, the results are
     * stored in numeric order. For type String, the results are stored in
     * order of ASCII character code values. For type Binary, DynamoDB treats
     * each byte of the binary data as unsigned. 
    If
     * ScanIndexForward is true, DynamoDB returns the
     * results in the order in which they are stored (by sort key value).
     * This is the default behavior. If ScanIndexForward is
     * false, DynamoDB reads the results in reverse order by
     * sort key value, and then returns the results to the client.
     *
     * @param scanIndexForward Specifies the order for index traversal: If true
     *         (default), the traversal is performed in ascending order; if
     *         false, the traversal is performed in descending order.
     *         
    Items with the same partition key value are stored in sorted order
     *         by sort key. If the sort key data type is Number, the results are
     *         stored in numeric order. For type String, the results are stored in
     *         order of ASCII character code values. For type Binary, DynamoDB treats
     *         each byte of the binary data as unsigned. 
    If
     *         ScanIndexForward is true, DynamoDB returns the
     *         results in the order in which they are stored (by sort key value).
     *         This is the default behavior. If ScanIndexForward is
     *         false, DynamoDB reads the results in reverse order by
     *         sort key value, and then returns the results to the client.
     */
    public void setScanIndexForward(Boolean scanIndexForward) {
        this.scanIndexForward = scanIndexForward;
    }
    
    /**
     * Specifies the order for index traversal: If true
     * (default), the traversal is performed in ascending order; if
     * false, the traversal is performed in descending order.
     * 
    Items with the same partition key value are stored in sorted order
     * by sort key. If the sort key data type is Number, the results are
     * stored in numeric order. For type String, the results are stored in
     * order of ASCII character code values. For type Binary, DynamoDB treats
     * each byte of the binary data as unsigned. 
    If
     * ScanIndexForward is true, DynamoDB returns the
     * results in the order in which they are stored (by sort key value).
     * This is the default behavior. If ScanIndexForward is
     * false, DynamoDB reads the results in reverse order by
     * sort key value, and then returns the results to the client.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param scanIndexForward Specifies the order for index traversal: If true
     *         (default), the traversal is performed in ascending order; if
     *         false, the traversal is performed in descending order.
     *         
    Items with the same partition key value are stored in sorted order
     *         by sort key. If the sort key data type is Number, the results are
     *         stored in numeric order. For type String, the results are stored in
     *         order of ASCII character code values. For type Binary, DynamoDB treats
     *         each byte of the binary data as unsigned. 
    If
     *         ScanIndexForward is true, DynamoDB returns the
     *         results in the order in which they are stored (by sort key value).
     *         This is the default behavior. If ScanIndexForward is
     *         false, DynamoDB reads the results in reverse order by
     *         sort key value, and then returns the results to the client.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withScanIndexForward(Boolean scanIndexForward) {
        this.scanIndexForward = scanIndexForward;
        return this;
    }

    /**
     * Specifies the order for index traversal: If true
     * (default), the traversal is performed in ascending order; if
     * false, the traversal is performed in descending order.
     * 
    Items with the same partition key value are stored in sorted order
     * by sort key. If the sort key data type is Number, the results are
     * stored in numeric order. For type String, the results are stored in
     * order of ASCII character code values. For type Binary, DynamoDB treats
     * each byte of the binary data as unsigned. 
    If
     * ScanIndexForward is true, DynamoDB returns the
     * results in the order in which they are stored (by sort key value).
     * This is the default behavior. If ScanIndexForward is
     * false, DynamoDB reads the results in reverse order by
     * sort key value, and then returns the results to the client.
     *
     * @return Specifies the order for index traversal: If true
     *         (default), the traversal is performed in ascending order; if
     *         false, the traversal is performed in descending order.
     *         
    Items with the same partition key value are stored in sorted order
     *         by sort key. If the sort key data type is Number, the results are
     *         stored in numeric order. For type String, the results are stored in
     *         order of ASCII character code values. For type Binary, DynamoDB treats
     *         each byte of the binary data as unsigned. 
    If
     *         ScanIndexForward is true, DynamoDB returns the
     *         results in the order in which they are stored (by sort key value).
     *         This is the default behavior. If ScanIndexForward is
     *         false, DynamoDB reads the results in reverse order by
     *         sort key value, and then returns the results to the client.
     */
    public Boolean getScanIndexForward() {
        return scanIndexForward;
    }

    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     *
     * @return The primary key of the first item that this operation will evaluate.
     *         Use the value that was returned for LastEvaluatedKey in the
     *         previous operation. 
    The data type for ExclusiveStartKey must
     *         be String, Number or Binary. No set data types are allowed.
     */
    public java.util.Map getExclusiveStartKey() {
        
        return exclusiveStartKey;
    }
    
    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     *
     * @param exclusiveStartKey The primary key of the first item that this operation will evaluate.
     *         Use the value that was returned for LastEvaluatedKey in the
     *         previous operation. 
    The data type for ExclusiveStartKey must
     *         be String, Number or Binary. No set data types are allowed.
     */
    public void setExclusiveStartKey(java.util.Map exclusiveStartKey) {
        this.exclusiveStartKey = exclusiveStartKey;
    }
    
    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param exclusiveStartKey The primary key of the first item that this operation will evaluate.
     *         Use the value that was returned for LastEvaluatedKey in the
     *         previous operation. 
    The data type for ExclusiveStartKey must
     *         be String, Number or Binary. No set data types are allowed.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withExclusiveStartKey(java.util.Map exclusiveStartKey) {
        setExclusiveStartKey(exclusiveStartKey);
        return this;
    }

    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     * 
    
     * This method accepts the hashKey, rangeKey of ExclusiveStartKey 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 setExclusiveStartKey(java.util.Map.Entry hashKey, java.util.Map.Entry rangeKey) throws IllegalArgumentException {
        java.util.HashMap exclusiveStartKey = new java.util.HashMap();
        
        if (hashKey != null) {
            exclusiveStartKey.put(hashKey.getKey(), hashKey.getValue());
        } else
            throw new IllegalArgumentException("hashKey must be non-null object.");
        if (rangeKey != null) {
            exclusiveStartKey.put(rangeKey.getKey(), rangeKey.getValue());
        } 
        setExclusiveStartKey(exclusiveStartKey);
    }
    
    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     * 
    
     * This method accepts the hashKey, rangeKey of ExclusiveStartKey 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 QueryRequest withExclusiveStartKey(java.util.Map.Entry hashKey, java.util.Map.Entry rangeKey) throws IllegalArgumentException {
        setExclusiveStartKey(hashKey, rangeKey);
        return this;
    }

    /**
     * The primary key of the first item that this operation will evaluate.
     * Use the value that was returned for LastEvaluatedKey in the
     * previous operation. 
    The data type for ExclusiveStartKey must
     * be String, Number or Binary. No set data types are allowed.
     * 
    
     * The method adds a new key-value pair into ExclusiveStartKey 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 ExclusiveStartKey.
     * @param value The corresponding value of the entry to be added into ExclusiveStartKey.
     */
    public QueryRequest addExclusiveStartKeyEntry(String key, AttributeValue value) {
        if (null == this.exclusiveStartKey) {
            this.exclusiveStartKey = new java.util.HashMap();
        }
        if (this.exclusiveStartKey.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.exclusiveStartKey.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into ExclusiveStartKey.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     */
    public QueryRequest clearExclusiveStartKeyEntries() {
        this.exclusiveStartKey = 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 QueryRequest 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 QueryRequest withReturnConsumedCapacity(ReturnConsumedCapacity returnConsumedCapacity) {
        this.returnConsumedCapacity = returnConsumedCapacity.toString();
        return this;
    }

    /**
     * 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.
     * 
    ProjectionExpression replaces the legacy
     * AttributesToGet parameter.
     *
     * @return 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.
     *         
    ProjectionExpression replaces the legacy
     *         AttributesToGet parameter.
     */
    public String getProjectionExpression() {
        return 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.
     * 
    ProjectionExpression replaces the legacy
     * AttributesToGet parameter.
     *
     * @param 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.
     *         
    ProjectionExpression replaces the legacy
     *         AttributesToGet parameter.
     */
    public void setProjectionExpression(String projectionExpression) {
        this.projectionExpression = 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.
     * 
    ProjectionExpression replaces the legacy
     * AttributesToGet parameter.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param 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.
     *         
    ProjectionExpression replaces the legacy
     *         AttributesToGet parameter.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withProjectionExpression(String projectionExpression) {
        this.projectionExpression = projectionExpression;
        return this;
    }

    /**
     * A string that contains conditions that DynamoDB applies after the
     * Query operation, but before the data is returned to you. Items
     * that do not satisfy the FilterExpression criteria are not
     * returned.  
    A FilterExpression is applied after the
     * items have already been read; the process of filtering does not
     * consume any additional read capacity units.  
    For more
     * information, see Filter
     * Expressions in the Amazon DynamoDB Developer Guide.
     * 
    FilterExpression replaces the legacy
     * QueryFilter and ConditionalOperator parameters.
     *
     * @return A string that contains conditions that DynamoDB applies after the
     *         Query operation, but before the data is returned to you. Items
     *         that do not satisfy the FilterExpression criteria are not
     *         returned.  
    A FilterExpression is applied after the
     *         items have already been read; the process of filtering does not
     *         consume any additional read capacity units.  
    For more
     *         information, see Filter
     *         Expressions in the Amazon DynamoDB Developer Guide.
     *         
    FilterExpression replaces the legacy
     *         QueryFilter and ConditionalOperator parameters.
     */
    public String getFilterExpression() {
        return filterExpression;
    }
    
    /**
     * A string that contains conditions that DynamoDB applies after the
     * Query operation, but before the data is returned to you. Items
     * that do not satisfy the FilterExpression criteria are not
     * returned.  
    A FilterExpression is applied after the
     * items have already been read; the process of filtering does not
     * consume any additional read capacity units.  
    For more
     * information, see Filter
     * Expressions in the Amazon DynamoDB Developer Guide.
     * 
    FilterExpression replaces the legacy
     * QueryFilter and ConditionalOperator parameters.
     *
     * @param filterExpression A string that contains conditions that DynamoDB applies after the
     *         Query operation, but before the data is returned to you. Items
     *         that do not satisfy the FilterExpression criteria are not
     *         returned.  
    A FilterExpression is applied after the
     *         items have already been read; the process of filtering does not
     *         consume any additional read capacity units.  
    For more
     *         information, see Filter
     *         Expressions in the Amazon DynamoDB Developer Guide.
     *         
    FilterExpression replaces the legacy
     *         QueryFilter and ConditionalOperator parameters.
     */
    public void setFilterExpression(String filterExpression) {
        this.filterExpression = filterExpression;
    }
    
    /**
     * A string that contains conditions that DynamoDB applies after the
     * Query operation, but before the data is returned to you. Items
     * that do not satisfy the FilterExpression criteria are not
     * returned.  
    A FilterExpression is applied after the
     * items have already been read; the process of filtering does not
     * consume any additional read capacity units.  
    For more
     * information, see Filter
     * Expressions in the Amazon DynamoDB Developer Guide.
     * 
    FilterExpression replaces the legacy
     * QueryFilter and ConditionalOperator parameters.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param filterExpression A string that contains conditions that DynamoDB applies after the
     *         Query operation, but before the data is returned to you. Items
     *         that do not satisfy the FilterExpression criteria are not
     *         returned.  
    A FilterExpression is applied after the
     *         items have already been read; the process of filtering does not
     *         consume any additional read capacity units.  
    For more
     *         information, see Filter
     *         Expressions in the Amazon DynamoDB Developer Guide.
     *         
    FilterExpression replaces the legacy
     *         QueryFilter and ConditionalOperator parameters.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withFilterExpression(String filterExpression) {
        this.filterExpression = filterExpression;
        return this;
    }

    /**
     * The condition that specifies the key value(s) for items to be
     * retrieved by the Query action. 
    The condition must perform an
     * equality test on a single partition key value. The condition can also
     * perform one of several comparison tests on a single sort key value.
     * Query can use KeyConditionExpression to retrieve one
     * item with a given partition key value and sort key value, or several
     * items that have the same partition key value but different sort key
     * values. 
    The partition key equality test is required, and must be
     * specified in the following format: 
     partitionKeyName
     * = :partitionkeyval 
    If you also want to provide
     * a condition for the sort key, it must be combined using AND
     * with the condition for the sort key. Following is an example, using
     * the = comparison operator for the sort key: 
    
     * partitionKeyName = :partitionkeyval
     * AND sortKeyName = :sortkeyval
     * 
    Valid comparisons for the sort key condition are as follows: 
      
     * 
    •  
      sortKeyName = :sortkeyval -
     * true if the sort key value is equal to :sortkeyval. 
      • 
     * 
    •  
      sortKeyName < :sortkeyval -
     * true if the sort key value is less than :sortkeyval.
     * 
      •  
    •  
      sortKeyName <=
     * :sortkeyval - true if the sort key value is less than or
     * equal to :sortkeyval. 
      •  
    • 
     * 
      sortKeyName > :sortkeyval - true
     * if the sort key value is greater than :sortkeyval. 
      • 
     * 
    •  
      sortKeyName >= :sortkeyval -
     * true if the sort key value is greater than or equal to
     * :sortkeyval. 
      •  
    •  
      sortKeyName
     * BETWEEN :sortkeyval1 AND
     * :sortkeyval2 - true if the sort key value is greater than
     * or equal to :sortkeyval1, and less than or equal to
     * :sortkeyval2. 
      •  
    •  
      begins_with
     * (sortKeyName, :sortkeyval) - true
     * if the sort key value begins with a particular operand. (You cannot
     * use this function with a sort key that is of type Number.) Note that
     * the function name begins_with is case-sensitive. 
      • 
     * 
     
    Use the ExpressionAttributeValues parameter to replace
     * tokens such as :partitionval and :sortval
     * with actual values at runtime. 
    You can optionally use the
     * ExpressionAttributeNames parameter to replace the names of the
     * partition key and sort key with placeholder tokens. This option might
     * be necessary if an attribute name conflicts with a DynamoDB reserved
     * word. For example, the following KeyConditionExpression
     * parameter causes an error because Size is a reserved word: 
      
     * 
    •  Size = :myval 
      •  
     
    To work around this,
     * define a placeholder (such a #S) to represent the
     * attribute name Size. KeyConditionExpression then is as
     * follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     * of reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide. 
    For more
     * information on ExpressionAttributeNames and
     * ExpressionAttributeValues, see Using
     * Placeholders for Attribute Names and Values in the Amazon
     * DynamoDB Developer Guide.  
    KeyConditionExpression
     * replaces the legacy KeyConditions parameter. 
     *
     * @return The condition that specifies the key value(s) for items to be
     *         retrieved by the Query action. 
    The condition must perform an
     *         equality test on a single partition key value. The condition can also
     *         perform one of several comparison tests on a single sort key value.
     *         Query can use KeyConditionExpression to retrieve one
     *         item with a given partition key value and sort key value, or several
     *         items that have the same partition key value but different sort key
     *         values. 
    The partition key equality test is required, and must be
     *         specified in the following format: 
     partitionKeyName
     *         = :partitionkeyval 
    If you also want to provide
     *         a condition for the sort key, it must be combined using AND
     *         with the condition for the sort key. Following is an example, using
     *         the = comparison operator for the sort key: 
    
     *         partitionKeyName = :partitionkeyval
     *         AND sortKeyName = :sortkeyval
     *         
    Valid comparisons for the sort key condition are as follows: 
      
     *         
    •  
      sortKeyName = :sortkeyval -
     *         true if the sort key value is equal to :sortkeyval. 
      • 
     *         
    •  
      sortKeyName < :sortkeyval -
     *         true if the sort key value is less than :sortkeyval.
     *         
      •  
    •  
      sortKeyName <=
     *         :sortkeyval - true if the sort key value is less than or
     *         equal to :sortkeyval. 
      •  
    • 
     *         
      sortKeyName > :sortkeyval - true
     *         if the sort key value is greater than :sortkeyval. 
      • 
     *         
    •  
      sortKeyName >= :sortkeyval -
     *         true if the sort key value is greater than or equal to
     *         :sortkeyval. 
      •  
    •  
      sortKeyName
     *         BETWEEN :sortkeyval1 AND
     *         :sortkeyval2 - true if the sort key value is greater than
     *         or equal to :sortkeyval1, and less than or equal to
     *         :sortkeyval2. 
      •  
    •  
      begins_with
     *         (sortKeyName, :sortkeyval) - true
     *         if the sort key value begins with a particular operand. (You cannot
     *         use this function with a sort key that is of type Number.) Note that
     *         the function name begins_with is case-sensitive. 
      • 
     *         
     
    Use the ExpressionAttributeValues parameter to replace
     *         tokens such as :partitionval and :sortval
     *         with actual values at runtime. 
    You can optionally use the
     *         ExpressionAttributeNames parameter to replace the names of the
     *         partition key and sort key with placeholder tokens. This option might
     *         be necessary if an attribute name conflicts with a DynamoDB reserved
     *         word. For example, the following KeyConditionExpression
     *         parameter causes an error because Size is a reserved word: 
      
     *         
    •  Size = :myval 
      •  
     
    To work around this,
     *         define a placeholder (such a #S) to represent the
     *         attribute name Size. KeyConditionExpression then is as
     *         follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     *         of reserved words, see Reserved
     *         Words in the Amazon DynamoDB Developer Guide. 
    For more
     *         information on ExpressionAttributeNames and
     *         ExpressionAttributeValues, see Using
     *         Placeholders for Attribute Names and Values in the Amazon
     *         DynamoDB Developer Guide.  
    KeyConditionExpression
     *         replaces the legacy KeyConditions parameter. 
     */
    public String getKeyConditionExpression() {
        return keyConditionExpression;
    }
    
    /**
     * The condition that specifies the key value(s) for items to be
     * retrieved by the Query action. 
    The condition must perform an
     * equality test on a single partition key value. The condition can also
     * perform one of several comparison tests on a single sort key value.
     * Query can use KeyConditionExpression to retrieve one
     * item with a given partition key value and sort key value, or several
     * items that have the same partition key value but different sort key
     * values. 
    The partition key equality test is required, and must be
     * specified in the following format: 
     partitionKeyName
     * = :partitionkeyval 
    If you also want to provide
     * a condition for the sort key, it must be combined using AND
     * with the condition for the sort key. Following is an example, using
     * the = comparison operator for the sort key: 
    
     * partitionKeyName = :partitionkeyval
     * AND sortKeyName = :sortkeyval
     * 
    Valid comparisons for the sort key condition are as follows: 
      
     * 
    •  
      sortKeyName = :sortkeyval -
     * true if the sort key value is equal to :sortkeyval. 
      • 
     * 
    •  
      sortKeyName < :sortkeyval -
     * true if the sort key value is less than :sortkeyval.
     * 
      •  
    •  
      sortKeyName <=
     * :sortkeyval - true if the sort key value is less than or
     * equal to :sortkeyval. 
      •  
    • 
     * 
      sortKeyName > :sortkeyval - true
     * if the sort key value is greater than :sortkeyval. 
      • 
     * 
    •  
      sortKeyName >= :sortkeyval -
     * true if the sort key value is greater than or equal to
     * :sortkeyval. 
      •  
    •  
      sortKeyName
     * BETWEEN :sortkeyval1 AND
     * :sortkeyval2 - true if the sort key value is greater than
     * or equal to :sortkeyval1, and less than or equal to
     * :sortkeyval2. 
      •  
    •  
      begins_with
     * (sortKeyName, :sortkeyval) - true
     * if the sort key value begins with a particular operand. (You cannot
     * use this function with a sort key that is of type Number.) Note that
     * the function name begins_with is case-sensitive. 
      • 
     * 
     
    Use the ExpressionAttributeValues parameter to replace
     * tokens such as :partitionval and :sortval
     * with actual values at runtime. 
    You can optionally use the
     * ExpressionAttributeNames parameter to replace the names of the
     * partition key and sort key with placeholder tokens. This option might
     * be necessary if an attribute name conflicts with a DynamoDB reserved
     * word. For example, the following KeyConditionExpression
     * parameter causes an error because Size is a reserved word: 
      
     * 
    •  Size = :myval 
      •  
     
    To work around this,
     * define a placeholder (such a #S) to represent the
     * attribute name Size. KeyConditionExpression then is as
     * follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     * of reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide. 
    For more
     * information on ExpressionAttributeNames and
     * ExpressionAttributeValues, see Using
     * Placeholders for Attribute Names and Values in the Amazon
     * DynamoDB Developer Guide.  
    KeyConditionExpression
     * replaces the legacy KeyConditions parameter. 
     *
     * @param keyConditionExpression The condition that specifies the key value(s) for items to be
     *         retrieved by the Query action. 
    The condition must perform an
     *         equality test on a single partition key value. The condition can also
     *         perform one of several comparison tests on a single sort key value.
     *         Query can use KeyConditionExpression to retrieve one
     *         item with a given partition key value and sort key value, or several
     *         items that have the same partition key value but different sort key
     *         values. 
    The partition key equality test is required, and must be
     *         specified in the following format: 
     partitionKeyName
     *         = :partitionkeyval 
    If you also want to provide
     *         a condition for the sort key, it must be combined using AND
     *         with the condition for the sort key. Following is an example, using
     *         the = comparison operator for the sort key: 
    
     *         partitionKeyName = :partitionkeyval
     *         AND sortKeyName = :sortkeyval
     *         
    Valid comparisons for the sort key condition are as follows: 
      
     *         
    •  
      sortKeyName = :sortkeyval -
     *         true if the sort key value is equal to :sortkeyval. 
      • 
     *         
    •  
      sortKeyName < :sortkeyval -
     *         true if the sort key value is less than :sortkeyval.
     *         
      •  
    •  
      sortKeyName <=
     *         :sortkeyval - true if the sort key value is less than or
     *         equal to :sortkeyval. 
      •  
    • 
     *         
      sortKeyName > :sortkeyval - true
     *         if the sort key value is greater than :sortkeyval. 
      • 
     *         
    •  
      sortKeyName >= :sortkeyval -
     *         true if the sort key value is greater than or equal to
     *         :sortkeyval. 
      •  
    •  
      sortKeyName
     *         BETWEEN :sortkeyval1 AND
     *         :sortkeyval2 - true if the sort key value is greater than
     *         or equal to :sortkeyval1, and less than or equal to
     *         :sortkeyval2. 
      •  
    •  
      begins_with
     *         (sortKeyName, :sortkeyval) - true
     *         if the sort key value begins with a particular operand. (You cannot
     *         use this function with a sort key that is of type Number.) Note that
     *         the function name begins_with is case-sensitive. 
      • 
     *         
     
    Use the ExpressionAttributeValues parameter to replace
     *         tokens such as :partitionval and :sortval
     *         with actual values at runtime. 
    You can optionally use the
     *         ExpressionAttributeNames parameter to replace the names of the
     *         partition key and sort key with placeholder tokens. This option might
     *         be necessary if an attribute name conflicts with a DynamoDB reserved
     *         word. For example, the following KeyConditionExpression
     *         parameter causes an error because Size is a reserved word: 
      
     *         
    •  Size = :myval 
      •  
     
    To work around this,
     *         define a placeholder (such a #S) to represent the
     *         attribute name Size. KeyConditionExpression then is as
     *         follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     *         of reserved words, see Reserved
     *         Words in the Amazon DynamoDB Developer Guide. 
    For more
     *         information on ExpressionAttributeNames and
     *         ExpressionAttributeValues, see Using
     *         Placeholders for Attribute Names and Values in the Amazon
     *         DynamoDB Developer Guide.  
    KeyConditionExpression
     *         replaces the legacy KeyConditions parameter. 
     */
    public void setKeyConditionExpression(String keyConditionExpression) {
        this.keyConditionExpression = keyConditionExpression;
    }
    
    /**
     * The condition that specifies the key value(s) for items to be
     * retrieved by the Query action. 
    The condition must perform an
     * equality test on a single partition key value. The condition can also
     * perform one of several comparison tests on a single sort key value.
     * Query can use KeyConditionExpression to retrieve one
     * item with a given partition key value and sort key value, or several
     * items that have the same partition key value but different sort key
     * values. 
    The partition key equality test is required, and must be
     * specified in the following format: 
     partitionKeyName
     * = :partitionkeyval 
    If you also want to provide
     * a condition for the sort key, it must be combined using AND
     * with the condition for the sort key. Following is an example, using
     * the = comparison operator for the sort key: 
    
     * partitionKeyName = :partitionkeyval
     * AND sortKeyName = :sortkeyval
     * 
    Valid comparisons for the sort key condition are as follows: 
      
     * 
    •  
      sortKeyName = :sortkeyval -
     * true if the sort key value is equal to :sortkeyval. 
      • 
     * 
    •  
      sortKeyName < :sortkeyval -
     * true if the sort key value is less than :sortkeyval.
     * 
      •  
    •  
      sortKeyName <=
     * :sortkeyval - true if the sort key value is less than or
     * equal to :sortkeyval. 
      •  
    • 
     * 
      sortKeyName > :sortkeyval - true
     * if the sort key value is greater than :sortkeyval. 
      • 
     * 
    •  
      sortKeyName >= :sortkeyval -
     * true if the sort key value is greater than or equal to
     * :sortkeyval. 
      •  
    •  
      sortKeyName
     * BETWEEN :sortkeyval1 AND
     * :sortkeyval2 - true if the sort key value is greater than
     * or equal to :sortkeyval1, and less than or equal to
     * :sortkeyval2. 
      •  
    •  
      begins_with
     * (sortKeyName, :sortkeyval) - true
     * if the sort key value begins with a particular operand. (You cannot
     * use this function with a sort key that is of type Number.) Note that
     * the function name begins_with is case-sensitive. 
      • 
     * 
     
    Use the ExpressionAttributeValues parameter to replace
     * tokens such as :partitionval and :sortval
     * with actual values at runtime. 
    You can optionally use the
     * ExpressionAttributeNames parameter to replace the names of the
     * partition key and sort key with placeholder tokens. This option might
     * be necessary if an attribute name conflicts with a DynamoDB reserved
     * word. For example, the following KeyConditionExpression
     * parameter causes an error because Size is a reserved word: 
      
     * 
    •  Size = :myval 
      •  
     
    To work around this,
     * define a placeholder (such a #S) to represent the
     * attribute name Size. KeyConditionExpression then is as
     * follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     * of reserved words, see Reserved
     * Words in the Amazon DynamoDB Developer Guide. 
    For more
     * information on ExpressionAttributeNames and
     * ExpressionAttributeValues, see Using
     * Placeholders for Attribute Names and Values in the Amazon
     * DynamoDB Developer Guide.  
    KeyConditionExpression
     * replaces the legacy KeyConditions parameter. 
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param keyConditionExpression The condition that specifies the key value(s) for items to be
     *         retrieved by the Query action. 
    The condition must perform an
     *         equality test on a single partition key value. The condition can also
     *         perform one of several comparison tests on a single sort key value.
     *         Query can use KeyConditionExpression to retrieve one
     *         item with a given partition key value and sort key value, or several
     *         items that have the same partition key value but different sort key
     *         values. 
    The partition key equality test is required, and must be
     *         specified in the following format: 
     partitionKeyName
     *         = :partitionkeyval 
    If you also want to provide
     *         a condition for the sort key, it must be combined using AND
     *         with the condition for the sort key. Following is an example, using
     *         the = comparison operator for the sort key: 
    
     *         partitionKeyName = :partitionkeyval
     *         AND sortKeyName = :sortkeyval
     *         
    Valid comparisons for the sort key condition are as follows: 
      
     *         
    •  
      sortKeyName = :sortkeyval -
     *         true if the sort key value is equal to :sortkeyval. 
      • 
     *         
    •  
      sortKeyName < :sortkeyval -
     *         true if the sort key value is less than :sortkeyval.
     *         
      •  
    •  
      sortKeyName <=
     *         :sortkeyval - true if the sort key value is less than or
     *         equal to :sortkeyval. 
      •  
    • 
     *         
      sortKeyName > :sortkeyval - true
     *         if the sort key value is greater than :sortkeyval. 
      • 
     *         
    •  
      sortKeyName >= :sortkeyval -
     *         true if the sort key value is greater than or equal to
     *         :sortkeyval. 
      •  
    •  
      sortKeyName
     *         BETWEEN :sortkeyval1 AND
     *         :sortkeyval2 - true if the sort key value is greater than
     *         or equal to :sortkeyval1, and less than or equal to
     *         :sortkeyval2. 
      •  
    •  
      begins_with
     *         (sortKeyName, :sortkeyval) - true
     *         if the sort key value begins with a particular operand. (You cannot
     *         use this function with a sort key that is of type Number.) Note that
     *         the function name begins_with is case-sensitive. 
      • 
     *         
     
    Use the ExpressionAttributeValues parameter to replace
     *         tokens such as :partitionval and :sortval
     *         with actual values at runtime. 
    You can optionally use the
     *         ExpressionAttributeNames parameter to replace the names of the
     *         partition key and sort key with placeholder tokens. This option might
     *         be necessary if an attribute name conflicts with a DynamoDB reserved
     *         word. For example, the following KeyConditionExpression
     *         parameter causes an error because Size is a reserved word: 
      
     *         
    •  Size = :myval 
      •  
     
    To work around this,
     *         define a placeholder (such a #S) to represent the
     *         attribute name Size. KeyConditionExpression then is as
     *         follows: 
       
    •  #S = :myval 
      •  
     
    For a list
     *         of reserved words, see Reserved
     *         Words in the Amazon DynamoDB Developer Guide. 
    For more
     *         information on ExpressionAttributeNames and
     *         ExpressionAttributeValues, see Using
     *         Placeholders for Attribute Names and Values in the Amazon
     *         DynamoDB Developer Guide.  
    KeyConditionExpression
     *         replaces the legacy KeyConditions parameter. 
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withKeyConditionExpression(String keyConditionExpression) {
        this.keyConditionExpression = keyConditionExpression;
        return this;
    }

    /**
     * One or more substitution tokens for attribute names in an expression.
     * 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.
     *
     * @return One or more substitution tokens for attribute names in an expression.
     *         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.
     */
    public java.util.Map getExpressionAttributeNames() {
        
        return expressionAttributeNames;
    }
    
    /**
     * One or more substitution tokens for attribute names in an expression.
     * 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.
     *
     * @param expressionAttributeNames One or more substitution tokens for attribute names in an expression.
     *         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.
     */
    public void setExpressionAttributeNames(java.util.Map expressionAttributeNames) {
        this.expressionAttributeNames = expressionAttributeNames;
    }
    
    /**
     * One or more substitution tokens for attribute names in an expression.
     * 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.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param expressionAttributeNames One or more substitution tokens for attribute names in an expression.
     *         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.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withExpressionAttributeNames(java.util.Map expressionAttributeNames) {
        setExpressionAttributeNames(expressionAttributeNames);
        return this;
    }

    /**
     * One or more substitution tokens for attribute names in an expression.
     * 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.
     * 
    
     * The method adds a new key-value pair into ExpressionAttributeNames
     * parameter, and returns a reference to this object so that method calls
     * can be chained together.
     *
     * @param key The key of the entry to be added into ExpressionAttributeNames.
     * @param value The corresponding value of the entry to be added into ExpressionAttributeNames.
     */
    public QueryRequest addExpressionAttributeNamesEntry(String key, String value) {
        if (null == this.expressionAttributeNames) {
            this.expressionAttributeNames = new java.util.HashMap();
        }
        if (this.expressionAttributeNames.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.expressionAttributeNames.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into ExpressionAttributeNames.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     */
    public QueryRequest clearExpressionAttributeNamesEntries() {
        this.expressionAttributeNames = null;
        return this;
    }
    
    /**
     * One or more values that can be substituted in an expression. 
    Use
     * the : (colon) character in an expression to dereference an
     * attribute value. For example, suppose that you wanted to check whether
     * the value of the ProductStatus attribute was one of the
     * following: 
    Available | Backordered | Discontinued
     * 
    You would first need to specify ExpressionAttributeValues as
     * follows: 
    { ":avail":{"S":"Available"},
     * ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     * 
    You could then use these values in an expression, such as this:
     * 
    ProductStatus IN (:avail, :back, :disc) 
    For more
     * information on expression attribute values, see Specifying
     * Conditions in the Amazon DynamoDB Developer Guide.
     *
     * @return One or more values that can be substituted in an expression. 
    Use
     *         the : (colon) character in an expression to dereference an
     *         attribute value. For example, suppose that you wanted to check whether
     *         the value of the ProductStatus attribute was one of the
     *         following: 
    Available | Backordered | Discontinued
     *         
    You would first need to specify ExpressionAttributeValues as
     *         follows: 
    { ":avail":{"S":"Available"},
     *         ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     *         
    You could then use these values in an expression, such as this:
     *         
    ProductStatus IN (:avail, :back, :disc) 
    For more
     *         information on expression attribute values, see Specifying
     *         Conditions in the Amazon DynamoDB Developer Guide.
     */
    public java.util.Map getExpressionAttributeValues() {
        
        return expressionAttributeValues;
    }
    
    /**
     * One or more values that can be substituted in an expression. 
    Use
     * the : (colon) character in an expression to dereference an
     * attribute value. For example, suppose that you wanted to check whether
     * the value of the ProductStatus attribute was one of the
     * following: 
    Available | Backordered | Discontinued
     * 
    You would first need to specify ExpressionAttributeValues as
     * follows: 
    { ":avail":{"S":"Available"},
     * ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     * 
    You could then use these values in an expression, such as this:
     * 
    ProductStatus IN (:avail, :back, :disc) 
    For more
     * information on expression attribute values, see Specifying
     * Conditions in the Amazon DynamoDB Developer Guide.
     *
     * @param expressionAttributeValues One or more values that can be substituted in an expression. 
    Use
     *         the : (colon) character in an expression to dereference an
     *         attribute value. For example, suppose that you wanted to check whether
     *         the value of the ProductStatus attribute was one of the
     *         following: 
    Available | Backordered | Discontinued
     *         
    You would first need to specify ExpressionAttributeValues as
     *         follows: 
    { ":avail":{"S":"Available"},
     *         ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     *         
    You could then use these values in an expression, such as this:
     *         
    ProductStatus IN (:avail, :back, :disc) 
    For more
     *         information on expression attribute values, see Specifying
     *         Conditions in the Amazon DynamoDB Developer Guide.
     */
    public void setExpressionAttributeValues(java.util.Map expressionAttributeValues) {
        this.expressionAttributeValues = expressionAttributeValues;
    }
    
    /**
     * One or more values that can be substituted in an expression. 
    Use
     * the : (colon) character in an expression to dereference an
     * attribute value. For example, suppose that you wanted to check whether
     * the value of the ProductStatus attribute was one of the
     * following: 
    Available | Backordered | Discontinued
     * 
    You would first need to specify ExpressionAttributeValues as
     * follows: 
    { ":avail":{"S":"Available"},
     * ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     * 
    You could then use these values in an expression, such as this:
     * 
    ProductStatus IN (:avail, :back, :disc) 
    For more
     * information on expression attribute values, see Specifying
     * Conditions in the Amazon DynamoDB Developer Guide.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     *
     * @param expressionAttributeValues One or more values that can be substituted in an expression. 
    Use
     *         the : (colon) character in an expression to dereference an
     *         attribute value. For example, suppose that you wanted to check whether
     *         the value of the ProductStatus attribute was one of the
     *         following: 
    Available | Backordered | Discontinued
     *         
    You would first need to specify ExpressionAttributeValues as
     *         follows: 
    { ":avail":{"S":"Available"},
     *         ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     *         
    You could then use these values in an expression, such as this:
     *         
    ProductStatus IN (:avail, :back, :disc) 
    For more
     *         information on expression attribute values, see Specifying
     *         Conditions in the Amazon DynamoDB Developer Guide.
     *
     * @return A reference to this updated object so that method calls can be chained
     *         together.
     */
    public QueryRequest withExpressionAttributeValues(java.util.Map expressionAttributeValues) {
        setExpressionAttributeValues(expressionAttributeValues);
        return this;
    }

    /**
     * One or more values that can be substituted in an expression. 
    Use
     * the : (colon) character in an expression to dereference an
     * attribute value. For example, suppose that you wanted to check whether
     * the value of the ProductStatus attribute was one of the
     * following: 
    Available | Backordered | Discontinued
     * 
    You would first need to specify ExpressionAttributeValues as
     * follows: 
    { ":avail":{"S":"Available"},
     * ":back":{"S":"Backordered"}, ":disc":{"S":"Discontinued"} }
     * 
    You could then use these values in an expression, such as this:
     * 
    ProductStatus IN (:avail, :back, :disc) 
    For more
     * information on expression attribute values, see Specifying
     * Conditions in the Amazon DynamoDB Developer Guide.
     * 
    
     * The method adds a new key-value pair into ExpressionAttributeValues
     * parameter, and returns a reference to this object so that method calls
     * can be chained together.
     *
     * @param key The key of the entry to be added into ExpressionAttributeValues.
     * @param value The corresponding value of the entry to be added into ExpressionAttributeValues.
     */
    public QueryRequest addExpressionAttributeValuesEntry(String key, AttributeValue value) {
        if (null == this.expressionAttributeValues) {
            this.expressionAttributeValues = new java.util.HashMap();
        }
        if (this.expressionAttributeValues.containsKey(key))
            throw new IllegalArgumentException("Duplicated keys (" + key.toString() + ") are provided.");
        this.expressionAttributeValues.put(key, value);
        return this;
    }

    /**
     * Removes all the entries added into ExpressionAttributeValues.
     * 
    
     * Returns a reference to this object so that method calls can be chained together.
     */
    public QueryRequest clearExpressionAttributeValuesEntries() {
        this.expressionAttributeValues = null;
        return this;
    }
    
    /**
     * Returns a string representation of this object; useful for testing and
     * debugging.
     *
     * @return A string representation of this object.
     *
     * @see java.lang.Object#toString()
     */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("{");
        if (getTableName() != null) sb.append("TableName: " + getTableName() + ",");
        if (getIndexName() != null) sb.append("IndexName: " + getIndexName() + ",");
        if (getSelect() != null) sb.append("Select: " + getSelect() + ",");
        if (getAttributesToGet() != null) sb.append("AttributesToGet: " + getAttributesToGet() + ",");
        if (getLimit() != null) sb.append("Limit: " + getLimit() + ",");
        if (isConsistentRead() != null) sb.append("ConsistentRead: " + isConsistentRead() + ",");
        if (getKeyConditions() != null) sb.append("KeyConditions: " + getKeyConditions() + ",");
        if (getQueryFilter() != null) sb.append("QueryFilter: " + getQueryFilter() + ",");
        if (getConditionalOperator() != null) sb.append("ConditionalOperator: " + getConditionalOperator() + ",");
        if (isScanIndexForward() != null) sb.append("ScanIndexForward: " + isScanIndexForward() + ",");
        if (getExclusiveStartKey() != null) sb.append("ExclusiveStartKey: " + getExclusiveStartKey() + ",");
        if (getReturnConsumedCapacity() != null) sb.append("ReturnConsumedCapacity: " + getReturnConsumedCapacity() + ",");
        if (getProjectionExpression() != null) sb.append("ProjectionExpression: " + getProjectionExpression() + ",");
        if (getFilterExpression() != null) sb.append("FilterExpression: " + getFilterExpression() + ",");
        if (getKeyConditionExpression() != null) sb.append("KeyConditionExpression: " + getKeyConditionExpression() + ",");
        if (getExpressionAttributeNames() != null) sb.append("ExpressionAttributeNames: " + getExpressionAttributeNames() + ",");
        if (getExpressionAttributeValues() != null) sb.append("ExpressionAttributeValues: " + getExpressionAttributeValues() );
        sb.append("}");
        return sb.toString();
    }
    
    @Override
    public int hashCode() {
        final int prime = 31;
        int hashCode = 1;
        
        hashCode = prime * hashCode + ((getTableName() == null) ? 0 : getTableName().hashCode()); 
        hashCode = prime * hashCode + ((getIndexName() == null) ? 0 : getIndexName().hashCode()); 
        hashCode = prime * hashCode + ((getSelect() == null) ? 0 : getSelect().hashCode()); 
        hashCode = prime * hashCode + ((getAttributesToGet() == null) ? 0 : getAttributesToGet().hashCode()); 
        hashCode = prime * hashCode + ((getLimit() == null) ? 0 : getLimit().hashCode()); 
        hashCode = prime * hashCode + ((isConsistentRead() == null) ? 0 : isConsistentRead().hashCode()); 
        hashCode = prime * hashCode + ((getKeyConditions() == null) ? 0 : getKeyConditions().hashCode()); 
        hashCode = prime * hashCode + ((getQueryFilter() == null) ? 0 : getQueryFilter().hashCode()); 
        hashCode = prime * hashCode + ((getConditionalOperator() == null) ? 0 : getConditionalOperator().hashCode()); 
        hashCode = prime * hashCode + ((isScanIndexForward() == null) ? 0 : isScanIndexForward().hashCode()); 
        hashCode = prime * hashCode + ((getExclusiveStartKey() == null) ? 0 : getExclusiveStartKey().hashCode()); 
        hashCode = prime * hashCode + ((getReturnConsumedCapacity() == null) ? 0 : getReturnConsumedCapacity().hashCode()); 
        hashCode = prime * hashCode + ((getProjectionExpression() == null) ? 0 : getProjectionExpression().hashCode()); 
        hashCode = prime * hashCode + ((getFilterExpression() == null) ? 0 : getFilterExpression().hashCode()); 
        hashCode = prime * hashCode + ((getKeyConditionExpression() == null) ? 0 : getKeyConditionExpression().hashCode()); 
        hashCode = prime * hashCode + ((getExpressionAttributeNames() == null) ? 0 : getExpressionAttributeNames().hashCode()); 
        hashCode = prime * hashCode + ((getExpressionAttributeValues() == null) ? 0 : getExpressionAttributeValues().hashCode()); 
        return hashCode;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null) return false;

        if (obj instanceof QueryRequest == false) return false;
        QueryRequest other = (QueryRequest)obj;
        
        if (other.getTableName() == null ^ this.getTableName() == null) return false;
        if (other.getTableName() != null && other.getTableName().equals(this.getTableName()) == false) return false; 
        if (other.getIndexName() == null ^ this.getIndexName() == null) return false;
        if (other.getIndexName() != null && other.getIndexName().equals(this.getIndexName()) == false) return false; 
        if (other.getSelect() == null ^ this.getSelect() == null) return false;
        if (other.getSelect() != null && other.getSelect().equals(this.getSelect()) == false) return false; 
        if (other.getAttributesToGet() == null ^ this.getAttributesToGet() == null) return false;
        if (other.getAttributesToGet() != null && other.getAttributesToGet().equals(this.getAttributesToGet()) == false) return false; 
        if (other.getLimit() == null ^ this.getLimit() == null) return false;
        if (other.getLimit() != null && other.getLimit().equals(this.getLimit()) == false) return false; 
        if (other.isConsistentRead() == null ^ this.isConsistentRead() == null) return false;
        if (other.isConsistentRead() != null && other.isConsistentRead().equals(this.isConsistentRead()) == false) return false; 
        if (other.getKeyConditions() == null ^ this.getKeyConditions() == null) return false;
        if (other.getKeyConditions() != null && other.getKeyConditions().equals(this.getKeyConditions()) == false) return false; 
        if (other.getQueryFilter() == null ^ this.getQueryFilter() == null) return false;
        if (other.getQueryFilter() != null && other.getQueryFilter().equals(this.getQueryFilter()) == false) return false; 
        if (other.getConditionalOperator() == null ^ this.getConditionalOperator() == null) return false;
        if (other.getConditionalOperator() != null && other.getConditionalOperator().equals(this.getConditionalOperator()) == false) return false; 
        if (other.isScanIndexForward() == null ^ this.isScanIndexForward() == null) return false;
        if (other.isScanIndexForward() != null && other.isScanIndexForward().equals(this.isScanIndexForward()) == false) return false; 
        if (other.getExclusiveStartKey() == null ^ this.getExclusiveStartKey() == null) return false;
        if (other.getExclusiveStartKey() != null && other.getExclusiveStartKey().equals(this.getExclusiveStartKey()) == 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.getProjectionExpression() == null ^ this.getProjectionExpression() == null) return false;
        if (other.getProjectionExpression() != null && other.getProjectionExpression().equals(this.getProjectionExpression()) == false) return false; 
        if (other.getFilterExpression() == null ^ this.getFilterExpression() == null) return false;
        if (other.getFilterExpression() != null && other.getFilterExpression().equals(this.getFilterExpression()) == false) return false; 
        if (other.getKeyConditionExpression() == null ^ this.getKeyConditionExpression() == null) return false;
        if (other.getKeyConditionExpression() != null && other.getKeyConditionExpression().equals(this.getKeyConditionExpression()) == false) return false; 
        if (other.getExpressionAttributeNames() == null ^ this.getExpressionAttributeNames() == null) return false;
        if (other.getExpressionAttributeNames() != null && other.getExpressionAttributeNames().equals(this.getExpressionAttributeNames()) == false) return false; 
        if (other.getExpressionAttributeValues() == null ^ this.getExpressionAttributeValues() == null) return false;
        if (other.getExpressionAttributeValues() != null && other.getExpressionAttributeValues().equals(this.getExpressionAttributeValues()) == false) return false; 
        return true;
    }
    
}




    © 2015 - 2025 Weber Informatics LLC | Privacy Policy