blib/lib/Paws/SDB.pm

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