blib/lib/Paws/Athena.pm untested

filter: Statementstmt 0.0% 0 / 257 Branchbran 0.0% 0 / 28 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 48 Podpod 0.0% 0 / 47 totaltotal 0.0% 0 / 380 CC 15 SCAR 16.8
CC
15
Cov
0%
GetAllQueryResults
12.0
ListAllDatabases
12.0
ListAllDataCatalogs
12.0
CRAP 5.4
1 package Paws::Athena;
2 use Moose;
3 sub service { 'athena' }
4 sub signing_name { 'athena' }
5 sub version { '2017-05-18' }
6 sub target_prefix { 'AmazonAthena' }
7 sub json_version { "1.1" }
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 BatchGetNamedQuery {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::Athena::BatchGetNamedQuery', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub BatchGetQueryExecution {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::Athena::BatchGetQueryExecution', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateDataCatalog {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::Athena::CreateDataCatalog', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateNamedQuery {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::Athena::CreateNamedQuery', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreatePreparedStatement {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::Athena::CreatePreparedStatement', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateWorkGroup {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::Athena::CreateWorkGroup', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub DeleteDataCatalog {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::Athena::DeleteDataCatalog', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub DeleteNamedQuery {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::Athena::DeleteNamedQuery', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub DeletePreparedStatement {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::Athena::DeletePreparedStatement', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub DeleteWorkGroup {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::Athena::DeleteWorkGroup', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub GetDatabase {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::Athena::GetDatabase', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub GetDataCatalog {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::Athena::GetDataCatalog', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub GetNamedQuery {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::Athena::GetNamedQuery', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub GetPreparedStatement {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::Athena::GetPreparedStatement', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub GetQueryExecution {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::Athena::GetQueryExecution', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub GetQueryResults {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::Athena::GetQueryResults', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub GetTableMetadata {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::Athena::GetTableMetadata', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub GetWorkGroup {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::Athena::GetWorkGroup', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub ListDatabases {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::Athena::ListDatabases', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub ListDataCatalogs {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::Athena::ListDataCatalogs', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub ListEngineVersions {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::Athena::ListEngineVersions', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub ListNamedQueries {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::Athena::ListNamedQueries', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub ListPreparedStatements {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::Athena::ListPreparedStatements', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub ListQueryExecutions {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::Athena::ListQueryExecutions', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub ListTableMetadata {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::Athena::ListTableMetadata', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub ListTagsForResource {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::Athena::ListTagsForResource', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub ListWorkGroups {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::Athena::ListWorkGroups', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub StartQueryExecution {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::Athena::StartQueryExecution', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub StopQueryExecution {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::Athena::StopQueryExecution', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub TagResource {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::Athena::TagResource', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub UntagResource {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::Athena::UntagResource', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub UpdateDataCatalog {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::Athena::UpdateDataCatalog', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub UpdatePreparedStatement {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::Athena::UpdatePreparedStatement', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub UpdateWorkGroup {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::Athena::UpdateWorkGroup', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188
189 sub GetAllQueryResults {
190 my $self = shift;
191  
192 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
193 my $result = $self->GetQueryResults(@_);
194 my $next_result = $result;
195  
196 if (not defined $callback) {
197 while ($next_result->NextToken) {
198 $next_result = $self->GetQueryResults(@_, NextToken => $next_result->NextToken);
199 push @{ $result->ResultSet->Rows }, @{ $next_result->ResultSet->Rows };
200 }
201 return $result;
202 } else {
203 while ($result->NextToken) {
204 $callback->($_ => 'ResultSet.Rows') foreach (@{ $result->ResultSet->Rows });
205 $result = $self->GetQueryResults(@_, NextToken => $result->NextToken);
206 }
207 $callback->($_ => 'ResultSet.Rows') foreach (@{ $result->ResultSet->Rows });
208 }
209  
210 return undef
211 }
212 sub ListAllDatabases {
213 my $self = shift;
214  
215 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
216 my $result = $self->ListDatabases(@_);
217 my $next_result = $result;
218  
219 if (not defined $callback) {
220 while ($next_result->NextToken) {
221 $next_result = $self->ListDatabases(@_, NextToken => $next_result->NextToken);
222 push @{ $result->DatabaseList }, @{ $next_result->DatabaseList };
223 }
224 return $result;
225 } else {
226 while ($result->NextToken) {
227 $callback->($_ => 'DatabaseList') foreach (@{ $result->DatabaseList });
228 $result = $self->ListDatabases(@_, NextToken => $result->NextToken);
229 }
230 $callback->($_ => 'DatabaseList') foreach (@{ $result->DatabaseList });
231 }
232  
233 return undef
234 }
235 sub ListAllDataCatalogs {
236 my $self = shift;
237  
238 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
239 my $result = $self->ListDataCatalogs(@_);
240 my $next_result = $result;
241  
242 if (not defined $callback) {
243 while ($next_result->NextToken) {
244 $next_result = $self->ListDataCatalogs(@_, NextToken => $next_result->NextToken);
245 push @{ $result->DataCatalogsSummary }, @{ $next_result->DataCatalogsSummary };
246 }
247 return $result;
248 } else {
249 while ($result->NextToken) {
250 $callback->($_ => 'DataCatalogsSummary') foreach (@{ $result->DataCatalogsSummary });
251 $result = $self->ListDataCatalogs(@_, NextToken => $result->NextToken);
252 }
253 $callback->($_ => 'DataCatalogsSummary') foreach (@{ $result->DataCatalogsSummary });
254 }
255  
256 return undef
257 }
258 sub ListAllNamedQueries {
259 my $self = shift;
260  
261 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
262 my $result = $self->ListNamedQueries(@_);
263 my $next_result = $result;
264  
265 if (not defined $callback) {
266 while ($next_result->NextToken) {
267 $next_result = $self->ListNamedQueries(@_, NextToken => $next_result->NextToken);
268 push @{ $result->NamedQueryIds }, @{ $next_result->NamedQueryIds };
269 }
270 return $result;
271 } else {
272 while ($result->NextToken) {
273 $callback->($_ => 'NamedQueryIds') foreach (@{ $result->NamedQueryIds });
274 $result = $self->ListNamedQueries(@_, NextToken => $result->NextToken);
275 }
276 $callback->($_ => 'NamedQueryIds') foreach (@{ $result->NamedQueryIds });
277 }
278  
279 return undef
280 }
281 sub ListAllQueryExecutions {
282 my $self = shift;
283  
284 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
285 my $result = $self->ListQueryExecutions(@_);
286 my $next_result = $result;
287  
288 if (not defined $callback) {
289 while ($next_result->NextToken) {
290 $next_result = $self->ListQueryExecutions(@_, NextToken => $next_result->NextToken);
291 push @{ $result->QueryExecutionIds }, @{ $next_result->QueryExecutionIds };
292 }
293 return $result;
294 } else {
295 while ($result->NextToken) {
296 $callback->($_ => 'QueryExecutionIds') foreach (@{ $result->QueryExecutionIds });
297 $result = $self->ListQueryExecutions(@_, NextToken => $result->NextToken);
298 }
299 $callback->($_ => 'QueryExecutionIds') foreach (@{ $result->QueryExecutionIds });
300 }
301  
302 return undef
303 }
304 sub ListAllTableMetadata {
305 my $self = shift;
306  
307 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
308 my $result = $self->ListTableMetadata(@_);
309 my $next_result = $result;
310  
311 if (not defined $callback) {
312 while ($next_result->NextToken) {
313 $next_result = $self->ListTableMetadata(@_, NextToken => $next_result->NextToken);
314 push @{ $result->TableMetadataList }, @{ $next_result->TableMetadataList };
315 }
316 return $result;
317 } else {
318 while ($result->NextToken) {
319 $callback->($_ => 'TableMetadataList') foreach (@{ $result->TableMetadataList });
320 $result = $self->ListTableMetadata(@_, NextToken => $result->NextToken);
321 }
322 $callback->($_ => 'TableMetadataList') foreach (@{ $result->TableMetadataList });
323 }
324  
325 return undef
326 }
327 sub ListAllTagsForResource {
328 my $self = shift;
329  
330 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
331 my $result = $self->ListTagsForResource(@_);
332 my $next_result = $result;
333  
334 if (not defined $callback) {
335 while ($next_result->NextToken) {
336 $next_result = $self->ListTagsForResource(@_, NextToken => $next_result->NextToken);
337 push @{ $result->Tags }, @{ $next_result->Tags };
338 }
339 return $result;
340 } else {
341 while ($result->NextToken) {
342 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
343 $result = $self->ListTagsForResource(@_, NextToken => $result->NextToken);
344 }
345 $callback->($_ => 'Tags') foreach (@{ $result->Tags });
346 }
347  
348 return undef
349 }
350  
351  
352 sub operations { qw/BatchGetNamedQuery BatchGetQueryExecution CreateDataCatalog CreateNamedQuery CreatePreparedStatement CreateWorkGroup DeleteDataCatalog DeleteNamedQuery DeletePreparedStatement DeleteWorkGroup GetDatabase GetDataCatalog GetNamedQuery GetPreparedStatement GetQueryExecution GetQueryResults GetTableMetadata GetWorkGroup ListDatabases ListDataCatalogs ListEngineVersions ListNamedQueries ListPreparedStatements ListQueryExecutions ListTableMetadata ListTagsForResource ListWorkGroups StartQueryExecution StopQueryExecution TagResource UntagResource UpdateDataCatalog UpdatePreparedStatement UpdateWorkGroup / }
353  
354 1;
355  
356 ### main pod documentation begin ###
357  
358 =head1 NAME
359  
360 Paws::Athena - Perl Interface to AWS Amazon Athena
361  
362 =head1 SYNOPSIS
363  
364 use Paws;
365  
366 my $obj = Paws->service('Athena');
367 my $res = $obj->Method(
368 Arg1 => $val1,
369 Arg2 => [ 'V1', 'V2' ],
370 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
371 # of the arguments type
372 Arg3 => { Att1 => 'Val1' },
373 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
374 # the constructor of the arguments type
375 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
376 );
377  
378 =head1 DESCRIPTION
379  
380 Amazon Athena is an interactive query service that lets you use
381 standard SQL to analyze data directly in Amazon S3. You can point
382 Athena at your data in Amazon S3 and run ad-hoc queries and get results
383 in seconds. Athena is serverless, so there is no infrastructure to set
384 up or manage. You pay only for the queries you run. Athena scales
385 automaticallyE<mdash>executing queries in parallelE<mdash>so results
386 are fast, even with large datasets and complex queries. For more
387 information, see What is Amazon Athena
388 (http://docs.aws.amazon.com/athena/latest/ug/what-is.html) in the
389 I<Amazon Athena User Guide>.
390  
391 If you connect to Athena using the JDBC driver, use version 1.1.0 of
392 the driver or later with the Amazon Athena API. Earlier version drivers
393 do not support the API. For more information and to download the
394 driver, see Accessing Amazon Athena with JDBC
395 (https://docs.aws.amazon.com/athena/latest/ug/connect-with-jdbc.html).
396  
397 For code samples using the AWS SDK for Java, see Examples and Code
398 Samples
399 (https://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the
400 I<Amazon Athena User Guide>.
401  
402 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/athena-2017-05-18>
403  
404  
405 =head1 METHODS
406  
407 =head2 BatchGetNamedQuery
408  
409 =over
410  
411 =item NamedQueryIds => ArrayRef[Str|Undef]
412  
413  
414 =back
415  
416 Each argument is described in detail in: L<Paws::Athena::BatchGetNamedQuery>
417  
418 Returns: a L<Paws::Athena::BatchGetNamedQueryOutput> instance
419  
420 Returns the details of a single named query or a list of up to 50
421 queries, which you provide as an array of query ID strings. Requires
422 you to have access to the workgroup in which the queries were saved.
423 Use ListNamedQueriesInput to get the list of named query IDs in the
424 specified workgroup. If information could not be retrieved for a
425 submitted query ID, information about the query ID submitted is listed
426 under UnprocessedNamedQueryId. Named queries differ from executed
427 queries. Use BatchGetQueryExecutionInput to get details about each
428 unique query execution, and ListQueryExecutionsInput to get a list of
429 query execution IDs.
430  
431  
432 =head2 BatchGetQueryExecution
433  
434 =over
435  
436 =item QueryExecutionIds => ArrayRef[Str|Undef]
437  
438  
439 =back
440  
441 Each argument is described in detail in: L<Paws::Athena::BatchGetQueryExecution>
442  
443 Returns: a L<Paws::Athena::BatchGetQueryExecutionOutput> instance
444  
445 Returns the details of a single query execution or a list of up to 50
446 query executions, which you provide as an array of query execution ID
447 strings. Requires you to have access to the workgroup in which the
448 queries ran. To get a list of query execution IDs, use
449 ListQueryExecutionsInput$WorkGroup. Query executions differ from named
450 (saved) queries. Use BatchGetNamedQueryInput to get details about named
451 queries.
452  
453  
454 =head2 CreateDataCatalog
455  
456 =over
457  
458 =item Name => Str
459  
460 =item Type => Str
461  
462 =item [Description => Str]
463  
464 =item [Parameters => L<Paws::Athena::ParametersMap>]
465  
466 =item [Tags => ArrayRef[L<Paws::Athena::Tag>]]
467  
468  
469 =back
470  
471 Each argument is described in detail in: L<Paws::Athena::CreateDataCatalog>
472  
473 Returns: a L<Paws::Athena::CreateDataCatalogOutput> instance
474  
475 Creates (registers) a data catalog with the specified name and
476 properties. Catalogs created are visible to all users of the same AWS
477 account.
478  
479  
480 =head2 CreateNamedQuery
481  
482 =over
483  
484 =item Database => Str
485  
486 =item Name => Str
487  
488 =item QueryString => Str
489  
490 =item [ClientRequestToken => Str]
491  
492 =item [Description => Str]
493  
494 =item [WorkGroup => Str]
495  
496  
497 =back
498  
499 Each argument is described in detail in: L<Paws::Athena::CreateNamedQuery>
500  
501 Returns: a L<Paws::Athena::CreateNamedQueryOutput> instance
502  
503 Creates a named query in the specified workgroup. Requires that you
504 have access to the workgroup.
505  
506 For code samples using the AWS SDK for Java, see Examples and Code
507 Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html)
508 in the I<Amazon Athena User Guide>.
509  
510  
511 =head2 CreatePreparedStatement
512  
513 =over
514  
515 =item QueryStatement => Str
516  
517 =item StatementName => Str
518  
519 =item WorkGroup => Str
520  
521 =item [Description => Str]
522  
523  
524 =back
525  
526 Each argument is described in detail in: L<Paws::Athena::CreatePreparedStatement>
527  
528 Returns: a L<Paws::Athena::CreatePreparedStatementOutput> instance
529  
530 Creates a prepared statement for use with SQL queries in Athena.
531  
532  
533 =head2 CreateWorkGroup
534  
535 =over
536  
537 =item Name => Str
538  
539 =item [Configuration => L<Paws::Athena::WorkGroupConfiguration>]
540  
541 =item [Description => Str]
542  
543 =item [Tags => ArrayRef[L<Paws::Athena::Tag>]]
544  
545  
546 =back
547  
548 Each argument is described in detail in: L<Paws::Athena::CreateWorkGroup>
549  
550 Returns: a L<Paws::Athena::CreateWorkGroupOutput> instance
551  
552 Creates a workgroup with the specified name.
553  
554  
555 =head2 DeleteDataCatalog
556  
557 =over
558  
559 =item Name => Str
560  
561  
562 =back
563  
564 Each argument is described in detail in: L<Paws::Athena::DeleteDataCatalog>
565  
566 Returns: a L<Paws::Athena::DeleteDataCatalogOutput> instance
567  
568 Deletes a data catalog.
569  
570  
571 =head2 DeleteNamedQuery
572  
573 =over
574  
575 =item NamedQueryId => Str
576  
577  
578 =back
579  
580 Each argument is described in detail in: L<Paws::Athena::DeleteNamedQuery>
581  
582 Returns: a L<Paws::Athena::DeleteNamedQueryOutput> instance
583  
584 Deletes the named query if you have access to the workgroup in which
585 the query was saved.
586  
587 For code samples using the AWS SDK for Java, see Examples and Code
588 Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html)
589 in the I<Amazon Athena User Guide>.
590  
591  
592 =head2 DeletePreparedStatement
593  
594 =over
595  
596 =item StatementName => Str
597  
598 =item WorkGroup => Str
599  
600  
601 =back
602  
603 Each argument is described in detail in: L<Paws::Athena::DeletePreparedStatement>
604  
605 Returns: a L<Paws::Athena::DeletePreparedStatementOutput> instance
606  
607 Deletes the prepared statement with the specified name from the
608 specified workgroup.
609  
610  
611 =head2 DeleteWorkGroup
612  
613 =over
614  
615 =item WorkGroup => Str
616  
617 =item [RecursiveDeleteOption => Bool]
618  
619  
620 =back
621  
622 Each argument is described in detail in: L<Paws::Athena::DeleteWorkGroup>
623  
624 Returns: a L<Paws::Athena::DeleteWorkGroupOutput> instance
625  
626 Deletes the workgroup with the specified name. The primary workgroup
627 cannot be deleted.
628  
629  
630 =head2 GetDatabase
631  
632 =over
633  
634 =item CatalogName => Str
635  
636 =item DatabaseName => Str
637  
638  
639 =back
640  
641 Each argument is described in detail in: L<Paws::Athena::GetDatabase>
642  
643 Returns: a L<Paws::Athena::GetDatabaseOutput> instance
644  
645 Returns a database object for the specified database and data catalog.
646  
647  
648 =head2 GetDataCatalog
649  
650 =over
651  
652 =item Name => Str
653  
654  
655 =back
656  
657 Each argument is described in detail in: L<Paws::Athena::GetDataCatalog>
658  
659 Returns: a L<Paws::Athena::GetDataCatalogOutput> instance
660  
661 Returns the specified data catalog.
662  
663  
664 =head2 GetNamedQuery
665  
666 =over
667  
668 =item NamedQueryId => Str
669  
670  
671 =back
672  
673 Each argument is described in detail in: L<Paws::Athena::GetNamedQuery>
674  
675 Returns: a L<Paws::Athena::GetNamedQueryOutput> instance
676  
677 Returns information about a single query. Requires that you have access
678 to the workgroup in which the query was saved.
679  
680  
681 =head2 GetPreparedStatement
682  
683 =over
684  
685 =item StatementName => Str
686  
687 =item WorkGroup => Str
688  
689  
690 =back
691  
692 Each argument is described in detail in: L<Paws::Athena::GetPreparedStatement>
693  
694 Returns: a L<Paws::Athena::GetPreparedStatementOutput> instance
695  
696 Retrieves the prepared statement with the specified name from the
697 specified workgroup.
698  
699  
700 =head2 GetQueryExecution
701  
702 =over
703  
704 =item QueryExecutionId => Str
705  
706  
707 =back
708  
709 Each argument is described in detail in: L<Paws::Athena::GetQueryExecution>
710  
711 Returns: a L<Paws::Athena::GetQueryExecutionOutput> instance
712  
713 Returns information about a single execution of a query if you have
714 access to the workgroup in which the query ran. Each time a query
715 executes, information about the query execution is saved with a unique
716 ID.
717  
718  
719 =head2 GetQueryResults
720  
721 =over
722  
723 =item QueryExecutionId => Str
724  
725 =item [MaxResults => Int]
726  
727 =item [NextToken => Str]
728  
729  
730 =back
731  
732 Each argument is described in detail in: L<Paws::Athena::GetQueryResults>
733  
734 Returns: a L<Paws::Athena::GetQueryResultsOutput> instance
735  
736 Streams the results of a single query execution specified by
737 C<QueryExecutionId> from the Athena query results location in Amazon
738 S3. For more information, see Query Results
739 (https://docs.aws.amazon.com/athena/latest/ug/querying.html) in the
740 I<Amazon Athena User Guide>. This request does not execute the query
741 but returns results. Use StartQueryExecution to run a query.
742  
743 To stream query results successfully, the IAM principal with permission
744 to call C<GetQueryResults> also must have permissions to the Amazon S3
745 C<GetObject> action for the Athena query results location.
746  
747 IAM principals with permission to the Amazon S3 C<GetObject> action for
748 the query results location are able to retrieve query results from
749 Amazon S3 even if permission to the C<GetQueryResults> action is
750 denied. To restrict user or role access, ensure that Amazon S3
751 permissions to the Athena query location are denied.
752  
753  
754 =head2 GetTableMetadata
755  
756 =over
757  
758 =item CatalogName => Str
759  
760 =item DatabaseName => Str
761  
762 =item TableName => Str
763  
764  
765 =back
766  
767 Each argument is described in detail in: L<Paws::Athena::GetTableMetadata>
768  
769 Returns: a L<Paws::Athena::GetTableMetadataOutput> instance
770  
771 Returns table metadata for the specified catalog, database, and table.
772  
773  
774 =head2 GetWorkGroup
775  
776 =over
777  
778 =item WorkGroup => Str
779  
780  
781 =back
782  
783 Each argument is described in detail in: L<Paws::Athena::GetWorkGroup>
784  
785 Returns: a L<Paws::Athena::GetWorkGroupOutput> instance
786  
787 Returns information about the workgroup with the specified name.
788  
789  
790 =head2 ListDatabases
791  
792 =over
793  
794 =item CatalogName => Str
795  
796 =item [MaxResults => Int]
797  
798 =item [NextToken => Str]
799  
800  
801 =back
802  
803 Each argument is described in detail in: L<Paws::Athena::ListDatabases>
804  
805 Returns: a L<Paws::Athena::ListDatabasesOutput> instance
806  
807 Lists the databases in the specified data catalog.
808  
809  
810 =head2 ListDataCatalogs
811  
812 =over
813  
814 =item [MaxResults => Int]
815  
816 =item [NextToken => Str]
817  
818  
819 =back
820  
821 Each argument is described in detail in: L<Paws::Athena::ListDataCatalogs>
822  
823 Returns: a L<Paws::Athena::ListDataCatalogsOutput> instance
824  
825 Lists the data catalogs in the current AWS account.
826  
827  
828 =head2 ListEngineVersions
829  
830 =over
831  
832 =item [MaxResults => Int]
833  
834 =item [NextToken => Str]
835  
836  
837 =back
838  
839 Each argument is described in detail in: L<Paws::Athena::ListEngineVersions>
840  
841 Returns: a L<Paws::Athena::ListEngineVersionsOutput> instance
842  
843 Returns a list of engine versions that are available to choose from,
844 including the Auto option.
845  
846  
847 =head2 ListNamedQueries
848  
849 =over
850  
851 =item [MaxResults => Int]
852  
853 =item [NextToken => Str]
854  
855 =item [WorkGroup => Str]
856  
857  
858 =back
859  
860 Each argument is described in detail in: L<Paws::Athena::ListNamedQueries>
861  
862 Returns: a L<Paws::Athena::ListNamedQueriesOutput> instance
863  
864 Provides a list of available query IDs only for queries saved in the
865 specified workgroup. Requires that you have access to the specified
866 workgroup. If a workgroup is not specified, lists the saved queries for
867 the primary workgroup.
868  
869 For code samples using the AWS SDK for Java, see Examples and Code
870 Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html)
871 in the I<Amazon Athena User Guide>.
872  
873  
874 =head2 ListPreparedStatements
875  
876 =over
877  
878 =item WorkGroup => Str
879  
880 =item [MaxResults => Int]
881  
882 =item [NextToken => Str]
883  
884  
885 =back
886  
887 Each argument is described in detail in: L<Paws::Athena::ListPreparedStatements>
888  
889 Returns: a L<Paws::Athena::ListPreparedStatementsOutput> instance
890  
891 Lists the prepared statements in the specfied workgroup.
892  
893  
894 =head2 ListQueryExecutions
895  
896 =over
897  
898 =item [MaxResults => Int]
899  
900 =item [NextToken => Str]
901  
902 =item [WorkGroup => Str]
903  
904  
905 =back
906  
907 Each argument is described in detail in: L<Paws::Athena::ListQueryExecutions>
908  
909 Returns: a L<Paws::Athena::ListQueryExecutionsOutput> instance
910  
911 Provides a list of available query execution IDs for the queries in the
912 specified workgroup. If a workgroup is not specified, returns a list of
913 query execution IDs for the primary workgroup. Requires you to have
914 access to the workgroup in which the queries ran.
915  
916 For code samples using the AWS SDK for Java, see Examples and Code
917 Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html)
918 in the I<Amazon Athena User Guide>.
919  
920  
921 =head2 ListTableMetadata
922  
923 =over
924  
925 =item CatalogName => Str
926  
927 =item DatabaseName => Str
928  
929 =item [Expression => Str]
930  
931 =item [MaxResults => Int]
932  
933 =item [NextToken => Str]
934  
935  
936 =back
937  
938 Each argument is described in detail in: L<Paws::Athena::ListTableMetadata>
939  
940 Returns: a L<Paws::Athena::ListTableMetadataOutput> instance
941  
942 Lists the metadata for the tables in the specified data catalog
943 database.
944  
945  
946 =head2 ListTagsForResource
947  
948 =over
949  
950 =item ResourceARN => Str
951  
952 =item [MaxResults => Int]
953  
954 =item [NextToken => Str]
955  
956  
957 =back
958  
959 Each argument is described in detail in: L<Paws::Athena::ListTagsForResource>
960  
961 Returns: a L<Paws::Athena::ListTagsForResourceOutput> instance
962  
963 Lists the tags associated with an Athena workgroup or data catalog
964 resource.
965  
966  
967 =head2 ListWorkGroups
968  
969 =over
970  
971 =item [MaxResults => Int]
972  
973 =item [NextToken => Str]
974  
975  
976 =back
977  
978 Each argument is described in detail in: L<Paws::Athena::ListWorkGroups>
979  
980 Returns: a L<Paws::Athena::ListWorkGroupsOutput> instance
981  
982 Lists available workgroups for the account.
983  
984  
985 =head2 StartQueryExecution
986  
987 =over
988  
989 =item QueryString => Str
990  
991 =item [ClientRequestToken => Str]
992  
993 =item [QueryExecutionContext => L<Paws::Athena::QueryExecutionContext>]
994  
995 =item [ResultConfiguration => L<Paws::Athena::ResultConfiguration>]
996  
997 =item [WorkGroup => Str]
998  
999  
1000 =back
1001  
1002 Each argument is described in detail in: L<Paws::Athena::StartQueryExecution>
1003  
1004 Returns: a L<Paws::Athena::StartQueryExecutionOutput> instance
1005  
1006 Runs the SQL query statements contained in the C<Query>. Requires you
1007 to have access to the workgroup in which the query ran. Running queries
1008 against an external catalog requires GetDataCatalog permission to the
1009 catalog. For code samples using the AWS SDK for Java, see Examples and
1010 Code Samples
1011 (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html) in the
1012 I<Amazon Athena User Guide>.
1013  
1014  
1015 =head2 StopQueryExecution
1016  
1017 =over
1018  
1019 =item QueryExecutionId => Str
1020  
1021  
1022 =back
1023  
1024 Each argument is described in detail in: L<Paws::Athena::StopQueryExecution>
1025  
1026 Returns: a L<Paws::Athena::StopQueryExecutionOutput> instance
1027  
1028 Stops a query execution. Requires you to have access to the workgroup
1029 in which the query ran.
1030  
1031 For code samples using the AWS SDK for Java, see Examples and Code
1032 Samples (http://docs.aws.amazon.com/athena/latest/ug/code-samples.html)
1033 in the I<Amazon Athena User Guide>.
1034  
1035  
1036 =head2 TagResource
1037  
1038 =over
1039  
1040 =item ResourceARN => Str
1041  
1042 =item Tags => ArrayRef[L<Paws::Athena::Tag>]
1043  
1044  
1045 =back
1046  
1047 Each argument is described in detail in: L<Paws::Athena::TagResource>
1048  
1049 Returns: a L<Paws::Athena::TagResourceOutput> instance
1050  
1051 Adds one or more tags to an Athena resource. A tag is a label that you
1052 assign to a resource. In Athena, a resource can be a workgroup or data
1053 catalog. Each tag consists of a key and an optional value, both of
1054 which you define. For example, you can use tags to categorize Athena
1055 workgroups or data catalogs by purpose, owner, or environment. Use a
1056 consistent set of tag keys to make it easier to search and filter
1057 workgroups or data catalogs in your account. For best practices, see
1058 Tagging Best Practices
1059 (https://aws.amazon.com/answers/account-management/aws-tagging-strategies/).
1060 Tag keys can be from 1 to 128 UTF-8 Unicode characters, and tag values
1061 can be from 0 to 256 UTF-8 Unicode characters. Tags can use letters and
1062 numbers representable in UTF-8, and the following characters: + - = . _
1063 : / @. Tag keys and values are case-sensitive. Tag keys must be unique
1064 per resource. If you specify more than one tag, separate them by
1065 commas.
1066  
1067  
1068 =head2 UntagResource
1069  
1070 =over
1071  
1072 =item ResourceARN => Str
1073  
1074 =item TagKeys => ArrayRef[Str|Undef]
1075  
1076  
1077 =back
1078  
1079 Each argument is described in detail in: L<Paws::Athena::UntagResource>
1080  
1081 Returns: a L<Paws::Athena::UntagResourceOutput> instance
1082  
1083 Removes one or more tags from a data catalog or workgroup resource.
1084  
1085  
1086 =head2 UpdateDataCatalog
1087  
1088 =over
1089  
1090 =item Name => Str
1091  
1092 =item Type => Str
1093  
1094 =item [Description => Str]
1095  
1096 =item [Parameters => L<Paws::Athena::ParametersMap>]
1097  
1098  
1099 =back
1100  
1101 Each argument is described in detail in: L<Paws::Athena::UpdateDataCatalog>
1102  
1103 Returns: a L<Paws::Athena::UpdateDataCatalogOutput> instance
1104  
1105 Updates the data catalog that has the specified name.
1106  
1107  
1108 =head2 UpdatePreparedStatement
1109  
1110 =over
1111  
1112 =item QueryStatement => Str
1113  
1114 =item StatementName => Str
1115  
1116 =item WorkGroup => Str
1117  
1118 =item [Description => Str]
1119  
1120  
1121 =back
1122  
1123 Each argument is described in detail in: L<Paws::Athena::UpdatePreparedStatement>
1124  
1125 Returns: a L<Paws::Athena::UpdatePreparedStatementOutput> instance
1126  
1127 Updates a prepared statement.
1128  
1129  
1130 =head2 UpdateWorkGroup
1131  
1132 =over
1133  
1134 =item WorkGroup => Str
1135  
1136 =item [ConfigurationUpdates => L<Paws::Athena::WorkGroupConfigurationUpdates>]
1137  
1138 =item [Description => Str]
1139  
1140 =item [State => Str]
1141  
1142  
1143 =back
1144  
1145 Each argument is described in detail in: L<Paws::Athena::UpdateWorkGroup>
1146  
1147 Returns: a L<Paws::Athena::UpdateWorkGroupOutput> instance
1148  
1149 Updates the workgroup with the specified name. The workgroup's name
1150 cannot be changed.
1151  
1152  
1153  
1154  
1155 =head1 PAGINATORS
1156  
1157 Paginator methods are helpers that repetively call methods that return partial results
1158  
1159 =head2 GetAllQueryResults(sub { },QueryExecutionId => Str, [MaxResults => Int, NextToken => Str])
1160  
1161 =head2 GetAllQueryResults(QueryExecutionId => Str, [MaxResults => Int, NextToken => Str])
1162  
1163  
1164 If passed a sub as first parameter, it will call the sub for each element found in :
1165  
1166 - ResultSet.Rows, passing the object as the first parameter, and the string 'ResultSet.Rows' as the second parameter
1167  
1168 If not, it will return a a L<Paws::Athena::GetQueryResultsOutput> 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.
1169  
1170  
1171 =head2 ListAllDatabases(sub { },CatalogName => Str, [MaxResults => Int, NextToken => Str])
1172  
1173 =head2 ListAllDatabases(CatalogName => Str, [MaxResults => Int, NextToken => Str])
1174  
1175  
1176 If passed a sub as first parameter, it will call the sub for each element found in :
1177  
1178 - DatabaseList, passing the object as the first parameter, and the string 'DatabaseList' as the second parameter
1179  
1180 If not, it will return a a L<Paws::Athena::ListDatabasesOutput> 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.
1181  
1182  
1183 =head2 ListAllDataCatalogs(sub { },[MaxResults => Int, NextToken => Str])
1184  
1185 =head2 ListAllDataCatalogs([MaxResults => Int, NextToken => Str])
1186  
1187  
1188 If passed a sub as first parameter, it will call the sub for each element found in :
1189  
1190 - DataCatalogsSummary, passing the object as the first parameter, and the string 'DataCatalogsSummary' as the second parameter
1191  
1192 If not, it will return a a L<Paws::Athena::ListDataCatalogsOutput> 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.
1193  
1194  
1195 =head2 ListAllNamedQueries(sub { },[MaxResults => Int, NextToken => Str, WorkGroup => Str])
1196  
1197 =head2 ListAllNamedQueries([MaxResults => Int, NextToken => Str, WorkGroup => Str])
1198  
1199  
1200 If passed a sub as first parameter, it will call the sub for each element found in :
1201  
1202 - NamedQueryIds, passing the object as the first parameter, and the string 'NamedQueryIds' as the second parameter
1203  
1204 If not, it will return a a L<Paws::Athena::ListNamedQueriesOutput> 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.
1205  
1206  
1207 =head2 ListAllQueryExecutions(sub { },[MaxResults => Int, NextToken => Str, WorkGroup => Str])
1208  
1209 =head2 ListAllQueryExecutions([MaxResults => Int, NextToken => Str, WorkGroup => Str])
1210  
1211  
1212 If passed a sub as first parameter, it will call the sub for each element found in :
1213  
1214 - QueryExecutionIds, passing the object as the first parameter, and the string 'QueryExecutionIds' as the second parameter
1215  
1216 If not, it will return a a L<Paws::Athena::ListQueryExecutionsOutput> 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.
1217  
1218  
1219 =head2 ListAllTableMetadata(sub { },CatalogName => Str, DatabaseName => Str, [Expression => Str, MaxResults => Int, NextToken => Str])
1220  
1221 =head2 ListAllTableMetadata(CatalogName => Str, DatabaseName => Str, [Expression => Str, MaxResults => Int, NextToken => Str])
1222  
1223  
1224 If passed a sub as first parameter, it will call the sub for each element found in :
1225  
1226 - TableMetadataList, passing the object as the first parameter, and the string 'TableMetadataList' as the second parameter
1227  
1228 If not, it will return a a L<Paws::Athena::ListTableMetadataOutput> 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.
1229  
1230  
1231 =head2 ListAllTagsForResource(sub { },ResourceARN => Str, [MaxResults => Int, NextToken => Str])
1232  
1233 =head2 ListAllTagsForResource(ResourceARN => Str, [MaxResults => Int, NextToken => Str])
1234  
1235  
1236 If passed a sub as first parameter, it will call the sub for each element found in :
1237  
1238 - Tags, passing the object as the first parameter, and the string 'Tags' as the second parameter
1239  
1240 If not, it will return a a L<Paws::Athena::ListTagsForResourceOutput> 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.
1241  
1242  
1243  
1244  
1245  
1246 =head1 SEE ALSO
1247  
1248 This service class forms part of L<Paws>
1249  
1250 =head1 BUGS and CONTRIBUTIONS
1251  
1252 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1253  
1254 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1255  
1256 =cut
1257