File Coverage

blib/lib/Paws/SDB.pm
Criterion Covered Total %
statement 34 76 44.7
branch 0 8 0.0
condition n/a
subroutine 12 18 66.6
pod 12 16 75.0
total 58 118 49.1


line stmt bran cond sub pod time code
1             package Paws::SDB;
2 1     1   5954 use Moose;
  1     3   4  
  1         15  
  3         2397  
  3         10  
  3         28  
3 19     19 0 72 sub service { 'sdb' }
4 0     0 0 0 sub version { '2009-04-15' }
5 0     0 0 0 sub flattened_arrays { 1 }
6             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
7             has retry => (is => 'ro', isa => 'HashRef', default => sub {
8             { base => 'rand', type => 'exponential', growth_factor => 2 }
9             });
10             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
11             ] });
12              
13             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V2Signature', 'Paws::Net::QueryCaller', 'Paws::Net::XMLResponse';
14              
15             has '+region_rules' => (default => sub {
16             my $regioninfo;
17             $regioninfo = [
18             {
19             constraints => [
20             [
21             'region',
22             'equals',
23             'us-east-1'
24             ]
25             ],
26             uri => 'https://sdb.amazonaws.com'
27             }
28             ];
29              
30             return $regioninfo;
31             });
32              
33            
34             sub BatchDeleteAttributes {
35 1     1 1 697 my $self = shift;
36 1         12 my $call_object = $self->new_with_coercions('Paws::SDB::BatchDeleteAttributes', @_);
37 1         872 return $self->caller->do_call($self, $call_object);
38             }
39             sub BatchPutAttributes {
40 1     1 1 594 my $self = shift;
41 1         7 my $call_object = $self->new_with_coercions('Paws::SDB::BatchPutAttributes', @_);
42 1         786 return $self->caller->do_call($self, $call_object);
43             }
44             sub CreateDomain {
45 1     1 1 296 my $self = shift;
46 1         6 my $call_object = $self->new_with_coercions('Paws::SDB::CreateDomain', @_);
47 1         520 return $self->caller->do_call($self, $call_object);
48             }
49             sub DeleteAttributes {
50 0     0 1 0 my $self = shift;
51 0         0 my $call_object = $self->new_with_coercions('Paws::SDB::DeleteAttributes', @_);
52 0         0 return $self->caller->do_call($self, $call_object);
53             }
54             sub DeleteDomain {
55 1     1 1 375 my $self = shift;
56 1         8 my $call_object = $self->new_with_coercions('Paws::SDB::DeleteDomain', @_);
57 1         469 return $self->caller->do_call($self, $call_object);
58             }
59             sub DomainMetadata {
60 1     1 1 288 my $self = shift;
61 1         7 my $call_object = $self->new_with_coercions('Paws::SDB::DomainMetadata', @_);
62 1         519 return $self->caller->do_call($self, $call_object);
63             }
64             sub GetAttributes {
65 1     1 1 438 my $self = shift;
66 1         7 my $call_object = $self->new_with_coercions('Paws::SDB::GetAttributes', @_);
67 1         951 return $self->caller->do_call($self, $call_object);
68             }
69             sub ListDomains {
70 3     3 1 262 my $self = shift;
71 3         28 my $call_object = $self->new_with_coercions('Paws::SDB::ListDomains', @_);
72 3         1220 return $self->caller->do_call($self, $call_object);
73             }
74             sub PutAttributes {
75 1     1 1 651 my $self = shift;
76 1         7 my $call_object = $self->new_with_coercions('Paws::SDB::PutAttributes', @_);
77 1         1130 return $self->caller->do_call($self, $call_object);
78             }
79             sub Select {
80 1     1 1 359 my $self = shift;
81 1         8 my $call_object = $self->new_with_coercions('Paws::SDB::Select', @_);
82 1         688 return $self->caller->do_call($self, $call_object);
83             }
84            
85             sub ListAllDomains {
86 0     0 1   my $self = shift;
87              
88 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
89 0           my $result = $self->ListDomains(@_);
90 0           my $next_result = $result;
91              
92 0 0         if (not defined $callback) {
93 0           while ($next_result->NextToken) {
94 0           $next_result = $self->ListDomains(@_, NextToken => $next_result->NextToken);
95 0           push @{ $result->DomainNames }, @{ $next_result->DomainNames };
  0            
  0            
96             }
97 0           return $result;
98             } else {
99 0           while ($result->NextToken) {
100 0           $callback->($_ => 'DomainNames') foreach (@{ $result->DomainNames });
  0            
101 0           $result = $self->ListDomains(@_, NextToken => $result->NextToken);
102             }
103 0           $callback->($_ => 'DomainNames') foreach (@{ $result->DomainNames });
  0            
104             }
105              
106             return undef
107 0           }
108             sub SelectAll {
109 0     0 1   my $self = shift;
110              
111 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
112 0           my $result = $self->Select(@_);
113 0           my $next_result = $result;
114              
115 0 0         if (not defined $callback) {
116 0           while ($next_result->NextToken) {
117 0           $next_result = $self->Select(@_, NextToken => $next_result->NextToken);
118 0           push @{ $result->Items }, @{ $next_result->Items };
  0            
  0            
119             }
120 0           return $result;
121             } else {
122 0           while ($result->NextToken) {
123 0           $callback->($_ => 'Items') foreach (@{ $result->Items });
  0            
124 0           $result = $self->Select(@_, NextToken => $result->NextToken);
125             }
126 0           $callback->($_ => 'Items') foreach (@{ $result->Items });
  0            
127             }
128              
129             return undef
130 0           }
131              
132              
133 0     0 0   sub operations { qw/BatchDeleteAttributes BatchPutAttributes CreateDomain DeleteAttributes DeleteDomain DomainMetadata GetAttributes ListDomains PutAttributes Select / }
134              
135             1;
136              
137             ### main pod documentation begin ###
138              
139             =head1 NAME
140              
141             Paws::SDB - Perl Interface to AWS Amazon SimpleDB
142              
143             =head1 SYNOPSIS
144              
145             use Paws;
146              
147             my $obj = Paws->service('SDB');
148             my $res = $obj->Method(
149             Arg1 => $val1,
150             Arg2 => [ 'V1', 'V2' ],
151             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
152             # of the arguments type
153             Arg3 => { Att1 => 'Val1' },
154             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
155             # the constructor of the arguments type
156             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
157             );
158              
159             =head1 DESCRIPTION
160              
161             Amazon SimpleDB is a web service providing the core database functions
162             of data indexing and querying in the cloud. By offloading the time and
163             effort associated with building and operating a web-scale database,
164             SimpleDB provides developers the freedom to focus on application
165             development.
166              
167             A traditional, clustered relational database requires a sizable upfront
168             capital outlay, is complex to design, and often requires extensive and
169             repetitive database administration. Amazon SimpleDB is dramatically
170             simpler, requiring no schema, automatically indexing your data and
171             providing a simple API for storage and access. This approach eliminates
172             the administrative burden of data modeling, index maintenance, and
173             performance tuning. Developers gain access to this functionality within
174             Amazon's proven computing environment, are able to scale instantly, and
175             pay only for what they use.
176              
177             Visit http://aws.amazon.com/simpledb/ for more information.
178              
179             =head1 METHODS
180              
181             =head2 BatchDeleteAttributes(DomainName => Str, Items => ArrayRef[L<Paws::SDB::DeletableItem>])
182              
183             Each argument is described in detail in: L<Paws::SDB::BatchDeleteAttributes>
184              
185             Returns: nothing
186              
187             Performs multiple DeleteAttributes operations in a single call, which
188             reduces round trips and latencies. This enables Amazon SimpleDB to
189             optimize requests, which generally yields better throughput.
190              
191             The following limitations are enforced for this operation:
192              
193             =over
194              
195             =item * 1 MB request size
196              
197             =item * 25 item limit per BatchDeleteAttributes operation
198              
199             =back
200              
201              
202              
203             =head2 BatchPutAttributes(DomainName => Str, Items => ArrayRef[L<Paws::SDB::ReplaceableItem>])
204              
205             Each argument is described in detail in: L<Paws::SDB::BatchPutAttributes>
206              
207             Returns: nothing
208              
209             The C<BatchPutAttributes> operation creates or replaces attributes
210             within one or more items. By using this operation, the client can
211             perform multiple PutAttribute operation with a single call. This helps
212             yield savings in round trips and latencies, enabling Amazon SimpleDB to
213             optimize requests and generally produce better throughput.
214              
215             The client may specify the item name with the C<Item.X.ItemName>
216             parameter. The client may specify new attributes using a combination of
217             the C<Item.X.Attribute.Y.Name> and C<Item.X.Attribute.Y.Value>
218             parameters. The client may specify the first attribute for the first
219             item using the parameters C<Item.0.Attribute.0.Name> and
220             C<Item.0.Attribute.0.Value>, and for the second attribute for the first
221             item by the parameters C<Item.0.Attribute.1.Name> and
222             C<Item.0.Attribute.1.Value>, and so on.
223              
224             Attributes are uniquely identified within an item by their name/value
225             combination. For example, a single item can have the attributes C<{
226             "first_name", "first_value" }> and C<{ "first_name", "second_value" }>.
227             However, it cannot have two attribute instances where both the
228             C<Item.X.Attribute.Y.Name> and C<Item.X.Attribute.Y.Value> are the
229             same.
230              
231             Optionally, the requester can supply the C<Replace> parameter for each
232             individual value. Setting this value to C<true> will cause the new
233             attribute values to replace the existing attribute values. For example,
234             if an item C<I> has the attributes C<{ 'a', '1' }, { 'b', '2'}> and C<{
235             'b', '3' }> and the requester does a BatchPutAttributes of C<{'I', 'b',
236             '4' }> with the Replace parameter set to true, the final attributes of
237             the item will be C<{ 'a', '1' }> and C<{ 'b', '4' }>, replacing the
238             previous values of the 'b' attribute with the new value.
239              
240             This operation is vulnerable to exceeding the maximum URL size when
241             making a REST request using the HTTP GET method. This operation does
242             not support conditions using C<Expected.X.Name>, C<Expected.X.Value>,
243             or C<Expected.X.Exists>.
244              
245             You can execute multiple C<BatchPutAttributes> operations and other
246             operations in parallel. However, large numbers of concurrent
247             C<BatchPutAttributes> calls can result in Service Unavailable (503)
248             responses.
249              
250             The following limitations are enforced for this operation:
251              
252             =over
253              
254             =item * 256 attribute name-value pairs per item
255              
256             =item * 1 MB request size
257              
258             =item * 1 billion attributes per domain
259              
260             =item * 10 GB of total user data storage per domain
261              
262             =item * 25 item limit per C<BatchPutAttributes> operation
263              
264             =back
265              
266              
267              
268             =head2 CreateDomain(DomainName => Str)
269              
270             Each argument is described in detail in: L<Paws::SDB::CreateDomain>
271              
272             Returns: nothing
273              
274             The C<CreateDomain> operation creates a new domain. The domain name
275             should be unique among the domains associated with the Access Key ID
276             provided in the request. The C<CreateDomain> operation may take 10 or
277             more seconds to complete.
278              
279             The client can create up to 100 domains per account.
280              
281             If the client requires additional domains, go to
282             http://aws.amazon.com/contact-us/simpledb-limit-request/.
283              
284              
285             =head2 DeleteAttributes(DomainName => Str, ItemName => Str, [Attributes => ArrayRef[L<Paws::SDB::DeletableAttribute>], Expected => L<Paws::SDB::UpdateCondition>])
286              
287             Each argument is described in detail in: L<Paws::SDB::DeleteAttributes>
288              
289             Returns: nothing
290              
291             Deletes one or more attributes associated with an item. If all
292             attributes of the item are deleted, the item is deleted.
293              
294             C<DeleteAttributes> is an idempotent operation; running it multiple
295             times on the same item or attribute does not result in an error
296             response.
297              
298             Because Amazon SimpleDB makes multiple copies of item data and uses an
299             eventual consistency update model, performing a GetAttributes or Select
300             operation (read) immediately after a C<DeleteAttributes> or
301             PutAttributes operation (write) might not return updated item data.
302              
303              
304             =head2 DeleteDomain(DomainName => Str)
305              
306             Each argument is described in detail in: L<Paws::SDB::DeleteDomain>
307              
308             Returns: nothing
309              
310             The C<DeleteDomain> operation deletes a domain. Any items (and their
311             attributes) in the domain are deleted as well. The C<DeleteDomain>
312             operation might take 10 or more seconds to complete.
313              
314              
315             =head2 DomainMetadata(DomainName => Str)
316              
317             Each argument is described in detail in: L<Paws::SDB::DomainMetadata>
318              
319             Returns: a L<Paws::SDB::DomainMetadataResult> instance
320              
321             Returns information about the domain, including when the domain was
322             created, the number of items and attributes in the domain, and the size
323             of the attribute names and values.
324              
325              
326             =head2 GetAttributes(DomainName => Str, ItemName => Str, [AttributeName => Str, ConsistentRead => Bool])
327              
328             Each argument is described in detail in: L<Paws::SDB::GetAttributes>
329              
330             Returns: a L<Paws::SDB::GetAttributesResult> instance
331              
332             Returns all of the attributes associated with the specified item.
333             Optionally, the attributes returned can be limited to one or more
334             attributes by specifying an attribute name parameter.
335              
336             If the item does not exist on the replica that was accessed for this
337             operation, an empty set is returned. The system does not return an
338             error as it cannot guarantee the item does not exist on other replicas.
339              
340              
341             =head2 ListDomains([MaxNumberOfDomains => Int, NextToken => Str])
342              
343             Each argument is described in detail in: L<Paws::SDB::ListDomains>
344              
345             Returns: a L<Paws::SDB::ListDomainsResult> instance
346              
347             The C<ListDomains> operation lists all domains associated with the
348             Access Key ID. It returns domain names up to the limit set by
349             MaxNumberOfDomains. A NextToken is returned if there are more than
350             C<MaxNumberOfDomains> domains. Calling C<ListDomains> successive times
351             with the C<NextToken> provided by the operation returns up to
352             C<MaxNumberOfDomains> more domain names with each successive operation
353             call.
354              
355              
356             =head2 PutAttributes(Attributes => ArrayRef[L<Paws::SDB::ReplaceableAttribute>], DomainName => Str, ItemName => Str, [Expected => L<Paws::SDB::UpdateCondition>])
357              
358             Each argument is described in detail in: L<Paws::SDB::PutAttributes>
359              
360             Returns: nothing
361              
362             The PutAttributes operation creates or replaces attributes in an item.
363             The client may specify new attributes using a combination of the
364             C<Attribute.X.Name> and C<Attribute.X.Value> parameters. The client
365             specifies the first attribute by the parameters C<Attribute.0.Name> and
366             C<Attribute.0.Value>, the second attribute by the parameters
367             C<Attribute.1.Name> and C<Attribute.1.Value>, and so on.
368              
369             Attributes are uniquely identified in an item by their name/value
370             combination. For example, a single item can have the attributes C<{
371             "first_name", "first_value" }> and C<{ "first_name", second_value" }>.
372             However, it cannot have two attribute instances where both the
373             C<Attribute.X.Name> and C<Attribute.X.Value> are the same.
374              
375             Optionally, the requestor can supply the C<Replace> parameter for each
376             individual attribute. Setting this value to C<true> causes the new
377             attribute value to replace the existing attribute value(s). For
378             example, if an item has the attributes C<{ 'a', '1' }>, C<{ 'b', '2'}>
379             and C<{ 'b', '3' }> and the requestor calls C<PutAttributes> using the
380             attributes C<{ 'b', '4' }> with the C<Replace> parameter set to true,
381             the final attributes of the item are changed to C<{ 'a', '1' }> and C<{
382             'b', '4' }>, which replaces the previous values of the 'b' attribute
383             with the new value.
384              
385             You cannot specify an empty string as an attribute name.
386              
387             Because Amazon SimpleDB makes multiple copies of client data and uses
388             an eventual consistency update model, an immediate GetAttributes or
389             Select operation (read) immediately after a PutAttributes or
390             DeleteAttributes operation (write) might not return the updated data.
391              
392             The following limitations are enforced for this operation:
393              
394             =over
395              
396             =item * 256 total attribute name-value pairs per item
397              
398             =item * One billion attributes per domain
399              
400             =item * 10 GB of total user data storage per domain
401              
402             =back
403              
404              
405              
406             =head2 Select(SelectExpression => Str, [ConsistentRead => Bool, NextToken => Str])
407              
408             Each argument is described in detail in: L<Paws::SDB::Select>
409              
410             Returns: a L<Paws::SDB::SelectResult> instance
411              
412             The C<Select> operation returns a set of attributes for C<ItemNames>
413             that match the select expression. C<Select> is similar to the standard
414             SQL SELECT statement.
415              
416             The total size of the response cannot exceed 1 MB in total size. Amazon
417             SimpleDB automatically adjusts the number of items returned per page to
418             enforce this limit. For example, if the client asks to retrieve 2500
419             items, but each individual item is 10 kB in size, the system returns
420             100 items and an appropriate C<NextToken> so the client can access the
421             next page of results.
422              
423             For information on how to construct select expressions, see Using
424             Select to Create Amazon SimpleDB Queries in the Developer Guide.
425              
426              
427              
428              
429             =head1 PAGINATORS
430              
431             Paginator methods are helpers that repetively call methods that return partial results
432              
433             =head2 ListAllDomains(sub { },[MaxNumberOfDomains => Int, NextToken => Str])
434              
435             =head2 ListAllDomains([MaxNumberOfDomains => Int, NextToken => Str])
436              
437              
438             If passed a sub as first parameter, it will call the sub for each element found in :
439              
440             - DomainNames, passing the object as the first parameter, and the string 'DomainNames' as the second parameter
441              
442             If not, it will return a a L<Paws::SDB::ListDomainsResult> 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.
443              
444              
445             =head2 SelectAll(sub { },SelectExpression => Str, [ConsistentRead => Bool, NextToken => Str])
446              
447             =head2 SelectAll(SelectExpression => Str, [ConsistentRead => Bool, NextToken => Str])
448              
449              
450             If passed a sub as first parameter, it will call the sub for each element found in :
451              
452             - Items, passing the object as the first parameter, and the string 'Items' as the second parameter
453              
454             If not, it will return a a L<Paws::SDB::SelectResult> 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.
455              
456              
457              
458              
459              
460             =head1 SEE ALSO
461              
462             This service class forms part of L<Paws>
463              
464             =head1 BUGS and CONTRIBUTIONS
465              
466             The source code is located here: https://github.com/pplu/aws-sdk-perl
467              
468             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
469              
470             =cut
471