class Aws::DynamoDB::Types::DeleteItemInput

Represents the input of a `DeleteItem` operation.

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

data as a hash:

    {
      table_name: "TableName", # required
      key: { # required
        "AttributeName" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
      },
      expected: {
        "AttributeName" => {
          value: "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
          exists: false,
          comparison_operator: "EQ", # accepts EQ, NE, IN, LE, LT, GE, GT, BETWEEN, NOT_NULL, NULL, CONTAINS, NOT_CONTAINS, BEGINS_WITH
          attribute_value_list: ["value"], # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
        },
      },
      conditional_operator: "AND", # accepts AND, OR
      return_values: "NONE", # accepts NONE, ALL_OLD, UPDATED_OLD, ALL_NEW, UPDATED_NEW
      return_consumed_capacity: "INDEXES", # accepts INDEXES, TOTAL, NONE
      return_item_collection_metrics: "SIZE", # accepts SIZE, NONE
      condition_expression: "ConditionExpression",
      expression_attribute_names: {
        "ExpressionAttributeNameVariable" => "AttributeName",
      },
      expression_attribute_values: {
        "ExpressionAttributeValueVariable" => "value", # value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>
      },
    }

@!attribute [rw] table_name

The name of the table from which to delete the item.
@return [String]

@!attribute [rw] key

A map of attribute names to `AttributeValue` objects, representing
the primary key of the item to delete.

For the primary key, you must provide all of the attributes. For
example, with a simple primary key, you only need to provide a value
for the partition key. For a composite primary key, you must provide
values for both the partition key and the sort key.
@return [Hash<String,Types::AttributeValue>]

@!attribute [rw] expected

This is a legacy parameter. Use `ConditionExpression` instead. For
more information, see [Expected][1] in the *Amazon DynamoDB
Developer Guide*.

[1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.Expected.html
@return [Hash<String,Types::ExpectedAttributeValue>]

@!attribute [rw] conditional_operator

This is a legacy parameter. Use `ConditionExpression` instead. For
more information, see [ConditionalOperator][1] in the *Amazon
DynamoDB Developer Guide*.

[1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ConditionalOperator.html
@return [String]

@!attribute [rw] return_values

Use `ReturnValues` if you want to get the item attributes as they
appeared before they were deleted. For `DeleteItem`, the valid
values are:

* `NONE` - If `ReturnValues` is not specified, or if its value is
  `NONE`, then nothing is returned. (This setting is the default for
  `ReturnValues`.)

* `ALL_OLD` - The content of the old item is returned.

<note markdown="1"> The `ReturnValues` parameter is used by several DynamoDB operations;
however, `DeleteItem` does not recognize any values other than
`NONE` or `ALL_OLD`.

 </note>
@return [String]

@!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]

@!attribute [rw] return_item_collection_metrics

Determines whether item collection metrics are returned. If set to
`SIZE`, the response includes statistics about item collections, if
any, that were modified during the operation are returned in the
response. If set to `NONE` (the default), no statistics are
returned.
@return [String]

@!attribute [rw] condition_expression

A condition that must be satisfied in order for a conditional
`DeleteItem` to succeed.

An expression can contain any of the following:

* Functions: `attribute_exists | attribute_not_exists |
  attribute_type | contains | begins_with | size`

  These function names are case-sensitive.

* Comparison operators: `= | <> | < | > | <= | >= | BETWEEN | IN `

* Logical operators: `AND | OR | NOT`

For more information about condition expressions, see [Condition
Expressions][1] in the *Amazon DynamoDB Developer Guide*.

[1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html
@return [String]

@!attribute [rw] expression_attribute_names

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][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 on expression attribute names, see [Specifying
Item Attributes][2] 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
@return [Hash<String,String>]

@!attribute [rw] expression_attribute_values

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 [Condition
Expressions][1] in the *Amazon DynamoDB Developer Guide*.

[1]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.SpecifyingConditions.html
@return [Hash<String,Types::AttributeValue>]

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

Constants

SENSITIVE