File Coverage

blib/lib/Paws/DynamoDB/DeleteItem.pm
Criterion Covered Total %
statement 6 6 100.0
branch n/a
condition n/a
subroutine 2 2 100.0
pod n/a
total 8 8 100.0


line stmt bran cond sub pod time code
1              
2             package Paws::DynamoDB::DeleteItem;
3 1     1   482 use Moose;
  1         3  
  1         7  
4             has ConditionalOperator => (is => 'ro', isa => 'Str');
5             has ConditionExpression => (is => 'ro', isa => 'Str');
6             has Expected => (is => 'ro', isa => 'Paws::DynamoDB::ExpectedAttributeMap');
7             has ExpressionAttributeNames => (is => 'ro', isa => 'Paws::DynamoDB::ExpressionAttributeNameMap');
8             has ExpressionAttributeValues => (is => 'ro', isa => 'Paws::DynamoDB::ExpressionAttributeValueMap');
9             has Key => (is => 'ro', isa => 'Paws::DynamoDB::Key', required => 1);
10             has ReturnConsumedCapacity => (is => 'ro', isa => 'Str');
11             has ReturnItemCollectionMetrics => (is => 'ro', isa => 'Str');
12             has ReturnValues => (is => 'ro', isa => 'Str');
13             has TableName => (is => 'ro', isa => 'Str', required => 1);
14              
15 1     1   6184 use MooseX::ClassAttribute;
  1         3  
  1         10  
