blib/lib/Paws/DynamoDB.pm

filter: Statementstmt 16.5% 48 / 290 Branchbran 2.3% 1 / 42 Conditioncond 33.3% 1 / 3 MC/DCmcdc 0.0% 0 / 2 Subroutinesub 29.8% 20 / 67 Podpod 90.1% 55 / 61 totaltotal 26.8% 125 / 465 CC 41 SCAR 36.7
CC
41
Cov
15%
QueryAll
132.0
ScanAll
132.0
ListAllBackups
56.0
CRAP 39.2
« blib/lib/Paws/SSM.pm ↑ Summary blib/lib/Paws/IAM.pm »
1 package Paws::DynamoDB;
2 4 ▶ use Moose;
Subroutine BEGIN: called CC=1 SCAR=0.0
3 16 ▶ sub service { 'dynamodb' }
Subroutine service: called CC=1 SCAR=0.0
Pod undocumented
4 8 ▶ sub signing_name { 'dynamodb' }
Subroutine signing_name: called CC=1 SCAR=0.0
Pod undocumented
5 7 ▶ sub version { '2012-08-10' }
Subroutine version: called CC=1 SCAR=0.0
Pod undocumented
6 7 ▶ sub target_prefix { 'DynamoDB_20120810' }
Subroutine target_prefix: called CC=1 SCAR=0.0
Pod undocumented
7 7 ▶ sub json_version { "1.0" }
Subroutine json_version: called CC=1 SCAR=0.0
Pod undocumented
8 4 has max_attempts => (is => 'ro', isa => 'Int', default => 10);
9 16 ▶ has retry => (is => 'ro', isa => 'HashRef', default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
10 16 { base => '0.05', type => 'exponential', growth_factor => 2 }
11 4 });
12 16 ▶ has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
Subroutine __ANON__: called CC=1 SCAR=0.4
13 4 ▶ sub { $_[0]->code eq 'Crc32Error' },
Subroutine __ANON__: called CC=1 SCAR=0.0
14 4 ▶ sub { defined $_[0]->http_status and $_[0]->http_status == 400 and $_[0]->code eq 'TransactionInProgressException' },
Subroutine __ANON__: called CC=3 SCAR=14.2
Branch: 1 branch
BranchTrueFalseTotal
defined $_[0]->http_status and $_[0]->http_status == 400 and $_[0]->code eq "TransactionInProgressException" 4 0 4
Condition33%1/3
defined $_[0]->http_status and $_[0]->http_status == 400
!ll&&!rl&&r
004
MC/DC0%0/2
defined $_[0]->http_status and $_[0]->http_status == 400
defined $_[0]->http_status $_[0]->http_status == 400
Truth table33%1/3
A and B
A= defined $_[0]->http_statusB= $_[0]->http_status == 400
ABresult
0X0
100
111
15 16 ] });
16  
17 4 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
18  
19 16 ▶ has '+region_rules' => (default => sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
20 16 my $regioninfo;
21 16 $regioninfo = [
22 {
23 constraints => [
24 [
25 'region',
26 'equals',
27 'local'
28 ]
29 ],
30 properties => {
31 credentialScope => {
32 region => 'us-east-1',
33 service => 'dynamodb'
34 }
35 },
36 uri => 'http://localhost:8000'
37 }
38 ];
39  
40 16 return $regioninfo;
41 4 });
42  
43
44 0 ▶ sub BatchExecuteStatement {
Subroutine BatchExecuteStatement: not called CC=1 SCAR=6.9
Pod documented
45 0 my $self = shift;
46 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::BatchExecuteStatement', @_);
47 0 return $self->caller->do_call($self, $call_object);
48 }
49 2 ▶ sub BatchGetItem {
Subroutine BatchGetItem: called CC=1 SCAR=0.0
Pod documented
50 2 my $self = shift;
51 2 my $call_object = $self->new_with_coercions('Paws::DynamoDB::BatchGetItem', @_);
52 2 return $self->caller->do_call($self, $call_object);
53 }
54 1 ▶ sub BatchWriteItem {
Subroutine BatchWriteItem: called CC=1 SCAR=0.0
Pod documented
55 1 my $self = shift;
56 1 my $call_object = $self->new_with_coercions('Paws::DynamoDB::BatchWriteItem', @_);
57 1 return $self->caller->do_call($self, $call_object);
58 }
59 0 ▶ sub CreateBackup {
Subroutine CreateBackup: not called CC=1 SCAR=6.9
Pod documented
60 0 my $self = shift;
61 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::CreateBackup', @_);
62 0 return $self->caller->do_call($self, $call_object);
63 }
64 0 ▶ sub CreateGlobalTable {
Subroutine CreateGlobalTable: not called CC=1 SCAR=6.9
Pod documented
65 0 my $self = shift;
66 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::CreateGlobalTable', @_);
67 0 return $self->caller->do_call($self, $call_object);
68 }
69 2 ▶ sub CreateTable {
Subroutine CreateTable: called CC=1 SCAR=0.0
Pod documented
70 2 my $self = shift;
71 2 my $call_object = $self->new_with_coercions('Paws::DynamoDB::CreateTable', @_);
72 2 return $self->caller->do_call($self, $call_object);
73 }
74 0 ▶ sub DeleteBackup {
Subroutine DeleteBackup: not called CC=1 SCAR=6.9
Pod documented
75 0 my $self = shift;
76 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DeleteBackup', @_);
77 0 return $self->caller->do_call($self, $call_object);
78 }
79 0 ▶ sub DeleteItem {
Subroutine DeleteItem: not called CC=1 SCAR=6.9
Pod documented
80 0 my $self = shift;
81 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DeleteItem', @_);
82 0 return $self->caller->do_call($self, $call_object);
83 }
84 2 ▶ sub DeleteTable {
Subroutine DeleteTable: called CC=1 SCAR=0.0
Pod documented
85 2 my $self = shift;
86 2 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DeleteTable', @_);
87 2 return $self->caller->do_call($self, $call_object);
88 }
89 0 ▶ sub DescribeBackup {
Subroutine DescribeBackup: not called CC=1 SCAR=6.9
Pod documented
90 0 my $self = shift;
91 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeBackup', @_);
92 0 return $self->caller->do_call($self, $call_object);
93 }
94 0 ▶ sub DescribeContinuousBackups {
Subroutine DescribeContinuousBackups: not called CC=1 SCAR=6.9
Pod documented
95 0 my $self = shift;
96 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeContinuousBackups', @_);
97 0 return $self->caller->do_call($self, $call_object);
98 }
99 0 ▶ sub DescribeContributorInsights {
Subroutine DescribeContributorInsights: not called CC=1 SCAR=6.9
Pod documented
100 0 my $self = shift;
101 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeContributorInsights', @_);
102 0 return $self->caller->do_call($self, $call_object);
103 }
104 0 ▶ sub DescribeEndpoints {
Subroutine DescribeEndpoints: not called CC=1 SCAR=6.9
Pod documented
105 0 my $self = shift;
106 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeEndpoints', @_);
107 0 return $self->caller->do_call($self, $call_object);
108 }
109 0 ▶ sub DescribeExport {
Subroutine DescribeExport: not called CC=1 SCAR=6.9
Pod documented
110 0 my $self = shift;
111 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeExport', @_);
112 0 return $self->caller->do_call($self, $call_object);
113 }
114 0 ▶ sub DescribeGlobalTable {
Subroutine DescribeGlobalTable: not called CC=1 SCAR=6.9
Pod documented
115 0 my $self = shift;
116 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeGlobalTable', @_);
117 0 return $self->caller->do_call($self, $call_object);
118 }
119 0 ▶ sub DescribeGlobalTableSettings {
Subroutine DescribeGlobalTableSettings: not called CC=1 SCAR=6.9
Pod documented
120 0 my $self = shift;
121 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeGlobalTableSettings', @_);
122 0 return $self->caller->do_call($self, $call_object);
123 }
124 0 ▶ sub DescribeKinesisStreamingDestination {
Subroutine DescribeKinesisStreamingDestination: not called CC=1 SCAR=6.9
Pod documented
125 0 my $self = shift;
126 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeKinesisStreamingDestination', @_);
127 0 return $self->caller->do_call($self, $call_object);
128 }
129 0 ▶ sub DescribeLimits {
Subroutine DescribeLimits: not called CC=1 SCAR=6.9
Pod documented
130 0 my $self = shift;
131 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeLimits', @_);
132 0 return $self->caller->do_call($self, $call_object);
133 }
134 1 ▶ sub DescribeTable {
Subroutine DescribeTable: called CC=1 SCAR=0.0
Pod documented
135 1 my $self = shift;
136 1 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeTable', @_);
137 1 return $self->caller->do_call($self, $call_object);
138 }
139 0 ▶ sub DescribeTableReplicaAutoScaling {
Subroutine DescribeTableReplicaAutoScaling: not called CC=1 SCAR=6.9
Pod documented
140 0 my $self = shift;
141 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeTableReplicaAutoScaling', @_);
142 0 return $self->caller->do_call($self, $call_object);
143 }
144 0 ▶ sub DescribeTimeToLive {
Subroutine DescribeTimeToLive: not called CC=1 SCAR=6.9
Pod documented
145 0 my $self = shift;
146 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DescribeTimeToLive', @_);
147 0 return $self->caller->do_call($self, $call_object);
148 }
149 0 ▶ sub DisableKinesisStreamingDestination {
Subroutine DisableKinesisStreamingDestination: not called CC=1 SCAR=6.9
Pod documented
150 0 my $self = shift;
151 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::DisableKinesisStreamingDestination', @_);
152 0 return $self->caller->do_call($self, $call_object);
153 }
154 0 ▶ sub EnableKinesisStreamingDestination {
Subroutine EnableKinesisStreamingDestination: not called CC=1 SCAR=6.9
Pod documented
155 0 my $self = shift;
156 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::EnableKinesisStreamingDestination', @_);
157 0 return $self->caller->do_call($self, $call_object);
158 }
159 0 ▶ sub ExecuteStatement {
Subroutine ExecuteStatement: not called CC=1 SCAR=6.9
Pod documented
160 0 my $self = shift;
161 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ExecuteStatement', @_);
162 0 return $self->caller->do_call($self, $call_object);
163 }
164 0 ▶ sub ExecuteTransaction {
Subroutine ExecuteTransaction: not called CC=1 SCAR=6.9
Pod documented
165 0 my $self = shift;
166 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ExecuteTransaction', @_);
167 0 return $self->caller->do_call($self, $call_object);
168 }
169 0 ▶ sub ExportTableToPointInTime {
Subroutine ExportTableToPointInTime: not called CC=1 SCAR=6.9
Pod documented
170 0 my $self = shift;
171 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ExportTableToPointInTime', @_);
172 0 return $self->caller->do_call($self, $call_object);
173 }
174 4 ▶ sub GetItem {
Subroutine GetItem: called CC=1 SCAR=0.0
Pod documented
175 4 my $self = shift;
176 4 my $call_object = $self->new_with_coercions('Paws::DynamoDB::GetItem', @_);
177 4 return $self->caller->do_call($self, $call_object);
178 }
179 0 ▶ sub ListBackups {
Subroutine ListBackups: not called CC=1 SCAR=6.9
Pod documented
180 0 my $self = shift;
181 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListBackups', @_);
182 0 return $self->caller->do_call($self, $call_object);
183 }
184 0 ▶ sub ListContributorInsights {
Subroutine ListContributorInsights: not called CC=1 SCAR=6.9
Pod documented
185 0 my $self = shift;
186 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListContributorInsights', @_);
187 0 return $self->caller->do_call($self, $call_object);
188 }
189 0 ▶ sub ListExports {
Subroutine ListExports: not called CC=1 SCAR=6.9
Pod documented
190 0 my $self = shift;
191 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListExports', @_);
192 0 return $self->caller->do_call($self, $call_object);
193 }
194 0 ▶ sub ListGlobalTables {
Subroutine ListGlobalTables: not called CC=1 SCAR=6.9
Pod documented
195 0 my $self = shift;
196 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListGlobalTables', @_);
197 0 return $self->caller->do_call($self, $call_object);
198 }
199 3 ▶ sub ListTables {
Subroutine ListTables: called CC=1 SCAR=0.0
Pod documented
200 3 my $self = shift;
201 3 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListTables', @_);
202 3 return $self->caller->do_call($self, $call_object);
203 }
204 0 ▶ sub ListTagsOfResource {
Subroutine ListTagsOfResource: not called CC=1 SCAR=6.9
Pod documented
205 0 my $self = shift;
206 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::ListTagsOfResource', @_);
207 0 return $self->caller->do_call($self, $call_object);
208 }
209 2 ▶ sub PutItem {
Subroutine PutItem: called CC=1 SCAR=0.0
Pod documented
210 2 my $self = shift;
211 2 my $call_object = $self->new_with_coercions('Paws::DynamoDB::PutItem', @_);
212 2 return $self->caller->do_call($self, $call_object);
213 }
214 0 ▶ sub Query {
Subroutine Query: not called CC=1 SCAR=6.9
Pod documented
215 0 my $self = shift;
216 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::Query', @_);
217 0 return $self->caller->do_call($self, $call_object);
218 }
219 0 ▶ sub RestoreTableFromBackup {
Subroutine RestoreTableFromBackup: not called CC=1 SCAR=6.9
Pod documented
220 0 my $self = shift;
221 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::RestoreTableFromBackup', @_);
222 0 return $self->caller->do_call($self, $call_object);
223 }
224 0 ▶ sub RestoreTableToPointInTime {
Subroutine RestoreTableToPointInTime: not called CC=1 SCAR=6.9
Pod documented
225 0 my $self = shift;
226 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::RestoreTableToPointInTime', @_);
227 0 return $self->caller->do_call($self, $call_object);
228 }
229 2 ▶ sub Scan {
Subroutine Scan: called CC=1 SCAR=0.0
Pod documented
230 2 my $self = shift;
231 2 my $call_object = $self->new_with_coercions('Paws::DynamoDB::Scan', @_);
232 2 return $self->caller->do_call($self, $call_object);
233 }
234 0 ▶ sub TagResource {
Subroutine TagResource: not called CC=1 SCAR=6.9
Pod documented
235 0 my $self = shift;
236 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::TagResource', @_);
237 0 return $self->caller->do_call($self, $call_object);
238 }
239 0 ▶ sub TransactGetItems {
Subroutine TransactGetItems: not called CC=1 SCAR=6.9
Pod documented
240 0 my $self = shift;
241 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::TransactGetItems', @_);
242 0 return $self->caller->do_call($self, $call_object);
243 }
244 0 ▶ sub TransactWriteItems {
Subroutine TransactWriteItems: not called CC=1 SCAR=6.9
Pod documented
245 0 my $self = shift;
246 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::TransactWriteItems', @_);
247 0 return $self->caller->do_call($self, $call_object);
248 }
249 0 ▶ sub UntagResource {
Subroutine UntagResource: not called CC=1 SCAR=6.9
Pod documented
250 0 my $self = shift;
251 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UntagResource', @_);
252 0 return $self->caller->do_call($self, $call_object);
253 }
254 0 ▶ sub UpdateContinuousBackups {
Subroutine UpdateContinuousBackups: not called CC=1 SCAR=6.9
Pod documented
255 0 my $self = shift;
256 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateContinuousBackups', @_);
257 0 return $self->caller->do_call($self, $call_object);
258 }
259 0 ▶ sub UpdateContributorInsights {
Subroutine UpdateContributorInsights: not called CC=1 SCAR=6.9
Pod documented
260 0 my $self = shift;
261 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateContributorInsights', @_);
262 0 return $self->caller->do_call($self, $call_object);
263 }
264 0 ▶ sub UpdateGlobalTable {
Subroutine UpdateGlobalTable: not called CC=1 SCAR=6.9
Pod documented
265 0 my $self = shift;
266 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateGlobalTable', @_);
267 0 return $self->caller->do_call($self, $call_object);
268 }
269 0 ▶ sub UpdateGlobalTableSettings {
Subroutine UpdateGlobalTableSettings: not called CC=1 SCAR=6.9
Pod documented
270 0 my $self = shift;
271 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateGlobalTableSettings', @_);
272 0 return $self->caller->do_call($self, $call_object);
273 }
274 0 ▶ sub UpdateItem {
Subroutine UpdateItem: not called CC=1 SCAR=6.9
Pod documented
275 0 my $self = shift;
276 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateItem', @_);
277 0 return $self->caller->do_call($self, $call_object);
278 }
279 0 ▶ sub UpdateTable {
Subroutine UpdateTable: not called CC=1 SCAR=6.9
Pod documented
280 0 my $self = shift;
281 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateTable', @_);
282 0 return $self->caller->do_call($self, $call_object);
283 }
284 0 ▶ sub UpdateTableReplicaAutoScaling {
Subroutine UpdateTableReplicaAutoScaling: not called CC=1 SCAR=6.9
Pod documented
285 0 my $self = shift;
286 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateTableReplicaAutoScaling', @_);
287 0 return $self->caller->do_call($self, $call_object);
288 }
289 0 ▶ sub UpdateTimeToLive {
Subroutine UpdateTimeToLive: not called CC=1 SCAR=6.9
Pod documented
290 0 my $self = shift;
291 0 my $call_object = $self->new_with_coercions('Paws::DynamoDB::UpdateTimeToLive', @_);
292 0 return $self->caller->do_call($self, $call_object);
293 }
294
295 0 ▶ sub ListAllBackups {
Subroutine ListAllBackups: not called CC=7 SCAR=40.3
Pod documented
296 0 my $self = shift;
297  
298 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
299 0 my $result = $self->ListBackups(@_);
300 0 my $next_result = $result;
301  
302 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
303 0 ▶ while ($next_result->LastEvaluatedBackupArn) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->LastEvaluatedBackupArn) 0 0 0
304 0 $next_result = $self->ListBackups(@_, ExclusiveStartBackupArn => $next_result->LastEvaluatedBackupArn);
305 0 push @{ $result->BackupSummaries }, @{ $next_result->BackupSummaries };
306 }
307 0 return $result;
308 } else {
309 0 ▶ while ($result->LastEvaluatedBackupArn) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->LastEvaluatedBackupArn) 0 0 0
310 0 $callback->($_ => 'BackupSummaries') foreach (@{ $result->BackupSummaries });
311 0 $result = $self->ListBackups(@_, ExclusiveStartBackupArn => $result->LastEvaluatedBackupArn);
312 }
313 0 $callback->($_ => 'BackupSummaries') foreach (@{ $result->BackupSummaries });
314 }
315  
316 return undef
317 0 }
318 0 ▶ sub ListAllTables {
Subroutine ListAllTables: not called CC=7 SCAR=40.3
Pod documented
319 0 my $self = shift;
320  
321 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
322 0 my $result = $self->ListTables(@_);
323 0 my $next_result = $result;
324  
325 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
326 0 ▶ while ($next_result->LastEvaluatedTableName) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->LastEvaluatedTableName) 0 0 0
327 0 $next_result = $self->ListTables(@_, ExclusiveStartTableName => $next_result->LastEvaluatedTableName);
328 0 push @{ $result->TableNames }, @{ $next_result->TableNames };
329 }
330 0 return $result;
331 } else {
332 0 ▶ while ($result->LastEvaluatedTableName) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->LastEvaluatedTableName) 0 0 0
333 0 $callback->($_ => 'TableNames') foreach (@{ $result->TableNames });
334 0 $result = $self->ListTables(@_, ExclusiveStartTableName => $result->LastEvaluatedTableName);
335 }
336 0 $callback->($_ => 'TableNames') foreach (@{ $result->TableNames });
337 }
338  
339 return undef
340 0 }
341 0 ▶ sub ListAllTagsOfResource {
Subroutine ListAllTagsOfResource: not called CC=7 SCAR=40.3
Pod documented
342 0 my $self = shift;
343  
344 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
345 0 my $result = $self->ListTagsOfResource(@_);
346 0 my $next_result = $result;
347  
348 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
349 0 ▶ while ($next_result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->NextToken) 0 0 0
350 0 $next_result = $self->ListTagsOfResource(@_, NextToken => $next_result->NextToken);
351 0 push @{ $result->Tags }, @{ $next_result->Tags };
352 }
353 0 return $result;
354 } else {
355 0 ▶ while ($result->NextToken) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->NextToken) 0 0 0
356 0 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
357 0 $result = $self->ListTagsOfResource(@_, NextToken => $result->NextToken);
358 }
359 0 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
360 }
361  
362 return undef
363 0 }
364 0 ▶ sub QueryAll {
Subroutine QueryAll: not called CC=11 SCAR=48.8
Pod documented
365 0 my $self = shift;
366  
367 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
368 0 my $result = $self->Query(@_);
369 0 my $next_result = $result;
370  
371 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
372 0 ▶ while ($next_result->LastEvaluatedKey) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->LastEvaluatedKey) 0 0 0
373 0 $next_result = $self->Query(@_, ExclusiveStartKey => $next_result->LastEvaluatedKey);
374 0 push @{ $result->Items }, @{ $next_result->Items };
375 0 push @{ $result->Count }, @{ $next_result->Count };
376 0 push @{ $result->ScannedCount }, @{ $next_result->ScannedCount };
377 }
378 0 return $result;
379 } else {
380 0 ▶ while ($result->LastEvaluatedKey) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->LastEvaluatedKey) 0 0 0
381 0 $callback->($_ => 'Items') foreach (@{ $result->Items });
382 0 $callback->($_ => 'Count') foreach (@{ $result->Count });
383 0 $callback->($_ => 'ScannedCount') foreach (@{ $result->ScannedCount });
384 0 $result = $self->Query(@_, ExclusiveStartKey => $result->LastEvaluatedKey);
385 }
386 0 $callback->($_ => 'Items') foreach (@{ $result->Items });
387 0 $callback->($_ => 'Count') foreach (@{ $result->Count });
388 0 $callback->($_ => 'ScannedCount') foreach (@{ $result->ScannedCount });
389 }
390  
391 return undef
392 0 }
393 0 ▶ sub ScanAll {
Subroutine ScanAll: not called CC=11 SCAR=48.8
Pod documented
394 0 my $self = shift;
395  
396 0 ▶ my $callback = shift @_ if (ref($_[0]) eq 'CODE');
Branch: 1 branch
BranchTrueFalseTotal
if ref $_[0] eq "CODE" 0 0 0
397 0 my $result = $self->Scan(@_);
398 0 my $next_result = $result;
399  
400 0 ▶ if (not defined $callback) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $callback) { } 0 0 0
401 0 ▶ while ($next_result->LastEvaluatedKey) {
Branch: 1 branch
BranchTrueFalseTotal
if ($next_result->LastEvaluatedKey) 0 0 0
402 0 $next_result = $self->Scan(@_, ExclusiveStartKey => $next_result->LastEvaluatedKey);
403 0 push @{ $result->Items }, @{ $next_result->Items };
404 0 push @{ $result->Count }, @{ $next_result->Count };
405 0 push @{ $result->ScannedCount }, @{ $next_result->ScannedCount };
406 }
407 0 return $result;
408 } else {
409 0 ▶ while ($result->LastEvaluatedKey) {
Branch: 1 branch
BranchTrueFalseTotal
if ($result->LastEvaluatedKey) 0 0 0
410 0 $callback->($_ => 'Items') foreach (@{ $result->Items });
411 0 $callback->($_ => 'Count') foreach (@{ $result->Count });
412 0 $callback->($_ => 'ScannedCount') foreach (@{ $result->ScannedCount });
413 0 $result = $self->Scan(@_, ExclusiveStartKey => $result->LastEvaluatedKey);
414 }
415 0 $callback->($_ => 'Items') foreach (@{ $result->Items });
416 0 $callback->($_ => 'Count') foreach (@{ $result->Count });
417 0 $callback->($_ => 'ScannedCount') foreach (@{ $result->ScannedCount });
418 }
419  
420 return undef
421 0 }
422  
423  
424 0 ▶ sub operations { qw/BatchExecuteStatement BatchGetItem BatchWriteItem CreateBackup CreateGlobalTable CreateTable DeleteBackup DeleteItem DeleteTable DescribeBackup DescribeContinuousBackups DescribeContributorInsights DescribeEndpoints DescribeExport DescribeGlobalTable DescribeGlobalTableSettings DescribeKinesisStreamingDestination DescribeLimits DescribeTable DescribeTableReplicaAutoScaling DescribeTimeToLive DisableKinesisStreamingDestination EnableKinesisStreamingDestination ExecuteStatement ExecuteTransaction ExportTableToPointInTime GetItem ListBackups ListContributorInsights ListExports ListGlobalTables ListTables ListTagsOfResource PutItem Query RestoreTableFromBackup RestoreTableToPointInTime Scan TagResource TransactGetItems TransactWriteItems UntagResource UpdateContinuousBackups UpdateContributorInsights UpdateGlobalTable UpdateGlobalTableSettings UpdateItem UpdateTable UpdateTableReplicaAutoScaling UpdateTimeToLive / }
Subroutine operations: not called CC=1 SCAR=6.9
Pod undocumented
425  
426 4 1;
427  
428 ### main pod documentation begin ###
429  
430 =head1 NAME
431  
432 Paws::DynamoDB - Perl Interface to AWS Amazon DynamoDB
433  
434 =head1 SYNOPSIS
435  
436 use Paws;
437  
438 my $obj = Paws->service('DynamoDB');
439 my $res = $obj->Method(
440 Arg1 => $val1,
441 Arg2 => [ 'V1', 'V2' ],
442 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
443 # of the arguments type
444 Arg3 => { Att1 => 'Val1' },
445 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
446 # the constructor of the arguments type
447 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
448 );
449  
450 =head1 DESCRIPTION
451  
452 Amazon DynamoDB
453  
454 Amazon DynamoDB is a fully managed NoSQL database service that provides
455 fast and predictable performance with seamless scalability. DynamoDB
456 lets you offload the administrative burdens of operating and scaling a
457 distributed database, so that you don't have to worry about hardware
458 provisioning, setup and configuration, replication, software patching,
459 or cluster scaling.
460  
461 With DynamoDB, you can create database tables that can store and
462 retrieve any amount of data, and serve any level of request traffic.
463 You can scale up or scale down your tables' throughput capacity without
464 downtime or performance degradation, and use the AWS Management Console
465 to monitor resource utilization and performance metrics.
466  
467 DynamoDB automatically spreads the data and traffic for your tables
468 over a sufficient number of servers to handle your throughput and
469 storage requirements, while maintaining consistent and fast
470 performance. All of your data is stored on solid state disks (SSDs) and
471 automatically replicated across multiple Availability Zones in an AWS
472 region, providing built-in high availability and data durability.
473  
474 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/dynamodb-2012-08-10>
475  
476  
477 =head1 METHODS
478  
479 =head2 BatchExecuteStatement
480  
481 =over
482  
483 =item Statements => ArrayRef[L<Paws::DynamoDB::BatchStatementRequest>]
484  
485  
486 =back
487  
488 Each argument is described in detail in: L<Paws::DynamoDB::BatchExecuteStatement>
489  
490 Returns: a L<Paws::DynamoDB::BatchExecuteStatementOutput> instance
491  
492 This operation allows you to perform batch reads and writes on data
493 stored in DynamoDB, using PartiQL.
494  
495  
496 =head2 BatchGetItem
497  
498 =over
499  
500 =item RequestItems => L<Paws::DynamoDB::BatchGetRequestMap>
501  
502 =item [ReturnConsumedCapacity => Str]
503  
504  
505 =back
506  
507 Each argument is described in detail in: L<Paws::DynamoDB::BatchGetItem>
508  
509 Returns: a L<Paws::DynamoDB::BatchGetItemOutput> instance
510  
511 The C<BatchGetItem> operation returns the attributes of one or more
512 items from one or more tables. You identify requested items by primary
513 key.
514  
515 A single operation can retrieve up to 16 MB of data, which can contain
516 as many as 100 items. C<BatchGetItem> returns a partial result if the
517 response size limit is exceeded, the table's provisioned throughput is
518 exceeded, or an internal processing failure occurs. If a partial result
519 is returned, the operation returns a value for C<UnprocessedKeys>. You
520 can use this value to retry the operation starting with the next item
521 to get.
522  
523 If you request more than 100 items, C<BatchGetItem> returns a
524 C<ValidationException> with the message "Too many items requested for
525 the BatchGetItem call."
526  
527 For example, if you ask to retrieve 100 items, but each individual item
528 is 300 KB in size, the system returns 52 items (so as not to exceed the
529 16 MB limit). It also returns an appropriate C<UnprocessedKeys> value
530 so you can get the next page of results. If desired, your application
531 can include its own logic to assemble the pages of results into one
532 dataset.
533  
534 If I<none> of the items can be processed due to insufficient
535 provisioned throughput on all of the tables in the request, then
536 C<BatchGetItem> returns a C<ProvisionedThroughputExceededException>. If
537 I<at least one> of the items is successfully processed, then
538 C<BatchGetItem> completes successfully, while returning the keys of the
539 unread items in C<UnprocessedKeys>.
540  
541 If DynamoDB returns any unprocessed items, you should retry the batch
542 operation on those items. However, I<we strongly recommend that you use
543 an exponential backoff algorithm>. If you retry the batch operation
544 immediately, the underlying read or write requests can still fail due
545 to throttling on the individual tables. If you delay the batch
546 operation using exponential backoff, the individual requests in the
547 batch are much more likely to succeed.
548  
549 For more information, see Batch Operations and Error Handling
550 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#BatchOperations)
551 in the I<Amazon DynamoDB Developer Guide>.
552  
553 By default, C<BatchGetItem> performs eventually consistent reads on
554 every table in the request. If you want strongly consistent reads
555 instead, you can set C<ConsistentRead> to C<true> for any or all
556 tables.
557  
558 In order to minimize response latency, C<BatchGetItem> retrieves items
559 in parallel.
560  
561 When designing your application, keep in mind that DynamoDB does not
562 return items in any particular order. To help parse the response by
563 item, include the primary key values for the items in your request in
564 the C<ProjectionExpression> parameter.
565  
566 If a requested item does not exist, it is not returned in the result.
567 Requests for nonexistent items consume the minimum read capacity units
568 according to the type of read. For more information, see Working with
569 Tables
570 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithTables.html#CapacityUnitCalculations)
571 in the I<Amazon DynamoDB Developer Guide>.
572  
573  
574 =head2 BatchWriteItem
575  
576 =over
577  
578 =item RequestItems => L<Paws::DynamoDB::BatchWriteItemRequestMap>
579  
580 =item [ReturnConsumedCapacity => Str]
581  
582 =item [ReturnItemCollectionMetrics => Str]
583  
584  
585 =back
586  
587 Each argument is described in detail in: L<Paws::DynamoDB::BatchWriteItem>
588  
589 Returns: a L<Paws::DynamoDB::BatchWriteItemOutput> instance
590  
591 The C<BatchWriteItem> operation puts or deletes multiple items in one
592 or more tables. A single call to C<BatchWriteItem> can write up to 16
593 MB of data, which can comprise as many as 25 put or delete requests.
594 Individual items to be written can be as large as 400 KB.
595  
596 C<BatchWriteItem> cannot update items. To update items, use the
597 C<UpdateItem> action.
598  
599 The individual C<PutItem> and C<DeleteItem> operations specified in
600 C<BatchWriteItem> are atomic; however C<BatchWriteItem> as a whole is
601 not. If any requested operations fail because the table's provisioned
602 throughput is exceeded or an internal processing failure occurs, the
603 failed operations are returned in the C<UnprocessedItems> response
604 parameter. You can investigate and optionally resend the requests.
605 Typically, you would call C<BatchWriteItem> in a loop. Each iteration
606 would check for unprocessed items and submit a new C<BatchWriteItem>
607 request with those unprocessed items until all items have been
608 processed.
609  
610 If I<none> of the items can be processed due to insufficient
611 provisioned throughput on all of the tables in the request, then
612 C<BatchWriteItem> returns a C<ProvisionedThroughputExceededException>.
613  
614 If DynamoDB returns any unprocessed items, you should retry the batch
615 operation on those items. However, I<we strongly recommend that you use
616 an exponential backoff algorithm>. If you retry the batch operation
617 immediately, the underlying read or write requests can still fail due
618 to throttling on the individual tables. If you delay the batch
619 operation using exponential backoff, the individual requests in the
620 batch are much more likely to succeed.
621  
622 For more information, see Batch Operations and Error Handling
623 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ErrorHandling.html#Programming.Errors.BatchOperations)
624 in the I<Amazon DynamoDB Developer Guide>.
625  
626 With C<BatchWriteItem>, you can efficiently write or delete large
627 amounts of data, such as from Amazon EMR, or copy data from another
628 database into DynamoDB. In order to improve performance with these
629 large-scale operations, C<BatchWriteItem> does not behave in the same
630 way as individual C<PutItem> and C<DeleteItem> calls would. For
631 example, you cannot specify conditions on individual put and delete
632 requests, and C<BatchWriteItem> does not return deleted items in the
633 response.
634  
635 If you use a programming language that supports concurrency, you can
636 use threads to write items in parallel. Your application must include
637 the necessary logic to manage the threads. With languages that don't
638 support threading, you must update or delete the specified items one at
639 a time. In both situations, C<BatchWriteItem> performs the specified
640 put and delete operations in parallel, giving you the power of the
641 thread pool approach without having to introduce complexity into your
642 application.
643  
644 Parallel processing reduces latency, but each specified put and delete
645 request consumes the same number of write capacity units whether it is
646 processed in parallel or not. Delete operations on nonexistent items
647 consume one write capacity unit.
648  
649 If one or more of the following is true, DynamoDB rejects the entire
650 batch write operation:
651  
652 =over
653  
654 =item *
655  
656 One or more tables specified in the C<BatchWriteItem> request does not
657 exist.
658  
659 =item *
660  
661 Primary key attributes specified on an item in the request do not match
662 those in the corresponding table's primary key schema.
663  
664 =item *
665  
666 You try to perform multiple operations on the same item in the same
667 C<BatchWriteItem> request. For example, you cannot put and delete the
668 same item in the same C<BatchWriteItem> request.
669  
670 =item *
671  
672 Your request contains at least two items with identical hash and range
673 keys (which essentially is two put operations).
674  
675 =item *
676  
677 There are more than 25 requests in the batch.
678  
679 =item *
680  
681 Any individual item in a batch exceeds 400 KB.
682  
683 =item *
684  
685 The total request size exceeds 16 MB.
686  
687 =back
688  
689  
690  
691 =head2 CreateBackup
692  
693 =over
694  
695 =item BackupName => Str
696  
697 =item TableName => Str
698  
699  
700 =back
701  
702 Each argument is described in detail in: L<Paws::DynamoDB::CreateBackup>
703  
704 Returns: a L<Paws::DynamoDB::CreateBackupOutput> instance
705  
706 Creates a backup for an existing table.
707  
708 Each time you create an on-demand backup, the entire table data is
709 backed up. There is no limit to the number of on-demand backups that
710 can be taken.
711  
712 When you create an on-demand backup, a time marker of the request is
713 cataloged, and the backup is created asynchronously, by applying all
714 changes until the time of the request to the last full table snapshot.
715 Backup requests are processed instantaneously and become available for
716 restore within minutes.
717  
718 You can call C<CreateBackup> at a maximum rate of 50 times per second.
719  
720 All backups in DynamoDB work without consuming any provisioned
721 throughput on the table.
722  
723 If you submit a backup request on 2018-12-14 at 14:25:00, the backup is
724 guaranteed to contain all data committed to the table up to 14:24:00,
725 and data committed after 14:26:00 will not be. The backup might contain
726 data modifications made between 14:24:00 and 14:26:00. On-demand backup
727 does not support causal consistency.
728  
729 Along with data, the following are also included on the backups:
730  
731 =over
732  
733 =item *
734  
735 Global secondary indexes (GSIs)
736  
737 =item *
738  
739 Local secondary indexes (LSIs)
740  
741 =item *
742  
743 Streams
744  
745 =item *
746  
747 Provisioned read and write capacity
748  
749 =back
750  
751  
752  
753 =head2 CreateGlobalTable
754  
755 =over
756  
757 =item GlobalTableName => Str
758  
759 =item ReplicationGroup => ArrayRef[L<Paws::DynamoDB::Replica>]
760  
761  
762 =back
763  
764 Each argument is described in detail in: L<Paws::DynamoDB::CreateGlobalTable>
765  
766 Returns: a L<Paws::DynamoDB::CreateGlobalTableOutput> instance
767  
768 Creates a global table from an existing table. A global table creates a
769 replication relationship between two or more DynamoDB tables with the
770 same table name in the provided Regions.
771  
772 This operation only applies to Version 2017.11.29
773 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html)
774 of global tables.
775  
776 If you want to add a new replica table to a global table, each of the
777 following conditions must be true:
778  
779 =over
780  
781 =item *
782  
783 The table must have the same primary key as all of the other replicas.
784  
785 =item *
786  
787 The table must have the same name as all of the other replicas.
788  
789 =item *
790  
791 The table must have DynamoDB Streams enabled, with the stream
792 containing both the new and the old images of the item.
793  
794 =item *
795  
796 None of the replica tables in the global table can contain any data.
797  
798 =back
799  
800 If global secondary indexes are specified, then the following
801 conditions must also be met:
802  
803 =over
804  
805 =item *
806  
807 The global secondary indexes must have the same name.
808  
809 =item *
810  
811 The global secondary indexes must have the same hash key and sort key
812 (if present).
813  
814 =back
815  
816 If local secondary indexes are specified, then the following conditions
817 must also be met:
818  
819 =over
820  
821 =item *
822  
823 The local secondary indexes must have the same name.
824  
825 =item *
826  
827 The local secondary indexes must have the same hash key and sort key
828 (if present).
829  
830 =back
831  
832 Write capacity settings should be set consistently across your replica
833 tables and secondary indexes. DynamoDB strongly recommends enabling
834 auto scaling to manage the write capacity settings for all of your
835 global tables replicas and indexes.
836  
837 If you prefer to manage write capacity settings manually, you should
838 provision equal replicated write capacity units to your replica tables.
839 You should also provision equal replicated write capacity units to
840 matching secondary indexes across your global table.
841  
842  
843 =head2 CreateTable
844  
845 =over
846  
847 =item AttributeDefinitions => ArrayRef[L<Paws::DynamoDB::AttributeDefinition>]
848  
849 =item KeySchema => ArrayRef[L<Paws::DynamoDB::KeySchemaElement>]
850  
851 =item TableName => Str
852  
853 =item [BillingMode => Str]
854  
855 =item [GlobalSecondaryIndexes => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndex>]]
856  
857 =item [LocalSecondaryIndexes => ArrayRef[L<Paws::DynamoDB::LocalSecondaryIndex>]]
858  
859 =item [ProvisionedThroughput => L<Paws::DynamoDB::ProvisionedThroughput>]
860  
861 =item [SSESpecification => L<Paws::DynamoDB::SSESpecification>]
862  
863 =item [StreamSpecification => L<Paws::DynamoDB::StreamSpecification>]
864  
865 =item [Tags => ArrayRef[L<Paws::DynamoDB::Tag>]]
866  
867  
868 =back
869  
870 Each argument is described in detail in: L<Paws::DynamoDB::CreateTable>
871  
872 Returns: a L<Paws::DynamoDB::CreateTableOutput> instance
873  
874 The C<CreateTable> operation adds a new table to your account. In an
875 AWS account, table names must be unique within each Region. That is,
876 you can have two tables with same name if you create the tables in
877 different Regions.
878  
879 C<CreateTable> is an asynchronous operation. Upon receiving a
880 C<CreateTable> request, DynamoDB immediately returns a response with a
881 C<TableStatus> of C<CREATING>. After the table is created, DynamoDB
882 sets the C<TableStatus> to C<ACTIVE>. You can perform read and write
883 operations only on an C<ACTIVE> table.
884  
885 You can optionally define secondary indexes on the new table, as part
886 of the C<CreateTable> operation. If you want to create multiple tables
887 with secondary indexes on them, you must create the tables
888 sequentially. Only one table with secondary indexes can be in the
889 C<CREATING> state at any given time.
890  
891 You can use the C<DescribeTable> action to check the table status.
892  
893  
894 =head2 DeleteBackup
895  
896 =over
897  
898 =item BackupArn => Str
899  
900  
901 =back
902  
903 Each argument is described in detail in: L<Paws::DynamoDB::DeleteBackup>
904  
905 Returns: a L<Paws::DynamoDB::DeleteBackupOutput> instance
906  
907 Deletes an existing backup of a table.
908  
909 You can call C<DeleteBackup> at a maximum rate of 10 times per second.
910  
911  
912 =head2 DeleteItem
913  
914 =over
915  
916 =item Key => L<Paws::DynamoDB::Key>
917  
918 =item TableName => Str
919  
920 =item [ConditionalOperator => Str]
921  
922 =item [ConditionExpression => Str]
923  
924 =item [Expected => L<Paws::DynamoDB::ExpectedAttributeMap>]
925  
926 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
927  
928 =item [ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>]
929  
930 =item [ReturnConsumedCapacity => Str]
931  
932 =item [ReturnItemCollectionMetrics => Str]
933  
934 =item [ReturnValues => Str]
935  
936  
937 =back
938  
939 Each argument is described in detail in: L<Paws::DynamoDB::DeleteItem>
940  
941 Returns: a L<Paws::DynamoDB::DeleteItemOutput> instance
942  
943 Deletes a single item in a table by primary key. You can perform a
944 conditional delete operation that deletes the item if it exists, or if
945 it has an expected attribute value.
946  
947 In addition to deleting an item, you can also return the item's
948 attribute values in the same operation, using the C<ReturnValues>
949 parameter.
950  
951 Unless you specify conditions, the C<DeleteItem> is an idempotent
952 operation; running it multiple times on the same item or attribute does
953 I<not> result in an error response.
954  
955 Conditional deletes are useful for deleting items only if specific
956 conditions are met. If those conditions are met, DynamoDB performs the
957 delete. Otherwise, the item is not deleted.
958  
959  
960 =head2 DeleteTable
961  
962 =over
963  
964 =item TableName => Str
965  
966  
967 =back
968  
969 Each argument is described in detail in: L<Paws::DynamoDB::DeleteTable>
970  
971 Returns: a L<Paws::DynamoDB::DeleteTableOutput> instance
972  
973 The C<DeleteTable> operation deletes a table and all of its items.
974 After a C<DeleteTable> request, the specified table is in the
975 C<DELETING> state until DynamoDB completes the deletion. If the table
976 is in the C<ACTIVE> state, you can delete it. If a table is in
977 C<CREATING> or C<UPDATING> states, then DynamoDB returns a
978 C<ResourceInUseException>. If the specified table does not exist,
979 DynamoDB returns a C<ResourceNotFoundException>. If table is already in
980 the C<DELETING> state, no error is returned.
981  
982 DynamoDB might continue to accept data read and write operations, such
983 as C<GetItem> and C<PutItem>, on a table in the C<DELETING> state until
984 the table deletion is complete.
985  
986 When you delete a table, any indexes on that table are also deleted.
987  
988 If you have DynamoDB Streams enabled on the table, then the
989 corresponding stream on that table goes into the C<DISABLED> state, and
990 the stream is automatically deleted after 24 hours.
991  
992 Use the C<DescribeTable> action to check the status of the table.
993  
994  
995 =head2 DescribeBackup
996  
997 =over
998  
999 =item BackupArn => Str
1000  
1001  
1002 =back
1003  
1004 Each argument is described in detail in: L<Paws::DynamoDB::DescribeBackup>
1005  
1006 Returns: a L<Paws::DynamoDB::DescribeBackupOutput> instance
1007  
1008 Describes an existing backup of a table.
1009  
1010 You can call C<DescribeBackup> at a maximum rate of 10 times per
1011 second.
1012  
1013  
1014 =head2 DescribeContinuousBackups
1015  
1016 =over
1017  
1018 =item TableName => Str
1019  
1020  
1021 =back
1022  
1023 Each argument is described in detail in: L<Paws::DynamoDB::DescribeContinuousBackups>
1024  
1025 Returns: a L<Paws::DynamoDB::DescribeContinuousBackupsOutput> instance
1026  
1027 Checks the status of continuous backups and point in time recovery on
1028 the specified table. Continuous backups are C<ENABLED> on all tables at
1029 table creation. If point in time recovery is enabled,
1030 C<PointInTimeRecoveryStatus> will be set to ENABLED.
1031  
1032 After continuous backups and point in time recovery are enabled, you
1033 can restore to any point in time within C<EarliestRestorableDateTime>
1034 and C<LatestRestorableDateTime>.
1035  
1036 C<LatestRestorableDateTime> is typically 5 minutes before the current
1037 time. You can restore your table to any point in time during the last
1038 35 days.
1039  
1040 You can call C<DescribeContinuousBackups> at a maximum rate of 10 times
1041 per second.
1042  
1043  
1044 =head2 DescribeContributorInsights
1045  
1046 =over
1047  
1048 =item TableName => Str
1049  
1050 =item [IndexName => Str]
1051  
1052  
1053 =back
1054  
1055 Each argument is described in detail in: L<Paws::DynamoDB::DescribeContributorInsights>
1056  
1057 Returns: a L<Paws::DynamoDB::DescribeContributorInsightsOutput> instance
1058  
1059 Returns information about contributor insights, for a given table or
1060 global secondary index.
1061  
1062  
1063 =head2 DescribeEndpoints
1064  
1065  
1066  
1067  
1068  
1069  
1070 Each argument is described in detail in: L<Paws::DynamoDB::DescribeEndpoints>
1071  
1072 Returns: a L<Paws::DynamoDB::DescribeEndpointsResponse> instance
1073  
1074 Returns the regional endpoint information.
1075  
1076  
1077 =head2 DescribeExport
1078  
1079 =over
1080  
1081 =item ExportArn => Str
1082  
1083  
1084 =back
1085  
1086 Each argument is described in detail in: L<Paws::DynamoDB::DescribeExport>
1087  
1088 Returns: a L<Paws::DynamoDB::DescribeExportOutput> instance
1089  
1090 Describes an existing table export.
1091  
1092  
1093 =head2 DescribeGlobalTable
1094  
1095 =over
1096  
1097 =item GlobalTableName => Str
1098  
1099  
1100 =back
1101  
1102 Each argument is described in detail in: L<Paws::DynamoDB::DescribeGlobalTable>
1103  
1104 Returns: a L<Paws::DynamoDB::DescribeGlobalTableOutput> instance
1105  
1106 Returns information about the specified global table.
1107  
1108 This operation only applies to Version 2017.11.29
1109 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html)
1110 of global tables. If you are using global tables Version 2019.11.21
1111 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html)
1112 you can use DescribeTable
1113 (https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DescribeTable.html)
1114 instead.
1115  
1116  
1117 =head2 DescribeGlobalTableSettings
1118  
1119 =over
1120  
1121 =item GlobalTableName => Str
1122  
1123  
1124 =back
1125  
1126 Each argument is described in detail in: L<Paws::DynamoDB::DescribeGlobalTableSettings>
1127  
1128 Returns: a L<Paws::DynamoDB::DescribeGlobalTableSettingsOutput> instance
1129  
1130 Describes Region-specific settings for a global table.
1131  
1132 This operation only applies to Version 2017.11.29
1133 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html)
1134 of global tables.
1135  
1136  
1137 =head2 DescribeKinesisStreamingDestination
1138  
1139 =over
1140  
1141 =item TableName => Str
1142  
1143  
1144 =back
1145  
1146 Each argument is described in detail in: L<Paws::DynamoDB::DescribeKinesisStreamingDestination>
1147  
1148 Returns: a L<Paws::DynamoDB::DescribeKinesisStreamingDestinationOutput> instance
1149  
1150 Returns information about the status of Kinesis streaming.
1151  
1152  
1153 =head2 DescribeLimits
1154  
1155  
1156  
1157  
1158  
1159  
1160 Each argument is described in detail in: L<Paws::DynamoDB::DescribeLimits>
1161  
1162 Returns: a L<Paws::DynamoDB::DescribeLimitsOutput> instance
1163  
1164 Returns the current provisioned-capacity quotas for your AWS account in
1165 a Region, both for the Region as a whole and for any one DynamoDB table
1166 that you create there.
1167  
1168 When you establish an AWS account, the account has initial quotas on
1169 the maximum read capacity units and write capacity units that you can
1170 provision across all of your DynamoDB tables in a given Region. Also,
1171 there are per-table quotas that apply when you create a table there.
1172 For more information, see Service, Account, and Table Quotas
1173 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Limits.html)
1174 page in the I<Amazon DynamoDB Developer Guide>.
1175  
1176 Although you can increase these quotas by filing a case at AWS Support
1177 Center (https://console.aws.amazon.com/support/home#/), obtaining the
1178 increase is not instantaneous. The C<DescribeLimits> action lets you
1179 write code to compare the capacity you are currently using to those
1180 quotas imposed by your account so that you have enough time to apply
1181 for an increase before you hit a quota.
1182  
1183 For example, you could use one of the AWS SDKs to do the following:
1184  
1185 =over
1186  
1187 =item 1.
1188  
1189 Call C<DescribeLimits> for a particular Region to obtain your current
1190 account quotas on provisioned capacity there.
1191  
1192 =item 2.
1193  
1194 Create a variable to hold the aggregate read capacity units provisioned
1195 for all your tables in that Region, and one to hold the aggregate write
1196 capacity units. Zero them both.
1197  
1198 =item 3.
1199  
1200 Call C<ListTables> to obtain a list of all your DynamoDB tables.
1201  
1202 =item 4.
1203  
1204 For each table name listed by C<ListTables>, do the following:
1205  
1206 =over
1207  
1208 =item *
1209  
1210 Call C<DescribeTable> with the table name.
1211  
1212 =item *
1213  
1214 Use the data returned by C<DescribeTable> to add the read capacity
1215 units and write capacity units provisioned for the table itself to your
1216 variables.
1217  
1218 =item *
1219  
1220 If the table has one or more global secondary indexes (GSIs), loop over
1221 these GSIs and add their provisioned capacity values to your variables
1222 as well.
1223  
1224 =back
1225  
1226 =item 5.
1227  
1228 Report the account quotas for that Region returned by
1229 C<DescribeLimits>, along with the total current provisioned capacity
1230 levels you have calculated.
1231  
1232 =back
1233  
1234 This will let you see whether you are getting close to your
1235 account-level quotas.
1236  
1237 The per-table quotas apply only when you are creating a new table. They
1238 restrict the sum of the provisioned capacity of the new table itself
1239 and all its global secondary indexes.
1240  
1241 For existing tables and their GSIs, DynamoDB doesn't let you increase
1242 provisioned capacity extremely rapidly, but the only quota that applies
1243 is that the aggregate provisioned capacity over all your tables and
1244 GSIs cannot exceed either of the per-account quotas.
1245  
1246 C<DescribeLimits> should only be called periodically. You can expect
1247 throttling errors if you call it more than once in a minute.
1248  
1249 The C<DescribeLimits> Request element has no content.
1250  
1251  
1252 =head2 DescribeTable
1253  
1254 =over
1255  
1256 =item TableName => Str
1257  
1258  
1259 =back
1260  
1261 Each argument is described in detail in: L<Paws::DynamoDB::DescribeTable>
1262  
1263 Returns: a L<Paws::DynamoDB::DescribeTableOutput> instance
1264  
1265 Returns information about the table, including the current status of
1266 the table, when it was created, the primary key schema, and any indexes
1267 on the table.
1268  
1269 If you issue a C<DescribeTable> request immediately after a
1270 C<CreateTable> request, DynamoDB might return a
1271 C<ResourceNotFoundException>. This is because C<DescribeTable> uses an
1272 eventually consistent query, and the metadata for your table might not
1273 be available at that moment. Wait for a few seconds, and then try the
1274 C<DescribeTable> request again.
1275  
1276  
1277 =head2 DescribeTableReplicaAutoScaling
1278  
1279 =over
1280  
1281 =item TableName => Str
1282  
1283  
1284 =back
1285  
1286 Each argument is described in detail in: L<Paws::DynamoDB::DescribeTableReplicaAutoScaling>
1287  
1288 Returns: a L<Paws::DynamoDB::DescribeTableReplicaAutoScalingOutput> instance
1289  
1290 Describes auto scaling settings across replicas of the global table at
1291 once.
1292  
1293 This operation only applies to Version 2019.11.21
1294 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html)
1295 of global tables.
1296  
1297  
1298 =head2 DescribeTimeToLive
1299  
1300 =over
1301  
1302 =item TableName => Str
1303  
1304  
1305 =back
1306  
1307 Each argument is described in detail in: L<Paws::DynamoDB::DescribeTimeToLive>
1308  
1309 Returns: a L<Paws::DynamoDB::DescribeTimeToLiveOutput> instance
1310  
1311 Gives a description of the Time to Live (TTL) status on the specified
1312 table.
1313  
1314  
1315 =head2 DisableKinesisStreamingDestination
1316  
1317 =over
1318  
1319 =item StreamArn => Str
1320  
1321 =item TableName => Str
1322  
1323  
1324 =back
1325  
1326 Each argument is described in detail in: L<Paws::DynamoDB::DisableKinesisStreamingDestination>
1327  
1328 Returns: a L<Paws::DynamoDB::KinesisStreamingDestinationOutput> instance
1329  
1330 Stops replication from the DynamoDB table to the Kinesis data stream.
1331 This is done without deleting either of the resources.
1332  
1333  
1334 =head2 EnableKinesisStreamingDestination
1335  
1336 =over
1337  
1338 =item StreamArn => Str
1339  
1340 =item TableName => Str
1341  
1342  
1343 =back
1344  
1345 Each argument is described in detail in: L<Paws::DynamoDB::EnableKinesisStreamingDestination>
1346  
1347 Returns: a L<Paws::DynamoDB::KinesisStreamingDestinationOutput> instance
1348  
1349 Starts table data replication to the specified Kinesis data stream at a
1350 timestamp chosen during the enable workflow. If this operation doesn't
1351 return results immediately, use DescribeKinesisStreamingDestination to
1352 check if streaming to the Kinesis data stream is ACTIVE.
1353  
1354  
1355 =head2 ExecuteStatement
1356  
1357 =over
1358  
1359 =item Statement => Str
1360  
1361 =item [ConsistentRead => Bool]
1362  
1363 =item [NextToken => Str]
1364  
1365 =item [Parameters => ArrayRef[L<Paws::DynamoDB::AttributeValue>]]
1366  
1367  
1368 =back
1369  
1370 Each argument is described in detail in: L<Paws::DynamoDB::ExecuteStatement>
1371  
1372 Returns: a L<Paws::DynamoDB::ExecuteStatementOutput> instance
1373  
1374 This operation allows you to perform reads and singleton writes on data
1375 stored in DynamoDB, using PartiQL.
1376  
1377  
1378 =head2 ExecuteTransaction
1379  
1380 =over
1381  
1382 =item TransactStatements => ArrayRef[L<Paws::DynamoDB::ParameterizedStatement>]
1383  
1384 =item [ClientRequestToken => Str]
1385  
1386  
1387 =back
1388  
1389 Each argument is described in detail in: L<Paws::DynamoDB::ExecuteTransaction>
1390  
1391 Returns: a L<Paws::DynamoDB::ExecuteTransactionOutput> instance
1392  
1393 This operation allows you to perform transactional reads or writes on
1394 data stored in DynamoDB, using PartiQL.
1395  
1396  
1397 =head2 ExportTableToPointInTime
1398  
1399 =over
1400  
1401 =item S3Bucket => Str
1402  
1403 =item TableArn => Str
1404  
1405 =item [ClientToken => Str]
1406  
1407 =item [ExportFormat => Str]
1408  
1409 =item [ExportTime => Str]
1410  
1411 =item [S3BucketOwner => Str]
1412  
1413 =item [S3Prefix => Str]
1414  
1415 =item [S3SseAlgorithm => Str]
1416  
1417 =item [S3SseKmsKeyId => Str]
1418  
1419  
1420 =back
1421  
1422 Each argument is described in detail in: L<Paws::DynamoDB::ExportTableToPointInTime>
1423  
1424 Returns: a L<Paws::DynamoDB::ExportTableToPointInTimeOutput> instance
1425  
1426 Exports table data to an S3 bucket. The table must have point in time
1427 recovery enabled, and you can export data from any time within the
1428 point in time recovery window.
1429  
1430  
1431 =head2 GetItem
1432  
1433 =over
1434  
1435 =item Key => L<Paws::DynamoDB::Key>
1436  
1437 =item TableName => Str
1438  
1439 =item [AttributesToGet => ArrayRef[Str|Undef]]
1440  
1441 =item [ConsistentRead => Bool]
1442  
1443 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
1444  
1445 =item [ProjectionExpression => Str]
1446  
1447 =item [ReturnConsumedCapacity => Str]
1448  
1449  
1450 =back
1451  
1452 Each argument is described in detail in: L<Paws::DynamoDB::GetItem>
1453  
1454 Returns: a L<Paws::DynamoDB::GetItemOutput> instance
1455  
1456 The C<GetItem> operation returns a set of attributes for the item with
1457 the given primary key. If there is no matching item, C<GetItem> does
1458 not return any data and there will be no C<Item> element in the
1459 response.
1460  
1461 C<GetItem> provides an eventually consistent read by default. If your
1462 application requires a strongly consistent read, set C<ConsistentRead>
1463 to C<true>. Although a strongly consistent read might take more time
1464 than an eventually consistent read, it always returns the last updated
1465 value.
1466  
1467  
1468 =head2 ListBackups
1469  
1470 =over
1471  
1472 =item [BackupType => Str]
1473  
1474 =item [ExclusiveStartBackupArn => Str]
1475  
1476 =item [Limit => Int]
1477  
1478 =item [TableName => Str]
1479  
1480 =item [TimeRangeLowerBound => Str]
1481  
1482 =item [TimeRangeUpperBound => Str]
1483  
1484  
1485 =back
1486  
1487 Each argument is described in detail in: L<Paws::DynamoDB::ListBackups>
1488  
1489 Returns: a L<Paws::DynamoDB::ListBackupsOutput> instance
1490  
1491 List backups associated with an AWS account. To list backups for a
1492 given table, specify C<TableName>. C<ListBackups> returns a paginated
1493 list of results with at most 1 MB worth of items in a page. You can
1494 also specify a maximum number of entries to be returned in a page.
1495  
1496 In the request, start time is inclusive, but end time is exclusive.
1497 Note that these boundaries are for the time at which the original
1498 backup was requested.
1499  
1500 You can call C<ListBackups> a maximum of five times per second.
1501  
1502  
1503 =head2 ListContributorInsights
1504  
1505 =over
1506  
1507 =item [MaxResults => Int]
1508  
1509 =item [NextToken => Str]
1510  
1511 =item [TableName => Str]
1512  
1513  
1514 =back
1515  
1516 Each argument is described in detail in: L<Paws::DynamoDB::ListContributorInsights>
1517  
1518 Returns: a L<Paws::DynamoDB::ListContributorInsightsOutput> instance
1519  
1520 Returns a list of ContributorInsightsSummary for a table and all its
1521 global secondary indexes.
1522  
1523  
1524 =head2 ListExports
1525  
1526 =over
1527  
1528 =item [MaxResults => Int]
1529  
1530 =item [NextToken => Str]
1531  
1532 =item [TableArn => Str]
1533  
1534  
1535 =back
1536  
1537 Each argument is described in detail in: L<Paws::DynamoDB::ListExports>
1538  
1539 Returns: a L<Paws::DynamoDB::ListExportsOutput> instance
1540  
1541 Lists completed exports within the past 90 days.
1542  
1543  
1544 =head2 ListGlobalTables
1545  
1546 =over
1547  
1548 =item [ExclusiveStartGlobalTableName => Str]
1549  
1550 =item [Limit => Int]
1551  
1552 =item [RegionName => Str]
1553  
1554  
1555 =back
1556  
1557 Each argument is described in detail in: L<Paws::DynamoDB::ListGlobalTables>
1558  
1559 Returns: a L<Paws::DynamoDB::ListGlobalTablesOutput> instance
1560  
1561 Lists all global tables that have a replica in the specified Region.
1562  
1563 This operation only applies to Version 2017.11.29
1564 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V1.html)
1565 of global tables.
1566  
1567  
1568 =head2 ListTables
1569  
1570 =over
1571  
1572 =item [ExclusiveStartTableName => Str]
1573  
1574 =item [Limit => Int]
1575  
1576  
1577 =back
1578  
1579 Each argument is described in detail in: L<Paws::DynamoDB::ListTables>
1580  
1581 Returns: a L<Paws::DynamoDB::ListTablesOutput> instance
1582  
1583 Returns an array of table names associated with the current account and
1584 endpoint. The output from C<ListTables> is paginated, with each page
1585 returning a maximum of 100 table names.
1586  
1587  
1588 =head2 ListTagsOfResource
1589  
1590 =over
1591  
1592 =item ResourceArn => Str
1593  
1594 =item [NextToken => Str]
1595  
1596  
1597 =back
1598  
1599 Each argument is described in detail in: L<Paws::DynamoDB::ListTagsOfResource>
1600  
1601 Returns: a L<Paws::DynamoDB::ListTagsOfResourceOutput> instance
1602  
1603 List all tags on an Amazon DynamoDB resource. You can call
1604 ListTagsOfResource up to 10 times per second, per account.
1605  
1606 For an overview on tagging DynamoDB resources, see Tagging for DynamoDB
1607 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html)
1608 in the I<Amazon DynamoDB Developer Guide>.
1609  
1610  
1611 =head2 PutItem
1612  
1613 =over
1614  
1615 =item Item => L<Paws::DynamoDB::PutItemInputAttributeMap>
1616  
1617 =item TableName => Str
1618  
1619 =item [ConditionalOperator => Str]
1620  
1621 =item [ConditionExpression => Str]
1622  
1623 =item [Expected => L<Paws::DynamoDB::ExpectedAttributeMap>]
1624  
1625 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
1626  
1627 =item [ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>]
1628  
1629 =item [ReturnConsumedCapacity => Str]
1630  
1631 =item [ReturnItemCollectionMetrics => Str]
1632  
1633 =item [ReturnValues => Str]
1634  
1635  
1636 =back
1637  
1638 Each argument is described in detail in: L<Paws::DynamoDB::PutItem>
1639  
1640 Returns: a L<Paws::DynamoDB::PutItemOutput> instance
1641  
1642 Creates a new item, or replaces an old item with a new item. If an item
1643 that has the same primary key as the new item already exists in the
1644 specified table, the new item completely replaces the existing item.
1645 You can perform a conditional put operation (add a new item if one with
1646 the specified primary key doesn't exist), or replace an existing item
1647 if it has certain attribute values. You can return the item's attribute
1648 values in the same operation, using the C<ReturnValues> parameter.
1649  
1650 This topic provides general information about the C<PutItem> API.
1651  
1652 For information on how to call the C<PutItem> API using the AWS SDK in
1653 specific languages, see the following:
1654  
1655 =over
1656  
1657 =item *
1658  
1659 PutItem in the AWS Command Line Interface
1660 (http://docs.aws.amazon.com/goto/aws-cli/dynamodb-2012-08-10/PutItem)
1661  
1662 =item *
1663  
1664 PutItem in the AWS SDK for .NET
1665 (http://docs.aws.amazon.com/goto/DotNetSDKV3/dynamodb-2012-08-10/PutItem)
1666  
1667 =item *
1668  
1669 PutItem in the AWS SDK for C++
1670 (http://docs.aws.amazon.com/goto/SdkForCpp/dynamodb-2012-08-10/PutItem)
1671  
1672 =item *
1673  
1674 PutItem in the AWS SDK for Go
1675 (http://docs.aws.amazon.com/goto/SdkForGoV1/dynamodb-2012-08-10/PutItem)
1676  
1677 =item *
1678  
1679 PutItem in the AWS SDK for Java
1680 (http://docs.aws.amazon.com/goto/SdkForJava/dynamodb-2012-08-10/PutItem)
1681  
1682 =item *
1683  
1684 PutItem in the AWS SDK for JavaScript
1685 (http://docs.aws.amazon.com/goto/AWSJavaScriptSDK/dynamodb-2012-08-10/PutItem)
1686  
1687 =item *
1688  
1689 PutItem in the AWS SDK for PHP V3
1690 (http://docs.aws.amazon.com/goto/SdkForPHPV3/dynamodb-2012-08-10/PutItem)
1691  
1692 =item *
1693  
1694 PutItem in the AWS SDK for Python
1695 (http://docs.aws.amazon.com/goto/boto3/dynamodb-2012-08-10/PutItem)
1696  
1697 =item *
1698  
1699 PutItem in the AWS SDK for Ruby V2
1700 (http://docs.aws.amazon.com/goto/SdkForRubyV2/dynamodb-2012-08-10/PutItem)
1701  
1702 =back
1703  
1704 When you add an item, the primary key attributes are the only required
1705 attributes. Attribute values cannot be null.
1706  
1707 Empty String and Binary attribute values are allowed. Attribute values
1708 of type String and Binary must have a length greater than zero if the
1709 attribute is used as a key attribute for a table or index. Set type
1710 attributes cannot be empty.
1711  
1712 Invalid Requests with empty values will be rejected with a
1713 C<ValidationException> exception.
1714  
1715 To prevent a new item from replacing an existing item, use a
1716 conditional expression that contains the C<attribute_not_exists>
1717 function with the name of the attribute being used as the partition key
1718 for the table. Since every record must contain that attribute, the
1719 C<attribute_not_exists> function will only succeed if no matching item
1720 exists.
1721  
1722 For more information about C<PutItem>, see Working with Items
1723 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html)
1724 in the I<Amazon DynamoDB Developer Guide>.
1725  
1726  
1727 =head2 Query
1728  
1729 =over
1730  
1731 =item TableName => Str
1732  
1733 =item [AttributesToGet => ArrayRef[Str|Undef]]
1734  
1735 =item [ConditionalOperator => Str]
1736  
1737 =item [ConsistentRead => Bool]
1738  
1739 =item [ExclusiveStartKey => L<Paws::DynamoDB::Key>]
1740  
1741 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
1742  
1743 =item [ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>]
1744  
1745 =item [FilterExpression => Str]
1746  
1747 =item [IndexName => Str]
1748  
1749 =item [KeyConditionExpression => Str]
1750  
1751 =item [KeyConditions => L<Paws::DynamoDB::KeyConditions>]
1752  
1753 =item [Limit => Int]
1754  
1755 =item [ProjectionExpression => Str]
1756  
1757 =item [QueryFilter => L<Paws::DynamoDB::FilterConditionMap>]
1758  
1759 =item [ReturnConsumedCapacity => Str]
1760  
1761 =item [ScanIndexForward => Bool]
1762  
1763 =item [Select => Str]
1764  
1765  
1766 =back
1767  
1768 Each argument is described in detail in: L<Paws::DynamoDB::Query>
1769  
1770 Returns: a L<Paws::DynamoDB::QueryOutput> instance
1771  
1772 The C<Query> operation finds items based on primary key values. You can
1773 query any table or secondary index that has a composite primary key (a
1774 partition key and a sort key).
1775  
1776 Use the C<KeyConditionExpression> parameter to provide a specific value
1777 for the partition key. The C<Query> operation will return all of the
1778 items from the table or index with that partition key value. You can
1779 optionally narrow the scope of the C<Query> operation by specifying a
1780 sort key value and a comparison operator in C<KeyConditionExpression>.
1781 To further refine the C<Query> results, you can optionally provide a
1782 C<FilterExpression>. A C<FilterExpression> determines which items
1783 within the results should be returned to you. All of the other results
1784 are discarded.
1785  
1786 A C<Query> operation always returns a result set. If no matching items
1787 are found, the result set will be empty. Queries that do not return
1788 results consume the minimum number of read capacity units for that type
1789 of read operation.
1790  
1791 DynamoDB calculates the number of read capacity units consumed based on
1792 item size, not on the amount of data that is returned to an
1793 application. The number of capacity units consumed will be the same
1794 whether you request all of the attributes (the default behavior) or
1795 just some of them (using a projection expression). The number will also
1796 be the same whether or not you use a C<FilterExpression>.
1797  
1798 C<Query> results are always sorted by the sort key value. If the data
1799 type of the sort key is Number, the results are returned in numeric
1800 order; otherwise, the results are returned in order of UTF-8 bytes. By
1801 default, the sort order is ascending. To reverse the order, set the
1802 C<ScanIndexForward> parameter to false.
1803  
1804 A single C<Query> operation will read up to the maximum number of items
1805 set (if using the C<Limit> parameter) or a maximum of 1 MB of data and
1806 then apply any filtering to the results using C<FilterExpression>. If
1807 C<LastEvaluatedKey> is present in the response, you will need to
1808 paginate the result set. For more information, see Paginating the
1809 Results
1810 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Query.html#Query.Pagination)
1811 in the I<Amazon DynamoDB Developer Guide>.
1812  
1813 C<FilterExpression> is applied after a C<Query> finishes, but before
1814 the results are returned. A C<FilterExpression> cannot contain
1815 partition key or sort key attributes. You need to specify those
1816 attributes in the C<KeyConditionExpression>.
1817  
1818 A C<Query> operation can return an empty result set and a
1819 C<LastEvaluatedKey> if all the items read for the page of results are
1820 filtered out.
1821  
1822 You can query a table, a local secondary index, or a global secondary
1823 index. For a query on a table or on a local secondary index, you can
1824 set the C<ConsistentRead> parameter to C<true> and obtain a strongly
1825 consistent result. Global secondary indexes support eventually
1826 consistent reads only, so do not specify C<ConsistentRead> when
1827 querying a global secondary index.
1828  
1829  
1830 =head2 RestoreTableFromBackup
1831  
1832 =over
1833  
1834 =item BackupArn => Str
1835  
1836 =item TargetTableName => Str
1837  
1838 =item [BillingModeOverride => Str]
1839  
1840 =item [GlobalSecondaryIndexOverride => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndex>]]
1841  
1842 =item [LocalSecondaryIndexOverride => ArrayRef[L<Paws::DynamoDB::LocalSecondaryIndex>]]
1843  
1844 =item [ProvisionedThroughputOverride => L<Paws::DynamoDB::ProvisionedThroughput>]
1845  
1846 =item [SSESpecificationOverride => L<Paws::DynamoDB::SSESpecification>]
1847  
1848  
1849 =back
1850  
1851 Each argument is described in detail in: L<Paws::DynamoDB::RestoreTableFromBackup>
1852  
1853 Returns: a L<Paws::DynamoDB::RestoreTableFromBackupOutput> instance
1854  
1855 Creates a new table from an existing backup. Any number of users can
1856 execute up to 4 concurrent restores (any type of restore) in a given
1857 account.
1858  
1859 You can call C<RestoreTableFromBackup> at a maximum rate of 10 times
1860 per second.
1861  
1862 You must manually set up the following on the restored table:
1863  
1864 =over
1865  
1866 =item *
1867  
1868 Auto scaling policies
1869  
1870 =item *
1871  
1872 IAM policies
1873  
1874 =item *
1875  
1876 Amazon CloudWatch metrics and alarms
1877  
1878 =item *
1879  
1880 Tags
1881  
1882 =item *
1883  
1884 Stream settings
1885  
1886 =item *
1887  
1888 Time to Live (TTL) settings
1889  
1890 =back
1891  
1892  
1893  
1894 =head2 RestoreTableToPointInTime
1895  
1896 =over
1897  
1898 =item TargetTableName => Str
1899  
1900 =item [BillingModeOverride => Str]
1901  
1902 =item [GlobalSecondaryIndexOverride => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndex>]]
1903  
1904 =item [LocalSecondaryIndexOverride => ArrayRef[L<Paws::DynamoDB::LocalSecondaryIndex>]]
1905  
1906 =item [ProvisionedThroughputOverride => L<Paws::DynamoDB::ProvisionedThroughput>]
1907  
1908 =item [RestoreDateTime => Str]
1909  
1910 =item [SourceTableArn => Str]
1911  
1912 =item [SourceTableName => Str]
1913  
1914 =item [SSESpecificationOverride => L<Paws::DynamoDB::SSESpecification>]
1915  
1916 =item [UseLatestRestorableTime => Bool]
1917  
1918  
1919 =back
1920  
1921 Each argument is described in detail in: L<Paws::DynamoDB::RestoreTableToPointInTime>
1922  
1923 Returns: a L<Paws::DynamoDB::RestoreTableToPointInTimeOutput> instance
1924  
1925 Restores the specified table to the specified point in time within
1926 C<EarliestRestorableDateTime> and C<LatestRestorableDateTime>. You can
1927 restore your table to any point in time during the last 35 days. Any
1928 number of users can execute up to 4 concurrent restores (any type of
1929 restore) in a given account.
1930  
1931 When you restore using point in time recovery, DynamoDB restores your
1932 table data to the state based on the selected date and time
1933 (day:hour:minute:second) to a new table.
1934  
1935 Along with data, the following are also included on the new restored
1936 table using point in time recovery:
1937  
1938 =over
1939  
1940 =item *
1941  
1942 Global secondary indexes (GSIs)
1943  
1944 =item *
1945  
1946 Local secondary indexes (LSIs)
1947  
1948 =item *
1949  
1950 Provisioned read and write capacity
1951  
1952 =item *
1953  
1954 Encryption settings
1955  
1956 All these settings come from the current settings of the source table
1957 at the time of restore.
1958  
1959 =back
1960  
1961 You must manually set up the following on the restored table:
1962  
1963 =over
1964  
1965 =item *
1966  
1967 Auto scaling policies
1968  
1969 =item *
1970  
1971 IAM policies
1972  
1973 =item *
1974  
1975 Amazon CloudWatch metrics and alarms
1976  
1977 =item *
1978  
1979 Tags
1980  
1981 =item *
1982  
1983 Stream settings
1984  
1985 =item *
1986  
1987 Time to Live (TTL) settings
1988  
1989 =item *
1990  
1991 Point in time recovery settings
1992  
1993 =back
1994  
1995  
1996  
1997 =head2 Scan
1998  
1999 =over
2000  
2001 =item TableName => Str
2002  
2003 =item [AttributesToGet => ArrayRef[Str|Undef]]
2004  
2005 =item [ConditionalOperator => Str]
2006  
2007 =item [ConsistentRead => Bool]
2008  
2009 =item [ExclusiveStartKey => L<Paws::DynamoDB::Key>]
2010  
2011 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
2012  
2013 =item [ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>]
2014  
2015 =item [FilterExpression => Str]
2016  
2017 =item [IndexName => Str]
2018  
2019 =item [Limit => Int]
2020  
2021 =item [ProjectionExpression => Str]
2022  
2023 =item [ReturnConsumedCapacity => Str]
2024  
2025 =item [ScanFilter => L<Paws::DynamoDB::FilterConditionMap>]
2026  
2027 =item [Segment => Int]
2028  
2029 =item [Select => Str]
2030  
2031 =item [TotalSegments => Int]
2032  
2033  
2034 =back
2035  
2036 Each argument is described in detail in: L<Paws::DynamoDB::Scan>
2037  
2038 Returns: a L<Paws::DynamoDB::ScanOutput> instance
2039  
2040 The C<Scan> operation returns one or more items and item attributes by
2041 accessing every item in a table or a secondary index. To have DynamoDB
2042 return fewer items, you can provide a C<FilterExpression> operation.
2043  
2044 If the total number of scanned items exceeds the maximum dataset size
2045 limit of 1 MB, the scan stops and results are returned to the user as a
2046 C<LastEvaluatedKey> value to continue the scan in a subsequent
2047 operation. The results also include the number of items exceeding the
2048 limit. A scan can result in no table data meeting the filter criteria.
2049  
2050 A single C<Scan> operation reads up to the maximum number of items set
2051 (if using the C<Limit> parameter) or a maximum of 1 MB of data and then
2052 apply any filtering to the results using C<FilterExpression>. If
2053 C<LastEvaluatedKey> is present in the response, you need to paginate
2054 the result set. For more information, see Paginating the Results
2055 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.Pagination)
2056 in the I<Amazon DynamoDB Developer Guide>.
2057  
2058 C<Scan> operations proceed sequentially; however, for faster
2059 performance on a large table or secondary index, applications can
2060 request a parallel C<Scan> operation by providing the C<Segment> and
2061 C<TotalSegments> parameters. For more information, see Parallel Scan
2062 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html#Scan.ParallelScan)
2063 in the I<Amazon DynamoDB Developer Guide>.
2064  
2065 C<Scan> uses eventually consistent reads when accessing the data in a
2066 table; therefore, the result set might not include the changes to data
2067 in the table immediately before the operation began. If you need a
2068 consistent copy of the data, as of the time that the C<Scan> begins,
2069 you can set the C<ConsistentRead> parameter to C<true>.
2070  
2071  
2072 =head2 TagResource
2073  
2074 =over
2075  
2076 =item ResourceArn => Str
2077  
2078 =item Tags => ArrayRef[L<Paws::DynamoDB::Tag>]
2079  
2080  
2081 =back
2082  
2083 Each argument is described in detail in: L<Paws::DynamoDB::TagResource>
2084  
2085 Returns: nothing
2086  
2087 Associate a set of tags with an Amazon DynamoDB resource. You can then
2088 activate these user-defined tags so that they appear on the Billing and
2089 Cost Management console for cost allocation tracking. You can call
2090 TagResource up to five times per second, per account.
2091  
2092 For an overview on tagging DynamoDB resources, see Tagging for DynamoDB
2093 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html)
2094 in the I<Amazon DynamoDB Developer Guide>.
2095  
2096  
2097 =head2 TransactGetItems
2098  
2099 =over
2100  
2101 =item TransactItems => ArrayRef[L<Paws::DynamoDB::TransactGetItem>]
2102  
2103 =item [ReturnConsumedCapacity => Str]
2104  
2105  
2106 =back
2107  
2108 Each argument is described in detail in: L<Paws::DynamoDB::TransactGetItems>
2109  
2110 Returns: a L<Paws::DynamoDB::TransactGetItemsOutput> instance
2111  
2112 C<TransactGetItems> is a synchronous operation that atomically
2113 retrieves multiple items from one or more tables (but not from indexes)
2114 in a single account and Region. A C<TransactGetItems> call can contain
2115 up to 25 C<TransactGetItem> objects, each of which contains a C<Get>
2116 structure that specifies an item to retrieve from a table in the
2117 account and Region. A call to C<TransactGetItems> cannot retrieve items
2118 from tables in more than one AWS account or Region. The aggregate size
2119 of the items in the transaction cannot exceed 4 MB.
2120  
2121 DynamoDB rejects the entire C<TransactGetItems> request if any of the
2122 following is true:
2123  
2124 =over
2125  
2126 =item *
2127  
2128 A conflicting operation is in the process of updating an item to be
2129 read.
2130  
2131 =item *
2132  
2133 There is insufficient provisioned capacity for the transaction to be
2134 completed.
2135  
2136 =item *
2137  
2138 There is a user error, such as an invalid data format.
2139  
2140 =item *
2141  
2142 The aggregate size of the items in the transaction cannot exceed 4 MB.
2143  
2144 =back
2145  
2146  
2147  
2148 =head2 TransactWriteItems
2149  
2150 =over
2151  
2152 =item TransactItems => ArrayRef[L<Paws::DynamoDB::TransactWriteItem>]
2153  
2154 =item [ClientRequestToken => Str]
2155  
2156 =item [ReturnConsumedCapacity => Str]
2157  
2158 =item [ReturnItemCollectionMetrics => Str]
2159  
2160  
2161 =back
2162  
2163 Each argument is described in detail in: L<Paws::DynamoDB::TransactWriteItems>
2164  
2165 Returns: a L<Paws::DynamoDB::TransactWriteItemsOutput> instance
2166  
2167 C<TransactWriteItems> is a synchronous write operation that groups up
2168 to 25 action requests. These actions can target items in different
2169 tables, but not in different AWS accounts or Regions, and no two
2170 actions can target the same item. For example, you cannot both
2171 C<ConditionCheck> and C<Update> the same item. The aggregate size of
2172 the items in the transaction cannot exceed 4 MB.
2173  
2174 The actions are completed atomically so that either all of them
2175 succeed, or all of them fail. They are defined by the following
2176 objects:
2177  
2178 =over
2179  
2180 =item *
2181  
2182 C<Put> E<151> Initiates a C<PutItem> operation to write a new item.
2183 This structure specifies the primary key of the item to be written, the
2184 name of the table to write it in, an optional condition expression that
2185 must be satisfied for the write to succeed, a list of the item's
2186 attributes, and a field indicating whether to retrieve the item's
2187 attributes if the condition is not met.
2188  
2189 =item *
2190  
2191 C<Update> E<151> Initiates an C<UpdateItem> operation to update an
2192 existing item. This structure specifies the primary key of the item to
2193 be updated, the name of the table where it resides, an optional
2194 condition expression that must be satisfied for the update to succeed,
2195 an expression that defines one or more attributes to be updated, and a
2196 field indicating whether to retrieve the item's attributes if the
2197 condition is not met.
2198  
2199 =item *
2200  
2201 C<Delete> E<151> Initiates a C<DeleteItem> operation to delete an
2202 existing item. This structure specifies the primary key of the item to
2203 be deleted, the name of the table where it resides, an optional
2204 condition expression that must be satisfied for the deletion to
2205 succeed, and a field indicating whether to retrieve the item's
2206 attributes if the condition is not met.
2207  
2208 =item *
2209  
2210 C<ConditionCheck> E<151> Applies a condition to an item that is not
2211 being modified by the transaction. This structure specifies the primary
2212 key of the item to be checked, the name of the table where it resides,
2213 a condition expression that must be satisfied for the transaction to
2214 succeed, and a field indicating whether to retrieve the item's
2215 attributes if the condition is not met.
2216  
2217 =back
2218  
2219 DynamoDB rejects the entire C<TransactWriteItems> request if any of the
2220 following is true:
2221  
2222 =over
2223  
2224 =item *
2225  
2226 A condition in one of the condition expressions is not met.
2227  
2228 =item *
2229  
2230 An ongoing operation is in the process of updating the same item.
2231  
2232 =item *
2233  
2234 There is insufficient provisioned capacity for the transaction to be
2235 completed.
2236  
2237 =item *
2238  
2239 An item size becomes too large (bigger than 400 KB), a local secondary
2240 index (LSI) becomes too large, or a similar validation error occurs
2241 because of changes made by the transaction.
2242  
2243 =item *
2244  
2245 The aggregate size of the items in the transaction exceeds 4 MB.
2246  
2247 =item *
2248  
2249 There is a user error, such as an invalid data format.
2250  
2251 =back
2252  
2253  
2254  
2255 =head2 UntagResource
2256  
2257 =over
2258  
2259 =item ResourceArn => Str
2260  
2261 =item TagKeys => ArrayRef[Str|Undef]
2262  
2263  
2264 =back
2265  
2266 Each argument is described in detail in: L<Paws::DynamoDB::UntagResource>
2267  
2268 Returns: nothing
2269  
2270 Removes the association of tags from an Amazon DynamoDB resource. You
2271 can call C<UntagResource> up to five times per second, per account.
2272  
2273 For an overview on tagging DynamoDB resources, see Tagging for DynamoDB
2274 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Tagging.html)
2275 in the I<Amazon DynamoDB Developer Guide>.
2276  
2277  
2278 =head2 UpdateContinuousBackups
2279  
2280 =over
2281  
2282 =item PointInTimeRecoverySpecification => L<Paws::DynamoDB::PointInTimeRecoverySpecification>
2283  
2284 =item TableName => Str
2285  
2286  
2287 =back
2288  
2289 Each argument is described in detail in: L<Paws::DynamoDB::UpdateContinuousBackups>
2290  
2291 Returns: a L<Paws::DynamoDB::UpdateContinuousBackupsOutput> instance
2292  
2293 C<UpdateContinuousBackups> enables or disables point in time recovery
2294 for the specified table. A successful C<UpdateContinuousBackups> call
2295 returns the current C<ContinuousBackupsDescription>. Continuous backups
2296 are C<ENABLED> on all tables at table creation. If point in time
2297 recovery is enabled, C<PointInTimeRecoveryStatus> will be set to
2298 ENABLED.
2299  
2300 Once continuous backups and point in time recovery are enabled, you can
2301 restore to any point in time within C<EarliestRestorableDateTime> and
2302 C<LatestRestorableDateTime>.
2303  
2304 C<LatestRestorableDateTime> is typically 5 minutes before the current
2305 time. You can restore your table to any point in time during the last
2306 35 days.
2307  
2308  
2309 =head2 UpdateContributorInsights
2310  
2311 =over
2312  
2313 =item ContributorInsightsAction => Str
2314  
2315 =item TableName => Str
2316  
2317 =item [IndexName => Str]
2318  
2319  
2320 =back
2321  
2322 Each argument is described in detail in: L<Paws::DynamoDB::UpdateContributorInsights>
2323  
2324 Returns: a L<Paws::DynamoDB::UpdateContributorInsightsOutput> instance
2325  
2326 Updates the status for contributor insights for a specific table or
2327 index.
2328  
2329  
2330 =head2 UpdateGlobalTable
2331  
2332 =over
2333  
2334 =item GlobalTableName => Str
2335  
2336 =item ReplicaUpdates => ArrayRef[L<Paws::DynamoDB::ReplicaUpdate>]
2337  
2338  
2339 =back
2340  
2341 Each argument is described in detail in: L<Paws::DynamoDB::UpdateGlobalTable>
2342  
2343 Returns: a L<Paws::DynamoDB::UpdateGlobalTableOutput> instance
2344  
2345 Adds or removes replicas in the specified global table. The global
2346 table must already exist to be able to use this operation. Any replica
2347 to be added must be empty, have the same name as the global table, have
2348 the same key schema, have DynamoDB Streams enabled, and have the same
2349 provisioned and maximum write capacity units.
2350  
2351 Although you can use C<UpdateGlobalTable> to add replicas and remove
2352 replicas in a single request, for simplicity we recommend that you
2353 issue separate requests for adding or removing replicas.
2354  
2355 If global secondary indexes are specified, then the following
2356 conditions must also be met:
2357  
2358 =over
2359  
2360 =item *
2361  
2362 The global secondary indexes must have the same name.
2363  
2364 =item *
2365  
2366 The global secondary indexes must have the same hash key and sort key
2367 (if present).
2368  
2369 =item *
2370  
2371 The global secondary indexes must have the same provisioned and maximum
2372 write capacity units.
2373  
2374 =back
2375  
2376  
2377  
2378 =head2 UpdateGlobalTableSettings
2379  
2380 =over
2381  
2382 =item GlobalTableName => Str
2383  
2384 =item [GlobalTableBillingMode => Str]
2385  
2386 =item [GlobalTableGlobalSecondaryIndexSettingsUpdate => ArrayRef[L<Paws::DynamoDB::GlobalTableGlobalSecondaryIndexSettingsUpdate>]]
2387  
2388 =item [GlobalTableProvisionedWriteCapacityAutoScalingSettingsUpdate => L<Paws::DynamoDB::AutoScalingSettingsUpdate>]
2389  
2390 =item [GlobalTableProvisionedWriteCapacityUnits => Int]
2391  
2392 =item [ReplicaSettingsUpdate => ArrayRef[L<Paws::DynamoDB::ReplicaSettingsUpdate>]]
2393  
2394  
2395 =back
2396  
2397 Each argument is described in detail in: L<Paws::DynamoDB::UpdateGlobalTableSettings>
2398  
2399 Returns: a L<Paws::DynamoDB::UpdateGlobalTableSettingsOutput> instance
2400  
2401 Updates settings for a global table.
2402  
2403  
2404 =head2 UpdateItem
2405  
2406 =over
2407  
2408 =item Key => L<Paws::DynamoDB::Key>
2409  
2410 =item TableName => Str
2411  
2412 =item [AttributeUpdates => L<Paws::DynamoDB::AttributeUpdates>]
2413  
2414 =item [ConditionalOperator => Str]
2415  
2416 =item [ConditionExpression => Str]
2417  
2418 =item [Expected => L<Paws::DynamoDB::ExpectedAttributeMap>]
2419  
2420 =item [ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>]
2421  
2422 =item [ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>]
2423  
2424 =item [ReturnConsumedCapacity => Str]
2425  
2426 =item [ReturnItemCollectionMetrics => Str]
2427  
2428 =item [ReturnValues => Str]
2429  
2430 =item [UpdateExpression => Str]
2431  
2432  
2433 =back
2434  
2435 Each argument is described in detail in: L<Paws::DynamoDB::UpdateItem>
2436  
2437 Returns: a L<Paws::DynamoDB::UpdateItemOutput> instance
2438  
2439 Edits an existing item's attributes, or adds a new item to the table if
2440 it does not already exist. You can put, delete, or add attribute
2441 values. You can also perform a conditional update on an existing item
2442 (insert a new attribute name-value pair if it doesn't exist, or replace
2443 an existing name-value pair if it has certain expected attribute
2444 values).
2445  
2446 You can also return the item's attribute values in the same
2447 C<UpdateItem> operation using the C<ReturnValues> parameter.
2448  
2449  
2450 =head2 UpdateTable
2451  
2452 =over
2453  
2454 =item TableName => Str
2455  
2456 =item [AttributeDefinitions => ArrayRef[L<Paws::DynamoDB::AttributeDefinition>]]
2457  
2458 =item [BillingMode => Str]
2459  
2460 =item [GlobalSecondaryIndexUpdates => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndexUpdate>]]
2461  
2462 =item [ProvisionedThroughput => L<Paws::DynamoDB::ProvisionedThroughput>]
2463  
2464 =item [ReplicaUpdates => ArrayRef[L<Paws::DynamoDB::ReplicationGroupUpdate>]]
2465  
2466 =item [SSESpecification => L<Paws::DynamoDB::SSESpecification>]
2467  
2468 =item [StreamSpecification => L<Paws::DynamoDB::StreamSpecification>]
2469  
2470  
2471 =back
2472  
2473 Each argument is described in detail in: L<Paws::DynamoDB::UpdateTable>
2474  
2475 Returns: a L<Paws::DynamoDB::UpdateTableOutput> instance
2476  
2477 Modifies the provisioned throughput settings, global secondary indexes,
2478 or DynamoDB Streams settings for a given table.
2479  
2480 You can only perform one of the following operations at once:
2481  
2482 =over
2483  
2484 =item *
2485  
2486 Modify the provisioned throughput settings of the table.
2487  
2488 =item *
2489  
2490 Enable or disable DynamoDB Streams on the table.
2491  
2492 =item *
2493  
2494 Remove a global secondary index from the table.
2495  
2496 =item *
2497  
2498 Create a new global secondary index on the table. After the index
2499 begins backfilling, you can use C<UpdateTable> to perform other
2500 operations.
2501  
2502 =back
2503  
2504 C<UpdateTable> is an asynchronous operation; while it is executing, the
2505 table status changes from C<ACTIVE> to C<UPDATING>. While it is
2506 C<UPDATING>, you cannot issue another C<UpdateTable> request. When the
2507 table returns to the C<ACTIVE> state, the C<UpdateTable> operation is
2508 complete.
2509  
2510  
2511 =head2 UpdateTableReplicaAutoScaling
2512  
2513 =over
2514  
2515 =item TableName => Str
2516  
2517 =item [GlobalSecondaryIndexUpdates => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndexAutoScalingUpdate>]]
2518  
2519 =item [ProvisionedWriteCapacityAutoScalingUpdate => L<Paws::DynamoDB::AutoScalingSettingsUpdate>]
2520  
2521 =item [ReplicaUpdates => ArrayRef[L<Paws::DynamoDB::ReplicaAutoScalingUpdate>]]
2522  
2523  
2524 =back
2525  
2526 Each argument is described in detail in: L<Paws::DynamoDB::UpdateTableReplicaAutoScaling>
2527  
2528 Returns: a L<Paws::DynamoDB::UpdateTableReplicaAutoScalingOutput> instance
2529  
2530 Updates auto scaling settings on your global tables at once.
2531  
2532 This operation only applies to Version 2019.11.21
2533 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/globaltables.V2.html)
2534 of global tables.
2535  
2536  
2537 =head2 UpdateTimeToLive
2538  
2539 =over
2540  
2541 =item TableName => Str
2542  
2543 =item TimeToLiveSpecification => L<Paws::DynamoDB::TimeToLiveSpecification>
2544  
2545  
2546 =back
2547  
2548 Each argument is described in detail in: L<Paws::DynamoDB::UpdateTimeToLive>
2549  
2550 Returns: a L<Paws::DynamoDB::UpdateTimeToLiveOutput> instance
2551  
2552 The C<UpdateTimeToLive> method enables or disables Time to Live (TTL)
2553 for the specified table. A successful C<UpdateTimeToLive> call returns
2554 the current C<TimeToLiveSpecification>. It can take up to one hour for
2555 the change to fully process. Any additional C<UpdateTimeToLive> calls
2556 for the same table during this one hour duration result in a
2557 C<ValidationException>.
2558  
2559 TTL compares the current time in epoch time format to the time stored
2560 in the TTL attribute of an item. If the epoch time value stored in the
2561 attribute is less than the current time, the item is marked as expired
2562 and subsequently deleted.
2563  
2564 The epoch time format is the number of seconds elapsed since 12:00:00
2565 AM January 1, 1970 UTC.
2566  
2567 DynamoDB deletes expired items on a best-effort basis to ensure
2568 availability of throughput for other data operations.
2569  
2570 DynamoDB typically deletes expired items within two days of expiration.
2571 The exact duration within which an item gets deleted after expiration
2572 is specific to the nature of the workload. Items that have expired and
2573 not been deleted will still show up in reads, queries, and scans.
2574  
2575 As items are deleted, they are removed from any local secondary index
2576 and global secondary index immediately in the same eventually
2577 consistent way as a standard delete operation.
2578  
2579 For more information, see Time To Live
2580 (https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/TTL.html)
2581 in the Amazon DynamoDB Developer Guide.
2582  
2583  
2584  
2585  
2586 =head1 PAGINATORS
2587  
2588 Paginator methods are helpers that repetively call methods that return partial results
2589  
2590 =head2 ListAllBackups(sub { },[BackupType => Str, ExclusiveStartBackupArn => Str, Limit => Int, TableName => Str, TimeRangeLowerBound => Str, TimeRangeUpperBound => Str])
2591  
2592 =head2 ListAllBackups([BackupType => Str, ExclusiveStartBackupArn => Str, Limit => Int, TableName => Str, TimeRangeLowerBound => Str, TimeRangeUpperBound => Str])
2593  
2594  
2595 If passed a sub as first parameter, it will call the sub for each element found in :
2596  
2597 - BackupSummaries, passing the object as the first parameter, and the string 'BackupSummaries' as the second parameter
2598  
2599 If not, it will return a a L<Paws::DynamoDB::ListBackupsOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2600  
2601  
2602 =head2 ListAllTables(sub { },[ExclusiveStartTableName => Str, Limit => Int])
2603  
2604 =head2 ListAllTables([ExclusiveStartTableName => Str, Limit => Int])
2605  
2606  
2607 If passed a sub as first parameter, it will call the sub for each element found in :
2608  
2609 - TableNames, passing the object as the first parameter, and the string 'TableNames' as the second parameter
2610  
2611 If not, it will return a a L<Paws::DynamoDB::ListTablesOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2612  
2613  
2614 =head2 ListAllTagsOfResource(sub { },ResourceArn => Str, [NextToken => Str])
2615  
2616 =head2 ListAllTagsOfResource(ResourceArn => Str, [NextToken => Str])
2617  
2618  
2619 If passed a sub as first parameter, it will call the sub for each element found in :
2620  
2621 - Tags, passing the object as the first parameter, and the string 'Tags' as the second parameter
2622  
2623 If not, it will return a a L<Paws::DynamoDB::ListTagsOfResourceOutput> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2624  
2625  
2626 =head2 QueryAll(sub { },TableName => Str, [AttributesToGet => ArrayRef[Str|Undef], ConditionalOperator => Str, ConsistentRead => Bool, ExclusiveStartKey => L<Paws::DynamoDB::Key>, ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>, ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>, FilterExpression => Str, IndexName => Str, KeyConditionExpression => Str, KeyConditions => L<Paws::DynamoDB::KeyConditions>, Limit => Int, ProjectionExpression => Str, QueryFilter => L<Paws::DynamoDB::FilterConditionMap>, ReturnConsumedCapacity => Str, ScanIndexForward => Bool, Select => Str])
2627  
2628 =head2 QueryAll(TableName => Str, [AttributesToGet => ArrayRef[Str|Undef], ConditionalOperator => Str, ConsistentRead => Bool, ExclusiveStartKey => L<Paws::DynamoDB::Key>, ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>, ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>, FilterExpression => Str, IndexName => Str, KeyConditionExpression => Str, KeyConditions => L<Paws::DynamoDB::KeyConditions>, Limit => Int, ProjectionExpression => Str, QueryFilter => L<Paws::DynamoDB::FilterConditionMap>, ReturnConsumedCapacity => Str, ScanIndexForward => Bool, Select => Str])
2629  
2630  
2631 If passed a sub as first parameter, it will call the sub for each element found in :
2632  
2633 - Items, passing the object as the first parameter, and the string 'Items' as the second parameter
2634  
2635 - Count, passing the object as the first parameter, and the string 'Count' as the second parameter
2636  
2637 - ScannedCount, passing the object as the first parameter, and the string 'ScannedCount' as the second parameter
2638  
2639 If not, it will return a a L<Paws::DynamoDB::QueryOutput> instance with all the C<param>s; andC<param>s; andC<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2640  
2641  
2642 =head2 ScanAll(sub { },TableName => Str, [AttributesToGet => ArrayRef[Str|Undef], ConditionalOperator => Str, ConsistentRead => Bool, ExclusiveStartKey => L<Paws::DynamoDB::Key>, ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>, ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>, FilterExpression => Str, IndexName => Str, Limit => Int, ProjectionExpression => Str, ReturnConsumedCapacity => Str, ScanFilter => L<Paws::DynamoDB::FilterConditionMap>, Segment => Int, Select => Str, TotalSegments => Int])
2643  
2644 =head2 ScanAll(TableName => Str, [AttributesToGet => ArrayRef[Str|Undef], ConditionalOperator => Str, ConsistentRead => Bool, ExclusiveStartKey => L<Paws::DynamoDB::Key>, ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>, ExpressionAttributeValues => L<Paws::DynamoDB::ExpressionAttributeValueMap>, FilterExpression => Str, IndexName => Str, Limit => Int, ProjectionExpression => Str, ReturnConsumedCapacity => Str, ScanFilter => L<Paws::DynamoDB::FilterConditionMap>, Segment => Int, Select => Str, TotalSegments => Int])
2645  
2646  
2647 If passed a sub as first parameter, it will call the sub for each element found in :
2648  
2649 - Items, passing the object as the first parameter, and the string 'Items' as the second parameter
2650  
2651 - Count, passing the object as the first parameter, and the string 'Count' as the second parameter
2652  
2653 - ScannedCount, passing the object as the first parameter, and the string 'ScannedCount' as the second parameter
2654  
2655 If not, it will return a a L<Paws::DynamoDB::ScanOutput> instance with all the C<param>s; andC<param>s; andC<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
2656  
2657  
2658  
2659  
2660  
2661 =head1 SEE ALSO
2662  
2663 This service class forms part of L<Paws>
2664  
2665 =head1 BUGS and CONTRIBUTIONS
2666  
2667 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
2668  
2669 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
2670  
2671 =cut
2672  
« blib/lib/Paws/SSM.pm ↑ Summary blib/lib/Paws/IAM.pm »