File Coverage

blib/lib/Paws/DynamoDB/KeysAndAttributes.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::KeysAndAttributes;
2 1     1   414 use Moose;
  1     2   3  
  1         7  
  2         638  
  2         5  
  2         11  
3             has AttributesToGet => (is => 'ro', isa => 'ArrayRef[Str|Undef]');
4             has ConsistentRead => (is => 'ro', isa => 'Bool');
5             has ExpressionAttributeNames => (is => 'ro', isa => 'Paws::DynamoDB::ExpressionAttributeNameMap');
6             has Keys => (is => 'ro', isa => 'ArrayRef[Paws::DynamoDB::Key]', required => 1);
7             has ProjectionExpression => (is => 'ro', isa => 'Str');
8             1;
9              
10             ### main pod documentation begin ###
11              
12             =head1 NAME
13              
14             Paws::DynamoDB::KeysAndAttributes
15              
16             =head1 USAGE
17              
18             This class represents one of two things:
19              
20             =head3 Arguments in a call to a service
21              
22             Use the attributes of this class as arguments to methods. You shouldn't make instances of this class.
23             Each attribute should be used as a named argument in the calls that expect this type of object.
24              
25             As an example, if Att1 is expected to be a Paws::DynamoDB::KeysAndAttributes object:
26              
27             $service_obj->Method(Att1 => { AttributesToGet => $value, ..., ProjectionExpression => $value });
28              
29             =head3 Results returned from an API call
30              
31             Use accessors for each attribute. If Att1 is expected to be an Paws::DynamoDB::KeysAndAttributes object:
32              
33             $result = $service_obj->Method(...);
34             $result->Att1->AttributesToGet
35              
36             =head1 DESCRIPTION
37              
38             Represents a set of primary keys and, for each key, the attributes to
39             retrieve from the table.
40              
41             For each primary key, you must provide I<all> of the key attributes.
42             For example, with a simple primary key, you only need to provide the
43             partition key. For a composite primary key, you must provide I<both>
44             the partition key and the sort key.
45              
46             =head1 ATTRIBUTES
47              
48              
49             =head2 AttributesToGet => ArrayRef[Str|Undef]
50              
51             This is a legacy parameter. Use C<ProjectionExpression> instead. For
52             more information, see Legacy Conditional Parameters in the I<Amazon
53             DynamoDB Developer Guide>.
54              
55              
56             =head2 ConsistentRead => Bool
57              
58             The consistency of a read operation. If set to C<true>, then a strongly
59             consistent read is used; otherwise, an eventually consistent read is
60             used.
61              
62              
63             =head2 ExpressionAttributeNames => L<Paws::DynamoDB::ExpressionAttributeNameMap>
64              
65             One or more substitution tokens for attribute names in an expression.
66             The following are some use cases for using C<ExpressionAttributeNames>:
67              
68             =over
69              
70             =item *
71              
72             To access an attribute whose name conflicts with a DynamoDB reserved
73             word.
74              
75             =item *
76              
77             To create a placeholder for repeating occurrences of an attribute name
78             in an expression.
79              
80             =item *
81              
82             To prevent special characters in an attribute name from being
83             misinterpreted in an expression.
84              
85             =back
86              
87             Use the B<#> character in an expression to dereference an attribute
88             name. For example, consider the following attribute name:
89              
90             =over
91              
92             =item *
93              
94             C<Percentile>
95              
96             =back
97              
98             The name of this attribute conflicts with a reserved word, so it cannot
99             be used directly in an expression. (For the complete list of reserved
100             words, see Reserved Words in the I<Amazon DynamoDB Developer Guide>).
101             To work around this, you could specify the following for
102             C<ExpressionAttributeNames>:
103              
104             =over
105              
106             =item *
107              
108             C<{"#P":"Percentile"}>
109              
110             =back
111              
112             You could then use this substitution in an expression, as in this
113             example:
114              
115             =over
116              
117             =item *
118              
119             C<#P = :val>
120              
121             =back
122              
123             Tokens that begin with the B<:> character are I<expression attribute
124             values>, which are placeholders for the actual value at runtime.
125              
126             For more information on expression attribute names, see Accessing Item
127             Attributes in the I<Amazon DynamoDB Developer Guide>.
128              
129              
130             =head2 B<REQUIRED> Keys => ArrayRef[L<Paws::DynamoDB::Key>]
131              
132             The primary key attribute values that define the items and the
133             attributes associated with the items.
134              
135              
136             =head2 ProjectionExpression => Str
137              
138             A string that identifies one or more attributes to retrieve from the
139             table. These attributes can include scalars, sets, or elements of a
140             JSON document. The attributes in the C<ProjectionExpression> must be
141             separated by commas.
142              
143             If no attribute names are specified, then all attributes will be
144             returned. If any of the requested attributes are not found, they will
145             not appear in the result.
146              
147             For more information, see Accessing Item Attributes in the I<Amazon
148             DynamoDB Developer Guide>.
149              
150              
151              
152             =head1 SEE ALSO
153              
154             This class forms part of L<Paws>, describing an object used in L<Paws::DynamoDB>
155              
156             =head1 BUGS and CONTRIBUTIONS
157              
158             The source code is located here: https://github.com/pplu/aws-sdk-perl
159              
160             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
161              
162             =cut
163