blib/lib/Paws/TimestreamWrite.pm untested

filter: Statementstmt 0.0% 0 / 60 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 22 Podpod 0.0% 0 / 21 totaltotal 0.0% 0 / 103 CC 1 SCAR 6.9
CC
1
Cov
0%
service
2.0
signing_name
2.0
version
2.0
CRAP 2.0
1 package Paws::TimestreamWrite;
2 use Moose;
3 sub service { 'ingest.timestream' }
4 sub signing_name { 'timestream' }
5 sub version { '2018-11-01' }
6 sub target_prefix { 'Timestream_20181101' }
7 sub json_version { "1.0" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub CreateDatabase {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::CreateDatabase', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CreateTable {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::CreateTable', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub DeleteDatabase {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::DeleteDatabase', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub DeleteTable {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::DeleteTable', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub DescribeDatabase {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::DescribeDatabase', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub DescribeEndpoints {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::DescribeEndpoints', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DescribeTable {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::DescribeTable', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub ListDatabases {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::ListDatabases', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub ListTables {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::ListTables', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub ListTagsForResource {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::ListTagsForResource', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub TagResource {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::TagResource', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub UntagResource {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::UntagResource', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub UpdateDatabase {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::UpdateDatabase', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub UpdateTable {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::UpdateTable', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub WriteRecords {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::TimestreamWrite::WriteRecords', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93
94  
95  
96 sub operations { qw/CreateDatabase CreateTable DeleteDatabase DeleteTable DescribeDatabase DescribeEndpoints DescribeTable ListDatabases ListTables ListTagsForResource TagResource UntagResource UpdateDatabase UpdateTable WriteRecords / }
97  
98 1;
99  
100 ### main pod documentation begin ###
101  
102 =head1 NAME
103  
104 Paws::TimestreamWrite - Perl Interface to AWS Amazon Timestream Write
105  
106 =head1 SYNOPSIS
107  
108 use Paws;
109  
110 my $obj = Paws->service('TimestreamWrite');
111 my $res = $obj->Method(
112 Arg1 => $val1,
113 Arg2 => [ 'V1', 'V2' ],
114 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
115 # of the arguments type
116 Arg3 => { Att1 => 'Val1' },
117 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
118 # the constructor of the arguments type
119 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
120 );
121  
122 =head1 DESCRIPTION
123  
124 Amazon Timestream is a fast, scalable, fully managed time series
125 database service that makes it easy to store and analyze trillions of
126 time series data points per day. With Timestream, you can easily store
127 and analyze IoT sensor data to derive insights from your IoT
128 applications. You can analyze industrial telemetry to streamline
129 equipment management and maintenance. You can also store and analyze
130 log data and metrics to improve the performance and availability of
131 your applications. Timestream is built from the ground up to
132 effectively ingest, process, and store time series data. It organizes
133 data to optimize query processing. It automatically scales based on the
134 volume of data ingested and on the query volume to ensure you receive
135 optimal performance while inserting and querying data. As your data
136 grows over time, TimestreamE<rsquo>s adaptive query processing engine
137 spans across storage tiers to provide fast analysis while reducing
138 costs.
139  
140 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/ingest.timestream-2018-11-01>
141  
142  
143 =head1 METHODS
144  
145 =head2 CreateDatabase
146  
147 =over
148  
149 =item DatabaseName => Str
150  
151 =item [KmsKeyId => Str]
152  
153 =item [Tags => ArrayRef[L<Paws::TimestreamWrite::Tag>]]
154  
155  
156 =back
157  
158 Each argument is described in detail in: L<Paws::TimestreamWrite::CreateDatabase>
159  
160 Returns: a L<Paws::TimestreamWrite::CreateDatabaseResponse> instance
161  
162 Creates a new Timestream database. If the KMS key is not specified, the
163 database will be encrypted with a Timestream managed KMS key located in
164 your account. Refer to AWS managed KMS keys
165 (https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#aws-managed-cmk)
166 for more info. Service quotas apply. For more information, see Access
167 Management
168 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
169 in the Timestream Developer Guide.
170  
171  
172 =head2 CreateTable
173  
174 =over
175  
176 =item DatabaseName => Str
177  
178 =item TableName => Str
179  
180 =item [RetentionProperties => L<Paws::TimestreamWrite::RetentionProperties>]
181  
182 =item [Tags => ArrayRef[L<Paws::TimestreamWrite::Tag>]]
183  
184  
185 =back
186  
187 Each argument is described in detail in: L<Paws::TimestreamWrite::CreateTable>
188  
189 Returns: a L<Paws::TimestreamWrite::CreateTableResponse> instance
190  
191 The CreateTable operation adds a new table to an existing database in
192 your account. In an AWS account, table names must be at least unique
193 within each Region if they are in the same database. You may have
194 identical table names in the same Region if the tables are in seperate
195 databases. While creating the table, you must specify the table name,
196 database name, and the retention properties. Service quotas apply. For
197 more information, see Access Management
198 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
199 in the Timestream Developer Guide.
200  
201  
202 =head2 DeleteDatabase
203  
204 =over
205  
206 =item DatabaseName => Str
207  
208  
209 =back
210  
211 Each argument is described in detail in: L<Paws::TimestreamWrite::DeleteDatabase>
212  
213 Returns: nothing
214  
215 Deletes a given Timestream database. I<This is an irreversible
216 operation. After a database is deleted, the time series data from its
217 tables cannot be recovered.>
218  
219 All tables in the database must be deleted first, or a
220 ValidationException error will be thrown.
221  
222 Due to the nature of distributed retries, the operation can return
223 either success or a ResourceNotFoundException. Clients should consider
224 them equivalent.
225  
226  
227 =head2 DeleteTable
228  
229 =over
230  
231 =item DatabaseName => Str
232  
233 =item TableName => Str
234  
235  
236 =back
237  
238 Each argument is described in detail in: L<Paws::TimestreamWrite::DeleteTable>
239  
240 Returns: nothing
241  
242 Deletes a given Timestream table. This is an irreversible operation.
243 After a Timestream database table is deleted, the time series data
244 stored in the table cannot be recovered.
245  
246 Due to the nature of distributed retries, the operation can return
247 either success or a ResourceNotFoundException. Clients should consider
248 them equivalent.
249  
250  
251 =head2 DescribeDatabase
252  
253 =over
254  
255 =item DatabaseName => Str
256  
257  
258 =back
259  
260 Each argument is described in detail in: L<Paws::TimestreamWrite::DescribeDatabase>
261  
262 Returns: a L<Paws::TimestreamWrite::DescribeDatabaseResponse> instance
263  
264 Returns information about the database, including the database name,
265 time that the database was created, and the total number of tables
266 found within the database. Service quotas apply. For more information,
267 see Access Management
268 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
269 in the Timestream Developer Guide.
270  
271  
272 =head2 DescribeEndpoints
273  
274  
275  
276  
277  
278  
279 Each argument is described in detail in: L<Paws::TimestreamWrite::DescribeEndpoints>
280  
281 Returns: a L<Paws::TimestreamWrite::DescribeEndpointsResponse> instance
282  
283 DescribeEndpoints returns a list of available endpoints to make
284 Timestream API calls against. This API is available through both Write
285 and Query.
286  
287 Because TimestreamE<rsquo>s SDKs are designed to transparently work
288 with the serviceE<rsquo>s architecture, including the management and
289 mapping of the service endpoints, I<it is not recommended that you use
290 this API unless>:
291  
292 =over
293  
294 =item *
295  
296 Your application uses a programming language that does not yet have SDK
297 support
298  
299 =item *
300  
301 You require better control over the client-side implementation
302  
303 =back
304  
305 For detailed information on how to use DescribeEndpoints, see The
306 Endpoint Discovery Pattern and REST APIs
307 (https://docs.aws.amazon.com/timestream/latest/developerguide/Using-API.endpoint-discovery.html).
308  
309  
310 =head2 DescribeTable
311  
312 =over
313  
314 =item DatabaseName => Str
315  
316 =item TableName => Str
317  
318  
319 =back
320  
321 Each argument is described in detail in: L<Paws::TimestreamWrite::DescribeTable>
322  
323 Returns: a L<Paws::TimestreamWrite::DescribeTableResponse> instance
324  
325 Returns information about the table, including the table name, database
326 name, retention duration of the memory store and the magnetic store.
327 Service quotas apply. For more information, see Access Management
328 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
329 in the Timestream Developer Guide.
330  
331  
332 =head2 ListDatabases
333  
334 =over
335  
336 =item [MaxResults => Int]
337  
338 =item [NextToken => Str]
339  
340  
341 =back
342  
343 Each argument is described in detail in: L<Paws::TimestreamWrite::ListDatabases>
344  
345 Returns: a L<Paws::TimestreamWrite::ListDatabasesResponse> instance
346  
347 Returns a list of your Timestream databases. Service quotas apply. For
348 more information, see Access Management
349 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
350 in the Timestream Developer Guide.
351  
352  
353 =head2 ListTables
354  
355 =over
356  
357 =item [DatabaseName => Str]
358  
359 =item [MaxResults => Int]
360  
361 =item [NextToken => Str]
362  
363  
364 =back
365  
366 Each argument is described in detail in: L<Paws::TimestreamWrite::ListTables>
367  
368 Returns: a L<Paws::TimestreamWrite::ListTablesResponse> instance
369  
370 A list of tables, along with the name, status and retention properties
371 of each table.
372  
373  
374 =head2 ListTagsForResource
375  
376 =over
377  
378 =item ResourceARN => Str
379  
380  
381 =back
382  
383 Each argument is described in detail in: L<Paws::TimestreamWrite::ListTagsForResource>
384  
385 Returns: a L<Paws::TimestreamWrite::ListTagsForResourceResponse> instance
386  
387 List all tags on a Timestream resource.
388  
389  
390 =head2 TagResource
391  
392 =over
393  
394 =item ResourceARN => Str
395  
396 =item Tags => ArrayRef[L<Paws::TimestreamWrite::Tag>]
397  
398  
399 =back
400  
401 Each argument is described in detail in: L<Paws::TimestreamWrite::TagResource>
402  
403 Returns: a L<Paws::TimestreamWrite::TagResourceResponse> instance
404  
405 Associate a set of tags with a Timestream resource. You can then
406 activate these user-defined tags so that they appear on the Billing and
407 Cost Management console for cost allocation tracking.
408  
409  
410 =head2 UntagResource
411  
412 =over
413  
414 =item ResourceARN => Str
415  
416 =item TagKeys => ArrayRef[Str|Undef]
417  
418  
419 =back
420  
421 Each argument is described in detail in: L<Paws::TimestreamWrite::UntagResource>
422  
423 Returns: a L<Paws::TimestreamWrite::UntagResourceResponse> instance
424  
425 Removes the association of tags from a Timestream resource.
426  
427  
428 =head2 UpdateDatabase
429  
430 =over
431  
432 =item DatabaseName => Str
433  
434 =item KmsKeyId => Str
435  
436  
437 =back
438  
439 Each argument is described in detail in: L<Paws::TimestreamWrite::UpdateDatabase>
440  
441 Returns: a L<Paws::TimestreamWrite::UpdateDatabaseResponse> instance
442  
443 Modifies the KMS key for an existing database. While updating the
444 database, you must specify the database name and the identifier of the
445 new KMS key to be used (C<KmsKeyId>). If there are any concurrent
446 C<UpdateDatabase> requests, first writer wins.
447  
448  
449 =head2 UpdateTable
450  
451 =over
452  
453 =item DatabaseName => Str
454  
455 =item RetentionProperties => L<Paws::TimestreamWrite::RetentionProperties>
456  
457 =item TableName => Str
458  
459  
460 =back
461  
462 Each argument is described in detail in: L<Paws::TimestreamWrite::UpdateTable>
463  
464 Returns: a L<Paws::TimestreamWrite::UpdateTableResponse> instance
465  
466 Modifies the retention duration of the memory store and magnetic store
467 for your Timestream table. Note that the change in retention duration
468 takes effect immediately. For example, if the retention period of the
469 memory store was initially set to 2 hours and then changed to 24 hours,
470 the memory store will be capable of holding 24 hours of data, but will
471 be populated with 24 hours of data 22 hours after this change was made.
472 Timestream does not retrieve data from the magnetic store to populate
473 the memory store.
474  
475 Service quotas apply. For more information, see Access Management
476 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
477 in the Timestream Developer Guide.
478  
479  
480 =head2 WriteRecords
481  
482 =over
483  
484 =item DatabaseName => Str
485  
486 =item Records => ArrayRef[L<Paws::TimestreamWrite::Record>]
487  
488 =item TableName => Str
489  
490 =item [CommonAttributes => L<Paws::TimestreamWrite::Record>]
491  
492  
493 =back
494  
495 Each argument is described in detail in: L<Paws::TimestreamWrite::WriteRecords>
496  
497 Returns: nothing
498  
499 The WriteRecords operation enables you to write your time series data
500 into Timestream. You can specify a single data point or a batch of data
501 points to be inserted into the system. Timestream offers you with a
502 flexible schema that auto detects the column names and data types for
503 your Timestream tables based on the dimension names and data types of
504 the data points you specify when invoking writes into the database.
505 Timestream support eventual consistency read semantics. This means that
506 when you query data immediately after writing a batch of data into
507 Timestream, the query results might not reflect the results of a
508 recently completed write operation. The results may also include some
509 stale data. If you repeat the query request after a short time, the
510 results should return the latest data. Service quotas apply. For more
511 information, see Access Management
512 (https://docs.aws.amazon.com/timestream/latest/developerguide/ts-limits.html)
513 in the Timestream Developer Guide.
514  
515  
516  
517  
518 =head1 PAGINATORS
519  
520 Paginator methods are helpers that repetively call methods that return partial results
521  
522  
523  
524  
525 =head1 SEE ALSO
526  
527 This service class forms part of L<Paws>
528  
529 =head1 BUGS and CONTRIBUTIONS
530  
531 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
532  
533 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
534  
535 =cut
536