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