class Aws::DynamoDB::Types::BatchGetItemInput

Represents the input of a `BatchGetItem` operation.

@note When making an API call, you may pass BatchGetItemInput

data as a hash:

    {
      request_items: { # required
        "TableName" => {
          keys: [ # required
            {
              "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
            },
          ],
          attributes_to_get: ["AttributeName"],
          consistent_read: false,
          projection_expression: "ProjectionExpression",
          expression_attribute_names: {
            "ExpressionAttributeNameVariable" => "AttributeName",
          },
        },
      },
      return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
    }

@!attribute [rw] request_items

A map of one or more table names and, for each table, a map that
describes one or more items to retrieve from that table. Each table
name can be used only once per `BatchGetItem` request.

Each element in the map of items to retrieve consists of the
following:

* `ConsistentRead` - If `true`, a strongly consistent read is used;
  if `false` (the default), an eventually consistent read is used.

* `ExpressionAttributeNames` - One or more substitution tokens for
  attribute names in the `ProjectionExpression` parameter. The
  following are some use cases for using
  `ExpressionAttributeNames`\:

  * To access an attribute whose name conflicts with a DynamoDB
    reserved word.

  * To create a placeholder for repeating occurrences of an
    attribute name in an expression.

  * To prevent special characters in an attribute name from being
    misinterpreted in an expression.

  Use the **#** character in an expression to dereference an
  attribute name. For example, consider the following attribute
  name:

  * `Percentile`

  ^

  The name of this attribute conflicts with a reserved word, so it
  cannot be used directly in an expression. (For the complete list
  of reserved words, see [Reserved Words][1] 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`

  ^

  <note markdown="1"> Tokens that begin with the **\:** character are *expression
  attribute values*, which are placeholders for the actual value at
  runtime.

   </note>

  For more information about expression attribute names, see
  [Accessing Item Attributes][2] in the *Amazon DynamoDB Developer
  Guide*.

* `Keys` - An array of primary key attribute values that define
  specific items in the table. For each primary key, you must
  provide *all* of the key attributes. For example, with a simple
  primary key, you only need to provide the partition key value. For
  a composite key, you must provide *both* the partition key value
  and the sort key value.

* `ProjectionExpression` - A string that identifies one or more
  attributes to retrieve from the table. These attributes can
  include scalars, sets, or elements of a JSON document. The
  attributes in the expression must be separated by commas.

  If no attribute names are specified, then all attributes are
  returned. If any of the requested attributes are not found, they
  do not appear in the result.

  For more information, see [Accessing Item Attributes][2] in the
  *Amazon DynamoDB Developer Guide*.

* `AttributesToGet` - This is a legacy parameter. Use
  `ProjectionExpression` instead. For more information, see
  [AttributesToGet][3] in the *Amazon DynamoDB Developer Guide*.

[1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html
[2]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.AccessingItemAttributes.html
[3]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.AttributesToGet.html
@return [Hash<String,Types::KeysAndAttributes>]

@!attribute [rw] return_consumed_capacity

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 [String]

@see docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10/BatchGetItemInput AWS API Documentation

Constants

SENSITIVE