16              
17             class_has _api_call => (isa => 'Str', is => 'ro', default => 'DeleteItem');
18             class_has _returns => (isa => 'Str', is => 'ro', default => 'Paws::DynamoDB::DeleteItemOutput');
19             class_has _result_key => (isa => 'Str', is => 'ro');
20             1;
21              
22             ### main pod documentation begin ###
23              
24             =head1 NAME
25              
26             Paws::DynamoDB::DeleteItem - Arguments for method DeleteItem on Paws::DynamoDB
27              
28             =head1 DESCRIPTION
29              
30             This class represents the parameters used for calling the method DeleteItem on the
31             Amazon DynamoDB service. Use the attributes of this class
32             as arguments to method DeleteItem.
33              
34             You shouldn't make instances of this class. Each attribute should be used as a named argument in the call to DeleteItem.
35              
36             As an example:
37              
38             $service_obj->DeleteItem(Att1 => $value1, Att2 => $value2, ...);
39              
40             Values for attributes that are native types (Int, String, Float, etc) can passed as-is (scalar values). Values for complex Types (objects) can be passed as a HashRef. The keys and values of the hashref will be used to instance the underlying object.
41              
42             =head1 ATTRIBUTES
43              
44              
45             =head2 ConditionalOperator => Str
46              
47             This is a legacy parameter. Use C<ConditionExpression> instead. For
48             more information, see ConditionalOperator in the I<Amazon DynamoDB
49             Developer Guide>.
50              
51             Valid values are: C<"AND">, C<"OR">
52              
53             =head2 ConditionExpression => Str
54              
55             A condition that must be satisfied in order for a conditional
56             C<DeleteItem> to succeed.
57              
58             An expression can contain any of the following:
59              
60             =over
61              
62             =item *
63              
64             Functions: C<attribute_exists | attribute_not_exists | attribute_type |
65             contains | begins_with | size>
66              
67             These function names are case-sensitive.
68              
69             =item *
70              
71             Comparison operators: C<= | E<lt>E<gt> | E<lt> | E<gt> | E<lt>= |
72             E<gt>= | BETWEEN | IN>
73              
74             =item *
75              
76             Logical operators: C<AND | OR | NOT>
77              
78             =back
79              
80             For more information on condition expressions, see Specifying
81             Conditions in the I<Amazon DynamoDB Developer Guide>.
82              
83              
84              
85             =head2 Expected => L<Paws::DynamoDB::ExpectedAttributeMap>
86              
87             This is a legacy parameter. Use C<ConditionExpression> instead. For
88             more information, see Expected in the I<Amazon DynamoDB Developer
89             Guide>.
90              
91              
92              
93             =head2 ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>
94              
95             One or more substitution tokens for attribute names in an expression.
96             The following are some use cases for using C<ExpressionAttributeNames>:
97              
98             =over
99              
100             =item *
101              
102             To access an attribute whose name conflicts with a DynamoDB reserved
103             word.
104              
105             =item *
106              
107             To create a placeholder for repeating occurrences of an attribute name
108             in an expression.
109              
110             =item *
111              
112             To prevent special characters in an attribute name from being
113             misinterpreted in an expression.
114              
115             =back
116              
117             Use the B<#> character in an expression to dereference an attribute
118             name. For example, consider the following attribute name:
119              
120             =over
121              
122             =item *
123              
124             C<Percentile>
125              
126             =back
127              
128             The name of this attribute conflicts with a reserved word, so it cannot
129             be used directly in an expression. (For the complete list of reserved
130             words, see Reserved Words in the I<Amazon DynamoDB Developer Guide>).
131             To work around this, you could specify the following for
132             C<ExpressionAttributeNames>:
133              
134             =over
135              
136             =item *
137              
138             C<{"#P":"Percentile"}>
139              
140             =back
141              
142             You could then use this substitution in an expression, as in this
143             example:
144              
145             =over
146              
147             =item *
148              
149             C<#P = :val>
150              
151             =back
152              
153             Tokens that begin with the B<:> character are I<expression attribute
154             values>, which are placeholders for the actual value at runtime.
155              
156             For more information on expression attribute names, see Accessing Item
157             Attributes in the I<Amazon DynamoDB Developer Guide>.
158              
159              
160              
161             =head2 ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>
162              
163             One or more values that can be substituted in an expression.
164              
165             Use the B<:> (colon) character in an expression to dereference an
166             attribute value. For example, suppose that you wanted to check whether
167             the value of the I<ProductStatus> attribute was one of the following:
168              
169             C<Available | Backordered | Discontinued>
170              
171             You would first need to specify C<ExpressionAttributeValues> as
172             follows:
173              
174             C<{ ":avail":{"S":"Available"}, ":back":{"S":"Backordered"},
175             ":disc":{"S":"Discontinued"} }>
176              
177             You could then use these values in an expression, such as this:
178              
179             C<ProductStatus IN (:avail, :back, :disc)>
180              
181             For more information on expression attribute values, see Specifying
182             Conditions in the I<Amazon DynamoDB Developer Guide>.
183              
184              
185              
186             =head2 B<REQUIRED> Key => L<Paws::DynamoDB::Key>
187              
188             A map of attribute names to C<AttributeValue> objects, representing the
189             primary key of the item to delete.
190              
191             For the primary key, you must provide all of the attributes. For
192             example, with a simple primary key, you only need to provide a value
193             for the partition key. For a composite primary key, you must provide
194             values for both the partition key and the sort key.
195              
196              
197              
198             =head2 ReturnConsumedCapacity => Str
199              
200              
201              
202             Valid values are: C<"INDEXES">, C<"TOTAL">, C<"NONE">
203              
204             =head2 ReturnItemCollectionMetrics => Str
205              
206             Determines whether item collection metrics are returned. If set to
207             C<SIZE>, the response includes statistics about item collections, if
208             any, that were modified during the operation are returned in the
209             response. If set to C<NONE> (the default), no statistics are returned.
210              
211             Valid values are: C<"SIZE">, C<"NONE">
212              
213             =head2 ReturnValues => Str
214              
215             Use C<ReturnValues> if you want to get the item attributes as they
216             appeared before they were deleted. For C<DeleteItem>, the valid values
217             are:
218              
219             =over
220              
221             =item *
222              
223             C<NONE> - If C<ReturnValues> is not specified, or if its value is
224             C<NONE>, then nothing is returned. (This setting is the default for
225             C<ReturnValues>.)
226              
227             =item *
228              
229             C<ALL_OLD> - The content of the old item is returned.
230              
231             =back
232              
233             The C<ReturnValues> parameter is used by several DynamoDB operations;
234             however, C<DeleteItem> does not recognize any values other than C<NONE>
235             or C<ALL_OLD>.
236              
237             Valid values are: C<"NONE">, C<"ALL_OLD">, C<"UPDATED_OLD">, C<"ALL_NEW">, C<"UPDATED_NEW">
238              
239             =head2 B<REQUIRED> TableName => Str
240              
241             The name of the table from which to delete the item.
242              
243              
244              
245              
246             =head1 SEE ALSO
247              
248             This class forms part of L<Paws>, documenting arguments for method DeleteItem in L<Paws::DynamoDB>
249              
250             =head1 BUGS and CONTRIBUTIONS
251              
252             The source code is located here: https://github.com/pplu/aws-sdk-perl
253              
254             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
255              
256             =cut
257