blib/lib/Paws/Glue.pm untested

filter: Statementstmt 0.0% 0 / 866 Branchbran 0.0% 0 / 76 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 183 Podpod 0.0% 0 / 182 totaltotal 0.0% 0 / 1307 CC 39 SCAR 15.2
CC
39
Cov
0%
GetAllClassifiers
12.0
GetAllConnections
12.0
GetAllCrawlerMetrics
12.0
CRAP 4.6
1 package Paws::Glue;
2 use Moose;
3 sub service { 'glue' }
4 sub signing_name { 'glue' }
5 sub version { '2017-03-31' }
6 sub target_prefix { 'AWSGlue' }
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 BatchCreatePartition {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::Glue::BatchCreatePartition', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub BatchDeleteConnection {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::Glue::BatchDeleteConnection', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub BatchDeletePartition {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::Glue::BatchDeletePartition', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub BatchDeleteTable {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::Glue::BatchDeleteTable', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub BatchDeleteTableVersion {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::Glue::BatchDeleteTableVersion', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub BatchGetCrawlers {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetCrawlers', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub BatchGetDevEndpoints {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetDevEndpoints', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub BatchGetJobs {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetJobs', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub BatchGetPartition {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetPartition', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub BatchGetTriggers {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetTriggers', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub BatchGetWorkflows {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::Glue::BatchGetWorkflows', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub BatchStopJobRun {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::Glue::BatchStopJobRun', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub BatchUpdatePartition {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::Glue::BatchUpdatePartition', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub CancelMLTaskRun {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::Glue::CancelMLTaskRun', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub CheckSchemaVersionValidity {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::Glue::CheckSchemaVersionValidity', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub CreateClassifier {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::Glue::CreateClassifier', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub CreateConnection {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::Glue::CreateConnection', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub CreateCrawler {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::Glue::CreateCrawler', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub CreateDatabase {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::Glue::CreateDatabase', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub CreateDevEndpoint {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::Glue::CreateDevEndpoint', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub CreateJob {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::Glue::CreateJob', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub CreateMLTransform {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::Glue::CreateMLTransform', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub CreatePartition {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::Glue::CreatePartition', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub CreatePartitionIndex {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::Glue::CreatePartitionIndex', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub CreateRegistry {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::Glue::CreateRegistry', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub CreateSchema {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::Glue::CreateSchema', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub CreateScript {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::Glue::CreateScript', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub CreateSecurityConfiguration {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::Glue::CreateSecurityConfiguration', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub CreateTable {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::Glue::CreateTable', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub CreateTrigger {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::Glue::CreateTrigger', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub CreateUserDefinedFunction {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::Glue::CreateUserDefinedFunction', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub CreateWorkflow {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::Glue::CreateWorkflow', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub DeleteClassifier {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteClassifier', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub DeleteColumnStatisticsForPartition {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteColumnStatisticsForPartition', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub DeleteColumnStatisticsForTable {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteColumnStatisticsForTable', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub DeleteConnection {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteConnection', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub DeleteCrawler {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteCrawler', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub DeleteDatabase {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteDatabase', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub DeleteDevEndpoint {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteDevEndpoint', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub DeleteJob {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteJob', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub DeleteMLTransform {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteMLTransform', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub DeletePartition {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::Glue::DeletePartition', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub DeletePartitionIndex {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::Glue::DeletePartitionIndex', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub DeleteRegistry {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteRegistry', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub DeleteResourcePolicy {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteResourcePolicy', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub DeleteSchema {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteSchema', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub DeleteSchemaVersions {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteSchemaVersions', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub DeleteSecurityConfiguration {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteSecurityConfiguration', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub DeleteTable {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteTable', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub DeleteTableVersion {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteTableVersion', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub DeleteTrigger {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteTrigger', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub DeleteUserDefinedFunction {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteUserDefinedFunction', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278 sub DeleteWorkflow {
279 my $self = shift;
280 my $call_object = $self->new_with_coercions('Paws::Glue::DeleteWorkflow', @_);
281 return $self->caller->do_call($self, $call_object);
282 }
283 sub GetCatalogImportStatus {
284 my $self = shift;
285 my $call_object = $self->new_with_coercions('Paws::Glue::GetCatalogImportStatus', @_);
286 return $self->caller->do_call($self, $call_object);
287 }
288 sub GetClassifier {
289 my $self = shift;
290 my $call_object = $self->new_with_coercions('Paws::Glue::GetClassifier', @_);
291 return $self->caller->do_call($self, $call_object);
292 }
293 sub GetClassifiers {
294 my $self = shift;
295 my $call_object = $self->new_with_coercions('Paws::Glue::GetClassifiers', @_);
296 return $self->caller->do_call($self, $call_object);
297 }
298 sub GetColumnStatisticsForPartition {
299 my $self = shift;
300 my $call_object = $self->new_with_coercions('Paws::Glue::GetColumnStatisticsForPartition', @_);
301 return $self->caller->do_call($self, $call_object);
302 }
303 sub GetColumnStatisticsForTable {
304 my $self = shift;
305 my $call_object = $self->new_with_coercions('Paws::Glue::GetColumnStatisticsForTable', @_);
306 return $self->caller->do_call($self, $call_object);
307 }
308 sub GetConnection {
309 my $self = shift;
310 my $call_object = $self->new_with_coercions('Paws::Glue::GetConnection', @_);
311 return $self->caller->do_call($self, $call_object);
312 }
313 sub GetConnections {
314 my $self = shift;
315 my $call_object = $self->new_with_coercions('Paws::Glue::GetConnections', @_);
316 return $self->caller->do_call($self, $call_object);
317 }
318 sub GetCrawler {
319 my $self = shift;
320 my $call_object = $self->new_with_coercions('Paws::Glue::GetCrawler', @_);
321 return $self->caller->do_call($self, $call_object);
322 }
323 sub GetCrawlerMetrics {
324 my $self = shift;
325 my $call_object = $self->new_with_coercions('Paws::Glue::GetCrawlerMetrics', @_);
326 return $self->caller->do_call($self, $call_object);
327 }
328 sub GetCrawlers {
329 my $self = shift;
330 my $call_object = $self->new_with_coercions('Paws::Glue::GetCrawlers', @_);
331 return $self->caller->do_call($self, $call_object);
332 }
333 sub GetDatabase {
334 my $self = shift;
335 my $call_object = $self->new_with_coercions('Paws::Glue::GetDatabase', @_);
336 return $self->caller->do_call($self, $call_object);
337 }
338 sub GetDatabases {
339 my $self = shift;
340 my $call_object = $self->new_with_coercions('Paws::Glue::GetDatabases', @_);
341 return $self->caller->do_call($self, $call_object);
342 }
343 sub GetDataCatalogEncryptionSettings {
344 my $self = shift;
345 my $call_object = $self->new_with_coercions('Paws::Glue::GetDataCatalogEncryptionSettings', @_);
346 return $self->caller->do_call($self, $call_object);
347 }
348 sub GetDataflowGraph {
349 my $self = shift;
350 my $call_object = $self->new_with_coercions('Paws::Glue::GetDataflowGraph', @_);
351 return $self->caller->do_call($self, $call_object);
352 }
353 sub GetDevEndpoint {
354 my $self = shift;
355 my $call_object = $self->new_with_coercions('Paws::Glue::GetDevEndpoint', @_);
356 return $self->caller->do_call($self, $call_object);
357 }
358 sub GetDevEndpoints {
359 my $self = shift;
360 my $call_object = $self->new_with_coercions('Paws::Glue::GetDevEndpoints', @_);
361 return $self->caller->do_call($self, $call_object);
362 }
363 sub GetJob {
364 my $self = shift;
365 my $call_object = $self->new_with_coercions('Paws::Glue::GetJob', @_);
366 return $self->caller->do_call($self, $call_object);
367 }
368 sub GetJobBookmark {
369 my $self = shift;
370 my $call_object = $self->new_with_coercions('Paws::Glue::GetJobBookmark', @_);
371 return $self->caller->do_call($self, $call_object);
372 }
373 sub GetJobRun {
374 my $self = shift;
375 my $call_object = $self->new_with_coercions('Paws::Glue::GetJobRun', @_);
376 return $self->caller->do_call($self, $call_object);
377 }
378 sub GetJobRuns {
379 my $self = shift;
380 my $call_object = $self->new_with_coercions('Paws::Glue::GetJobRuns', @_);
381 return $self->caller->do_call($self, $call_object);
382 }
383 sub GetJobs {
384 my $self = shift;
385 my $call_object = $self->new_with_coercions('Paws::Glue::GetJobs', @_);
386 return $self->caller->do_call($self, $call_object);
387 }
388 sub GetMapping {
389 my $self = shift;
390 my $call_object = $self->new_with_coercions('Paws::Glue::GetMapping', @_);
391 return $self->caller->do_call($self, $call_object);
392 }
393 sub GetMLTaskRun {
394 my $self = shift;
395 my $call_object = $self->new_with_coercions('Paws::Glue::GetMLTaskRun', @_);
396 return $self->caller->do_call($self, $call_object);
397 }
398 sub GetMLTaskRuns {
399 my $self = shift;
400 my $call_object = $self->new_with_coercions('Paws::Glue::GetMLTaskRuns', @_);
401 return $self->caller->do_call($self, $call_object);
402 }
403 sub GetMLTransform {
404 my $self = shift;
405 my $call_object = $self->new_with_coercions('Paws::Glue::GetMLTransform', @_);
406 return $self->caller->do_call($self, $call_object);
407 }
408 sub GetMLTransforms {
409 my $self = shift;
410 my $call_object = $self->new_with_coercions('Paws::Glue::GetMLTransforms', @_);
411 return $self->caller->do_call($self, $call_object);
412 }
413 sub GetPartition {
414 my $self = shift;
415 my $call_object = $self->new_with_coercions('Paws::Glue::GetPartition', @_);
416 return $self->caller->do_call($self, $call_object);
417 }
418 sub GetPartitionIndexes {
419 my $self = shift;
420 my $call_object = $self->new_with_coercions('Paws::Glue::GetPartitionIndexes', @_);
421 return $self->caller->do_call($self, $call_object);
422 }
423 sub GetPartitions {
424 my $self = shift;
425 my $call_object = $self->new_with_coercions('Paws::Glue::GetPartitions', @_);
426 return $self->caller->do_call($self, $call_object);
427 }
428 sub GetPlan {
429 my $self = shift;
430 my $call_object = $self->new_with_coercions('Paws::Glue::GetPlan', @_);
431 return $self->caller->do_call($self, $call_object);
432 }
433 sub GetRegistry {
434 my $self = shift;
435 my $call_object = $self->new_with_coercions('Paws::Glue::GetRegistry', @_);
436 return $self->caller->do_call($self, $call_object);
437 }
438 sub GetResourcePolicies {
439 my $self = shift;
440 my $call_object = $self->new_with_coercions('Paws::Glue::GetResourcePolicies', @_);
441 return $self->caller->do_call($self, $call_object);
442 }
443 sub GetResourcePolicy {
444 my $self = shift;
445 my $call_object = $self->new_with_coercions('Paws::Glue::GetResourcePolicy', @_);
446 return $self->caller->do_call($self, $call_object);
447 }
448 sub GetSchema {
449 my $self = shift;
450 my $call_object = $self->new_with_coercions('Paws::Glue::GetSchema', @_);
451 return $self->caller->do_call($self, $call_object);
452 }
453 sub GetSchemaByDefinition {
454 my $self = shift;
455 my $call_object = $self->new_with_coercions('Paws::Glue::GetSchemaByDefinition', @_);
456 return $self->caller->do_call($self, $call_object);
457 }
458 sub GetSchemaVersion {
459 my $self = shift;
460 my $call_object = $self->new_with_coercions('Paws::Glue::GetSchemaVersion', @_);
461 return $self->caller->do_call($self, $call_object);
462 }
463 sub GetSchemaVersionsDiff {
464 my $self = shift;
465 my $call_object = $self->new_with_coercions('Paws::Glue::GetSchemaVersionsDiff', @_);
466 return $self->caller->do_call($self, $call_object);
467 }
468 sub GetSecurityConfiguration {
469 my $self = shift;
470 my $call_object = $self->new_with_coercions('Paws::Glue::GetSecurityConfiguration', @_);
471 return $self->caller->do_call($self, $call_object);
472 }
473 sub GetSecurityConfigurations {
474 my $self = shift;
475 my $call_object = $self->new_with_coercions('Paws::Glue::GetSecurityConfigurations', @_);
476 return $self->caller->do_call($self, $call_object);
477 }
478 sub GetTable {
479 my $self = shift;
480 my $call_object = $self->new_with_coercions('Paws::Glue::GetTable', @_);
481 return $self->caller->do_call($self, $call_object);
482 }
483 sub GetTables {
484 my $self = shift;
485 my $call_object = $self->new_with_coercions('Paws::Glue::GetTables', @_);
486 return $self->caller->do_call($self, $call_object);
487 }
488 sub GetTableVersion {
489 my $self = shift;
490 my $call_object = $self->new_with_coercions('Paws::Glue::GetTableVersion', @_);
491 return $self->caller->do_call($self, $call_object);
492 }
493 sub GetTableVersions {
494 my $self = shift;
495 my $call_object = $self->new_with_coercions('Paws::Glue::GetTableVersions', @_);
496 return $self->caller->do_call($self, $call_object);
497 }
498 sub GetTags {
499 my $self = shift;
500 my $call_object = $self->new_with_coercions('Paws::Glue::GetTags', @_);
501 return $self->caller->do_call($self, $call_object);
502 }
503 sub GetTrigger {
504 my $self = shift;
505 my $call_object = $self->new_with_coercions('Paws::Glue::GetTrigger', @_);
506 return $self->caller->do_call($self, $call_object);
507 }
508 sub GetTriggers {
509 my $self = shift;
510 my $call_object = $self->new_with_coercions('Paws::Glue::GetTriggers', @_);
511 return $self->caller->do_call($self, $call_object);
512 }
513 sub GetUserDefinedFunction {
514 my $self = shift;
515 my $call_object = $self->new_with_coercions('Paws::Glue::GetUserDefinedFunction', @_);
516 return $self->caller->do_call($self, $call_object);
517 }
518 sub GetUserDefinedFunctions {
519 my $self = shift;
520 my $call_object = $self->new_with_coercions('Paws::Glue::GetUserDefinedFunctions', @_);
521 return $self->caller->do_call($self, $call_object);
522 }
523 sub GetWorkflow {
524 my $self = shift;
525 my $call_object = $self->new_with_coercions('Paws::Glue::GetWorkflow', @_);
526 return $self->caller->do_call($self, $call_object);
527 }
528 sub GetWorkflowRun {
529 my $self = shift;
530 my $call_object = $self->new_with_coercions('Paws::Glue::GetWorkflowRun', @_);
531 return $self->caller->do_call($self, $call_object);
532 }
533 sub GetWorkflowRunProperties {
534 my $self = shift;
535 my $call_object = $self->new_with_coercions('Paws::Glue::GetWorkflowRunProperties', @_);
536 return $self->caller->do_call($self, $call_object);
537 }
538 sub GetWorkflowRuns {
539 my $self = shift;
540 my $call_object = $self->new_with_coercions('Paws::Glue::GetWorkflowRuns', @_);
541 return $self->caller->do_call($self, $call_object);
542 }
543 sub ImportCatalogToGlue {
544 my $self = shift;
545 my $call_object = $self->new_with_coercions('Paws::Glue::ImportCatalogToGlue', @_);
546 return $self->caller->do_call($self, $call_object);
547 }
548 sub ListCrawlers {
549 my $self = shift;
550 my $call_object = $self->new_with_coercions('Paws::Glue::ListCrawlers', @_);
551 return $self->caller->do_call($self, $call_object);
552 }
553 sub ListDevEndpoints {
554 my $self = shift;
555 my $call_object = $self->new_with_coercions('Paws::Glue::ListDevEndpoints', @_);
556 return $self->caller->do_call($self, $call_object);
557 }
558 sub ListJobs {
559 my $self = shift;
560 my $call_object = $self->new_with_coercions('Paws::Glue::ListJobs', @_);
561 return $self->caller->do_call($self, $call_object);
562 }
563 sub ListMLTransforms {
564 my $self = shift;
565 my $call_object = $self->new_with_coercions('Paws::Glue::ListMLTransforms', @_);
566 return $self->caller->do_call($self, $call_object);
567 }
568 sub ListRegistries {
569 my $self = shift;
570 my $call_object = $self->new_with_coercions('Paws::Glue::ListRegistries', @_);
571 return $self->caller->do_call($self, $call_object);
572 }
573 sub ListSchemas {
574 my $self = shift;
575 my $call_object = $self->new_with_coercions('Paws::Glue::ListSchemas', @_);
576 return $self->caller->do_call($self, $call_object);
577 }
578 sub ListSchemaVersions {
579 my $self = shift;
580 my $call_object = $self->new_with_coercions('Paws::Glue::ListSchemaVersions', @_);
581 return $self->caller->do_call($self, $call_object);
582 }
583 sub ListTriggers {
584 my $self = shift;
585 my $call_object = $self->new_with_coercions('Paws::Glue::ListTriggers', @_);
586 return $self->caller->do_call($self, $call_object);
587 }
588 sub ListWorkflows {
589 my $self = shift;
590 my $call_object = $self->new_with_coercions('Paws::Glue::ListWorkflows', @_);
591 return $self->caller->do_call($self, $call_object);
592 }
593 sub PutDataCatalogEncryptionSettings {
594 my $self = shift;
595 my $call_object = $self->new_with_coercions('Paws::Glue::PutDataCatalogEncryptionSettings', @_);
596 return $self->caller->do_call($self, $call_object);
597 }
598 sub PutResourcePolicy {
599 my $self = shift;
600 my $call_object = $self->new_with_coercions('Paws::Glue::PutResourcePolicy', @_);
601 return $self->caller->do_call($self, $call_object);
602 }
603 sub PutSchemaVersionMetadata {
604 my $self = shift;
605 my $call_object = $self->new_with_coercions('Paws::Glue::PutSchemaVersionMetadata', @_);
606 return $self->caller->do_call($self, $call_object);
607 }
608 sub PutWorkflowRunProperties {
609 my $self = shift;
610 my $call_object = $self->new_with_coercions('Paws::Glue::PutWorkflowRunProperties', @_);
611 return $self->caller->do_call($self, $call_object);
612 }
613 sub QuerySchemaVersionMetadata {
614 my $self = shift;
615 my $call_object = $self->new_with_coercions('Paws::Glue::QuerySchemaVersionMetadata', @_);
616 return $self->caller->do_call($self, $call_object);
617 }
618 sub RegisterSchemaVersion {
619 my $self = shift;
620 my $call_object = $self->new_with_coercions('Paws::Glue::RegisterSchemaVersion', @_);
621 return $self->caller->do_call($self, $call_object);
622 }
623 sub RemoveSchemaVersionMetadata {
624 my $self = shift;
625 my $call_object = $self->new_with_coercions('Paws::Glue::RemoveSchemaVersionMetadata', @_);
626 return $self->caller->do_call($self, $call_object);
627 }
628 sub ResetJobBookmark {
629 my $self = shift;
630 my $call_object = $self->new_with_coercions('Paws::Glue::ResetJobBookmark', @_);
631 return $self->caller->do_call($self, $call_object);
632 }
633 sub ResumeWorkflowRun {
634 my $self = shift;
635 my $call_object = $self->new_with_coercions('Paws::Glue::ResumeWorkflowRun', @_);
636 return $self->caller->do_call($self, $call_object);
637 }
638 sub SearchTables {
639 my $self = shift;
640 my $call_object = $self->new_with_coercions('Paws::Glue::SearchTables', @_);
641 return $self->caller->do_call($self, $call_object);
642 }
643 sub StartCrawler {
644 my $self = shift;
645 my $call_object = $self->new_with_coercions('Paws::Glue::StartCrawler', @_);
646 return $self->caller->do_call($self, $call_object);
647 }
648 sub StartCrawlerSchedule {
649 my $self = shift;
650 my $call_object = $self->new_with_coercions('Paws::Glue::StartCrawlerSchedule', @_);
651 return $self->caller->do_call($self, $call_object);
652 }
653 sub StartExportLabelsTaskRun {
654 my $self = shift;
655 my $call_object = $self->new_with_coercions('Paws::Glue::StartExportLabelsTaskRun', @_);
656 return $self->caller->do_call($self, $call_object);
657 }
658 sub StartImportLabelsTaskRun {
659 my $self = shift;
660 my $call_object = $self->new_with_coercions('Paws::Glue::StartImportLabelsTaskRun', @_);
661 return $self->caller->do_call($self, $call_object);
662 }
663 sub StartJobRun {
664 my $self = shift;
665 my $call_object = $self->new_with_coercions('Paws::Glue::StartJobRun', @_);
666 return $self->caller->do_call($self, $call_object);
667 }
668 sub StartMLEvaluationTaskRun {
669 my $self = shift;
670 my $call_object = $self->new_with_coercions('Paws::Glue::StartMLEvaluationTaskRun', @_);
671 return $self->caller->do_call($self, $call_object);
672 }
673 sub StartMLLabelingSetGenerationTaskRun {
674 my $self = shift;
675 my $call_object = $self->new_with_coercions('Paws::Glue::StartMLLabelingSetGenerationTaskRun', @_);
676 return $self->caller->do_call($self, $call_object);
677 }
678 sub StartTrigger {
679 my $self = shift;
680 my $call_object = $self->new_with_coercions('Paws::Glue::StartTrigger', @_);
681 return $self->caller->do_call($self, $call_object);
682 }
683 sub StartWorkflowRun {
684 my $self = shift;
685 my $call_object = $self->new_with_coercions('Paws::Glue::StartWorkflowRun', @_);
686 return $self->caller->do_call($self, $call_object);
687 }
688 sub StopCrawler {
689 my $self = shift;
690 my $call_object = $self->new_with_coercions('Paws::Glue::StopCrawler', @_);
691 return $self->caller->do_call($self, $call_object);
692 }
693 sub StopCrawlerSchedule {
694 my $self = shift;
695 my $call_object = $self->new_with_coercions('Paws::Glue::StopCrawlerSchedule', @_);
696 return $self->caller->do_call($self, $call_object);
697 }
698 sub StopTrigger {
699 my $self = shift;
700 my $call_object = $self->new_with_coercions('Paws::Glue::StopTrigger', @_);
701 return $self->caller->do_call($self, $call_object);
702 }
703 sub StopWorkflowRun {
704 my $self = shift;
705 my $call_object = $self->new_with_coercions('Paws::Glue::StopWorkflowRun', @_);
706 return $self->caller->do_call($self, $call_object);
707 }
708 sub TagResource {
709 my $self = shift;
710 my $call_object = $self->new_with_coercions('Paws::Glue::TagResource', @_);
711 return $self->caller->do_call($self, $call_object);
712 }
713 sub UntagResource {
714 my $self = shift;
715 my $call_object = $self->new_with_coercions('Paws::Glue::UntagResource', @_);
716 return $self->caller->do_call($self, $call_object);
717 }
718 sub UpdateClassifier {
719 my $self = shift;
720 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateClassifier', @_);
721 return $self->caller->do_call($self, $call_object);
722 }
723 sub UpdateColumnStatisticsForPartition {
724 my $self = shift;
725 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateColumnStatisticsForPartition', @_);
726 return $self->caller->do_call($self, $call_object);
727 }
728 sub UpdateColumnStatisticsForTable {
729 my $self = shift;
730 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateColumnStatisticsForTable', @_);
731 return $self->caller->do_call($self, $call_object);
732 }
733 sub UpdateConnection {
734 my $self = shift;
735 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateConnection', @_);
736 return $self->caller->do_call($self, $call_object);
737 }
738 sub UpdateCrawler {
739 my $self = shift;
740 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateCrawler', @_);
741 return $self->caller->do_call($self, $call_object);
742 }
743 sub UpdateCrawlerSchedule {
744 my $self = shift;
745 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateCrawlerSchedule', @_);
746 return $self->caller->do_call($self, $call_object);
747 }
748 sub UpdateDatabase {
749 my $self = shift;
750 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateDatabase', @_);
751 return $self->caller->do_call($self, $call_object);
752 }
753 sub UpdateDevEndpoint {
754 my $self = shift;
755 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateDevEndpoint', @_);
756 return $self->caller->do_call($self, $call_object);
757 }
758 sub UpdateJob {
759 my $self = shift;
760 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateJob', @_);
761 return $self->caller->do_call($self, $call_object);
762 }
763 sub UpdateMLTransform {
764 my $self = shift;
765 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateMLTransform', @_);
766 return $self->caller->do_call($self, $call_object);
767 }
768 sub UpdatePartition {
769 my $self = shift;
770 my $call_object = $self->new_with_coercions('Paws::Glue::UpdatePartition', @_);
771 return $self->caller->do_call($self, $call_object);
772 }
773 sub UpdateRegistry {
774 my $self = shift;
775 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateRegistry', @_);
776 return $self->caller->do_call($self, $call_object);
777 }
778 sub UpdateSchema {
779 my $self = shift;
780 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateSchema', @_);
781 return $self->caller->do_call($self, $call_object);
782 }
783 sub UpdateTable {
784 my $self = shift;
785 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateTable', @_);
786 return $self->caller->do_call($self, $call_object);
787 }
788 sub UpdateTrigger {
789 my $self = shift;
790 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateTrigger', @_);
791 return $self->caller->do_call($self, $call_object);
792 }
793 sub UpdateUserDefinedFunction {
794 my $self = shift;
795 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateUserDefinedFunction', @_);
796 return $self->caller->do_call($self, $call_object);
797 }
798 sub UpdateWorkflow {
799 my $self = shift;
800 my $call_object = $self->new_with_coercions('Paws::Glue::UpdateWorkflow', @_);
801 return $self->caller->do_call($self, $call_object);
802 }
803
804 sub GetAllClassifiers {
805 my $self = shift;
806  
807 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
808 my $result = $self->GetClassifiers(@_);
809 my $next_result = $result;
810  
811 if (not defined $callback) {
812 while ($next_result->NextToken) {
813 $next_result = $self->GetClassifiers(@_, NextToken => $next_result->NextToken);
814 push @{ $result->Classifiers }, @{ $next_result->Classifiers };
815 }
816 return $result;
817 } else {
818 while ($result->NextToken) {
819 $callback->($_ => 'Classifiers') foreach (@{ $result->Classifiers });
820 $result = $self->GetClassifiers(@_, NextToken => $result->NextToken);
821 }
822 $callback->($_ => 'Classifiers') foreach (@{ $result->Classifiers });
823 }
824  
825 return undef
826 }
827 sub GetAllConnections {
828 my $self = shift;
829  
830 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
831 my $result = $self->GetConnections(@_);
832 my $next_result = $result;
833  
834 if (not defined $callback) {
835 while ($next_result->NextToken) {
836 $next_result = $self->GetConnections(@_, NextToken => $next_result->NextToken);
837 push @{ $result->ConnectionList }, @{ $next_result->ConnectionList };
838 }
839 return $result;
840 } else {
841 while ($result->NextToken) {
842 $callback->($_ => 'ConnectionList') foreach (@{ $result->ConnectionList });
843 $result = $self->GetConnections(@_, NextToken => $result->NextToken);
844 }
845 $callback->($_ => 'ConnectionList') foreach (@{ $result->ConnectionList });
846 }
847  
848 return undef
849 }
850 sub GetAllCrawlerMetrics {
851 my $self = shift;
852  
853 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
854 my $result = $self->GetCrawlerMetrics(@_);
855 my $next_result = $result;
856  
857 if (not defined $callback) {
858 while ($next_result->NextToken) {
859 $next_result = $self->GetCrawlerMetrics(@_, NextToken => $next_result->NextToken);
860 push @{ $result->CrawlerMetricsList }, @{ $next_result->CrawlerMetricsList };
861 }
862 return $result;
863 } else {
864 while ($result->NextToken) {
865 $callback->($_ => 'CrawlerMetricsList') foreach (@{ $result->CrawlerMetricsList });
866 $result = $self->GetCrawlerMetrics(@_, NextToken => $result->NextToken);
867 }
868 $callback->($_ => 'CrawlerMetricsList') foreach (@{ $result->CrawlerMetricsList });
869 }
870  
871 return undef
872 }
873 sub GetAllCrawlers {
874 my $self = shift;
875  
876 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
877 my $result = $self->GetCrawlers(@_);
878 my $next_result = $result;
879  
880 if (not defined $callback) {
881 while ($next_result->NextToken) {
882 $next_result = $self->GetCrawlers(@_, NextToken => $next_result->NextToken);
883 push @{ $result->Crawlers }, @{ $next_result->Crawlers };
884 }
885 return $result;
886 } else {
887 while ($result->NextToken) {
888 $callback->($_ => 'Crawlers') foreach (@{ $result->Crawlers });
889 $result = $self->GetCrawlers(@_, NextToken => $result->NextToken);
890 }
891 $callback->($_ => 'Crawlers') foreach (@{ $result->Crawlers });
892 }
893  
894 return undef
895 }
896 sub GetAllDatabases {
897 my $self = shift;
898  
899 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
900 my $result = $self->GetDatabases(@_);
901 my $next_result = $result;
902  
903 if (not defined $callback) {
904 while ($next_result->NextToken) {
905 $next_result = $self->GetDatabases(@_, NextToken => $next_result->NextToken);
906 push @{ $result->DatabaseList }, @{ $next_result->DatabaseList };
907 }
908 return $result;
909 } else {
910 while ($result->NextToken) {
911 $callback->($_ => 'DatabaseList') foreach (@{ $result->DatabaseList });
912 $result = $self->GetDatabases(@_, NextToken => $result->NextToken);
913 }
914 $callback->($_ => 'DatabaseList') foreach (@{ $result->DatabaseList });
915 }
916  
917 return undef
918 }
919 sub GetAllDevEndpoints {
920 my $self = shift;
921  
922 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
923 my $result = $self->GetDevEndpoints(@_);
924 my $next_result = $result;
925  
926 if (not defined $callback) {
927 while ($next_result->NextToken) {
928 $next_result = $self->GetDevEndpoints(@_, NextToken => $next_result->NextToken);
929 push @{ $result->DevEndpoints }, @{ $next_result->DevEndpoints };
930 }
931 return $result;
932 } else {
933 while ($result->NextToken) {
934 $callback->($_ => 'DevEndpoints') foreach (@{ $result->DevEndpoints });
935 $result = $self->GetDevEndpoints(@_, NextToken => $result->NextToken);
936 }
937 $callback->($_ => 'DevEndpoints') foreach (@{ $result->DevEndpoints });
938 }
939  
940 return undef
941 }
942 sub GetAllJobRuns {
943 my $self = shift;
944  
945 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
946 my $result = $self->GetJobRuns(@_);
947 my $next_result = $result;
948  
949 if (not defined $callback) {
950 while ($next_result->NextToken) {
951 $next_result = $self->GetJobRuns(@_, NextToken => $next_result->NextToken);
952 push @{ $result->JobRuns }, @{ $next_result->JobRuns };
953 }
954 return $result;
955 } else {
956 while ($result->NextToken) {
957 $callback->($_ => 'JobRuns') foreach (@{ $result->JobRuns });
958 $result = $self->GetJobRuns(@_, NextToken => $result->NextToken);
959 }
960 $callback->($_ => 'JobRuns') foreach (@{ $result->JobRuns });
961 }
962  
963 return undef
964 }
965 sub GetAllJobs {
966 my $self = shift;
967  
968 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
969 my $result = $self->GetJobs(@_);
970 my $next_result = $result;
971  
972 if (not defined $callback) {
973 while ($next_result->NextToken) {
974 $next_result = $self->GetJobs(@_, NextToken => $next_result->NextToken);
975 push @{ $result->Jobs }, @{ $next_result->Jobs };
976 }
977 return $result;
978 } else {
979 while ($result->NextToken) {
980 $callback->($_ => 'Jobs') foreach (@{ $result->Jobs });
981 $result = $self->GetJobs(@_, NextToken => $result->NextToken);
982 }
983 $callback->($_ => 'Jobs') foreach (@{ $result->Jobs });
984 }
985  
986 return undef
987 }
988 sub GetAllPartitionIndexes {
989 my $self = shift;
990  
991 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
992 my $result = $self->GetPartitionIndexes(@_);
993 my $next_result = $result;
994  
995 if (not defined $callback) {
996 while ($next_result->NextToken) {
997 $next_result = $self->GetPartitionIndexes(@_, NextToken => $next_result->NextToken);
998 push @{ $result->PartitionIndexDescriptorList }, @{ $next_result->PartitionIndexDescriptorList };
999 }
1000 return $result;
1001 } else {
1002 while ($result->NextToken) {
1003 $callback->($_ => 'PartitionIndexDescriptorList') foreach (@{ $result->PartitionIndexDescriptorList });
1004 $result = $self->GetPartitionIndexes(@_, NextToken => $result->NextToken);
1005 }
1006 $callback->($_ => 'PartitionIndexDescriptorList') foreach (@{ $result->PartitionIndexDescriptorList });
1007 }
1008  
1009 return undef
1010 }
1011 sub GetAllPartitions {
1012 my $self = shift;
1013  
1014 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1015 my $result = $self->GetPartitions(@_);
1016 my $next_result = $result;
1017  
1018 if (not defined $callback) {
1019 while ($next_result->NextToken) {
1020 $next_result = $self->GetPartitions(@_, NextToken => $next_result->NextToken);
1021 push @{ $result->Partitions }, @{ $next_result->Partitions };
1022 }
1023 return $result;
1024 } else {
1025 while ($result->NextToken) {
1026 $callback->($_ => 'Partitions') foreach (@{ $result->Partitions });
1027 $result = $self->GetPartitions(@_, NextToken => $result->NextToken);
1028 }
1029 $callback->($_ => 'Partitions') foreach (@{ $result->Partitions });
1030 }
1031  
1032 return undef
1033 }
1034 sub GetAllResourcePolicies {
1035 my $self = shift;
1036  
1037 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1038 my $result = $self->GetResourcePolicies(@_);
1039 my $next_result = $result;
1040  
1041 if (not defined $callback) {
1042 while ($next_result->NextToken) {
1043 $next_result = $self->GetResourcePolicies(@_, NextToken => $next_result->NextToken);
1044 push @{ $result->GetResourcePoliciesResponseList }, @{ $next_result->GetResourcePoliciesResponseList };
1045 }
1046 return $result;
1047 } else {
1048 while ($result->NextToken) {
1049 $callback->($_ => 'GetResourcePoliciesResponseList') foreach (@{ $result->GetResourcePoliciesResponseList });
1050 $result = $self->GetResourcePolicies(@_, NextToken => $result->NextToken);
1051 }
1052 $callback->($_ => 'GetResourcePoliciesResponseList') foreach (@{ $result->GetResourcePoliciesResponseList });
1053 }
1054  
1055 return undef
1056 }
1057 sub GetAllSecurityConfigurations {
1058 my $self = shift;
1059  
1060 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1061 my $result = $self->GetSecurityConfigurations(@_);
1062 my $next_result = $result;
1063  
1064 if (not defined $callback) {
1065 while ($next_result->NextToken) {
1066 $next_result = $self->GetSecurityConfigurations(@_, NextToken => $next_result->NextToken);
1067 push @{ $result->SecurityConfigurations }, @{ $next_result->SecurityConfigurations };
1068 }
1069 return $result;
1070 } else {
1071 while ($result->NextToken) {
1072 $callback->($_ => 'SecurityConfigurations') foreach (@{ $result->SecurityConfigurations });
1073 $result = $self->GetSecurityConfigurations(@_, NextToken => $result->NextToken);
1074 }
1075 $callback->($_ => 'SecurityConfigurations') foreach (@{ $result->SecurityConfigurations });
1076 }
1077  
1078 return undef
1079 }
1080 sub GetAllTables {
1081 my $self = shift;
1082  
1083 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1084 my $result = $self->GetTables(@_);
1085 my $next_result = $result;
1086  
1087 if (not defined $callback) {
1088 while ($next_result->NextToken) {
1089 $next_result = $self->GetTables(@_, NextToken => $next_result->NextToken);
1090 push @{ $result->TableList }, @{ $next_result->TableList };
1091 }
1092 return $result;
1093 } else {
1094 while ($result->NextToken) {
1095 $callback->($_ => 'TableList') foreach (@{ $result->TableList });
1096 $result = $self->GetTables(@_, NextToken => $result->NextToken);
1097 }
1098 $callback->($_ => 'TableList') foreach (@{ $result->TableList });
1099 }
1100  
1101 return undef
1102 }
1103 sub GetAllTableVersions {
1104 my $self = shift;
1105  
1106 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1107 my $result = $self->GetTableVersions(@_);
1108 my $next_result = $result;
1109  
1110 if (not defined $callback) {
1111 while ($next_result->NextToken) {
1112 $next_result = $self->GetTableVersions(@_, NextToken => $next_result->NextToken);
1113 push @{ $result->TableVersions }, @{ $next_result->TableVersions };
1114 }
1115 return $result;
1116 } else {
1117 while ($result->NextToken) {
1118 $callback->($_ => 'TableVersions') foreach (@{ $result->TableVersions });
1119 $result = $self->GetTableVersions(@_, NextToken => $result->NextToken);
1120 }
1121 $callback->($_ => 'TableVersions') foreach (@{ $result->TableVersions });
1122 }
1123  
1124 return undef
1125 }
1126 sub GetAllTriggers {
1127 my $self = shift;
1128  
1129 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1130 my $result = $self->GetTriggers(@_);
1131 my $next_result = $result;
1132  
1133 if (not defined $callback) {
1134 while ($next_result->NextToken) {
1135 $next_result = $self->GetTriggers(@_, NextToken => $next_result->NextToken);
1136 push @{ $result->Triggers }, @{ $next_result->Triggers };
1137 }
1138 return $result;
1139 } else {
1140 while ($result->NextToken) {
1141 $callback->($_ => 'Triggers') foreach (@{ $result->Triggers });
1142 $result = $self->GetTriggers(@_, NextToken => $result->NextToken);
1143 }
1144 $callback->($_ => 'Triggers') foreach (@{ $result->Triggers });
1145 }
1146  
1147 return undef
1148 }
1149 sub GetAllUserDefinedFunctions {
1150 my $self = shift;
1151  
1152 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1153 my $result = $self->GetUserDefinedFunctions(@_);
1154 my $next_result = $result;
1155  
1156 if (not defined $callback) {
1157 while ($next_result->NextToken) {
1158 $next_result = $self->GetUserDefinedFunctions(@_, NextToken => $next_result->NextToken);
1159 push @{ $result->UserDefinedFunctions }, @{ $next_result->UserDefinedFunctions };
1160 }
1161 return $result;
1162 } else {
1163 while ($result->NextToken) {
1164 $callback->($_ => 'UserDefinedFunctions') foreach (@{ $result->UserDefinedFunctions });
1165 $result = $self->GetUserDefinedFunctions(@_, NextToken => $result->NextToken);
1166 }
1167 $callback->($_ => 'UserDefinedFunctions') foreach (@{ $result->UserDefinedFunctions });
1168 }
1169  
1170 return undef
1171 }
1172 sub ListAllRegistries {
1173 my $self = shift;
1174  
1175 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1176 my $result = $self->ListRegistries(@_);
1177 my $next_result = $result;
1178  
1179 if (not defined $callback) {
1180 while ($next_result->NextToken) {
1181 $next_result = $self->ListRegistries(@_, NextToken => $next_result->NextToken);
1182 push @{ $result->Registries }, @{ $next_result->Registries };
1183 }
1184 return $result;
1185 } else {
1186 while ($result->NextToken) {
1187 $callback->($_ => 'Registries') foreach (@{ $result->Registries });
1188 $result = $self->ListRegistries(@_, NextToken => $result->NextToken);
1189 }
1190 $callback->($_ => 'Registries') foreach (@{ $result->Registries });
1191 }
1192  
1193 return undef
1194 }
1195 sub ListAllSchemas {
1196 my $self = shift;
1197  
1198 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1199 my $result = $self->ListSchemas(@_);
1200 my $next_result = $result;
1201  
1202 if (not defined $callback) {
1203 while ($next_result->NextToken) {
1204 $next_result = $self->ListSchemas(@_, NextToken => $next_result->NextToken);
1205 push @{ $result->Schemas }, @{ $next_result->Schemas };
1206 }
1207 return $result;
1208 } else {
1209 while ($result->NextToken) {
1210 $callback->($_ => 'Schemas') foreach (@{ $result->Schemas });
1211 $result = $self->ListSchemas(@_, NextToken => $result->NextToken);
1212 }
1213 $callback->($_ => 'Schemas') foreach (@{ $result->Schemas });
1214 }
1215  
1216 return undef
1217 }
1218 sub ListAllSchemaVersions {
1219 my $self = shift;
1220  
1221 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
1222 my $result = $self->ListSchemaVersions(@_);
1223 my $next_result = $result;
1224  
1225 if (not defined $callback) {
1226 while ($next_result->NextToken) {
1227 $next_result = $self->ListSchemaVersions(@_, NextToken => $next_result->NextToken);
1228 push @{ $result->Schemas }, @{ $next_result->Schemas };
1229 }
1230 return $result;
1231 } else {
1232 while ($result->NextToken) {
1233 $callback->($_ => 'Schemas') foreach (@{ $result->Schemas });
1234 $result = $self->ListSchemaVersions(@_, NextToken => $result->NextToken);
1235 }
1236 $callback->($_ => 'Schemas') foreach (@{ $result->Schemas });
1237 }
1238  
1239 return undef
1240 }
1241  
1242  
1243 sub operations { qw/BatchCreatePartition BatchDeleteConnection BatchDeletePartition BatchDeleteTable BatchDeleteTableVersion BatchGetCrawlers BatchGetDevEndpoints BatchGetJobs BatchGetPartition BatchGetTriggers BatchGetWorkflows BatchStopJobRun BatchUpdatePartition CancelMLTaskRun CheckSchemaVersionValidity CreateClassifier CreateConnection CreateCrawler CreateDatabase CreateDevEndpoint CreateJob CreateMLTransform CreatePartition CreatePartitionIndex CreateRegistry CreateSchema CreateScript CreateSecurityConfiguration CreateTable CreateTrigger CreateUserDefinedFunction CreateWorkflow DeleteClassifier DeleteColumnStatisticsForPartition DeleteColumnStatisticsForTable DeleteConnection DeleteCrawler DeleteDatabase DeleteDevEndpoint DeleteJob DeleteMLTransform DeletePartition DeletePartitionIndex DeleteRegistry DeleteResourcePolicy DeleteSchema DeleteSchemaVersions DeleteSecurityConfiguration DeleteTable DeleteTableVersion DeleteTrigger DeleteUserDefinedFunction DeleteWorkflow GetCatalogImportStatus GetClassifier GetClassifiers GetColumnStatisticsForPartition GetColumnStatisticsForTable GetConnection GetConnections GetCrawler GetCrawlerMetrics GetCrawlers GetDatabase GetDatabases GetDataCatalogEncryptionSettings GetDataflowGraph GetDevEndpoint GetDevEndpoints GetJob GetJobBookmark GetJobRun GetJobRuns GetJobs GetMapping GetMLTaskRun GetMLTaskRuns GetMLTransform GetMLTransforms GetPartition GetPartitionIndexes GetPartitions GetPlan GetRegistry GetResourcePolicies GetResourcePolicy GetSchema GetSchemaByDefinition GetSchemaVersion GetSchemaVersionsDiff GetSecurityConfiguration GetSecurityConfigurations GetTable GetTables GetTableVersion GetTableVersions GetTags GetTrigger GetTriggers GetUserDefinedFunction GetUserDefinedFunctions GetWorkflow GetWorkflowRun GetWorkflowRunProperties GetWorkflowRuns ImportCatalogToGlue ListCrawlers ListDevEndpoints ListJobs ListMLTransforms ListRegistries ListSchemas ListSchemaVersions ListTriggers ListWorkflows PutDataCatalogEncryptionSettings PutResourcePolicy PutSchemaVersionMetadata PutWorkflowRunProperties QuerySchemaVersionMetadata RegisterSchemaVersion RemoveSchemaVersionMetadata ResetJobBookmark ResumeWorkflowRun SearchTables StartCrawler StartCrawlerSchedule StartExportLabelsTaskRun StartImportLabelsTaskRun StartJobRun StartMLEvaluationTaskRun StartMLLabelingSetGenerationTaskRun StartTrigger StartWorkflowRun StopCrawler StopCrawlerSchedule StopTrigger StopWorkflowRun TagResource UntagResource UpdateClassifier UpdateColumnStatisticsForPartition UpdateColumnStatisticsForTable UpdateConnection UpdateCrawler UpdateCrawlerSchedule UpdateDatabase UpdateDevEndpoint UpdateJob UpdateMLTransform UpdatePartition UpdateRegistry UpdateSchema UpdateTable UpdateTrigger UpdateUserDefinedFunction UpdateWorkflow / }
1244  
1245 1;
1246  
1247 ### main pod documentation begin ###
1248  
1249 =head1 NAME
1250  
1251 Paws::Glue - Perl Interface to AWS AWS Glue
1252  
1253 =head1 SYNOPSIS
1254  
1255 use Paws;
1256  
1257 my $obj = Paws->service('Glue');
1258 my $res = $obj->Method(
1259 Arg1 => $val1,
1260 Arg2 => [ 'V1', 'V2' ],
1261 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
1262 # of the arguments type
1263 Arg3 => { Att1 => 'Val1' },
1264 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
1265 # the constructor of the arguments type
1266 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
1267 );
1268  
1269 =head1 DESCRIPTION
1270  
1271 Glue
1272  
1273 Defines the public endpoint for the Glue service.
1274  
1275 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/glue-2017-03-31>
1276  
1277  
1278 =head1 METHODS
1279  
1280 =head2 BatchCreatePartition
1281  
1282 =over
1283  
1284 =item DatabaseName => Str
1285  
1286 =item PartitionInputList => ArrayRef[L<Paws::Glue::PartitionInput>]
1287  
1288 =item TableName => Str
1289  
1290 =item [CatalogId => Str]
1291  
1292  
1293 =back
1294  
1295 Each argument is described in detail in: L<Paws::Glue::BatchCreatePartition>
1296  
1297 Returns: a L<Paws::Glue::BatchCreatePartitionResponse> instance
1298  
1299 Creates one or more partitions in a batch operation.
1300  
1301  
1302 =head2 BatchDeleteConnection
1303  
1304 =over
1305  
1306 =item ConnectionNameList => ArrayRef[Str|Undef]
1307  
1308 =item [CatalogId => Str]
1309  
1310  
1311 =back
1312  
1313 Each argument is described in detail in: L<Paws::Glue::BatchDeleteConnection>
1314  
1315 Returns: a L<Paws::Glue::BatchDeleteConnectionResponse> instance
1316  
1317 Deletes a list of connection definitions from the Data Catalog.
1318  
1319  
1320 =head2 BatchDeletePartition
1321  
1322 =over
1323  
1324 =item DatabaseName => Str
1325  
1326 =item PartitionsToDelete => ArrayRef[L<Paws::Glue::PartitionValueList>]
1327  
1328 =item TableName => Str
1329  
1330 =item [CatalogId => Str]
1331  
1332  
1333 =back
1334  
1335 Each argument is described in detail in: L<Paws::Glue::BatchDeletePartition>
1336  
1337 Returns: a L<Paws::Glue::BatchDeletePartitionResponse> instance
1338  
1339 Deletes one or more partitions in a batch operation.
1340  
1341  
1342 =head2 BatchDeleteTable
1343  
1344 =over
1345  
1346 =item DatabaseName => Str
1347  
1348 =item TablesToDelete => ArrayRef[Str|Undef]
1349  
1350 =item [CatalogId => Str]
1351  
1352  
1353 =back
1354  
1355 Each argument is described in detail in: L<Paws::Glue::BatchDeleteTable>
1356  
1357 Returns: a L<Paws::Glue::BatchDeleteTableResponse> instance
1358  
1359 Deletes multiple tables at once.
1360  
1361 After completing this operation, you no longer have access to the table
1362 versions and partitions that belong to the deleted table. Glue deletes
1363 these "orphaned" resources asynchronously in a timely manner, at the
1364 discretion of the service.
1365  
1366 To ensure the immediate deletion of all related resources, before
1367 calling C<BatchDeleteTable>, use C<DeleteTableVersion> or
1368 C<BatchDeleteTableVersion>, and C<DeletePartition> or
1369 C<BatchDeletePartition>, to delete any resources that belong to the
1370 table.
1371  
1372  
1373 =head2 BatchDeleteTableVersion
1374  
1375 =over
1376  
1377 =item DatabaseName => Str
1378  
1379 =item TableName => Str
1380  
1381 =item VersionIds => ArrayRef[Str|Undef]
1382  
1383 =item [CatalogId => Str]
1384  
1385  
1386 =back
1387  
1388 Each argument is described in detail in: L<Paws::Glue::BatchDeleteTableVersion>
1389  
1390 Returns: a L<Paws::Glue::BatchDeleteTableVersionResponse> instance
1391  
1392 Deletes a specified batch of versions of a table.
1393  
1394  
1395 =head2 BatchGetCrawlers
1396  
1397 =over
1398  
1399 =item CrawlerNames => ArrayRef[Str|Undef]
1400  
1401  
1402 =back
1403  
1404 Each argument is described in detail in: L<Paws::Glue::BatchGetCrawlers>
1405  
1406 Returns: a L<Paws::Glue::BatchGetCrawlersResponse> instance
1407  
1408 Returns a list of resource metadata for a given list of crawler names.
1409 After calling the C<ListCrawlers> operation, you can call this
1410 operation to access the data to which you have been granted
1411 permissions. This operation supports all IAM permissions, including
1412 permission conditions that uses tags.
1413  
1414  
1415 =head2 BatchGetDevEndpoints
1416  
1417 =over
1418  
1419 =item DevEndpointNames => ArrayRef[Str|Undef]
1420  
1421  
1422 =back
1423  
1424 Each argument is described in detail in: L<Paws::Glue::BatchGetDevEndpoints>
1425  
1426 Returns: a L<Paws::Glue::BatchGetDevEndpointsResponse> instance
1427  
1428 Returns a list of resource metadata for a given list of development
1429 endpoint names. After calling the C<ListDevEndpoints> operation, you
1430 can call this operation to access the data to which you have been
1431 granted permissions. This operation supports all IAM permissions,
1432 including permission conditions that uses tags.
1433  
1434  
1435 =head2 BatchGetJobs
1436  
1437 =over
1438  
1439 =item JobNames => ArrayRef[Str|Undef]
1440  
1441  
1442 =back
1443  
1444 Each argument is described in detail in: L<Paws::Glue::BatchGetJobs>
1445  
1446 Returns: a L<Paws::Glue::BatchGetJobsResponse> instance
1447  
1448 Returns a list of resource metadata for a given list of job names.
1449 After calling the C<ListJobs> operation, you can call this operation to
1450 access the data to which you have been granted permissions. This
1451 operation supports all IAM permissions, including permission conditions
1452 that uses tags.
1453  
1454  
1455 =head2 BatchGetPartition
1456  
1457 =over
1458  
1459 =item DatabaseName => Str
1460  
1461 =item PartitionsToGet => ArrayRef[L<Paws::Glue::PartitionValueList>]
1462  
1463 =item TableName => Str
1464  
1465 =item [CatalogId => Str]
1466  
1467  
1468 =back
1469  
1470 Each argument is described in detail in: L<Paws::Glue::BatchGetPartition>
1471  
1472 Returns: a L<Paws::Glue::BatchGetPartitionResponse> instance
1473  
1474 Retrieves partitions in a batch request.
1475  
1476  
1477 =head2 BatchGetTriggers
1478  
1479 =over
1480  
1481 =item TriggerNames => ArrayRef[Str|Undef]
1482  
1483  
1484 =back
1485  
1486 Each argument is described in detail in: L<Paws::Glue::BatchGetTriggers>
1487  
1488 Returns: a L<Paws::Glue::BatchGetTriggersResponse> instance
1489  
1490 Returns a list of resource metadata for a given list of trigger names.
1491 After calling the C<ListTriggers> operation, you can call this
1492 operation to access the data to which you have been granted
1493 permissions. This operation supports all IAM permissions, including
1494 permission conditions that uses tags.
1495  
1496  
1497 =head2 BatchGetWorkflows
1498  
1499 =over
1500  
1501 =item Names => ArrayRef[Str|Undef]
1502  
1503 =item [IncludeGraph => Bool]
1504  
1505  
1506 =back
1507  
1508 Each argument is described in detail in: L<Paws::Glue::BatchGetWorkflows>
1509  
1510 Returns: a L<Paws::Glue::BatchGetWorkflowsResponse> instance
1511  
1512 Returns a list of resource metadata for a given list of workflow names.
1513 After calling the C<ListWorkflows> operation, you can call this
1514 operation to access the data to which you have been granted
1515 permissions. This operation supports all IAM permissions, including
1516 permission conditions that uses tags.
1517  
1518  
1519 =head2 BatchStopJobRun
1520  
1521 =over
1522  
1523 =item JobName => Str
1524  
1525 =item JobRunIds => ArrayRef[Str|Undef]
1526  
1527  
1528 =back
1529  
1530 Each argument is described in detail in: L<Paws::Glue::BatchStopJobRun>
1531  
1532 Returns: a L<Paws::Glue::BatchStopJobRunResponse> instance
1533  
1534 Stops one or more job runs for a specified job definition.
1535  
1536  
1537 =head2 BatchUpdatePartition
1538  
1539 =over
1540  
1541 =item DatabaseName => Str
1542  
1543 =item Entries => ArrayRef[L<Paws::Glue::BatchUpdatePartitionRequestEntry>]
1544  
1545 =item TableName => Str
1546  
1547 =item [CatalogId => Str]
1548  
1549  
1550 =back
1551  
1552 Each argument is described in detail in: L<Paws::Glue::BatchUpdatePartition>
1553  
1554 Returns: a L<Paws::Glue::BatchUpdatePartitionResponse> instance
1555  
1556 Updates one or more partitions in a batch operation.
1557  
1558  
1559 =head2 CancelMLTaskRun
1560  
1561 =over
1562  
1563 =item TaskRunId => Str
1564  
1565 =item TransformId => Str
1566  
1567  
1568 =back
1569  
1570 Each argument is described in detail in: L<Paws::Glue::CancelMLTaskRun>
1571  
1572 Returns: a L<Paws::Glue::CancelMLTaskRunResponse> instance
1573  
1574 Cancels (stops) a task run. Machine learning task runs are asynchronous
1575 tasks that Glue runs on your behalf as part of various machine learning
1576 workflows. You can cancel a machine learning task run at any time by
1577 calling C<CancelMLTaskRun> with a task run's parent transform's
1578 C<TransformID> and the task run's C<TaskRunId>.
1579  
1580  
1581 =head2 CheckSchemaVersionValidity
1582  
1583 =over
1584  
1585 =item DataFormat => Str
1586  
1587 =item SchemaDefinition => Str
1588  
1589  
1590 =back
1591  
1592 Each argument is described in detail in: L<Paws::Glue::CheckSchemaVersionValidity>
1593  
1594 Returns: a L<Paws::Glue::CheckSchemaVersionValidityResponse> instance
1595  
1596 Validates the supplied schema. This call has no side effects, it simply
1597 validates using the supplied schema using C<DataFormat> as the format.
1598 Since it does not take a schema set name, no compatibility checks are
1599 performed.
1600  
1601  
1602 =head2 CreateClassifier
1603  
1604 =over
1605  
1606 =item [CsvClassifier => L<Paws::Glue::CreateCsvClassifierRequest>]
1607  
1608 =item [GrokClassifier => L<Paws::Glue::CreateGrokClassifierRequest>]
1609  
1610 =item [JsonClassifier => L<Paws::Glue::CreateJsonClassifierRequest>]
1611  
1612 =item [XMLClassifier => L<Paws::Glue::CreateXMLClassifierRequest>]
1613  
1614  
1615 =back
1616  
1617 Each argument is described in detail in: L<Paws::Glue::CreateClassifier>
1618  
1619 Returns: a L<Paws::Glue::CreateClassifierResponse> instance
1620  
1621 Creates a classifier in the user's account. This can be a
1622 C<GrokClassifier>, an C<XMLClassifier>, a C<JsonClassifier>, or a
1623 C<CsvClassifier>, depending on which field of the request is present.
1624  
1625  
1626 =head2 CreateConnection
1627  
1628 =over
1629  
1630 =item ConnectionInput => L<Paws::Glue::ConnectionInput>
1631  
1632 =item [CatalogId => Str]
1633  
1634  
1635 =back
1636  
1637 Each argument is described in detail in: L<Paws::Glue::CreateConnection>
1638  
1639 Returns: a L<Paws::Glue::CreateConnectionResponse> instance
1640  
1641 Creates a connection definition in the Data Catalog.
1642  
1643  
1644 =head2 CreateCrawler
1645  
1646 =over
1647  
1648 =item Name => Str
1649  
1650 =item Role => Str
1651  
1652 =item Targets => L<Paws::Glue::CrawlerTargets>
1653  
1654 =item [Classifiers => ArrayRef[Str|Undef]]
1655  
1656 =item [Configuration => Str]
1657  
1658 =item [CrawlerSecurityConfiguration => Str]
1659  
1660 =item [DatabaseName => Str]
1661  
1662 =item [Description => Str]
1663  
1664 =item [LineageConfiguration => L<Paws::Glue::LineageConfiguration>]
1665  
1666 =item [RecrawlPolicy => L<Paws::Glue::RecrawlPolicy>]
1667  
1668 =item [Schedule => Str]
1669  
1670 =item [SchemaChangePolicy => L<Paws::Glue::SchemaChangePolicy>]
1671  
1672 =item [TablePrefix => Str]
1673  
1674 =item [Tags => L<Paws::Glue::TagsMap>]
1675  
1676  
1677 =back
1678  
1679 Each argument is described in detail in: L<Paws::Glue::CreateCrawler>
1680  
1681 Returns: a L<Paws::Glue::CreateCrawlerResponse> instance
1682  
1683 Creates a new crawler with specified targets, role, configuration, and
1684 optional schedule. At least one crawl target must be specified, in the
1685 C<s3Targets> field, the C<jdbcTargets> field, or the C<DynamoDBTargets>
1686 field.
1687  
1688  
1689 =head2 CreateDatabase
1690  
1691 =over
1692  
1693 =item DatabaseInput => L<Paws::Glue::DatabaseInput>
1694  
1695 =item [CatalogId => Str]
1696  
1697  
1698 =back
1699  
1700 Each argument is described in detail in: L<Paws::Glue::CreateDatabase>
1701  
1702 Returns: a L<Paws::Glue::CreateDatabaseResponse> instance
1703  
1704 Creates a new database in a Data Catalog.
1705  
1706  
1707 =head2 CreateDevEndpoint
1708  
1709 =over
1710  
1711 =item EndpointName => Str
1712  
1713 =item RoleArn => Str
1714  
1715 =item [Arguments => L<Paws::Glue::MapValue>]
1716  
1717 =item [ExtraJarsS3Path => Str]
1718  
1719 =item [ExtraPythonLibsS3Path => Str]
1720  
1721 =item [GlueVersion => Str]
1722  
1723 =item [NumberOfNodes => Int]
1724  
1725 =item [NumberOfWorkers => Int]
1726  
1727 =item [PublicKey => Str]
1728  
1729 =item [PublicKeys => ArrayRef[Str|Undef]]
1730  
1731 =item [SecurityConfiguration => Str]
1732  
1733 =item [SecurityGroupIds => ArrayRef[Str|Undef]]
1734  
1735 =item [SubnetId => Str]
1736  
1737 =item [Tags => L<Paws::Glue::TagsMap>]
1738  
1739 =item [WorkerType => Str]
1740  
1741  
1742 =back
1743  
1744 Each argument is described in detail in: L<Paws::Glue::CreateDevEndpoint>
1745  
1746 Returns: a L<Paws::Glue::CreateDevEndpointResponse> instance
1747  
1748 Creates a new development endpoint.
1749  
1750  
1751 =head2 CreateJob
1752  
1753 =over
1754  
1755 =item Command => L<Paws::Glue::JobCommand>
1756  
1757 =item Name => Str
1758  
1759 =item Role => Str
1760  
1761 =item [AllocatedCapacity => Int]
1762  
1763 =item [Connections => L<Paws::Glue::ConnectionsList>]
1764  
1765 =item [DefaultArguments => L<Paws::Glue::GenericMap>]
1766  
1767 =item [Description => Str]
1768  
1769 =item [ExecutionProperty => L<Paws::Glue::ExecutionProperty>]
1770  
1771 =item [GlueVersion => Str]
1772  
1773 =item [LogUri => Str]
1774  
1775 =item [MaxCapacity => Num]
1776  
1777 =item [MaxRetries => Int]
1778  
1779 =item [NonOverridableArguments => L<Paws::Glue::GenericMap>]
1780  
1781 =item [NotificationProperty => L<Paws::Glue::NotificationProperty>]
1782  
1783 =item [NumberOfWorkers => Int]
1784  
1785 =item [SecurityConfiguration => Str]
1786  
1787 =item [Tags => L<Paws::Glue::TagsMap>]
1788  
1789 =item [Timeout => Int]
1790  
1791 =item [WorkerType => Str]
1792  
1793  
1794 =back
1795  
1796 Each argument is described in detail in: L<Paws::Glue::CreateJob>
1797  
1798 Returns: a L<Paws::Glue::CreateJobResponse> instance
1799  
1800 Creates a new job definition.
1801  
1802  
1803 =head2 CreateMLTransform
1804  
1805 =over
1806  
1807 =item InputRecordTables => ArrayRef[L<Paws::Glue::GlueTable>]
1808  
1809 =item Name => Str
1810  
1811 =item Parameters => L<Paws::Glue::TransformParameters>
1812  
1813 =item Role => Str
1814  
1815 =item [Description => Str]
1816  
1817 =item [GlueVersion => Str]
1818  
1819 =item [MaxCapacity => Num]
1820  
1821 =item [MaxRetries => Int]
1822  
1823 =item [NumberOfWorkers => Int]
1824  
1825 =item [Tags => L<Paws::Glue::TagsMap>]
1826  
1827 =item [Timeout => Int]
1828  
1829 =item [TransformEncryption => L<Paws::Glue::TransformEncryption>]
1830  
1831 =item [WorkerType => Str]
1832  
1833  
1834 =back
1835  
1836 Each argument is described in detail in: L<Paws::Glue::CreateMLTransform>
1837  
1838 Returns: a L<Paws::Glue::CreateMLTransformResponse> instance
1839  
1840 Creates an Glue machine learning transform. This operation creates the
1841 transform and all the necessary parameters to train it.
1842  
1843 Call this operation as the first step in the process of using a machine
1844 learning transform (such as the C<FindMatches> transform) for
1845 deduplicating data. You can provide an optional C<Description>, in
1846 addition to the parameters that you want to use for your algorithm.
1847  
1848 You must also specify certain parameters for the tasks that Glue runs
1849 on your behalf as part of learning from your data and creating a
1850 high-quality machine learning transform. These parameters include
1851 C<Role>, and optionally, C<AllocatedCapacity>, C<Timeout>, and
1852 C<MaxRetries>. For more information, see Jobs
1853 (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-jobs-job.html).
1854  
1855  
1856 =head2 CreatePartition
1857  
1858 =over
1859  
1860 =item DatabaseName => Str
1861  
1862 =item PartitionInput => L<Paws::Glue::PartitionInput>
1863  
1864 =item TableName => Str
1865  
1866 =item [CatalogId => Str]
1867  
1868  
1869 =back
1870  
1871 Each argument is described in detail in: L<Paws::Glue::CreatePartition>
1872  
1873 Returns: a L<Paws::Glue::CreatePartitionResponse> instance
1874  
1875 Creates a new partition.
1876  
1877  
1878 =head2 CreatePartitionIndex
1879  
1880 =over
1881  
1882 =item DatabaseName => Str
1883  
1884 =item PartitionIndex => L<Paws::Glue::PartitionIndex>
1885  
1886 =item TableName => Str
1887  
1888 =item [CatalogId => Str]
1889  
1890  
1891 =back
1892  
1893 Each argument is described in detail in: L<Paws::Glue::CreatePartitionIndex>
1894  
1895 Returns: a L<Paws::Glue::CreatePartitionIndexResponse> instance
1896  
1897 Creates a specified partition index in an existing table.
1898  
1899  
1900 =head2 CreateRegistry
1901  
1902 =over
1903  
1904 =item RegistryName => Str
1905  
1906 =item [Description => Str]
1907  
1908 =item [Tags => L<Paws::Glue::TagsMap>]
1909  
1910  
1911 =back
1912  
1913 Each argument is described in detail in: L<Paws::Glue::CreateRegistry>
1914  
1915 Returns: a L<Paws::Glue::CreateRegistryResponse> instance
1916  
1917 Creates a new registry which may be used to hold a collection of
1918 schemas.
1919  
1920  
1921 =head2 CreateSchema
1922  
1923 =over
1924  
1925 =item DataFormat => Str
1926  
1927 =item SchemaName => Str
1928  
1929 =item [Compatibility => Str]
1930  
1931 =item [Description => Str]
1932  
1933 =item [RegistryId => L<Paws::Glue::RegistryId>]
1934  
1935 =item [SchemaDefinition => Str]
1936  
1937 =item [Tags => L<Paws::Glue::TagsMap>]
1938  
1939  
1940 =back
1941  
1942 Each argument is described in detail in: L<Paws::Glue::CreateSchema>
1943  
1944 Returns: a L<Paws::Glue::CreateSchemaResponse> instance
1945  
1946 Creates a new schema set and registers the schema definition. Returns
1947 an error if the schema set already exists without actually registering
1948 the version.
1949  
1950 When the schema set is created, a version checkpoint will be set to the
1951 first version. Compatibility mode "DISABLED" restricts any additional
1952 schema versions from being added after the first schema version. For
1953 all other compatibility modes, validation of compatibility settings
1954 will be applied only from the second version onwards when the
1955 C<RegisterSchemaVersion> API is used.
1956  
1957 When this API is called without a C<RegistryId>, this will create an
1958 entry for a "default-registry" in the registry database tables, if it
1959 is not already present.
1960  
1961  
1962 =head2 CreateScript
1963  
1964 =over
1965  
1966 =item [DagEdges => ArrayRef[L<Paws::Glue::CodeGenEdge>]]
1967  
1968 =item [DagNodes => ArrayRef[L<Paws::Glue::CodeGenNode>]]
1969  
1970 =item [Language => Str]
1971  
1972  
1973 =back
1974  
1975 Each argument is described in detail in: L<Paws::Glue::CreateScript>
1976  
1977 Returns: a L<Paws::Glue::CreateScriptResponse> instance
1978  
1979 Transforms a directed acyclic graph (DAG) into code.
1980  
1981  
1982 =head2 CreateSecurityConfiguration
1983  
1984 =over
1985  
1986 =item EncryptionConfiguration => L<Paws::Glue::EncryptionConfiguration>
1987  
1988 =item Name => Str
1989  
1990  
1991 =back
1992  
1993 Each argument is described in detail in: L<Paws::Glue::CreateSecurityConfiguration>
1994  
1995 Returns: a L<Paws::Glue::CreateSecurityConfigurationResponse> instance
1996  
1997 Creates a new security configuration. A security configuration is a set
1998 of security properties that can be used by Glue. You can use a security
1999 configuration to encrypt data at rest. For information about using
2000 security configurations in Glue, see Encrypting Data Written by
2001 Crawlers, Jobs, and Development Endpoints
2002 (https://docs.aws.amazon.com/glue/latest/dg/encryption-security-configuration.html).
2003  
2004  
2005 =head2 CreateTable
2006  
2007 =over
2008  
2009 =item DatabaseName => Str
2010  
2011 =item TableInput => L<Paws::Glue::TableInput>
2012  
2013 =item [CatalogId => Str]
2014  
2015 =item [PartitionIndexes => ArrayRef[L<Paws::Glue::PartitionIndex>]]
2016  
2017  
2018 =back
2019  
2020 Each argument is described in detail in: L<Paws::Glue::CreateTable>
2021  
2022 Returns: a L<Paws::Glue::CreateTableResponse> instance
2023  
2024 Creates a new table definition in the Data Catalog.
2025  
2026  
2027 =head2 CreateTrigger
2028  
2029 =over
2030  
2031 =item Actions => ArrayRef[L<Paws::Glue::Action>]
2032  
2033 =item Name => Str
2034  
2035 =item Type => Str
2036  
2037 =item [Description => Str]
2038  
2039 =item [Predicate => L<Paws::Glue::Predicate>]
2040  
2041 =item [Schedule => Str]
2042  
2043 =item [StartOnCreation => Bool]
2044  
2045 =item [Tags => L<Paws::Glue::TagsMap>]
2046  
2047 =item [WorkflowName => Str]
2048  
2049  
2050 =back
2051  
2052 Each argument is described in detail in: L<Paws::Glue::CreateTrigger>
2053  
2054 Returns: a L<Paws::Glue::CreateTriggerResponse> instance
2055  
2056 Creates a new trigger.
2057  
2058  
2059 =head2 CreateUserDefinedFunction
2060  
2061 =over
2062  
2063 =item DatabaseName => Str
2064  
2065 =item FunctionInput => L<Paws::Glue::UserDefinedFunctionInput>
2066  
2067 =item [CatalogId => Str]
2068  
2069  
2070 =back
2071  
2072 Each argument is described in detail in: L<Paws::Glue::CreateUserDefinedFunction>
2073  
2074 Returns: a L<Paws::Glue::CreateUserDefinedFunctionResponse> instance
2075  
2076 Creates a new function definition in the Data Catalog.
2077  
2078  
2079 =head2 CreateWorkflow
2080  
2081 =over
2082  
2083 =item Name => Str
2084  
2085 =item [DefaultRunProperties => L<Paws::Glue::WorkflowRunProperties>]
2086  
2087 =item [Description => Str]
2088  
2089 =item [MaxConcurrentRuns => Int]
2090  
2091 =item [Tags => L<Paws::Glue::TagsMap>]
2092  
2093  
2094 =back
2095  
2096 Each argument is described in detail in: L<Paws::Glue::CreateWorkflow>
2097  
2098 Returns: a L<Paws::Glue::CreateWorkflowResponse> instance
2099  
2100 Creates a new workflow.
2101  
2102  
2103 =head2 DeleteClassifier
2104  
2105 =over
2106  
2107 =item Name => Str
2108  
2109  
2110 =back
2111  
2112 Each argument is described in detail in: L<Paws::Glue::DeleteClassifier>
2113  
2114 Returns: a L<Paws::Glue::DeleteClassifierResponse> instance
2115  
2116 Removes a classifier from the Data Catalog.
2117  
2118  
2119 =head2 DeleteColumnStatisticsForPartition
2120  
2121 =over
2122  
2123 =item ColumnName => Str
2124  
2125 =item DatabaseName => Str
2126  
2127 =item PartitionValues => ArrayRef[Str|Undef]
2128  
2129 =item TableName => Str
2130  
2131 =item [CatalogId => Str]
2132  
2133  
2134 =back
2135  
2136 Each argument is described in detail in: L<Paws::Glue::DeleteColumnStatisticsForPartition>
2137  
2138 Returns: a L<Paws::Glue::DeleteColumnStatisticsForPartitionResponse> instance
2139  
2140 Delete the partition column statistics of a column.
2141  
2142 The Identity and Access Management (IAM) permission required for this
2143 operation is C<DeletePartition>.
2144  
2145  
2146 =head2 DeleteColumnStatisticsForTable
2147  
2148 =over
2149  
2150 =item ColumnName => Str
2151  
2152 =item DatabaseName => Str
2153  
2154 =item TableName => Str
2155  
2156 =item [CatalogId => Str]
2157  
2158  
2159 =back
2160  
2161 Each argument is described in detail in: L<Paws::Glue::DeleteColumnStatisticsForTable>
2162  
2163 Returns: a L<Paws::Glue::DeleteColumnStatisticsForTableResponse> instance
2164  
2165 Retrieves table statistics of columns.
2166  
2167 The Identity and Access Management (IAM) permission required for this
2168 operation is C<DeleteTable>.
2169  
2170  
2171 =head2 DeleteConnection
2172  
2173 =over
2174  
2175 =item ConnectionName => Str
2176  
2177 =item [CatalogId => Str]
2178  
2179  
2180 =back
2181  
2182 Each argument is described in detail in: L<Paws::Glue::DeleteConnection>
2183  
2184 Returns: a L<Paws::Glue::DeleteConnectionResponse> instance
2185  
2186 Deletes a connection from the Data Catalog.
2187  
2188  
2189 =head2 DeleteCrawler
2190  
2191 =over
2192  
2193 =item Name => Str
2194  
2195  
2196 =back
2197  
2198 Each argument is described in detail in: L<Paws::Glue::DeleteCrawler>
2199  
2200 Returns: a L<Paws::Glue::DeleteCrawlerResponse> instance
2201  
2202 Removes a specified crawler from the Glue Data Catalog, unless the
2203 crawler state is C<RUNNING>.
2204  
2205  
2206 =head2 DeleteDatabase
2207  
2208 =over
2209  
2210 =item Name => Str
2211  
2212 =item [CatalogId => Str]
2213  
2214  
2215 =back
2216  
2217 Each argument is described in detail in: L<Paws::Glue::DeleteDatabase>
2218  
2219 Returns: a L<Paws::Glue::DeleteDatabaseResponse> instance
2220  
2221 Removes a specified database from a Data Catalog.
2222  
2223 After completing this operation, you no longer have access to the
2224 tables (and all table versions and partitions that might belong to the
2225 tables) and the user-defined functions in the deleted database. Glue
2226 deletes these "orphaned" resources asynchronously in a timely manner,
2227 at the discretion of the service.
2228  
2229 To ensure the immediate deletion of all related resources, before
2230 calling C<DeleteDatabase>, use C<DeleteTableVersion> or
2231 C<BatchDeleteTableVersion>, C<DeletePartition> or
2232 C<BatchDeletePartition>, C<DeleteUserDefinedFunction>, and
2233 C<DeleteTable> or C<BatchDeleteTable>, to delete any resources that
2234 belong to the database.
2235  
2236  
2237 =head2 DeleteDevEndpoint
2238  
2239 =over
2240  
2241 =item EndpointName => Str
2242  
2243  
2244 =back
2245  
2246 Each argument is described in detail in: L<Paws::Glue::DeleteDevEndpoint>
2247  
2248 Returns: a L<Paws::Glue::DeleteDevEndpointResponse> instance
2249  
2250 Deletes a specified development endpoint.
2251  
2252  
2253 =head2 DeleteJob
2254  
2255 =over
2256  
2257 =item JobName => Str
2258  
2259  
2260 =back
2261  
2262 Each argument is described in detail in: L<Paws::Glue::DeleteJob>
2263  
2264 Returns: a L<Paws::Glue::DeleteJobResponse> instance
2265  
2266 Deletes a specified job definition. If the job definition is not found,
2267 no exception is thrown.
2268  
2269  
2270 =head2 DeleteMLTransform
2271  
2272 =over
2273  
2274 =item TransformId => Str
2275  
2276  
2277 =back
2278  
2279 Each argument is described in detail in: L<Paws::Glue::DeleteMLTransform>
2280  
2281 Returns: a L<Paws::Glue::DeleteMLTransformResponse> instance
2282  
2283 Deletes an Glue machine learning transform. Machine learning transforms
2284 are a special type of transform that use machine learning to learn the
2285 details of the transformation to be performed by learning from examples
2286 provided by humans. These transformations are then saved by Glue. If
2287 you no longer need a transform, you can delete it by calling
2288 C<DeleteMLTransforms>. However, any Glue jobs that still reference the
2289 deleted transform will no longer succeed.
2290  
2291  
2292 =head2 DeletePartition
2293  
2294 =over
2295  
2296 =item DatabaseName => Str
2297  
2298 =item PartitionValues => ArrayRef[Str|Undef]
2299  
2300 =item TableName => Str
2301  
2302 =item [CatalogId => Str]
2303  
2304  
2305 =back
2306  
2307 Each argument is described in detail in: L<Paws::Glue::DeletePartition>
2308  
2309 Returns: a L<Paws::Glue::DeletePartitionResponse> instance
2310  
2311 Deletes a specified partition.
2312  
2313  
2314 =head2 DeletePartitionIndex
2315  
2316 =over
2317  
2318 =item DatabaseName => Str
2319  
2320 =item IndexName => Str
2321  
2322 =item TableName => Str
2323  
2324 =item [CatalogId => Str]
2325  
2326  
2327 =back
2328  
2329 Each argument is described in detail in: L<Paws::Glue::DeletePartitionIndex>
2330  
2331 Returns: a L<Paws::Glue::DeletePartitionIndexResponse> instance
2332  
2333 Deletes a specified partition index from an existing table.
2334  
2335  
2336 =head2 DeleteRegistry
2337  
2338 =over
2339  
2340 =item RegistryId => L<Paws::Glue::RegistryId>
2341  
2342  
2343 =back
2344  
2345 Each argument is described in detail in: L<Paws::Glue::DeleteRegistry>
2346  
2347 Returns: a L<Paws::Glue::DeleteRegistryResponse> instance
2348  
2349 Delete the entire registry including schema and all of its versions. To
2350 get the status of the delete operation, you can call the C<GetRegistry>
2351 API after the asynchronous call. Deleting a registry will deactivate
2352 all online operations for the registry such as the C<UpdateRegistry>,
2353 C<CreateSchema>, C<UpdateSchema>, and C<RegisterSchemaVersion> APIs.
2354  
2355  
2356 =head2 DeleteResourcePolicy
2357  
2358 =over
2359  
2360 =item [PolicyHashCondition => Str]
2361  
2362 =item [ResourceArn => Str]
2363  
2364  
2365 =back
2366  
2367 Each argument is described in detail in: L<Paws::Glue::DeleteResourcePolicy>
2368  
2369 Returns: a L<Paws::Glue::DeleteResourcePolicyResponse> instance
2370  
2371 Deletes a specified policy.
2372  
2373  
2374 =head2 DeleteSchema
2375  
2376 =over
2377  
2378 =item SchemaId => L<Paws::Glue::SchemaId>
2379  
2380  
2381 =back
2382  
2383 Each argument is described in detail in: L<Paws::Glue::DeleteSchema>
2384  
2385 Returns: a L<Paws::Glue::DeleteSchemaResponse> instance
2386  
2387 Deletes the entire schema set, including the schema set and all of its
2388 versions. To get the status of the delete operation, you can call
2389 C<GetSchema> API after the asynchronous call. Deleting a registry will
2390 deactivate all online operations for the schema, such as the
2391 C<GetSchemaByDefinition>, and C<RegisterSchemaVersion> APIs.
2392  
2393  
2394 =head2 DeleteSchemaVersions
2395  
2396 =over
2397  
2398 =item SchemaId => L<Paws::Glue::SchemaId>
2399  
2400 =item Versions => Str
2401  
2402  
2403 =back
2404  
2405 Each argument is described in detail in: L<Paws::Glue::DeleteSchemaVersions>
2406  
2407 Returns: a L<Paws::Glue::DeleteSchemaVersionsResponse> instance
2408  
2409 Remove versions from the specified schema. A version number or range
2410 may be supplied. If the compatibility mode forbids deleting of a
2411 version that is necessary, such as BACKWARDS_FULL, an error is
2412 returned. Calling the C<GetSchemaVersions> API after this call will
2413 list the status of the deleted versions.
2414  
2415 When the range of version numbers contain check pointed version, the
2416 API will return a 409 conflict and will not proceed with the deletion.
2417 You have to remove the checkpoint first using the
2418 C<DeleteSchemaCheckpoint> API before using this API.
2419  
2420 You cannot use the C<DeleteSchemaVersions> API to delete the first
2421 schema version in the schema set. The first schema version can only be
2422 deleted by the C<DeleteSchema> API. This operation will also delete the
2423 attached C<SchemaVersionMetadata> under the schema versions. Hard
2424 deletes will be enforced on the database.
2425  
2426 If the compatibility mode forbids deleting of a version that is
2427 necessary, such as BACKWARDS_FULL, an error is returned.
2428  
2429  
2430 =head2 DeleteSecurityConfiguration
2431  
2432 =over
2433  
2434 =item Name => Str
2435  
2436  
2437 =back
2438  
2439 Each argument is described in detail in: L<Paws::Glue::DeleteSecurityConfiguration>
2440  
2441 Returns: a L<Paws::Glue::DeleteSecurityConfigurationResponse> instance
2442  
2443 Deletes a specified security configuration.
2444  
2445  
2446 =head2 DeleteTable
2447  
2448 =over
2449  
2450 =item DatabaseName => Str
2451  
2452 =item Name => Str
2453  
2454 =item [CatalogId => Str]
2455  
2456  
2457 =back
2458  
2459 Each argument is described in detail in: L<Paws::Glue::DeleteTable>
2460  
2461 Returns: a L<Paws::Glue::DeleteTableResponse> instance
2462  
2463 Removes a table definition from the Data Catalog.
2464  
2465 After completing this operation, you no longer have access to the table
2466 versions and partitions that belong to the deleted table. Glue deletes
2467 these "orphaned" resources asynchronously in a timely manner, at the
2468 discretion of the service.
2469  
2470 To ensure the immediate deletion of all related resources, before
2471 calling C<DeleteTable>, use C<DeleteTableVersion> or
2472 C<BatchDeleteTableVersion>, and C<DeletePartition> or
2473 C<BatchDeletePartition>, to delete any resources that belong to the
2474 table.
2475  
2476  
2477 =head2 DeleteTableVersion
2478  
2479 =over
2480  
2481 =item DatabaseName => Str
2482  
2483 =item TableName => Str
2484  
2485 =item VersionId => Str
2486  
2487 =item [CatalogId => Str]
2488  
2489  
2490 =back
2491  
2492 Each argument is described in detail in: L<Paws::Glue::DeleteTableVersion>
2493  
2494 Returns: a L<Paws::Glue::DeleteTableVersionResponse> instance
2495  
2496 Deletes a specified version of a table.
2497  
2498  
2499 =head2 DeleteTrigger
2500  
2501 =over
2502  
2503 =item Name => Str
2504  
2505  
2506 =back
2507  
2508 Each argument is described in detail in: L<Paws::Glue::DeleteTrigger>
2509  
2510 Returns: a L<Paws::Glue::DeleteTriggerResponse> instance
2511  
2512 Deletes a specified trigger. If the trigger is not found, no exception
2513 is thrown.
2514  
2515  
2516 =head2 DeleteUserDefinedFunction
2517  
2518 =over
2519  
2520 =item DatabaseName => Str
2521  
2522 =item FunctionName => Str
2523  
2524 =item [CatalogId => Str]
2525  
2526  
2527 =back
2528  
2529 Each argument is described in detail in: L<Paws::Glue::DeleteUserDefinedFunction>
2530  
2531 Returns: a L<Paws::Glue::DeleteUserDefinedFunctionResponse> instance
2532  
2533 Deletes an existing function definition from the Data Catalog.
2534  
2535  
2536 =head2 DeleteWorkflow
2537  
2538 =over
2539  
2540 =item Name => Str
2541  
2542  
2543 =back
2544  
2545 Each argument is described in detail in: L<Paws::Glue::DeleteWorkflow>
2546  
2547 Returns: a L<Paws::Glue::DeleteWorkflowResponse> instance
2548  
2549 Deletes a workflow.
2550  
2551  
2552 =head2 GetCatalogImportStatus
2553  
2554 =over
2555  
2556 =item [CatalogId => Str]
2557  
2558  
2559 =back
2560  
2561 Each argument is described in detail in: L<Paws::Glue::GetCatalogImportStatus>
2562  
2563 Returns: a L<Paws::Glue::GetCatalogImportStatusResponse> instance
2564  
2565 Retrieves the status of a migration operation.
2566  
2567  
2568 =head2 GetClassifier
2569  
2570 =over
2571  
2572 =item Name => Str
2573  
2574  
2575 =back
2576  
2577 Each argument is described in detail in: L<Paws::Glue::GetClassifier>
2578  
2579 Returns: a L<Paws::Glue::GetClassifierResponse> instance
2580  
2581 Retrieve a classifier by name.
2582  
2583  
2584 =head2 GetClassifiers
2585  
2586 =over
2587  
2588 =item [MaxResults => Int]
2589  
2590 =item [NextToken => Str]
2591  
2592  
2593 =back
2594  
2595 Each argument is described in detail in: L<Paws::Glue::GetClassifiers>
2596  
2597 Returns: a L<Paws::Glue::GetClassifiersResponse> instance
2598  
2599 Lists all classifier objects in the Data Catalog.
2600  
2601  
2602 =head2 GetColumnStatisticsForPartition
2603  
2604 =over
2605  
2606 =item ColumnNames => ArrayRef[Str|Undef]
2607  
2608 =item DatabaseName => Str
2609  
2610 =item PartitionValues => ArrayRef[Str|Undef]
2611  
2612 =item TableName => Str
2613  
2614 =item [CatalogId => Str]
2615  
2616  
2617 =back
2618  
2619 Each argument is described in detail in: L<Paws::Glue::GetColumnStatisticsForPartition>
2620  
2621 Returns: a L<Paws::Glue::GetColumnStatisticsForPartitionResponse> instance
2622  
2623 Retrieves partition statistics of columns.
2624  
2625 The Identity and Access Management (IAM) permission required for this
2626 operation is C<GetPartition>.
2627  
2628  
2629 =head2 GetColumnStatisticsForTable
2630  
2631 =over
2632  
2633 =item ColumnNames => ArrayRef[Str|Undef]
2634  
2635 =item DatabaseName => Str
2636  
2637 =item TableName => Str
2638  
2639 =item [CatalogId => Str]
2640  
2641  
2642 =back
2643  
2644 Each argument is described in detail in: L<Paws::Glue::GetColumnStatisticsForTable>
2645  
2646 Returns: a L<Paws::Glue::GetColumnStatisticsForTableResponse> instance
2647  
2648 Retrieves table statistics of columns.
2649  
2650 The Identity and Access Management (IAM) permission required for this
2651 operation is C<GetTable>.
2652  
2653  
2654 =head2 GetConnection
2655  
2656 =over
2657  
2658 =item Name => Str
2659  
2660 =item [CatalogId => Str]
2661  
2662 =item [HidePassword => Bool]
2663  
2664  
2665 =back
2666  
2667 Each argument is described in detail in: L<Paws::Glue::GetConnection>
2668  
2669 Returns: a L<Paws::Glue::GetConnectionResponse> instance
2670  
2671 Retrieves a connection definition from the Data Catalog.
2672  
2673  
2674 =head2 GetConnections
2675  
2676 =over
2677  
2678 =item [CatalogId => Str]
2679  
2680 =item [Filter => L<Paws::Glue::GetConnectionsFilter>]
2681  
2682 =item [HidePassword => Bool]
2683  
2684 =item [MaxResults => Int]
2685  
2686 =item [NextToken => Str]
2687  
2688  
2689 =back
2690  
2691 Each argument is described in detail in: L<Paws::Glue::GetConnections>
2692  
2693 Returns: a L<Paws::Glue::GetConnectionsResponse> instance
2694  
2695 Retrieves a list of connection definitions from the Data Catalog.
2696  
2697  
2698 =head2 GetCrawler
2699  
2700 =over
2701  
2702 =item Name => Str
2703  
2704  
2705 =back
2706  
2707 Each argument is described in detail in: L<Paws::Glue::GetCrawler>
2708  
2709 Returns: a L<Paws::Glue::GetCrawlerResponse> instance
2710  
2711 Retrieves metadata for a specified crawler.
2712  
2713  
2714 =head2 GetCrawlerMetrics
2715  
2716 =over
2717  
2718 =item [CrawlerNameList => ArrayRef[Str|Undef]]
2719  
2720 =item [MaxResults => Int]
2721  
2722 =item [NextToken => Str]
2723  
2724  
2725 =back
2726  
2727 Each argument is described in detail in: L<Paws::Glue::GetCrawlerMetrics>
2728  
2729 Returns: a L<Paws::Glue::GetCrawlerMetricsResponse> instance
2730  
2731 Retrieves metrics about specified crawlers.
2732  
2733  
2734 =head2 GetCrawlers
2735  
2736 =over
2737  
2738 =item [MaxResults => Int]
2739  
2740 =item [NextToken => Str]
2741  
2742  
2743 =back
2744  
2745 Each argument is described in detail in: L<Paws::Glue::GetCrawlers>
2746  
2747 Returns: a L<Paws::Glue::GetCrawlersResponse> instance
2748  
2749 Retrieves metadata for all crawlers defined in the customer account.
2750  
2751  
2752 =head2 GetDatabase
2753  
2754 =over
2755  
2756 =item Name => Str
2757  
2758 =item [CatalogId => Str]
2759  
2760  
2761 =back
2762  
2763 Each argument is described in detail in: L<Paws::Glue::GetDatabase>
2764  
2765 Returns: a L<Paws::Glue::GetDatabaseResponse> instance
2766  
2767 Retrieves the definition of a specified database.
2768  
2769  
2770 =head2 GetDatabases
2771  
2772 =over
2773  
2774 =item [CatalogId => Str]
2775  
2776 =item [MaxResults => Int]
2777  
2778 =item [NextToken => Str]
2779  
2780 =item [ResourceShareType => Str]
2781  
2782  
2783 =back
2784  
2785 Each argument is described in detail in: L<Paws::Glue::GetDatabases>
2786  
2787 Returns: a L<Paws::Glue::GetDatabasesResponse> instance
2788  
2789 Retrieves all databases defined in a given Data Catalog.
2790  
2791  
2792 =head2 GetDataCatalogEncryptionSettings
2793  
2794 =over
2795  
2796 =item [CatalogId => Str]
2797  
2798  
2799 =back
2800  
2801 Each argument is described in detail in: L<Paws::Glue::GetDataCatalogEncryptionSettings>
2802  
2803 Returns: a L<Paws::Glue::GetDataCatalogEncryptionSettingsResponse> instance
2804  
2805 Retrieves the security configuration for a specified catalog.
2806  
2807  
2808 =head2 GetDataflowGraph
2809  
2810 =over
2811  
2812 =item [PythonScript => Str]
2813  
2814  
2815 =back
2816  
2817 Each argument is described in detail in: L<Paws::Glue::GetDataflowGraph>
2818  
2819 Returns: a L<Paws::Glue::GetDataflowGraphResponse> instance
2820  
2821 Transforms a Python script into a directed acyclic graph (DAG).
2822  
2823  
2824 =head2 GetDevEndpoint
2825  
2826 =over
2827  
2828 =item EndpointName => Str
2829  
2830  
2831 =back
2832  
2833 Each argument is described in detail in: L<Paws::Glue::GetDevEndpoint>
2834  
2835 Returns: a L<Paws::Glue::GetDevEndpointResponse> instance
2836  
2837 Retrieves information about a specified development endpoint.
2838  
2839 When you create a development endpoint in a virtual private cloud
2840 (VPC), Glue returns only a private IP address, and the public IP
2841 address field is not populated. When you create a non-VPC development
2842 endpoint, Glue returns only a public IP address.
2843  
2844  
2845 =head2 GetDevEndpoints
2846  
2847 =over
2848  
2849 =item [MaxResults => Int]
2850  
2851 =item [NextToken => Str]
2852  
2853  
2854 =back
2855  
2856 Each argument is described in detail in: L<Paws::Glue::GetDevEndpoints>
2857  
2858 Returns: a L<Paws::Glue::GetDevEndpointsResponse> instance
2859  
2860 Retrieves all the development endpoints in this AWS account.
2861  
2862 When you create a development endpoint in a virtual private cloud
2863 (VPC), Glue returns only a private IP address and the public IP address
2864 field is not populated. When you create a non-VPC development endpoint,
2865 Glue returns only a public IP address.
2866  
2867  
2868 =head2 GetJob
2869  
2870 =over
2871  
2872 =item JobName => Str
2873  
2874  
2875 =back
2876  
2877 Each argument is described in detail in: L<Paws::Glue::GetJob>
2878  
2879 Returns: a L<Paws::Glue::GetJobResponse> instance
2880  
2881 Retrieves an existing job definition.
2882  
2883  
2884 =head2 GetJobBookmark
2885  
2886 =over
2887  
2888 =item JobName => Str
2889  
2890 =item [RunId => Str]
2891  
2892  
2893 =back
2894  
2895 Each argument is described in detail in: L<Paws::Glue::GetJobBookmark>
2896  
2897 Returns: a L<Paws::Glue::GetJobBookmarkResponse> instance
2898  
2899 Returns information on a job bookmark entry.
2900  
2901  
2902 =head2 GetJobRun
2903  
2904 =over
2905  
2906 =item JobName => Str
2907  
2908 =item RunId => Str
2909  
2910 =item [PredecessorsIncluded => Bool]
2911  
2912  
2913 =back
2914  
2915 Each argument is described in detail in: L<Paws::Glue::GetJobRun>
2916  
2917 Returns: a L<Paws::Glue::GetJobRunResponse> instance
2918  
2919 Retrieves the metadata for a given job run.
2920  
2921  
2922 =head2 GetJobRuns
2923  
2924 =over
2925  
2926 =item JobName => Str
2927  
2928 =item [MaxResults => Int]
2929  
2930 =item [NextToken => Str]
2931  
2932  
2933 =back
2934  
2935 Each argument is described in detail in: L<Paws::Glue::GetJobRuns>
2936  
2937 Returns: a L<Paws::Glue::GetJobRunsResponse> instance
2938  
2939 Retrieves metadata for all runs of a given job definition.
2940  
2941  
2942 =head2 GetJobs
2943  
2944 =over
2945  
2946 =item [MaxResults => Int]
2947  
2948 =item [NextToken => Str]
2949  
2950  
2951 =back
2952  
2953 Each argument is described in detail in: L<Paws::Glue::GetJobs>
2954  
2955 Returns: a L<Paws::Glue::GetJobsResponse> instance
2956  
2957 Retrieves all current job definitions.
2958  
2959  
2960 =head2 GetMapping
2961  
2962 =over
2963  
2964 =item Source => L<Paws::Glue::CatalogEntry>
2965  
2966 =item [Location => L<Paws::Glue::Location>]
2967  
2968 =item [Sinks => ArrayRef[L<Paws::Glue::CatalogEntry>]]
2969  
2970  
2971 =back
2972  
2973 Each argument is described in detail in: L<Paws::Glue::GetMapping>
2974  
2975 Returns: a L<Paws::Glue::GetMappingResponse> instance
2976  
2977 Creates mappings.
2978  
2979  
2980 =head2 GetMLTaskRun
2981  
2982 =over
2983  
2984 =item TaskRunId => Str
2985  
2986 =item TransformId => Str
2987  
2988  
2989 =back
2990  
2991 Each argument is described in detail in: L<Paws::Glue::GetMLTaskRun>
2992  
2993 Returns: a L<Paws::Glue::GetMLTaskRunResponse> instance
2994  
2995 Gets details for a specific task run on a machine learning transform.
2996 Machine learning task runs are asynchronous tasks that Glue runs on
2997 your behalf as part of various machine learning workflows. You can
2998 check the stats of any task run by calling C<GetMLTaskRun> with the
2999 C<TaskRunID> and its parent transform's C<TransformID>.
3000  
3001  
3002 =head2 GetMLTaskRuns
3003  
3004 =over
3005  
3006 =item TransformId => Str
3007  
3008 =item [Filter => L<Paws::Glue::TaskRunFilterCriteria>]
3009  
3010 =item [MaxResults => Int]
3011  
3012 =item [NextToken => Str]
3013  
3014 =item [Sort => L<Paws::Glue::TaskRunSortCriteria>]
3015  
3016  
3017 =back
3018  
3019 Each argument is described in detail in: L<Paws::Glue::GetMLTaskRuns>
3020  
3021 Returns: a L<Paws::Glue::GetMLTaskRunsResponse> instance
3022  
3023 Gets a list of runs for a machine learning transform. Machine learning
3024 task runs are asynchronous tasks that Glue runs on your behalf as part
3025 of various machine learning workflows. You can get a sortable,
3026 filterable list of machine learning task runs by calling
3027 C<GetMLTaskRuns> with their parent transform's C<TransformID> and other
3028 optional parameters as documented in this section.
3029  
3030 This operation returns a list of historic runs and must be paginated.
3031  
3032  
3033 =head2 GetMLTransform
3034  
3035 =over
3036  
3037 =item TransformId => Str
3038  
3039  
3040 =back
3041  
3042 Each argument is described in detail in: L<Paws::Glue::GetMLTransform>
3043  
3044 Returns: a L<Paws::Glue::GetMLTransformResponse> instance
3045  
3046 Gets an Glue machine learning transform artifact and all its
3047 corresponding metadata. Machine learning transforms are a special type
3048 of transform that use machine learning to learn the details of the
3049 transformation to be performed by learning from examples provided by
3050 humans. These transformations are then saved by Glue. You can retrieve
3051 their metadata by calling C<GetMLTransform>.
3052  
3053  
3054 =head2 GetMLTransforms
3055  
3056 =over
3057  
3058 =item [Filter => L<Paws::Glue::TransformFilterCriteria>]
3059  
3060 =item [MaxResults => Int]
3061  
3062 =item [NextToken => Str]
3063  
3064 =item [Sort => L<Paws::Glue::TransformSortCriteria>]
3065  
3066  
3067 =back
3068  
3069 Each argument is described in detail in: L<Paws::Glue::GetMLTransforms>
3070  
3071 Returns: a L<Paws::Glue::GetMLTransformsResponse> instance
3072  
3073 Gets a sortable, filterable list of existing Glue machine learning
3074 transforms. Machine learning transforms are a special type of transform
3075 that use machine learning to learn the details of the transformation to
3076 be performed by learning from examples provided by humans. These
3077 transformations are then saved by Glue, and you can retrieve their
3078 metadata by calling C<GetMLTransforms>.
3079  
3080  
3081 =head2 GetPartition
3082  
3083 =over
3084  
3085 =item DatabaseName => Str
3086  
3087 =item PartitionValues => ArrayRef[Str|Undef]
3088  
3089 =item TableName => Str
3090  
3091 =item [CatalogId => Str]
3092  
3093  
3094 =back
3095  
3096 Each argument is described in detail in: L<Paws::Glue::GetPartition>
3097  
3098 Returns: a L<Paws::Glue::GetPartitionResponse> instance
3099  
3100 Retrieves information about a specified partition.
3101  
3102  
3103 =head2 GetPartitionIndexes
3104  
3105 =over
3106  
3107 =item DatabaseName => Str
3108  
3109 =item TableName => Str
3110  
3111 =item [CatalogId => Str]
3112  
3113 =item [NextToken => Str]
3114  
3115  
3116 =back
3117  
3118 Each argument is described in detail in: L<Paws::Glue::GetPartitionIndexes>
3119  
3120 Returns: a L<Paws::Glue::GetPartitionIndexesResponse> instance
3121  
3122 Retrieves the partition indexes associated with a table.
3123  
3124  
3125 =head2 GetPartitions
3126  
3127 =over
3128  
3129 =item DatabaseName => Str
3130  
3131 =item TableName => Str
3132  
3133 =item [CatalogId => Str]
3134  
3135 =item [ExcludeColumnSchema => Bool]
3136  
3137 =item [Expression => Str]
3138  
3139 =item [MaxResults => Int]
3140  
3141 =item [NextToken => Str]
3142  
3143 =item [Segment => L<Paws::Glue::Segment>]
3144  
3145  
3146 =back
3147  
3148 Each argument is described in detail in: L<Paws::Glue::GetPartitions>
3149  
3150 Returns: a L<Paws::Glue::GetPartitionsResponse> instance
3151  
3152 Retrieves information about the partitions in a table.
3153  
3154  
3155 =head2 GetPlan
3156  
3157 =over
3158  
3159 =item Mapping => ArrayRef[L<Paws::Glue::MappingEntry>]
3160  
3161 =item Source => L<Paws::Glue::CatalogEntry>
3162  
3163 =item [AdditionalPlanOptionsMap => L<Paws::Glue::AdditionalPlanOptionsMap>]
3164  
3165 =item [Language => Str]
3166  
3167 =item [Location => L<Paws::Glue::Location>]
3168  
3169 =item [Sinks => ArrayRef[L<Paws::Glue::CatalogEntry>]]
3170  
3171  
3172 =back
3173  
3174 Each argument is described in detail in: L<Paws::Glue::GetPlan>
3175  
3176 Returns: a L<Paws::Glue::GetPlanResponse> instance
3177  
3178 Gets code to perform a specified mapping.
3179  
3180  
3181 =head2 GetRegistry
3182  
3183 =over
3184  
3185 =item RegistryId => L<Paws::Glue::RegistryId>
3186  
3187  
3188 =back
3189  
3190 Each argument is described in detail in: L<Paws::Glue::GetRegistry>
3191  
3192 Returns: a L<Paws::Glue::GetRegistryResponse> instance
3193  
3194 Describes the specified registry in detail.
3195  
3196  
3197 =head2 GetResourcePolicies
3198  
3199 =over
3200  
3201 =item [MaxResults => Int]
3202  
3203 =item [NextToken => Str]
3204  
3205  
3206 =back
3207  
3208 Each argument is described in detail in: L<Paws::Glue::GetResourcePolicies>
3209  
3210 Returns: a L<Paws::Glue::GetResourcePoliciesResponse> instance
3211  
3212 Retrieves the resource policies set on individual resources by Resource
3213 Access Manager during cross-account permission grants. Also retrieves
3214 the Data Catalog resource policy.
3215  
3216 If you enabled metadata encryption in Data Catalog settings, and you do
3217 not have permission on the KMS key, the operation can't return the Data
3218 Catalog resource policy.
3219  
3220  
3221 =head2 GetResourcePolicy
3222  
3223 =over
3224  
3225 =item [ResourceArn => Str]
3226  
3227  
3228 =back
3229  
3230 Each argument is described in detail in: L<Paws::Glue::GetResourcePolicy>
3231  
3232 Returns: a L<Paws::Glue::GetResourcePolicyResponse> instance
3233  
3234 Retrieves a specified resource policy.
3235  
3236  
3237 =head2 GetSchema
3238  
3239 =over
3240  
3241 =item SchemaId => L<Paws::Glue::SchemaId>
3242  
3243  
3244 =back
3245  
3246 Each argument is described in detail in: L<Paws::Glue::GetSchema>
3247  
3248 Returns: a L<Paws::Glue::GetSchemaResponse> instance
3249  
3250 Describes the specified schema in detail.
3251  
3252  
3253 =head2 GetSchemaByDefinition
3254  
3255 =over
3256  
3257 =item SchemaDefinition => Str
3258  
3259 =item SchemaId => L<Paws::Glue::SchemaId>
3260  
3261  
3262 =back
3263  
3264 Each argument is described in detail in: L<Paws::Glue::GetSchemaByDefinition>
3265  
3266 Returns: a L<Paws::Glue::GetSchemaByDefinitionResponse> instance
3267  
3268 Retrieves a schema by the C<SchemaDefinition>. The schema definition is
3269 sent to the Schema Registry, canonicalized, and hashed. If the hash is
3270 matched within the scope of the C<SchemaName> or ARN (or the default
3271 registry, if none is supplied), that schemaE<rsquo>s metadata is
3272 returned. Otherwise, a 404 or NotFound error is returned. Schema
3273 versions in C<Deleted> statuses will not be included in the results.
3274  
3275  
3276 =head2 GetSchemaVersion
3277  
3278 =over
3279  
3280 =item [SchemaId => L<Paws::Glue::SchemaId>]
3281  
3282 =item [SchemaVersionId => Str]
3283  
3284 =item [SchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>]
3285  
3286  
3287 =back
3288  
3289 Each argument is described in detail in: L<Paws::Glue::GetSchemaVersion>
3290  
3291 Returns: a L<Paws::Glue::GetSchemaVersionResponse> instance
3292  
3293 Get the specified schema by its unique ID assigned when a version of
3294 the schema is created or registered. Schema versions in Deleted status
3295 will not be included in the results.
3296  
3297  
3298 =head2 GetSchemaVersionsDiff
3299  
3300 =over
3301  
3302 =item FirstSchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>
3303  
3304 =item SchemaDiffType => Str
3305  
3306 =item SchemaId => L<Paws::Glue::SchemaId>
3307  
3308 =item SecondSchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>
3309  
3310  
3311 =back
3312  
3313 Each argument is described in detail in: L<Paws::Glue::GetSchemaVersionsDiff>
3314  
3315 Returns: a L<Paws::Glue::GetSchemaVersionsDiffResponse> instance
3316  
3317 Fetches the schema version difference in the specified difference type
3318 between two stored schema versions in the Schema Registry.
3319  
3320 This API allows you to compare two schema versions between two schema
3321 definitions under the same schema.
3322  
3323  
3324 =head2 GetSecurityConfiguration
3325  
3326 =over
3327  
3328 =item Name => Str
3329  
3330  
3331 =back
3332  
3333 Each argument is described in detail in: L<Paws::Glue::GetSecurityConfiguration>
3334  
3335 Returns: a L<Paws::Glue::GetSecurityConfigurationResponse> instance
3336  
3337 Retrieves a specified security configuration.
3338  
3339  
3340 =head2 GetSecurityConfigurations
3341  
3342 =over
3343  
3344 =item [MaxResults => Int]
3345  
3346 =item [NextToken => Str]
3347  
3348  
3349 =back
3350  
3351 Each argument is described in detail in: L<Paws::Glue::GetSecurityConfigurations>
3352  
3353 Returns: a L<Paws::Glue::GetSecurityConfigurationsResponse> instance
3354  
3355 Retrieves a list of all security configurations.
3356  
3357  
3358 =head2 GetTable
3359  
3360 =over
3361  
3362 =item DatabaseName => Str
3363  
3364 =item Name => Str
3365  
3366 =item [CatalogId => Str]
3367  
3368  
3369 =back
3370  
3371 Each argument is described in detail in: L<Paws::Glue::GetTable>
3372  
3373 Returns: a L<Paws::Glue::GetTableResponse> instance
3374  
3375 Retrieves the C<Table> definition in a Data Catalog for a specified
3376 table.
3377  
3378  
3379 =head2 GetTables
3380  
3381 =over
3382  
3383 =item DatabaseName => Str
3384  
3385 =item [CatalogId => Str]
3386  
3387 =item [Expression => Str]
3388  
3389 =item [MaxResults => Int]
3390  
3391 =item [NextToken => Str]
3392  
3393  
3394 =back
3395  
3396 Each argument is described in detail in: L<Paws::Glue::GetTables>
3397  
3398 Returns: a L<Paws::Glue::GetTablesResponse> instance
3399  
3400 Retrieves the definitions of some or all of the tables in a given
3401 C<Database>.
3402  
3403  
3404 =head2 GetTableVersion
3405  
3406 =over
3407  
3408 =item DatabaseName => Str
3409  
3410 =item TableName => Str
3411  
3412 =item [CatalogId => Str]
3413  
3414 =item [VersionId => Str]
3415  
3416  
3417 =back
3418  
3419 Each argument is described in detail in: L<Paws::Glue::GetTableVersion>
3420  
3421 Returns: a L<Paws::Glue::GetTableVersionResponse> instance
3422  
3423 Retrieves a specified version of a table.
3424  
3425  
3426 =head2 GetTableVersions
3427  
3428 =over
3429  
3430 =item DatabaseName => Str
3431  
3432 =item TableName => Str
3433  
3434 =item [CatalogId => Str]
3435  
3436 =item [MaxResults => Int]
3437  
3438 =item [NextToken => Str]
3439  
3440  
3441 =back
3442  
3443 Each argument is described in detail in: L<Paws::Glue::GetTableVersions>
3444  
3445 Returns: a L<Paws::Glue::GetTableVersionsResponse> instance
3446  
3447 Retrieves a list of strings that identify available versions of a
3448 specified table.
3449  
3450  
3451 =head2 GetTags
3452  
3453 =over
3454  
3455 =item ResourceArn => Str
3456  
3457  
3458 =back
3459  
3460 Each argument is described in detail in: L<Paws::Glue::GetTags>
3461  
3462 Returns: a L<Paws::Glue::GetTagsResponse> instance
3463  
3464 Retrieves a list of tags associated with a resource.
3465  
3466  
3467 =head2 GetTrigger
3468  
3469 =over
3470  
3471 =item Name => Str
3472  
3473  
3474 =back
3475  
3476 Each argument is described in detail in: L<Paws::Glue::GetTrigger>
3477  
3478 Returns: a L<Paws::Glue::GetTriggerResponse> instance
3479  
3480 Retrieves the definition of a trigger.
3481  
3482  
3483 =head2 GetTriggers
3484  
3485 =over
3486  
3487 =item [DependentJobName => Str]
3488  
3489 =item [MaxResults => Int]
3490  
3491 =item [NextToken => Str]
3492  
3493  
3494 =back
3495  
3496 Each argument is described in detail in: L<Paws::Glue::GetTriggers>
3497  
3498 Returns: a L<Paws::Glue::GetTriggersResponse> instance
3499  
3500 Gets all the triggers associated with a job.
3501  
3502  
3503 =head2 GetUserDefinedFunction
3504  
3505 =over
3506  
3507 =item DatabaseName => Str
3508  
3509 =item FunctionName => Str
3510  
3511 =item [CatalogId => Str]
3512  
3513  
3514 =back
3515  
3516 Each argument is described in detail in: L<Paws::Glue::GetUserDefinedFunction>
3517  
3518 Returns: a L<Paws::Glue::GetUserDefinedFunctionResponse> instance
3519  
3520 Retrieves a specified function definition from the Data Catalog.
3521  
3522  
3523 =head2 GetUserDefinedFunctions
3524  
3525 =over
3526  
3527 =item Pattern => Str
3528  
3529 =item [CatalogId => Str]
3530  
3531 =item [DatabaseName => Str]
3532  
3533 =item [MaxResults => Int]
3534  
3535 =item [NextToken => Str]
3536  
3537  
3538 =back
3539  
3540 Each argument is described in detail in: L<Paws::Glue::GetUserDefinedFunctions>
3541  
3542 Returns: a L<Paws::Glue::GetUserDefinedFunctionsResponse> instance
3543  
3544 Retrieves multiple function definitions from the Data Catalog.
3545  
3546  
3547 =head2 GetWorkflow
3548  
3549 =over
3550  
3551 =item Name => Str
3552  
3553 =item [IncludeGraph => Bool]
3554  
3555  
3556 =back
3557  
3558 Each argument is described in detail in: L<Paws::Glue::GetWorkflow>
3559  
3560 Returns: a L<Paws::Glue::GetWorkflowResponse> instance
3561  
3562 Retrieves resource metadata for a workflow.
3563  
3564  
3565 =head2 GetWorkflowRun
3566  
3567 =over
3568  
3569 =item Name => Str
3570  
3571 =item RunId => Str
3572  
3573 =item [IncludeGraph => Bool]
3574  
3575  
3576 =back
3577  
3578 Each argument is described in detail in: L<Paws::Glue::GetWorkflowRun>
3579  
3580 Returns: a L<Paws::Glue::GetWorkflowRunResponse> instance
3581  
3582 Retrieves the metadata for a given workflow run.
3583  
3584  
3585 =head2 GetWorkflowRunProperties
3586  
3587 =over
3588  
3589 =item Name => Str
3590  
3591 =item RunId => Str
3592  
3593  
3594 =back
3595  
3596 Each argument is described in detail in: L<Paws::Glue::GetWorkflowRunProperties>
3597  
3598 Returns: a L<Paws::Glue::GetWorkflowRunPropertiesResponse> instance
3599  
3600 Retrieves the workflow run properties which were set during the run.
3601  
3602  
3603 =head2 GetWorkflowRuns
3604  
3605 =over
3606  
3607 =item Name => Str
3608  
3609 =item [IncludeGraph => Bool]
3610  
3611 =item [MaxResults => Int]
3612  
3613 =item [NextToken => Str]
3614  
3615  
3616 =back
3617  
3618 Each argument is described in detail in: L<Paws::Glue::GetWorkflowRuns>
3619  
3620 Returns: a L<Paws::Glue::GetWorkflowRunsResponse> instance
3621  
3622 Retrieves metadata for all runs of a given workflow.
3623  
3624  
3625 =head2 ImportCatalogToGlue
3626  
3627 =over
3628  
3629 =item [CatalogId => Str]
3630  
3631  
3632 =back
3633  
3634 Each argument is described in detail in: L<Paws::Glue::ImportCatalogToGlue>
3635  
3636 Returns: a L<Paws::Glue::ImportCatalogToGlueResponse> instance
3637  
3638 Imports an existing Amazon Athena Data Catalog to Glue.
3639  
3640  
3641 =head2 ListCrawlers
3642  
3643 =over
3644  
3645 =item [MaxResults => Int]
3646  
3647 =item [NextToken => Str]
3648  
3649 =item [Tags => L<Paws::Glue::TagsMap>]
3650  
3651  
3652 =back
3653  
3654 Each argument is described in detail in: L<Paws::Glue::ListCrawlers>
3655  
3656 Returns: a L<Paws::Glue::ListCrawlersResponse> instance
3657  
3658 Retrieves the names of all crawler resources in this Amazon Web
3659 Services account, or the resources with the specified tag. This
3660 operation allows you to see which resources are available in your
3661 account, and their names.
3662  
3663 This operation takes the optional C<Tags> field, which you can use as a
3664 filter on the response so that tagged resources can be retrieved as a
3665 group. If you choose to use tags filtering, only resources with the tag
3666 are retrieved.
3667  
3668  
3669 =head2 ListDevEndpoints
3670  
3671 =over
3672  
3673 =item [MaxResults => Int]
3674  
3675 =item [NextToken => Str]
3676  
3677 =item [Tags => L<Paws::Glue::TagsMap>]
3678  
3679  
3680 =back
3681  
3682 Each argument is described in detail in: L<Paws::Glue::ListDevEndpoints>
3683  
3684 Returns: a L<Paws::Glue::ListDevEndpointsResponse> instance
3685  
3686 Retrieves the names of all C<DevEndpoint> resources in this Amazon Web
3687 Services account, or the resources with the specified tag. This
3688 operation allows you to see which resources are available in your
3689 account, and their names.
3690  
3691 This operation takes the optional C<Tags> field, which you can use as a
3692 filter on the response so that tagged resources can be retrieved as a
3693 group. If you choose to use tags filtering, only resources with the tag
3694 are retrieved.
3695  
3696  
3697 =head2 ListJobs
3698  
3699 =over
3700  
3701 =item [MaxResults => Int]
3702  
3703 =item [NextToken => Str]
3704  
3705 =item [Tags => L<Paws::Glue::TagsMap>]
3706  
3707  
3708 =back
3709  
3710 Each argument is described in detail in: L<Paws::Glue::ListJobs>
3711  
3712 Returns: a L<Paws::Glue::ListJobsResponse> instance
3713  
3714 Retrieves the names of all job resources in this Amazon Web Services
3715 account, or the resources with the specified tag. This operation allows
3716 you to see which resources are available in your account, and their
3717 names.
3718  
3719 This operation takes the optional C<Tags> field, which you can use as a
3720 filter on the response so that tagged resources can be retrieved as a
3721 group. If you choose to use tags filtering, only resources with the tag
3722 are retrieved.
3723  
3724  
3725 =head2 ListMLTransforms
3726  
3727 =over
3728  
3729 =item [Filter => L<Paws::Glue::TransformFilterCriteria>]
3730  
3731 =item [MaxResults => Int]
3732  
3733 =item [NextToken => Str]
3734  
3735 =item [Sort => L<Paws::Glue::TransformSortCriteria>]
3736  
3737 =item [Tags => L<Paws::Glue::TagsMap>]
3738  
3739  
3740 =back
3741  
3742 Each argument is described in detail in: L<Paws::Glue::ListMLTransforms>
3743  
3744 Returns: a L<Paws::Glue::ListMLTransformsResponse> instance
3745  
3746 Retrieves a sortable, filterable list of existing Glue machine learning
3747 transforms in this Amazon Web Services account, or the resources with
3748 the specified tag. This operation takes the optional C<Tags> field,
3749 which you can use as a filter of the responses so that tagged resources
3750 can be retrieved as a group. If you choose to use tag filtering, only
3751 resources with the tags are retrieved.
3752  
3753  
3754 =head2 ListRegistries
3755  
3756 =over
3757  
3758 =item [MaxResults => Int]
3759  
3760 =item [NextToken => Str]
3761  
3762  
3763 =back
3764  
3765 Each argument is described in detail in: L<Paws::Glue::ListRegistries>
3766  
3767 Returns: a L<Paws::Glue::ListRegistriesResponse> instance
3768  
3769 Returns a list of registries that you have created, with minimal
3770 registry information. Registries in the C<Deleting> status will not be
3771 included in the results. Empty results will be returned if there are no
3772 registries available.
3773  
3774  
3775 =head2 ListSchemas
3776  
3777 =over
3778  
3779 =item [MaxResults => Int]
3780  
3781 =item [NextToken => Str]
3782  
3783 =item [RegistryId => L<Paws::Glue::RegistryId>]
3784  
3785  
3786 =back
3787  
3788 Each argument is described in detail in: L<Paws::Glue::ListSchemas>
3789  
3790 Returns: a L<Paws::Glue::ListSchemasResponse> instance
3791  
3792 Returns a list of schemas with minimal details. Schemas in Deleting
3793 status will not be included in the results. Empty results will be
3794 returned if there are no schemas available.
3795  
3796 When the C<RegistryId> is not provided, all the schemas across
3797 registries will be part of the API response.
3798  
3799  
3800 =head2 ListSchemaVersions
3801  
3802 =over
3803  
3804 =item SchemaId => L<Paws::Glue::SchemaId>
3805  
3806 =item [MaxResults => Int]
3807  
3808 =item [NextToken => Str]
3809  
3810  
3811 =back
3812  
3813 Each argument is described in detail in: L<Paws::Glue::ListSchemaVersions>
3814  
3815 Returns: a L<Paws::Glue::ListSchemaVersionsResponse> instance
3816  
3817 Returns a list of schema versions that you have created, with minimal
3818 information. Schema versions in Deleted status will not be included in
3819 the results. Empty results will be returned if there are no schema
3820 versions available.
3821  
3822  
3823 =head2 ListTriggers
3824  
3825 =over
3826  
3827 =item [DependentJobName => Str]
3828  
3829 =item [MaxResults => Int]
3830  
3831 =item [NextToken => Str]
3832  
3833 =item [Tags => L<Paws::Glue::TagsMap>]
3834  
3835  
3836 =back
3837  
3838 Each argument is described in detail in: L<Paws::Glue::ListTriggers>
3839  
3840 Returns: a L<Paws::Glue::ListTriggersResponse> instance
3841  
3842 Retrieves the names of all trigger resources in this Amazon Web
3843 Services account, or the resources with the specified tag. This
3844 operation allows you to see which resources are available in your
3845 account, and their names.
3846  
3847 This operation takes the optional C<Tags> field, which you can use as a
3848 filter on the response so that tagged resources can be retrieved as a
3849 group. If you choose to use tags filtering, only resources with the tag
3850 are retrieved.
3851  
3852  
3853 =head2 ListWorkflows
3854  
3855 =over
3856  
3857 =item [MaxResults => Int]
3858  
3859 =item [NextToken => Str]
3860  
3861  
3862 =back
3863  
3864 Each argument is described in detail in: L<Paws::Glue::ListWorkflows>
3865  
3866 Returns: a L<Paws::Glue::ListWorkflowsResponse> instance
3867  
3868 Lists names of workflows created in the account.
3869  
3870  
3871 =head2 PutDataCatalogEncryptionSettings
3872  
3873 =over
3874  
3875 =item DataCatalogEncryptionSettings => L<Paws::Glue::DataCatalogEncryptionSettings>
3876  
3877 =item [CatalogId => Str]
3878  
3879  
3880 =back
3881  
3882 Each argument is described in detail in: L<Paws::Glue::PutDataCatalogEncryptionSettings>
3883  
3884 Returns: a L<Paws::Glue::PutDataCatalogEncryptionSettingsResponse> instance
3885  
3886 Sets the security configuration for a specified catalog. After the
3887 configuration has been set, the specified encryption is applied to
3888 every catalog write thereafter.
3889  
3890  
3891 =head2 PutResourcePolicy
3892  
3893 =over
3894  
3895 =item PolicyInJson => Str
3896  
3897 =item [EnableHybrid => Str]
3898  
3899 =item [PolicyExistsCondition => Str]
3900  
3901 =item [PolicyHashCondition => Str]
3902  
3903 =item [ResourceArn => Str]
3904  
3905  
3906 =back
3907  
3908 Each argument is described in detail in: L<Paws::Glue::PutResourcePolicy>
3909  
3910 Returns: a L<Paws::Glue::PutResourcePolicyResponse> instance
3911  
3912 Sets the Data Catalog resource policy for access control.
3913  
3914  
3915 =head2 PutSchemaVersionMetadata
3916  
3917 =over
3918  
3919 =item MetadataKeyValue => L<Paws::Glue::MetadataKeyValuePair>
3920  
3921 =item [SchemaId => L<Paws::Glue::SchemaId>]
3922  
3923 =item [SchemaVersionId => Str]
3924  
3925 =item [SchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>]
3926  
3927  
3928 =back
3929  
3930 Each argument is described in detail in: L<Paws::Glue::PutSchemaVersionMetadata>
3931  
3932 Returns: a L<Paws::Glue::PutSchemaVersionMetadataResponse> instance
3933  
3934 Puts the metadata key value pair for a specified schema version ID. A
3935 maximum of 10 key value pairs will be allowed per schema version. They
3936 can be added over one or more calls.
3937  
3938  
3939 =head2 PutWorkflowRunProperties
3940  
3941 =over
3942  
3943 =item Name => Str
3944  
3945 =item RunId => Str
3946  
3947 =item RunProperties => L<Paws::Glue::WorkflowRunProperties>
3948  
3949  
3950 =back
3951  
3952 Each argument is described in detail in: L<Paws::Glue::PutWorkflowRunProperties>
3953  
3954 Returns: a L<Paws::Glue::PutWorkflowRunPropertiesResponse> instance
3955  
3956 Puts the specified workflow run properties for the given workflow run.
3957 If a property already exists for the specified run, then it overrides
3958 the value otherwise adds the property to existing properties.
3959  
3960  
3961 =head2 QuerySchemaVersionMetadata
3962  
3963 =over
3964  
3965 =item [MaxResults => Int]
3966  
3967 =item [MetadataList => ArrayRef[L<Paws::Glue::MetadataKeyValuePair>]]
3968  
3969 =item [NextToken => Str]
3970  
3971 =item [SchemaId => L<Paws::Glue::SchemaId>]
3972  
3973 =item [SchemaVersionId => Str]
3974  
3975 =item [SchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>]
3976  
3977  
3978 =back
3979  
3980 Each argument is described in detail in: L<Paws::Glue::QuerySchemaVersionMetadata>
3981  
3982 Returns: a L<Paws::Glue::QuerySchemaVersionMetadataResponse> instance
3983  
3984 Queries for the schema version metadata information.
3985  
3986  
3987 =head2 RegisterSchemaVersion
3988  
3989 =over
3990  
3991 =item SchemaDefinition => Str
3992  
3993 =item SchemaId => L<Paws::Glue::SchemaId>
3994  
3995  
3996 =back
3997  
3998 Each argument is described in detail in: L<Paws::Glue::RegisterSchemaVersion>
3999  
4000 Returns: a L<Paws::Glue::RegisterSchemaVersionResponse> instance
4001  
4002 Adds a new version to the existing schema. Returns an error if new
4003 version of schema does not meet the compatibility requirements of the
4004 schema set. This API will not create a new schema set and will return a
4005 404 error if the schema set is not already present in the Schema
4006 Registry.
4007  
4008 If this is the first schema definition to be registered in the Schema
4009 Registry, this API will store the schema version and return
4010 immediately. Otherwise, this call has the potential to run longer than
4011 other operations due to compatibility modes. You can call the
4012 C<GetSchemaVersion> API with the C<SchemaVersionId> to check
4013 compatibility modes.
4014  
4015 If the same schema definition is already stored in Schema Registry as a
4016 version, the schema ID of the existing schema is returned to the
4017 caller.
4018  
4019  
4020 =head2 RemoveSchemaVersionMetadata
4021  
4022 =over
4023  
4024 =item MetadataKeyValue => L<Paws::Glue::MetadataKeyValuePair>
4025  
4026 =item [SchemaId => L<Paws::Glue::SchemaId>]
4027  
4028 =item [SchemaVersionId => Str]
4029  
4030 =item [SchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>]
4031  
4032  
4033 =back
4034  
4035 Each argument is described in detail in: L<Paws::Glue::RemoveSchemaVersionMetadata>
4036  
4037 Returns: a L<Paws::Glue::RemoveSchemaVersionMetadataResponse> instance
4038  
4039 Removes a key value pair from the schema version metadata for the
4040 specified schema version ID.
4041  
4042  
4043 =head2 ResetJobBookmark
4044  
4045 =over
4046  
4047 =item JobName => Str
4048  
4049 =item [RunId => Str]
4050  
4051  
4052 =back
4053  
4054 Each argument is described in detail in: L<Paws::Glue::ResetJobBookmark>
4055  
4056 Returns: a L<Paws::Glue::ResetJobBookmarkResponse> instance
4057  
4058 Resets a bookmark entry.
4059  
4060  
4061 =head2 ResumeWorkflowRun
4062  
4063 =over
4064  
4065 =item Name => Str
4066  
4067 =item NodeIds => ArrayRef[Str|Undef]
4068  
4069 =item RunId => Str
4070  
4071  
4072 =back
4073  
4074 Each argument is described in detail in: L<Paws::Glue::ResumeWorkflowRun>
4075  
4076 Returns: a L<Paws::Glue::ResumeWorkflowRunResponse> instance
4077  
4078 Restarts selected nodes of a previous partially completed workflow run
4079 and resumes the workflow run. The selected nodes and all nodes that are
4080 downstream from the selected nodes are run.
4081  
4082  
4083 =head2 SearchTables
4084  
4085 =over
4086  
4087 =item [CatalogId => Str]
4088  
4089 =item [Filters => ArrayRef[L<Paws::Glue::PropertyPredicate>]]
4090  
4091 =item [MaxResults => Int]
4092  
4093 =item [NextToken => Str]
4094  
4095 =item [ResourceShareType => Str]
4096  
4097 =item [SearchText => Str]
4098  
4099 =item [SortCriteria => ArrayRef[L<Paws::Glue::SortCriterion>]]
4100  
4101  
4102 =back
4103  
4104 Each argument is described in detail in: L<Paws::Glue::SearchTables>
4105  
4106 Returns: a L<Paws::Glue::SearchTablesResponse> instance
4107  
4108 Searches a set of tables based on properties in the table metadata as
4109 well as on the parent database. You can search against text or filter
4110 conditions.
4111  
4112 You can only get tables that you have access to based on the security
4113 policies defined in Lake Formation. You need at least a read-only
4114 access to the table for it to be returned. If you do not have access to
4115 all the columns in the table, these columns will not be searched
4116 against when returning the list of tables back to you. If you have
4117 access to the columns but not the data in the columns, those columns
4118 and the associated metadata for those columns will be included in the
4119 search.
4120  
4121  
4122 =head2 StartCrawler
4123  
4124 =over
4125  
4126 =item Name => Str
4127  
4128  
4129 =back
4130  
4131 Each argument is described in detail in: L<Paws::Glue::StartCrawler>
4132  
4133 Returns: a L<Paws::Glue::StartCrawlerResponse> instance
4134  
4135 Starts a crawl using the specified crawler, regardless of what is
4136 scheduled. If the crawler is already running, returns a
4137 CrawlerRunningException
4138 (https://docs.aws.amazon.com/glue/latest/dg/aws-glue-api-exceptions.html#aws-glue-api-exceptions-CrawlerRunningException).
4139  
4140  
4141 =head2 StartCrawlerSchedule
4142  
4143 =over
4144  
4145 =item CrawlerName => Str
4146  
4147  
4148 =back
4149  
4150 Each argument is described in detail in: L<Paws::Glue::StartCrawlerSchedule>
4151  
4152 Returns: a L<Paws::Glue::StartCrawlerScheduleResponse> instance
4153  
4154 Changes the schedule state of the specified crawler to C<SCHEDULED>,
4155 unless the crawler is already running or the schedule state is already
4156 C<SCHEDULED>.
4157  
4158  
4159 =head2 StartExportLabelsTaskRun
4160  
4161 =over
4162  
4163 =item OutputS3Path => Str
4164  
4165 =item TransformId => Str
4166  
4167  
4168 =back
4169  
4170 Each argument is described in detail in: L<Paws::Glue::StartExportLabelsTaskRun>
4171  
4172 Returns: a L<Paws::Glue::StartExportLabelsTaskRunResponse> instance
4173  
4174 Begins an asynchronous task to export all labeled data for a particular
4175 transform. This task is the only label-related API call that is not
4176 part of the typical active learning workflow. You typically use
4177 C<StartExportLabelsTaskRun> when you want to work with all of your
4178 existing labels at the same time, such as when you want to remove or
4179 change labels that were previously submitted as truth. This API
4180 operation accepts the C<TransformId> whose labels you want to export
4181 and an Amazon Simple Storage Service (Amazon S3) path to export the
4182 labels to. The operation returns a C<TaskRunId>. You can check on the
4183 status of your task run by calling the C<GetMLTaskRun> API.
4184  
4185  
4186 =head2 StartImportLabelsTaskRun
4187  
4188 =over
4189  
4190 =item InputS3Path => Str
4191  
4192 =item TransformId => Str
4193  
4194 =item [ReplaceAllLabels => Bool]
4195  
4196  
4197 =back
4198  
4199 Each argument is described in detail in: L<Paws::Glue::StartImportLabelsTaskRun>
4200  
4201 Returns: a L<Paws::Glue::StartImportLabelsTaskRunResponse> instance
4202  
4203 Enables you to provide additional labels (examples of truth) to be used
4204 to teach the machine learning transform and improve its quality. This
4205 API operation is generally used as part of the active learning workflow
4206 that starts with the C<StartMLLabelingSetGenerationTaskRun> call and
4207 that ultimately results in improving the quality of your machine
4208 learning transform.
4209  
4210 After the C<StartMLLabelingSetGenerationTaskRun> finishes, Glue machine
4211 learning will have generated a series of questions for humans to
4212 answer. (Answering these questions is often called 'labeling' in the
4213 machine learning workflows). In the case of the C<FindMatches>
4214 transform, these questions are of the form, E<ldquo>What is the correct
4215 way to group these rows together into groups composed entirely of
4216 matching records?E<rdquo> After the labeling process is finished, users
4217 upload their answers/labels with a call to C<StartImportLabelsTaskRun>.
4218 After C<StartImportLabelsTaskRun> finishes, all future runs of the
4219 machine learning transform use the new and improved labels and perform
4220 a higher-quality transformation.
4221  
4222 By default, C<StartMLLabelingSetGenerationTaskRun> continually learns
4223 from and combines all labels that you upload unless you set C<Replace>
4224 to true. If you set C<Replace> to true, C<StartImportLabelsTaskRun>
4225 deletes and forgets all previously uploaded labels and learns only from
4226 the exact set that you upload. Replacing labels can be helpful if you
4227 realize that you previously uploaded incorrect labels, and you believe
4228 that they are having a negative effect on your transform quality.
4229  
4230 You can check on the status of your task run by calling the
4231 C<GetMLTaskRun> operation.
4232  
4233  
4234 =head2 StartJobRun
4235  
4236 =over
4237  
4238 =item JobName => Str
4239  
4240 =item [AllocatedCapacity => Int]
4241  
4242 =item [Arguments => L<Paws::Glue::GenericMap>]
4243  
4244 =item [JobRunId => Str]
4245  
4246 =item [MaxCapacity => Num]
4247  
4248 =item [NotificationProperty => L<Paws::Glue::NotificationProperty>]
4249  
4250 =item [NumberOfWorkers => Int]
4251  
4252 =item [SecurityConfiguration => Str]
4253  
4254 =item [Timeout => Int]
4255  
4256 =item [WorkerType => Str]
4257  
4258  
4259 =back
4260  
4261 Each argument is described in detail in: L<Paws::Glue::StartJobRun>
4262  
4263 Returns: a L<Paws::Glue::StartJobRunResponse> instance
4264  
4265 Starts a job run using a job definition.
4266  
4267  
4268 =head2 StartMLEvaluationTaskRun
4269  
4270 =over
4271  
4272 =item TransformId => Str
4273  
4274  
4275 =back
4276  
4277 Each argument is described in detail in: L<Paws::Glue::StartMLEvaluationTaskRun>
4278  
4279 Returns: a L<Paws::Glue::StartMLEvaluationTaskRunResponse> instance
4280  
4281 Starts a task to estimate the quality of the transform.
4282  
4283 When you provide label sets as examples of truth, Glue machine learning
4284 uses some of those examples to learn from them. The rest of the labels
4285 are used as a test to estimate quality.
4286  
4287 Returns a unique identifier for the run. You can call C<GetMLTaskRun>
4288 to get more information about the stats of the C<EvaluationTaskRun>.
4289  
4290  
4291 =head2 StartMLLabelingSetGenerationTaskRun
4292  
4293 =over
4294  
4295 =item OutputS3Path => Str
4296  
4297 =item TransformId => Str
4298  
4299  
4300 =back
4301  
4302 Each argument is described in detail in: L<Paws::Glue::StartMLLabelingSetGenerationTaskRun>
4303  
4304 Returns: a L<Paws::Glue::StartMLLabelingSetGenerationTaskRunResponse> instance
4305  
4306 Starts the active learning workflow for your machine learning transform
4307 to improve the transform's quality by generating label sets and adding
4308 labels.
4309  
4310 When the C<StartMLLabelingSetGenerationTaskRun> finishes, Glue will
4311 have generated a "labeling set" or a set of questions for humans to
4312 answer.
4313  
4314 In the case of the C<FindMatches> transform, these questions are of the
4315 form, E<ldquo>What is the correct way to group these rows together into
4316 groups composed entirely of matching records?E<rdquo>
4317  
4318 After the labeling process is finished, you can upload your labels with
4319 a call to C<StartImportLabelsTaskRun>. After
4320 C<StartImportLabelsTaskRun> finishes, all future runs of the machine
4321 learning transform will use the new and improved labels and perform a
4322 higher-quality transformation.
4323  
4324  
4325 =head2 StartTrigger
4326  
4327 =over
4328  
4329 =item Name => Str
4330  
4331  
4332 =back
4333  
4334 Each argument is described in detail in: L<Paws::Glue::StartTrigger>
4335  
4336 Returns: a L<Paws::Glue::StartTriggerResponse> instance
4337  
4338 Starts an existing trigger. See Triggering Jobs
4339 (https://docs.aws.amazon.com/glue/latest/dg/trigger-job.html) for
4340 information about how different types of trigger are started.
4341  
4342  
4343 =head2 StartWorkflowRun
4344  
4345 =over
4346  
4347 =item Name => Str
4348  
4349  
4350 =back
4351  
4352 Each argument is described in detail in: L<Paws::Glue::StartWorkflowRun>
4353  
4354 Returns: a L<Paws::Glue::StartWorkflowRunResponse> instance
4355  
4356 Starts a new run of the specified workflow.
4357  
4358  
4359 =head2 StopCrawler
4360  
4361 =over
4362  
4363 =item Name => Str
4364  
4365  
4366 =back
4367  
4368 Each argument is described in detail in: L<Paws::Glue::StopCrawler>
4369  
4370 Returns: a L<Paws::Glue::StopCrawlerResponse> instance
4371  
4372 If the specified crawler is running, stops the crawl.
4373  
4374  
4375 =head2 StopCrawlerSchedule
4376  
4377 =over
4378  
4379 =item CrawlerName => Str
4380  
4381  
4382 =back
4383  
4384 Each argument is described in detail in: L<Paws::Glue::StopCrawlerSchedule>
4385  
4386 Returns: a L<Paws::Glue::StopCrawlerScheduleResponse> instance
4387  
4388 Sets the schedule state of the specified crawler to C<NOT_SCHEDULED>,
4389 but does not stop the crawler if it is already running.
4390  
4391  
4392 =head2 StopTrigger
4393  
4394 =over
4395  
4396 =item Name => Str
4397  
4398  
4399 =back
4400  
4401 Each argument is described in detail in: L<Paws::Glue::StopTrigger>
4402  
4403 Returns: a L<Paws::Glue::StopTriggerResponse> instance
4404  
4405 Stops a specified trigger.
4406  
4407  
4408 =head2 StopWorkflowRun
4409  
4410 =over
4411  
4412 =item Name => Str
4413  
4414 =item RunId => Str
4415  
4416  
4417 =back
4418  
4419 Each argument is described in detail in: L<Paws::Glue::StopWorkflowRun>
4420  
4421 Returns: a L<Paws::Glue::StopWorkflowRunResponse> instance
4422  
4423 Stops the execution of the specified workflow run.
4424  
4425  
4426 =head2 TagResource
4427  
4428 =over
4429  
4430 =item ResourceArn => Str
4431  
4432 =item TagsToAdd => L<Paws::Glue::TagsMap>
4433  
4434  
4435 =back
4436  
4437 Each argument is described in detail in: L<Paws::Glue::TagResource>
4438  
4439 Returns: a L<Paws::Glue::TagResourceResponse> instance
4440  
4441 Adds tags to a resource. A tag is a label you can assign to an Amazon
4442 Web Services resource. In Glue, you can tag only certain resources. For
4443 information about what resources you can tag, see Amazon Web Services
4444 Tags in Glue
4445 (https://docs.aws.amazon.com/glue/latest/dg/monitor-tags.html).
4446  
4447  
4448 =head2 UntagResource
4449  
4450 =over
4451  
4452 =item ResourceArn => Str
4453  
4454 =item TagsToRemove => ArrayRef[Str|Undef]
4455  
4456  
4457 =back
4458  
4459 Each argument is described in detail in: L<Paws::Glue::UntagResource>
4460  
4461 Returns: a L<Paws::Glue::UntagResourceResponse> instance
4462  
4463 Removes tags from a resource.
4464  
4465  
4466 =head2 UpdateClassifier
4467  
4468 =over
4469  
4470 =item [CsvClassifier => L<Paws::Glue::UpdateCsvClassifierRequest>]
4471  
4472 =item [GrokClassifier => L<Paws::Glue::UpdateGrokClassifierRequest>]
4473  
4474 =item [JsonClassifier => L<Paws::Glue::UpdateJsonClassifierRequest>]
4475  
4476 =item [XMLClassifier => L<Paws::Glue::UpdateXMLClassifierRequest>]
4477  
4478  
4479 =back
4480  
4481 Each argument is described in detail in: L<Paws::Glue::UpdateClassifier>
4482  
4483 Returns: a L<Paws::Glue::UpdateClassifierResponse> instance
4484  
4485 Modifies an existing classifier (a C<GrokClassifier>, an
4486 C<XMLClassifier>, a C<JsonClassifier>, or a C<CsvClassifier>, depending
4487 on which field is present).
4488  
4489  
4490 =head2 UpdateColumnStatisticsForPartition
4491  
4492 =over
4493  
4494 =item ColumnStatisticsList => ArrayRef[L<Paws::Glue::ColumnStatistics>]
4495  
4496 =item DatabaseName => Str
4497  
4498 =item PartitionValues => ArrayRef[Str|Undef]
4499  
4500 =item TableName => Str
4501  
4502 =item [CatalogId => Str]
4503  
4504  
4505 =back
4506  
4507 Each argument is described in detail in: L<Paws::Glue::UpdateColumnStatisticsForPartition>
4508  
4509 Returns: a L<Paws::Glue::UpdateColumnStatisticsForPartitionResponse> instance
4510  
4511 Creates or updates partition statistics of columns.
4512  
4513 The Identity and Access Management (IAM) permission required for this
4514 operation is C<UpdatePartition>.
4515  
4516  
4517 =head2 UpdateColumnStatisticsForTable
4518  
4519 =over
4520  
4521 =item ColumnStatisticsList => ArrayRef[L<Paws::Glue::ColumnStatistics>]
4522  
4523 =item DatabaseName => Str
4524  
4525 =item TableName => Str
4526  
4527 =item [CatalogId => Str]
4528  
4529  
4530 =back
4531  
4532 Each argument is described in detail in: L<Paws::Glue::UpdateColumnStatisticsForTable>
4533  
4534 Returns: a L<Paws::Glue::UpdateColumnStatisticsForTableResponse> instance
4535  
4536 Creates or updates table statistics of columns.
4537  
4538 The Identity and Access Management (IAM) permission required for this
4539 operation is C<UpdateTable>.
4540  
4541  
4542 =head2 UpdateConnection
4543  
4544 =over
4545  
4546 =item ConnectionInput => L<Paws::Glue::ConnectionInput>
4547  
4548 =item Name => Str
4549  
4550 =item [CatalogId => Str]
4551  
4552  
4553 =back
4554  
4555 Each argument is described in detail in: L<Paws::Glue::UpdateConnection>
4556  
4557 Returns: a L<Paws::Glue::UpdateConnectionResponse> instance
4558  
4559 Updates a connection definition in the Data Catalog.
4560  
4561  
4562 =head2 UpdateCrawler
4563  
4564 =over
4565  
4566 =item Name => Str
4567  
4568 =item [Classifiers => ArrayRef[Str|Undef]]
4569  
4570 =item [Configuration => Str]
4571  
4572 =item [CrawlerSecurityConfiguration => Str]
4573  
4574 =item [DatabaseName => Str]
4575  
4576 =item [Description => Str]
4577  
4578 =item [LineageConfiguration => L<Paws::Glue::LineageConfiguration>]
4579  
4580 =item [RecrawlPolicy => L<Paws::Glue::RecrawlPolicy>]
4581  
4582 =item [Role => Str]
4583  
4584 =item [Schedule => Str]
4585  
4586 =item [SchemaChangePolicy => L<Paws::Glue::SchemaChangePolicy>]
4587  
4588 =item [TablePrefix => Str]
4589  
4590 =item [Targets => L<Paws::Glue::CrawlerTargets>]
4591  
4592  
4593 =back
4594  
4595 Each argument is described in detail in: L<Paws::Glue::UpdateCrawler>
4596  
4597 Returns: a L<Paws::Glue::UpdateCrawlerResponse> instance
4598  
4599 Updates a crawler. If a crawler is running, you must stop it using
4600 C<StopCrawler> before updating it.
4601  
4602  
4603 =head2 UpdateCrawlerSchedule
4604  
4605 =over
4606  
4607 =item CrawlerName => Str
4608  
4609 =item [Schedule => Str]
4610  
4611  
4612 =back
4613  
4614 Each argument is described in detail in: L<Paws::Glue::UpdateCrawlerSchedule>
4615  
4616 Returns: a L<Paws::Glue::UpdateCrawlerScheduleResponse> instance
4617  
4618 Updates the schedule of a crawler using a C<cron> expression.
4619  
4620  
4621 =head2 UpdateDatabase
4622  
4623 =over
4624  
4625 =item DatabaseInput => L<Paws::Glue::DatabaseInput>
4626  
4627 =item Name => Str
4628  
4629 =item [CatalogId => Str]
4630  
4631  
4632 =back
4633  
4634 Each argument is described in detail in: L<Paws::Glue::UpdateDatabase>
4635  
4636 Returns: a L<Paws::Glue::UpdateDatabaseResponse> instance
4637  
4638 Updates an existing database definition in a Data Catalog.
4639  
4640  
4641 =head2 UpdateDevEndpoint
4642  
4643 =over
4644  
4645 =item EndpointName => Str
4646  
4647 =item [AddArguments => L<Paws::Glue::MapValue>]
4648  
4649 =item [AddPublicKeys => ArrayRef[Str|Undef]]
4650  
4651 =item [CustomLibraries => L<Paws::Glue::DevEndpointCustomLibraries>]
4652  
4653 =item [DeleteArguments => ArrayRef[Str|Undef]]
4654  
4655 =item [DeletePublicKeys => ArrayRef[Str|Undef]]
4656  
4657 =item [PublicKey => Str]
4658  
4659 =item [UpdateEtlLibraries => Bool]
4660  
4661  
4662 =back
4663  
4664 Each argument is described in detail in: L<Paws::Glue::UpdateDevEndpoint>
4665  
4666 Returns: a L<Paws::Glue::UpdateDevEndpointResponse> instance
4667  
4668 Updates a specified development endpoint.
4669  
4670  
4671 =head2 UpdateJob
4672  
4673 =over
4674  
4675 =item JobName => Str
4676  
4677 =item JobUpdate => L<Paws::Glue::JobUpdate>
4678  
4679  
4680 =back
4681  
4682 Each argument is described in detail in: L<Paws::Glue::UpdateJob>
4683  
4684 Returns: a L<Paws::Glue::UpdateJobResponse> instance
4685  
4686 Updates an existing job definition.
4687  
4688  
4689 =head2 UpdateMLTransform
4690  
4691 =over
4692  
4693 =item TransformId => Str
4694  
4695 =item [Description => Str]
4696  
4697 =item [GlueVersion => Str]
4698  
4699 =item [MaxCapacity => Num]
4700  
4701 =item [MaxRetries => Int]
4702  
4703 =item [Name => Str]
4704  
4705 =item [NumberOfWorkers => Int]
4706  
4707 =item [Parameters => L<Paws::Glue::TransformParameters>]
4708  
4709 =item [Role => Str]
4710  
4711 =item [Timeout => Int]
4712  
4713 =item [WorkerType => Str]
4714  
4715  
4716 =back
4717  
4718 Each argument is described in detail in: L<Paws::Glue::UpdateMLTransform>
4719  
4720 Returns: a L<Paws::Glue::UpdateMLTransformResponse> instance
4721  
4722 Updates an existing machine learning transform. Call this operation to
4723 tune the algorithm parameters to achieve better results.
4724  
4725 After calling this operation, you can call the
4726 C<StartMLEvaluationTaskRun> operation to assess how well your new
4727 parameters achieved your goals (such as improving the quality of your
4728 machine learning transform, or making it more cost-effective).
4729  
4730  
4731 =head2 UpdatePartition
4732  
4733 =over
4734  
4735 =item DatabaseName => Str
4736  
4737 =item PartitionInput => L<Paws::Glue::PartitionInput>
4738  
4739 =item PartitionValueList => ArrayRef[Str|Undef]
4740  
4741 =item TableName => Str
4742  
4743 =item [CatalogId => Str]
4744  
4745  
4746 =back
4747  
4748 Each argument is described in detail in: L<Paws::Glue::UpdatePartition>
4749  
4750 Returns: a L<Paws::Glue::UpdatePartitionResponse> instance
4751  
4752 Updates a partition.
4753  
4754  
4755 =head2 UpdateRegistry
4756  
4757 =over
4758  
4759 =item Description => Str
4760  
4761 =item RegistryId => L<Paws::Glue::RegistryId>
4762  
4763  
4764 =back
4765  
4766 Each argument is described in detail in: L<Paws::Glue::UpdateRegistry>
4767  
4768 Returns: a L<Paws::Glue::UpdateRegistryResponse> instance
4769  
4770 Updates an existing registry which is used to hold a collection of
4771 schemas. The updated properties relate to the registry, and do not
4772 modify any of the schemas within the registry.
4773  
4774  
4775 =head2 UpdateSchema
4776  
4777 =over
4778  
4779 =item SchemaId => L<Paws::Glue::SchemaId>
4780  
4781 =item [Compatibility => Str]
4782  
4783 =item [Description => Str]
4784  
4785 =item [SchemaVersionNumber => L<Paws::Glue::SchemaVersionNumber>]
4786  
4787  
4788 =back
4789  
4790 Each argument is described in detail in: L<Paws::Glue::UpdateSchema>
4791  
4792 Returns: a L<Paws::Glue::UpdateSchemaResponse> instance
4793  
4794 Updates the description, compatibility setting, or version checkpoint
4795 for a schema set.
4796  
4797 For updating the compatibility setting, the call will not validate
4798 compatibility for the entire set of schema versions with the new
4799 compatibility setting. If the value for C<Compatibility> is provided,
4800 the C<VersionNumber> (a checkpoint) is also required. The API will
4801 validate the checkpoint version number for consistency.
4802  
4803 If the value for the C<VersionNumber> (checkpoint) is provided,
4804 C<Compatibility> is optional and this can be used to set/reset a
4805 checkpoint for the schema.
4806  
4807 This update will happen only if the schema is in the AVAILABLE state.
4808  
4809  
4810 =head2 UpdateTable
4811  
4812 =over
4813  
4814 =item DatabaseName => Str
4815  
4816 =item TableInput => L<Paws::Glue::TableInput>
4817  
4818 =item [CatalogId => Str]
4819  
4820 =item [SkipArchive => Bool]
4821  
4822  
4823 =back
4824  
4825 Each argument is described in detail in: L<Paws::Glue::UpdateTable>
4826  
4827 Returns: a L<Paws::Glue::UpdateTableResponse> instance
4828  
4829 Updates a metadata table in the Data Catalog.
4830  
4831  
4832 =head2 UpdateTrigger
4833  
4834 =over
4835  
4836 =item Name => Str
4837  
4838 =item TriggerUpdate => L<Paws::Glue::TriggerUpdate>
4839  
4840  
4841 =back
4842  
4843 Each argument is described in detail in: L<Paws::Glue::UpdateTrigger>
4844  
4845 Returns: a L<Paws::Glue::UpdateTriggerResponse> instance
4846  
4847 Updates a trigger definition.
4848  
4849  
4850 =head2 UpdateUserDefinedFunction
4851  
4852 =over
4853  
4854 =item DatabaseName => Str
4855  
4856 =item FunctionInput => L<Paws::Glue::UserDefinedFunctionInput>
4857  
4858 =item FunctionName => Str
4859  
4860 =item [CatalogId => Str]
4861  
4862  
4863 =back
4864  
4865 Each argument is described in detail in: L<Paws::Glue::UpdateUserDefinedFunction>
4866  
4867 Returns: a L<Paws::Glue::UpdateUserDefinedFunctionResponse> instance
4868  
4869 Updates an existing function definition in the Data Catalog.
4870  
4871  
4872 =head2 UpdateWorkflow
4873  
4874 =over
4875  
4876 =item Name => Str
4877  
4878 =item [DefaultRunProperties => L<Paws::Glue::WorkflowRunProperties>]
4879  
4880 =item [Description => Str]
4881  
4882 =item [MaxConcurrentRuns => Int]
4883  
4884  
4885 =back
4886  
4887 Each argument is described in detail in: L<Paws::Glue::UpdateWorkflow>
4888  
4889 Returns: a L<Paws::Glue::UpdateWorkflowResponse> instance
4890  
4891 Updates an existing workflow.
4892  
4893  
4894  
4895  
4896 =head1 PAGINATORS
4897  
4898 Paginator methods are helpers that repetively call methods that return partial results
4899  
4900 =head2 GetAllClassifiers(sub { },[MaxResults => Int, NextToken => Str])
4901  
4902 =head2 GetAllClassifiers([MaxResults => Int, NextToken => Str])
4903  
4904  
4905 If passed a sub as first parameter, it will call the sub for each element found in :
4906  
4907 - Classifiers, passing the object as the first parameter, and the string 'Classifiers' as the second parameter
4908  
4909 If not, it will return a a L<Paws::Glue::GetClassifiersResponse> 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.
4910  
4911  
4912 =head2 GetAllConnections(sub { },[CatalogId => Str, Filter => L<Paws::Glue::GetConnectionsFilter>, HidePassword => Bool, MaxResults => Int, NextToken => Str])
4913  
4914 =head2 GetAllConnections([CatalogId => Str, Filter => L<Paws::Glue::GetConnectionsFilter>, HidePassword => Bool, MaxResults => Int, NextToken => Str])
4915  
4916  
4917 If passed a sub as first parameter, it will call the sub for each element found in :
4918  
4919 - ConnectionList, passing the object as the first parameter, and the string 'ConnectionList' as the second parameter
4920  
4921 If not, it will return a a L<Paws::Glue::GetConnectionsResponse> 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.
4922  
4923  
4924 =head2 GetAllCrawlerMetrics(sub { },[CrawlerNameList => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
4925  
4926 =head2 GetAllCrawlerMetrics([CrawlerNameList => ArrayRef[Str|Undef], MaxResults => Int, NextToken => Str])
4927  
4928  
4929 If passed a sub as first parameter, it will call the sub for each element found in :
4930  
4931 - CrawlerMetricsList, passing the object as the first parameter, and the string 'CrawlerMetricsList' as the second parameter
4932  
4933 If not, it will return a a L<Paws::Glue::GetCrawlerMetricsResponse> 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.
4934  
4935  
4936 =head2 GetAllCrawlers(sub { },[MaxResults => Int, NextToken => Str])
4937  
4938 =head2 GetAllCrawlers([MaxResults => Int, NextToken => Str])
4939  
4940  
4941 If passed a sub as first parameter, it will call the sub for each element found in :
4942  
4943 - Crawlers, passing the object as the first parameter, and the string 'Crawlers' as the second parameter
4944  
4945 If not, it will return a a L<Paws::Glue::GetCrawlersResponse> 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.
4946  
4947  
4948 =head2 GetAllDatabases(sub { },[CatalogId => Str, MaxResults => Int, NextToken => Str, ResourceShareType => Str])
4949  
4950 =head2 GetAllDatabases([CatalogId => Str, MaxResults => Int, NextToken => Str, ResourceShareType => Str])
4951  
4952  
4953 If passed a sub as first parameter, it will call the sub for each element found in :
4954  
4955 - DatabaseList, passing the object as the first parameter, and the string 'DatabaseList' as the second parameter
4956  
4957 If not, it will return a a L<Paws::Glue::GetDatabasesResponse> 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.
4958  
4959  
4960 =head2 GetAllDevEndpoints(sub { },[MaxResults => Int, NextToken => Str])
4961  
4962 =head2 GetAllDevEndpoints([MaxResults => Int, NextToken => Str])
4963  
4964  
4965 If passed a sub as first parameter, it will call the sub for each element found in :
4966  
4967 - DevEndpoints, passing the object as the first parameter, and the string 'DevEndpoints' as the second parameter
4968  
4969 If not, it will return a a L<Paws::Glue::GetDevEndpointsResponse> 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.
4970  
4971  
4972 =head2 GetAllJobRuns(sub { },JobName => Str, [MaxResults => Int, NextToken => Str])
4973  
4974 =head2 GetAllJobRuns(JobName => Str, [MaxResults => Int, NextToken => Str])
4975  
4976  
4977 If passed a sub as first parameter, it will call the sub for each element found in :
4978  
4979 - JobRuns, passing the object as the first parameter, and the string 'JobRuns' as the second parameter
4980  
4981 If not, it will return a a L<Paws::Glue::GetJobRunsResponse> 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.
4982  
4983  
4984 =head2 GetAllJobs(sub { },[MaxResults => Int, NextToken => Str])
4985  
4986 =head2 GetAllJobs([MaxResults => Int, NextToken => Str])
4987  
4988  
4989 If passed a sub as first parameter, it will call the sub for each element found in :
4990  
4991 - Jobs, passing the object as the first parameter, and the string 'Jobs' as the second parameter
4992  
4993 If not, it will return a a L<Paws::Glue::GetJobsResponse> 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.
4994  
4995  
4996 =head2 GetAllPartitionIndexes(sub { },DatabaseName => Str, TableName => Str, [CatalogId => Str, NextToken => Str])
4997  
4998 =head2 GetAllPartitionIndexes(DatabaseName => Str, TableName => Str, [CatalogId => Str, NextToken => Str])
4999  
5000  
5001 If passed a sub as first parameter, it will call the sub for each element found in :
5002  
5003 - PartitionIndexDescriptorList, passing the object as the first parameter, and the string 'PartitionIndexDescriptorList' as the second parameter
5004  
5005 If not, it will return a a L<Paws::Glue::GetPartitionIndexesResponse> 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.
5006  
5007  
5008 =head2 GetAllPartitions(sub { },DatabaseName => Str, TableName => Str, [CatalogId => Str, ExcludeColumnSchema => Bool, Expression => Str, MaxResults => Int, NextToken => Str, Segment => L<Paws::Glue::Segment>])
5009  
5010 =head2 GetAllPartitions(DatabaseName => Str, TableName => Str, [CatalogId => Str, ExcludeColumnSchema => Bool, Expression => Str, MaxResults => Int, NextToken => Str, Segment => L<Paws::Glue::Segment>])
5011  
5012  
5013 If passed a sub as first parameter, it will call the sub for each element found in :
5014  
5015 - Partitions, passing the object as the first parameter, and the string 'Partitions' as the second parameter
5016  
5017 If not, it will return a a L<Paws::Glue::GetPartitionsResponse> 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.
5018  
5019  
5020 =head2 GetAllResourcePolicies(sub { },[MaxResults => Int, NextToken => Str])
5021  
5022 =head2 GetAllResourcePolicies([MaxResults => Int, NextToken => Str])
5023  
5024  
5025 If passed a sub as first parameter, it will call the sub for each element found in :
5026  
5027 - GetResourcePoliciesResponseList, passing the object as the first parameter, and the string 'GetResourcePoliciesResponseList' as the second parameter
5028  
5029 If not, it will return a a L<Paws::Glue::GetResourcePoliciesResponse> 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.
5030  
5031  
5032 =head2 GetAllSecurityConfigurations(sub { },[MaxResults => Int, NextToken => Str])
5033  
5034 =head2 GetAllSecurityConfigurations([MaxResults => Int, NextToken => Str])
5035  
5036  
5037 If passed a sub as first parameter, it will call the sub for each element found in :
5038  
5039 - SecurityConfigurations, passing the object as the first parameter, and the string 'SecurityConfigurations' as the second parameter
5040  
5041 If not, it will return a a L<Paws::Glue::GetSecurityConfigurationsResponse> 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.
5042  
5043  
5044 =head2 GetAllTables(sub { },DatabaseName => Str, [CatalogId => Str, Expression => Str, MaxResults => Int, NextToken => Str])
5045  
5046 =head2 GetAllTables(DatabaseName => Str, [CatalogId => Str, Expression => Str, MaxResults => Int, NextToken => Str])
5047  
5048  
5049 If passed a sub as first parameter, it will call the sub for each element found in :
5050  
5051 - TableList, passing the object as the first parameter, and the string 'TableList' as the second parameter
5052  
5053 If not, it will return a a L<Paws::Glue::GetTablesResponse> 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.
5054  
5055  
5056 =head2 GetAllTableVersions(sub { },DatabaseName => Str, TableName => Str, [CatalogId => Str, MaxResults => Int, NextToken => Str])
5057  
5058 =head2 GetAllTableVersions(DatabaseName => Str, TableName => Str, [CatalogId => Str, MaxResults => Int, NextToken => Str])
5059  
5060  
5061 If passed a sub as first parameter, it will call the sub for each element found in :
5062  
5063 - TableVersions, passing the object as the first parameter, and the string 'TableVersions' as the second parameter
5064  
5065 If not, it will return a a L<Paws::Glue::GetTableVersionsResponse> 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.
5066  
5067  
5068 =head2 GetAllTriggers(sub { },[DependentJobName => Str, MaxResults => Int, NextToken => Str])
5069  
5070 =head2 GetAllTriggers([DependentJobName => Str, MaxResults => Int, NextToken => Str])
5071  
5072  
5073 If passed a sub as first parameter, it will call the sub for each element found in :
5074  
5075 - Triggers, passing the object as the first parameter, and the string 'Triggers' as the second parameter
5076  
5077 If not, it will return a a L<Paws::Glue::GetTriggersResponse> 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.
5078  
5079  
5080 =head2 GetAllUserDefinedFunctions(sub { },Pattern => Str, [CatalogId => Str, DatabaseName => Str, MaxResults => Int, NextToken => Str])
5081  
5082 =head2 GetAllUserDefinedFunctions(Pattern => Str, [CatalogId => Str, DatabaseName => Str, MaxResults => Int, NextToken => Str])
5083  
5084  
5085 If passed a sub as first parameter, it will call the sub for each element found in :
5086  
5087 - UserDefinedFunctions, passing the object as the first parameter, and the string 'UserDefinedFunctions' as the second parameter
5088  
5089 If not, it will return a a L<Paws::Glue::GetUserDefinedFunctionsResponse> 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.
5090  
5091  
5092 =head2 ListAllRegistries(sub { },[MaxResults => Int, NextToken => Str])
5093  
5094 =head2 ListAllRegistries([MaxResults => Int, NextToken => Str])
5095  
5096  
5097 If passed a sub as first parameter, it will call the sub for each element found in :
5098  
5099 - Registries, passing the object as the first parameter, and the string 'Registries' as the second parameter
5100  
5101 If not, it will return a a L<Paws::Glue::ListRegistriesResponse> 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.
5102  
5103  
5104 =head2 ListAllSchemas(sub { },[MaxResults => Int, NextToken => Str, RegistryId => L<Paws::Glue::RegistryId>])
5105  
5106 =head2 ListAllSchemas([MaxResults => Int, NextToken => Str, RegistryId => L<Paws::Glue::RegistryId>])
5107  
5108  
5109 If passed a sub as first parameter, it will call the sub for each element found in :
5110  
5111 - Schemas, passing the object as the first parameter, and the string 'Schemas' as the second parameter
5112  
5113 If not, it will return a a L<Paws::Glue::ListSchemasResponse> 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.
5114  
5115  
5116 =head2 ListAllSchemaVersions(sub { },SchemaId => L<Paws::Glue::SchemaId>, [MaxResults => Int, NextToken => Str])
5117  
5118 =head2 ListAllSchemaVersions(SchemaId => L<Paws::Glue::SchemaId>, [MaxResults => Int, NextToken => Str])
5119  
5120  
5121 If passed a sub as first parameter, it will call the sub for each element found in :
5122  
5123 - Schemas, passing the object as the first parameter, and the string 'Schemas' as the second parameter
5124  
5125 If not, it will return a a L<Paws::Glue::ListSchemaVersionsResponse> 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.
5126  
5127  
5128  
5129  
5130  
5131 =head1 SEE ALSO
5132  
5133 This service class forms part of L<Paws>
5134  
5135 =head1 BUGS and CONTRIBUTIONS
5136  
5137 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
5138  
5139 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
5140  
5141 =cut
5142