File Coverage

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


line stmt bran cond sub pod time code
1             package Paws::DynamoDB::TableDescription;
2 1     1   456 use Moose;
  1     1   2  
  1         7  
  1         353  
  1         3  
  1         5  
3             has AttributeDefinitions => (is => 'ro', isa => 'ArrayRef[Paws::DynamoDB::AttributeDefinition]');
4             has CreationDateTime => (is => 'ro', isa => 'Str');
5             has GlobalSecondaryIndexes => (is => 'ro', isa => 'ArrayRef[Paws::DynamoDB::GlobalSecondaryIndexDescription]');
6             has ItemCount => (is => 'ro', isa => 'Int');
7             has KeySchema => (is => 'ro', isa => 'ArrayRef[Paws::DynamoDB::KeySchemaElement]');
8             has LatestStreamArn => (is => 'ro', isa => 'Str');
9             has LatestStreamLabel => (is => 'ro', isa => 'Str');
10             has LocalSecondaryIndexes => (is => 'ro', isa => 'ArrayRef[Paws::DynamoDB::LocalSecondaryIndexDescription]');
11             has ProvisionedThroughput => (is => 'ro', isa => 'Paws::DynamoDB::ProvisionedThroughputDescription');
12             has StreamSpecification => (is => 'ro', isa => 'Paws::DynamoDB::StreamSpecification');
13             has TableArn => (is => 'ro', isa => 'Str');
14             has TableName => (is => 'ro', isa => 'Str');
15             has TableSizeBytes => (is => 'ro', isa => 'Int');
16             has TableStatus => (is => 'ro', isa => 'Str');
17             1;
18              
19             ### main pod documentation begin ###
20              
21             =head1 NAME
22              
23             Paws::DynamoDB::TableDescription
24              
25             =head1 USAGE
26              
27             This class represents one of two things:
28              
29             =head3 Arguments in a call to a service
30              
31             Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
32             Each attribute should be used as a named argument in the calls that expect this type of object.
33              
34             As an example, if Att1 is expected to be a Paws::DynamoDB::TableDescription object:
35              
36             $service_obj->Method(Att1 => { AttributeDefinitions => $value, ..., TableStatus => $value });
37              
38             =head3 Results returned from an API call
39              
40             Use accessors for each attribute. If Att1 is expected to be an Paws::DynamoDB::TableDescription object:
41              
42             $result = $service_obj->Method(...);
43             $result->Att1->AttributeDefinitions
44              
45             =head1 DESCRIPTION
46              
47             Represents the properties of a table.
48              
49             =head1 ATTRIBUTES
50              
51              
52             =head2 AttributeDefinitions => ArrayRef[L<Paws::DynamoDB::AttributeDefinition>]
53              
54             An array of C<AttributeDefinition> objects. Each of these objects
55             describes one attribute in the table and index key schema.
56              
57             Each C<AttributeDefinition> object in this array is composed of:
58              
59             =over
60              
61             =item *
62              
63             C<AttributeName> - The name of the attribute.
64              
65             =item *
66              
67             C<AttributeType> - The data type for the attribute.
68              
69             =back
70              
71              
72              
73             =head2 CreationDateTime => Str
74              
75             The date and time when the table was created, in UNIX epoch time
76             format.
77              
78              
79             =head2 GlobalSecondaryIndexes => ArrayRef[L<Paws::DynamoDB::GlobalSecondaryIndexDescription>]
80              
81             The global secondary indexes, if any, on the table. Each index is
82             scoped to a given partition key value. Each element is composed of:
83              
84             =over
85              
86             =item *
87              
88             C<Backfilling> - If true, then the index is currently in the
89             backfilling phase. Backfilling occurs only when a new global secondary
90             index is added to the table; it is the process by which DynamoDB
91             populates the new index with data from the table. (This attribute does
92             not appear for indexes that were created during a C<CreateTable>
93             operation.)
94              
95             =item *
96              
97             C<IndexName> - The name of the global secondary index.
98              
99             =item *
100              
101             C<IndexSizeBytes> - The total size of the global secondary index, in
102             bytes. DynamoDB updates this value approximately every six hours.
103             Recent changes might not be reflected in this value.
104              
105             =item *
106              
107             C<IndexStatus> - The current status of the global secondary index:
108              
109             =over
110              
111             =item *
112              
113             C<CREATING> - The index is being created.
114              
115             =item *
116              
117             C<UPDATING> - The index is being updated.
118              
119             =item *
120              
121             C<DELETING> - The index is being deleted.
122              
123             =item *
124              
125             C<ACTIVE> - The index is ready for use.
126              
127             =back
128              
129             =item *
130              
131             C<ItemCount> - The number of items in the global secondary index.
132             DynamoDB updates this value approximately every six hours. Recent
133             changes might not be reflected in this value.
134              
135             =item *
136              
137             C<KeySchema> - Specifies the complete index key schema. The attribute
138             names in the key schema must be between 1 and 255 characters
139             (inclusive). The key schema must begin with the same partition key as
140             the table.
141              
142             =item *
143              
144             C<Projection> - Specifies attributes that are copied (projected) from
145             the table into the index. These are in addition to the primary key
146             attributes and index key attributes, which are automatically projected.
147             Each attribute specification is composed of:
148              
149             =over
150              
151             =item *
152              
153             C<ProjectionType> - One of the following:
154              
155             =over
156              
157             =item *
158              
159             C<KEYS_ONLY> - Only the index and primary keys are projected into the
160             index.
161              
162             =item *
163              
164             C<INCLUDE> - Only the specified table attributes are projected into the
165             index. The list of projected attributes are in C<NonKeyAttributes>.
166              
167             =item *
168              
169             C<ALL> - All of the table attributes are projected into the index.
170              
171             =back
172              
173             =item *
174              
175             C<NonKeyAttributes> - A list of one or more non-key attribute names
176             that are projected into the secondary index. The total count of
177             attributes provided in C<NonKeyAttributes>, summed across all of the
178             secondary indexes, must not exceed 20. If you project the same
179             attribute into two different indexes, this counts as two distinct
180             attributes when determining the total.
181              
182             =back
183              
184             =item *
185              
186             C<ProvisionedThroughput> - The provisioned throughput settings for the
187             global secondary index, consisting of read and write capacity units,
188             along with data about increases and decreases.
189              
190             =back
191              
192             If the table is in the C<DELETING> state, no information about indexes
193             will be returned.
194              
195              
196             =head2 ItemCount => Int
197              
198             The number of items in the specified table. DynamoDB updates this value
199             approximately every six hours. Recent changes might not be reflected in
200             this value.
201              
202              
203             =head2 KeySchema => ArrayRef[L<Paws::DynamoDB::KeySchemaElement>]
204              
205             The primary key structure for the table. Each C<KeySchemaElement>
206             consists of:
207              
208             =over
209              
210             =item *
211              
212             C<AttributeName> - The name of the attribute.
213              
214             =item *
215              
216             C<KeyType> - The role of the attribute:
217              
218             =over
219              
220             =item *
221              
222             C<HASH> - partition key
223              
224             =item *
225              
226             C<RANGE> - sort key
227              
228             =back
229              
230             The partition key of an item is also known as its I<hash attribute>.
231             The term "hash attribute" derives from DynamoDB' usage of an internal
232             hash function to evenly distribute data items across partitions, based
233             on their partition key values.
234              
235             The sort key of an item is also known as its I<range attribute>. The
236             term "range attribute" derives from the way DynamoDB stores items with
237             the same partition key physically close together, in sorted order by
238             the sort key value.
239              
240             =back
241              
242             For more information about primary keys, see Primary Key in the
243             I<Amazon DynamoDB Developer Guide>.
244              
245              
246             =head2 LatestStreamArn => Str
247              
248             The Amazon Resource Name (ARN) that uniquely identifies the latest
249             stream for this table.
250              
251              
252             =head2 LatestStreamLabel => Str
253              
254             A timestamp, in ISO 8601 format, for this stream.
255              
256             Note that C<LatestStreamLabel> is not a unique identifier for the
257             stream, because it is possible that a stream from another table might
258             have the same timestamp. However, the combination of the following
259             three elements is guaranteed to be unique:
260              
261             =over
262              
263             =item *
264              
265             the AWS customer ID.
266              
267             =item *
268              
269             the table name.
270              
271             =item *
272              
273             the C<StreamLabel>.
274              
275             =back
276              
277              
278              
279             =head2 LocalSecondaryIndexes => ArrayRef[L<Paws::DynamoDB::LocalSecondaryIndexDescription>]
280              
281             Represents one or more local secondary indexes on the table. Each index
282             is scoped to a given partition key value. Tables with one or more local
283             secondary indexes are subject to an item collection size limit, where
284             the amount of data within a given item collection cannot exceed 10 GB.
285             Each element is composed of:
286              
287             =over
288              
289             =item *
290              
291             C<IndexName> - The name of the local secondary index.
292              
293             =item *
294              
295             C<KeySchema> - Specifies the complete index key schema. The attribute
296             names in the key schema must be between 1 and 255 characters
297             (inclusive). The key schema must begin with the same partition key as
298             the table.
299              
300             =item *
301              
302             C<Projection> - Specifies attributes that are copied (projected) from
303             the table into the index. These are in addition to the primary key
304             attributes and index key attributes, which are automatically projected.
305             Each attribute specification is composed of:
306              
307             =over
308              
309             =item *
310              
311             C<ProjectionType> - One of the following:
312              
313             =over
314              
315             =item *
316              
317             C<KEYS_ONLY> - Only the index and primary keys are projected into the
318             index.
319              
320             =item *
321              
322             C<INCLUDE> - Only the specified table attributes are projected into the
323             index. The list of projected attributes are in C<NonKeyAttributes>.
324              
325             =item *
326              
327             C<ALL> - All of the table attributes are projected into the index.
328              
329             =back
330              
331             =item *
332              
333             C<NonKeyAttributes> - A list of one or more non-key attribute names
334             that are projected into the secondary index. The total count of
335             attributes provided in C<NonKeyAttributes>, summed across all of the
336             secondary indexes, must not exceed 20. If you project the same
337             attribute into two different indexes, this counts as two distinct
338             attributes when determining the total.
339              
340             =back
341              
342             =item *
343              
344             C<IndexSizeBytes> - Represents the total size of the index, in bytes.
345             DynamoDB updates this value approximately every six hours. Recent
346             changes might not be reflected in this value.
347              
348             =item *
349              
350             C<ItemCount> - Represents the number of items in the index. DynamoDB
351             updates this value approximately every six hours. Recent changes might
352             not be reflected in this value.
353              
354             =back
355              
356             If the table is in the C<DELETING> state, no information about indexes
357             will be returned.
358              
359              
360             =head2 ProvisionedThroughput => L<Paws::DynamoDB::ProvisionedThroughputDescription>
361              
362             The provisioned throughput settings for the table, consisting of read
363             and write capacity units, along with data about increases and
364             decreases.
365              
366              
367             =head2 StreamSpecification => L<Paws::DynamoDB::StreamSpecification>
368              
369             The current DynamoDB Streams configuration for the table.
370              
371              
372             =head2 TableArn => Str
373              
374             The Amazon Resource Name (ARN) that uniquely identifies the table.
375              
376              
377             =head2 TableName => Str
378              
379             The name of the table.
380              
381              
382             =head2 TableSizeBytes => Int
383              
384             The total size of the specified table, in bytes. DynamoDB updates this
385             value approximately every six hours. Recent changes might not be
386             reflected in this value.
387              
388              
389             =head2 TableStatus => Str
390              
391             The current state of the table:
392              
393             =over
394              
395             =item *
396              
397             C<CREATING> - The table is being created.
398              
399             =item *
400              
401             C<UPDATING> - The table is being updated.
402              
403             =item *
404              
405             C<DELETING> - The table is being deleted.
406              
407             =item *
408              
409             C<ACTIVE> - The table is ready for use.
410              
411             =back
412              
413              
414              
415              
416             =head1 SEE ALSO
417              
418             This class forms part of L<Paws>, describing an object used in L<Paws::DynamoDB>
419              
420             =head1 BUGS and CONTRIBUTIONS
421              
422             The source code is located here: https://github.com/pplu/aws-sdk-perl
423              
424             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
425              
426             =cut
427