using AWSSDK.Glue.batch_create_partition
batch_create_partition([::AWSConfig], arguments::Dict)
batch_create_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionInputList=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchCreatePartition", arguments::Dict)
glue([::AWSConfig], "BatchCreatePartition", DatabaseName=, TableName=, PartitionInputList=, <keyword arguments>)

BatchCreatePartition Operation

Creates one or more partitions in a batch operation.

Arguments

CatalogId = ::String

The ID of the catalog in which the partion is to be created. Currently, this should be the AWS account ID.

DatabaseName = ::String – Required

The name of the metadata database in which the partition is to be created.

TableName = ::String – Required

The name of the metadata table in which the partition is to be created.

PartitionInputList = [[ ... ], ...] – Required

A list of PartitionInput structures that define the partitions to be created.

 PartitionInputList = [[
        "Values" =>  [::String, ...],
        "LastAccessTime" =>  timestamp,
        "StorageDescriptor" =>  [
            "Columns" =>  [[
                "Name" => <required> ::String,
                "Type" =>  ::String,
                "Comment" =>  ::String
            ], ...],
            "Location" =>  ::String,
            "InputFormat" =>  ::String,
            "OutputFormat" =>  ::String,
            "Compressed" =>  ::Bool,
            "NumberOfBuckets" =>  ::Int,
            "SerdeInfo" =>  [
                "Name" =>  ::String,
                "SerializationLibrary" =>  ::String,
                "Parameters" =>  ::Dict{String,String}
            ],
            "BucketColumns" =>  [::String, ...],
            "SortColumns" =>  [[
                "Column" => <required> ::String,
                "SortOrder" => <required> ::Int
            ], ...],
            "Parameters" =>  ::Dict{String,String},
            "SkewedInfo" =>  [
                "SkewedColumnNames" =>  [::String, ...],
                "SkewedColumnValues" =>  [::String, ...],
                "SkewedColumnValueLocationMaps" =>  ::Dict{String,String}
            ],
            "StoredAsSubDirectories" =>  ::Bool
        ],
        "Parameters" =>  ::Dict{String,String},
        "LastAnalyzedTime" =>  timestamp
    ], ...]

Returns

BatchCreatePartitionResponse

Exceptions

InvalidInputException, AlreadyExistsException, ResourceNumberLimitExceededException, InternalServiceException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.batch_delete_connection
batch_delete_connection([::AWSConfig], arguments::Dict)
batch_delete_connection([::AWSConfig]; ConnectionNameList=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchDeleteConnection", arguments::Dict)
glue([::AWSConfig], "BatchDeleteConnection", ConnectionNameList=, <keyword arguments>)

BatchDeleteConnection Operation

Deletes a list of connection definitions from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the connections reside. If none is supplied, the AWS account ID is used by default.

ConnectionNameList = [::String, ...] – Required

A list of names of the connections to delete.

Returns

BatchDeleteConnectionResponse

Exceptions

InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.batch_delete_partition
batch_delete_partition([::AWSConfig], arguments::Dict)
batch_delete_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionsToDelete=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchDeletePartition", arguments::Dict)
glue([::AWSConfig], "BatchDeletePartition", DatabaseName=, TableName=, PartitionsToDelete=, <keyword arguments>)

BatchDeletePartition Operation

Deletes one or more partitions in a batch operation.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partition to be deleted resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which the table in question resides.

TableName = ::String – Required

The name of the table where the partitions to be deleted is located.

PartitionsToDelete = [["Values" => <required> [::String, ...]], ...] – Required

A list of PartitionInput structures that define the partitions to be deleted.

Returns

BatchDeletePartitionResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.batch_delete_table
batch_delete_table([::AWSConfig], arguments::Dict)
batch_delete_table([::AWSConfig]; DatabaseName=, TablesToDelete=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchDeleteTable", arguments::Dict)
glue([::AWSConfig], "BatchDeleteTable", DatabaseName=, TablesToDelete=, <keyword arguments>)

BatchDeleteTable Operation

Deletes multiple tables at once.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the table resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the tables to delete reside.

TablesToDelete = [::String, ...] – Required

A list of the table to delete.

Returns

BatchDeleteTableResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.batch_get_partition
batch_get_partition([::AWSConfig], arguments::Dict)
batch_get_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionsToGet=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchGetPartition", arguments::Dict)
glue([::AWSConfig], "BatchGetPartition", DatabaseName=, TableName=, PartitionsToGet=, <keyword arguments>)

BatchGetPartition Operation

Retrieves partitions in a batch request.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partitions in question reside. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the partitions reside.

TableName = ::String – Required

The name of the partitions' table.

PartitionsToGet = [["Values" => <required> [::String, ...]], ...] – Required

A list of partition values identifying the partitions to retrieve.

Returns

BatchGetPartitionResponse

Exceptions

InvalidInputException, EntityNotFoundException, OperationTimeoutException or InternalServiceException.

See also: AWS API Documentation

using AWSSDK.Glue.batch_stop_job_run
batch_stop_job_run([::AWSConfig], arguments::Dict)
batch_stop_job_run([::AWSConfig]; JobName=, JobRunIds=)

using AWSCore.Services.glue
glue([::AWSConfig], "BatchStopJobRun", arguments::Dict)
glue([::AWSConfig], "BatchStopJobRun", JobName=, JobRunIds=)

BatchStopJobRun Operation

Stops a batch of job runs for a given job.

Arguments

JobName = ::String – Required

The name of the job whose job runs are to be stopped.

JobRunIds = [::String, ...] – Required

A list of job run Ids of the given job to be stopped.

Returns

BatchStopJobRunResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_classifier
create_classifier([::AWSConfig], arguments::Dict)
create_classifier([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateClassifier", arguments::Dict)
glue([::AWSConfig], "CreateClassifier", <keyword arguments>)

CreateClassifier Operation

Creates a Classifier in the user's account.

Arguments

GrokClassifier = [ ... ]

A grok classifier to create.

 GrokClassifier = [
        "Classification" => <required> ::String,
        "Name" => <required> ::String,
        "GrokPattern" => <required> ::String,
        "CustomPatterns" =>  ::String
    ]

Returns

CreateClassifierResponse

Exceptions

AlreadyExistsException, InvalidInputException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_connection
create_connection([::AWSConfig], arguments::Dict)
create_connection([::AWSConfig]; ConnectionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateConnection", arguments::Dict)
glue([::AWSConfig], "CreateConnection", ConnectionInput=, <keyword arguments>)

CreateConnection Operation

Creates a connection definition in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which to create the connection. If none is supplied, the AWS account ID is used by default.

ConnectionInput = [ ... ] – Required

A ConnectionInput object defining the connection to create.

 ConnectionInput = [
        "Name" =>  ::String,
        "Description" =>  ::String,
        "ConnectionType" =>  "JDBC" or "SFTP",
        "MatchCriteria" =>  [::String, ...],
        "ConnectionProperties" =>  ::Dict{String,String},
        "PhysicalConnectionRequirements" =>  [
            "SubnetId" =>  ::String,
            "SecurityGroupIdList" =>  [::String, ...],
            "AvailabilityZone" =>  ::String
        ]
    ]

Returns

CreateConnectionResponse

Exceptions

AlreadyExistsException, InvalidInputException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_crawler
create_crawler([::AWSConfig], arguments::Dict)
create_crawler([::AWSConfig]; Name=, Role=, DatabaseName=, Targets=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateCrawler", arguments::Dict)
glue([::AWSConfig], "CreateCrawler", Name=, Role=, DatabaseName=, Targets=, <keyword arguments>)

CreateCrawler Operation

Creates a new Crawler with specified targets, role, configuration, and optional schedule. At least one crawl target must be specified, in either the s3Targets or the jdbcTargets field.

Arguments

Name = ::String – Required

Name of the new Crawler.

Role = ::String – Required

The IAM role (or ARN of an IAM role) used by the new Crawler to access customer resources.

DatabaseName = ::String – Required

The Glue Database where results will be stored, such as: arn:aws:daylight:us-east-1::database/sometable/*.

Description = ::String

A description of the new Crawler.

Targets = [ ... ] – Required

A list of collection of targets to crawl.

 Targets = [
        "S3Targets" =>  [[
            "Path" =>  ::String,
            "Exclusions" =>  [::String, ...]
        ], ...],
        "JdbcTargets" =>  [[
            "ConnectionName" =>  ::String,
            "Path" =>  ::String,
            "Exclusions" =>  [::String, ...]
        ], ...]
    ]

Schedule = ::String

A cron expression used to specify the schedule (see Time-Based Schedules for Jobs and Crawlers. For example, to run something every day at 12:15 UTC, you would specify: cron(15 12 * * ? *).

Classifiers = [::String, ...]

A list of custom Classifier names that the user has registered. By default, all AWS classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.

TablePrefix = ::String

The table prefix used for catalog tables created.

SchemaChangePolicy = [ ... ]

Policy for the crawler's update and deletion behavior.

 SchemaChangePolicy = [
        "UpdateBehavior" =>  "LOG" or "UPDATE_IN_DATABASE",
        "DeleteBehavior" =>  "LOG", "DELETE_FROM_DATABASE" or "DEPRECATE_IN_DATABASE"
    ]

Returns

CreateCrawlerResponse

Exceptions

InvalidInputException, AlreadyExistsException, OperationTimeoutException or ResourceNumberLimitExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.create_database
create_database([::AWSConfig], arguments::Dict)
create_database([::AWSConfig]; DatabaseInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateDatabase", arguments::Dict)
glue([::AWSConfig], "CreateDatabase", DatabaseInput=, <keyword arguments>)

CreateDatabase Operation

Creates a new database in a Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which to create the database. If none is supplied, the AWS account ID is used by default.

DatabaseInput = [ ... ] – Required

A DatabaseInput object defining the metadata database to create in the catalog.

 DatabaseInput = [
        "Name" => <required> ::String,
        "Description" =>  ::String,
        "LocationUri" =>  ::String,
        "Parameters" =>  ::Dict{String,String}
    ]

Returns

CreateDatabaseResponse

Exceptions

InvalidInputException, AlreadyExistsException, ResourceNumberLimitExceededException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_dev_endpoint
create_dev_endpoint([::AWSConfig], arguments::Dict)
create_dev_endpoint([::AWSConfig]; EndpointName=, RoleArn=, PublicKey=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateDevEndpoint", arguments::Dict)
glue([::AWSConfig], "CreateDevEndpoint", EndpointName=, RoleArn=, PublicKey=, <keyword arguments>)

CreateDevEndpoint Operation

Creates a new DevEndpoint.

Arguments

EndpointName = ::String – Required

The name to be assigned to the new DevEndpoint.

RoleArn = ::String – Required

The IAM role for the DevEndpoint.

SecurityGroupIds = [::String, ...]

Security group IDs for the security groups to be used by the new DevEndpoint.

SubnetId = ::String

The subnet ID for the new DevEndpoint to use.

PublicKey = ::String – Required

The public key to use for authentication.

NumberOfNodes = ::Int

The number of AWS Glue Data Processing Units (DPUs) to allocate to this DevEndpoint.

ExtraPythonLibsS3Path = ::String

Path(s) to one or more Python libraries in an S3 bucket that should be loaded in your DevEndpoint. Multiple values must be complete paths separated by a comma.

Please note that only pure Python libraries can currently be used on a DevEndpoint. Libraries that rely on C extensions, such as the pandas Python data analysis library, are not yet supported.

ExtraJarsS3Path = ::String

Path to one or more Java Jars in an S3 bucket that should be loaded in your DevEndpoint.

Returns

CreateDevEndpointResponse

Exceptions

AccessDeniedException, AlreadyExistsException, IdempotentParameterMismatchException, InternalServiceException, OperationTimeoutException, InvalidInputException, ValidationException or ResourceNumberLimitExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.create_job
create_job([::AWSConfig], arguments::Dict)
create_job([::AWSConfig]; Name=, Role=, Command=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateJob", arguments::Dict)
glue([::AWSConfig], "CreateJob", Name=, Role=, Command=, <keyword arguments>)

CreateJob Operation

Creates a new job.

Arguments

Name = ::String – Required

The name you assign to this job.

Description = ::String

Description of the job.

LogUri = ::String

This field is reserved for future use.

Role = ::String – Required

The role associated with this job.

ExecutionProperty = ["MaxConcurrentRuns" => ::Int]

An ExecutionProperty specifying the maximum number of concurrent runs allowed for this job.

Command = [ ... ] – Required

The JobCommand that executes this job.

 Command = [
        "Name" =>  ::String,
        "ScriptLocation" =>  ::String
    ]

DefaultArguments = ::Dict{String,String}

The default parameters for this job.

Connections = ["Connections" => [::String, ...]]

The connections used for this job.

MaxRetries = ::Int

The maximum number of times to retry this job if it fails.

AllocatedCapacity = ::Int

The number of capacity units allocated to this job.

Returns

CreateJobResponse

Exceptions

InvalidInputException, IdempotentParameterMismatchException, AlreadyExistsException, InternalServiceException, OperationTimeoutException or ResourceNumberLimitExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.create_partition
create_partition([::AWSConfig], arguments::Dict)
create_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreatePartition", arguments::Dict)
glue([::AWSConfig], "CreatePartition", DatabaseName=, TableName=, PartitionInput=, <keyword arguments>)

CreatePartition Operation

Creates a new partition.

Arguments

CatalogId = ::String

The ID of the catalog in which the partion is to be created. Currently, this should be the AWS account ID.

DatabaseName = ::String – Required

The name of the metadata database in which the partition is to be created.

TableName = ::String – Required

The name of the metadata table in which the partition is to be created.

PartitionInput = [ ... ] – Required

A PartitionInput structure defining the partition to be created.

 PartitionInput = [
        "Values" =>  [::String, ...],
        "LastAccessTime" =>  timestamp,
        "StorageDescriptor" =>  [
            "Columns" =>  [[
                "Name" => <required> ::String,
                "Type" =>  ::String,
                "Comment" =>  ::String
            ], ...],
            "Location" =>  ::String,
            "InputFormat" =>  ::String,
            "OutputFormat" =>  ::String,
            "Compressed" =>  ::Bool,
            "NumberOfBuckets" =>  ::Int,
            "SerdeInfo" =>  [
                "Name" =>  ::String,
                "SerializationLibrary" =>  ::String,
                "Parameters" =>  ::Dict{String,String}
            ],
            "BucketColumns" =>  [::String, ...],
            "SortColumns" =>  [[
                "Column" => <required> ::String,
                "SortOrder" => <required> ::Int
            ], ...],
            "Parameters" =>  ::Dict{String,String},
            "SkewedInfo" =>  [
                "SkewedColumnNames" =>  [::String, ...],
                "SkewedColumnValues" =>  [::String, ...],
                "SkewedColumnValueLocationMaps" =>  ::Dict{String,String}
            ],
            "StoredAsSubDirectories" =>  ::Bool
        ],
        "Parameters" =>  ::Dict{String,String},
        "LastAnalyzedTime" =>  timestamp
    ]

Returns

CreatePartitionResponse

Exceptions

InvalidInputException, AlreadyExistsException, ResourceNumberLimitExceededException, InternalServiceException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_script
create_script([::AWSConfig], arguments::Dict)
create_script([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateScript", arguments::Dict)
glue([::AWSConfig], "CreateScript", <keyword arguments>)

CreateScript Operation

Transforms a directed acyclic graph (DAG) into a Python script.

Arguments

DagNodes = [[ ... ], ...]

A list of the nodes in the DAG.

 DagNodes = [[
        "Id" => <required> ::String,
        "NodeType" => <required> ::String,
        "Args" => <required> [[
            "Name" => <required> ::String,
            "Value" => <required> ::String,
            "Param" =>  ::Bool
        ], ...],
        "LineNumber" =>  ::Int
    ], ...]

DagEdges = [[ ... ], ...]

A list of the edges in the DAG.

 DagEdges = [[
        "Source" => <required> ::String,
        "Target" => <required> ::String,
        "TargetParameter" =>  ::String
    ], ...]

Returns

CreateScriptResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_table
create_table([::AWSConfig], arguments::Dict)
create_table([::AWSConfig]; DatabaseName=, TableInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateTable", arguments::Dict)
glue([::AWSConfig], "CreateTable", DatabaseName=, TableInput=, <keyword arguments>)

CreateTable Operation

Creates a new table definition in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which to create the Table. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The catalog database in which to create the new table.

TableInput = [ ... ] – Required

The TableInput object that defines the metadata table to create in the catalog.

 TableInput = [
        "Name" => <required> ::String,
        "Description" =>  ::String,
        "Owner" =>  ::String,
        "LastAccessTime" =>  timestamp,
        "LastAnalyzedTime" =>  timestamp,
        "Retention" =>  ::Int,
        "StorageDescriptor" =>  [
            "Columns" =>  [[
                "Name" => <required> ::String,
                "Type" =>  ::String,
                "Comment" =>  ::String
            ], ...],
            "Location" =>  ::String,
            "InputFormat" =>  ::String,
            "OutputFormat" =>  ::String,
            "Compressed" =>  ::Bool,
            "NumberOfBuckets" =>  ::Int,
            "SerdeInfo" =>  [
                "Name" =>  ::String,
                "SerializationLibrary" =>  ::String,
                "Parameters" =>  ::Dict{String,String}
            ],
            "BucketColumns" =>  [::String, ...],
            "SortColumns" =>  [[
                "Column" => <required> ::String,
                "SortOrder" => <required> ::Int
            ], ...],
            "Parameters" =>  ::Dict{String,String},
            "SkewedInfo" =>  [
                "SkewedColumnNames" =>  [::String, ...],
                "SkewedColumnValues" =>  [::String, ...],
                "SkewedColumnValueLocationMaps" =>  ::Dict{String,String}
            ],
            "StoredAsSubDirectories" =>  ::Bool
        ],
        "PartitionKeys" =>  [[
            "Name" => <required> ::String,
            "Type" =>  ::String,
            "Comment" =>  ::String
        ], ...],
        "ViewOriginalText" =>  ::String,
        "ViewExpandedText" =>  ::String,
        "TableType" =>  ::String,
        "Parameters" =>  ::Dict{String,String}
    ]

Returns

CreateTableResponse

Exceptions

AlreadyExistsException, InvalidInputException, EntityNotFoundException, ResourceNumberLimitExceededException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.create_trigger
create_trigger([::AWSConfig], arguments::Dict)
create_trigger([::AWSConfig]; Name=, Type=, Actions=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateTrigger", arguments::Dict)
glue([::AWSConfig], "CreateTrigger", Name=, Type=, Actions=, <keyword arguments>)

CreateTrigger Operation

Creates a new trigger.

Arguments

Name = ::String – Required

The name to assign to the new trigger.

Type = "SCHEDULED", "CONDITIONAL" or "ON_DEMAND" – Required

The type of the new trigger.

Schedule = ::String

A cron expression used to specify the schedule (see Time-Based Schedules for Jobs and Crawlers. For example, to run something every day at 12:15 UTC, you would specify: cron(15 12 * * ? *).

Predicate = [ ... ]

A predicate to specify when the new trigger should fire.

 Predicate = [
        "Logical" =>  "AND",
        "Conditions" =>  [[
            "LogicalOperator" =>  "EQUALS",
            "JobName" =>  ::String,
            "State" =>  "STARTING", "RUNNING", "STOPPING", "STOPPED", "SUCCEEDED" or "FAILED"
        ], ...]
    ]

Actions = [[ ... ], ...] – Required

The actions initiated by this trigger when it fires.

 Actions = [[
        "JobName" =>  ::String,
        "Arguments" =>  ::Dict{String,String}
    ], ...]

Description = ::String

A description of the new trigger.

Returns

CreateTriggerResponse

Exceptions

AlreadyExistsException, InvalidInputException, InternalServiceException, OperationTimeoutException or ResourceNumberLimitExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.create_user_defined_function
create_user_defined_function([::AWSConfig], arguments::Dict)
create_user_defined_function([::AWSConfig]; DatabaseName=, FunctionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "CreateUserDefinedFunction", arguments::Dict)
glue([::AWSConfig], "CreateUserDefinedFunction", DatabaseName=, FunctionInput=, <keyword arguments>)

CreateUserDefinedFunction Operation

Creates a new function definition in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which to create the function. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which to create the function.

FunctionInput = [ ... ] – Required

A FunctionInput object that defines the function to create in the Data Catalog.

 FunctionInput = [
        "FunctionName" =>  ::String,
        "ClassName" =>  ::String,
        "OwnerName" =>  ::String,
        "OwnerType" =>  "USER", "ROLE" or "GROUP",
        "ResourceUris" =>  [[
            "ResourceType" =>  "JAR", "FILE" or "ARCHIVE",
            "Uri" =>  ::String
        ], ...]
    ]

Returns

CreateUserDefinedFunctionResponse

Exceptions

AlreadyExistsException, InvalidInputException, InternalServiceException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_classifier
delete_classifier([::AWSConfig], arguments::Dict)
delete_classifier([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteClassifier", arguments::Dict)
glue([::AWSConfig], "DeleteClassifier", Name=)

DeleteClassifier Operation

Removes a Classifier from the metadata store.

Arguments

Name = ::String – Required

Name of the Classifier to remove.

Returns

DeleteClassifierResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_connection
delete_connection([::AWSConfig], arguments::Dict)
delete_connection([::AWSConfig]; ConnectionName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteConnection", arguments::Dict)
glue([::AWSConfig], "DeleteConnection", ConnectionName=, <keyword arguments>)

DeleteConnection Operation

Deletes a connection from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the connection resides. If none is supplied, the AWS account ID is used by default.

ConnectionName = ::String – Required

The name of the connection to delete.

Returns

DeleteConnectionResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_crawler
delete_crawler([::AWSConfig], arguments::Dict)
delete_crawler([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteCrawler", arguments::Dict)
glue([::AWSConfig], "DeleteCrawler", Name=)

DeleteCrawler Operation

Removes a specified Crawler from the metadata store, unless the Crawler state is RUNNING.

Arguments

Name = ::String – Required

Name of the Crawler to remove.

Returns

DeleteCrawlerResponse

Exceptions

EntityNotFoundException, CrawlerRunningException, SchedulerTransitioningException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_database
delete_database([::AWSConfig], arguments::Dict)
delete_database([::AWSConfig]; Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteDatabase", arguments::Dict)
glue([::AWSConfig], "DeleteDatabase", Name=, <keyword arguments>)

DeleteDatabase Operation

Removes a specified Database from a Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the database resides. If none is supplied, the AWS account ID is used by default.

Name = ::String – Required

The name of the Database to delete.

Returns

DeleteDatabaseResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_dev_endpoint
delete_dev_endpoint([::AWSConfig], arguments::Dict)
delete_dev_endpoint([::AWSConfig]; EndpointName=)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteDevEndpoint", arguments::Dict)
glue([::AWSConfig], "DeleteDevEndpoint", EndpointName=)

DeleteDevEndpoint Operation

Deletes a specified DevEndpoint.

Arguments

EndpointName = ::String – Required

The name of the DevEndpoint.

Returns

DeleteDevEndpointResponse

Exceptions

EntityNotFoundException, InternalServiceException, OperationTimeoutException or InvalidInputException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_job
delete_job([::AWSConfig], arguments::Dict)
delete_job([::AWSConfig]; JobName=)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteJob", arguments::Dict)
glue([::AWSConfig], "DeleteJob", JobName=)

DeleteJob Operation

Deletes a specified job.

Arguments

JobName = ::String – Required

The name of the job to delete.

Returns

DeleteJobResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_partition
delete_partition([::AWSConfig], arguments::Dict)
delete_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionValues=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "DeletePartition", arguments::Dict)
glue([::AWSConfig], "DeletePartition", DatabaseName=, TableName=, PartitionValues=, <keyword arguments>)

DeletePartition Operation

Deletes a specified partition.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partition to be deleted resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which the table in question resides.

TableName = ::String – Required

The name of the table where the partition to be deleted is located.

PartitionValues = [::String, ...] – Required

The values that define the partition.

Returns

DeletePartitionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_table
delete_table([::AWSConfig], arguments::Dict)
delete_table([::AWSConfig]; DatabaseName=, Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteTable", arguments::Dict)
glue([::AWSConfig], "DeleteTable", DatabaseName=, Name=, <keyword arguments>)

DeleteTable Operation

Removes a table definition from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the table resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which the table resides.

Name = ::String – Required

The name of the table to be deleted.

Returns

DeleteTableResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_trigger
delete_trigger([::AWSConfig], arguments::Dict)
delete_trigger([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteTrigger", arguments::Dict)
glue([::AWSConfig], "DeleteTrigger", Name=)

DeleteTrigger Operation

Deletes a specified trigger.

Arguments

Name = ::String – Required

The name of the trigger to delete.

Returns

DeleteTriggerResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.delete_user_defined_function
delete_user_defined_function([::AWSConfig], arguments::Dict)
delete_user_defined_function([::AWSConfig]; DatabaseName=, FunctionName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "DeleteUserDefinedFunction", arguments::Dict)
glue([::AWSConfig], "DeleteUserDefinedFunction", DatabaseName=, FunctionName=, <keyword arguments>)

DeleteUserDefinedFunction Operation

Deletes an existing function definition from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the function to be deleted is located. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the function is located.

FunctionName = ::String – Required

The name of the function definition to be deleted.

Returns

DeleteUserDefinedFunctionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_catalog_import_status
get_catalog_import_status([::AWSConfig], arguments::Dict)
get_catalog_import_status([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetCatalogImportStatus", arguments::Dict)
glue([::AWSConfig], "GetCatalogImportStatus", <keyword arguments>)

GetCatalogImportStatus Operation

Retrieves the status of a migration operation.

Arguments

CatalogId = ::String

The ID of the catalog to migrate. Currently, this should be the AWS account ID.

Returns

GetCatalogImportStatusResponse

Exceptions

InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_classifier
get_classifier([::AWSConfig], arguments::Dict)
get_classifier([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "GetClassifier", arguments::Dict)
glue([::AWSConfig], "GetClassifier", Name=)

GetClassifier Operation

Retrieve a Classifier by name.

Arguments

Name = ::String – Required

Name of the Classifier to retrieve.

Returns

GetClassifierResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_classifiers
get_classifiers([::AWSConfig], arguments::Dict)
get_classifiers([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetClassifiers", arguments::Dict)
glue([::AWSConfig], "GetClassifiers", <keyword arguments>)

GetClassifiers Operation

Lists all Classifier objects in the metadata store.

Arguments

MaxResults = ::Int

Size of the list to return (optional).

NextToken = ::String

An optional continuation token.

Returns

GetClassifiersResponse

Exceptions

OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_connection
get_connection([::AWSConfig], arguments::Dict)
get_connection([::AWSConfig]; Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetConnection", arguments::Dict)
glue([::AWSConfig], "GetConnection", Name=, <keyword arguments>)

GetConnection Operation

Retrieves a connection definition from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the connection resides. If none is supplied, the AWS account ID is used by default.

Name = ::String – Required

The name of the connection definition to retrieve.

Returns

GetConnectionResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_connections
get_connections([::AWSConfig], arguments::Dict)
get_connections([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetConnections", arguments::Dict)
glue([::AWSConfig], "GetConnections", <keyword arguments>)

GetConnections Operation

Retrieves a list of connection definitions from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the connections reside. If none is supplied, the AWS account ID is used by default.

Filter = [ ... ]

A filter that controls which connections will be returned.

 Filter = [
        "MatchCriteria" =>  [::String, ...],
        "ConnectionType" =>  "JDBC" or "SFTP"
    ]

NextToken = ::String

A continuation token, if this is a continuation call.

MaxResults = ::Int

The maximum number of connections to return in one response.

Returns

GetConnectionsResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_crawler
get_crawler([::AWSConfig], arguments::Dict)
get_crawler([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "GetCrawler", arguments::Dict)
glue([::AWSConfig], "GetCrawler", Name=)

GetCrawler Operation

Retrieves metadata for a specified Crawler.

Arguments

Name = ::String – Required

Name of the Crawler to retrieve metadata for.

Returns

GetCrawlerResponse

Exceptions

EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_crawler_metrics
get_crawler_metrics([::AWSConfig], arguments::Dict)
get_crawler_metrics([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetCrawlerMetrics", arguments::Dict)
glue([::AWSConfig], "GetCrawlerMetrics", <keyword arguments>)

GetCrawlerMetrics Operation

Retrieves metrics about specified crawlers.

Arguments

CrawlerNameList = [::String, ...]

A list of the names of crawlers about which to retrieve metrics.

MaxResults = ::Int

The maximum size of a list to return.

NextToken = ::String

A continuation token, if this is a continuation call.

Returns

GetCrawlerMetricsResponse

Exceptions

OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_crawlers
get_crawlers([::AWSConfig], arguments::Dict)
get_crawlers([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetCrawlers", arguments::Dict)
glue([::AWSConfig], "GetCrawlers", <keyword arguments>)

GetCrawlers Operation

Retrieves metadata for all Crawlers defined in the customer account.

Arguments

MaxResults = ::Int

The number of Crawlers to return on each call.

NextToken = ::String

A continuation token, if this is a continuation request.

Returns

GetCrawlersResponse

Exceptions

OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_database
get_database([::AWSConfig], arguments::Dict)
get_database([::AWSConfig]; Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetDatabase", arguments::Dict)
glue([::AWSConfig], "GetDatabase", Name=, <keyword arguments>)

GetDatabase Operation

Retrieves the definition of a specified database.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the database resides. If none is supplied, the AWS account ID is used by default.

Name = ::String – Required

The name of the database to retrieve.

Returns

GetDatabaseResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_databases
get_databases([::AWSConfig], arguments::Dict)
get_databases([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetDatabases", arguments::Dict)
glue([::AWSConfig], "GetDatabases", <keyword arguments>)

GetDatabases Operation

Retrieves all Databases defined in a given Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog from which to retrieve Databases. If none is supplied, the AWS account ID is used by default.

NextToken = ::String

A continuation token, if this is a continuation call.

MaxResults = ::Int

The maximum number of databases to return in one response.

Returns

GetDatabasesResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_dataflow_graph
get_dataflow_graph([::AWSConfig], arguments::Dict)
get_dataflow_graph([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetDataflowGraph", arguments::Dict)
glue([::AWSConfig], "GetDataflowGraph", <keyword arguments>)

GetDataflowGraph Operation

Transforms a Python script into a directed acyclic graph (DAG).

Arguments

PythonScript = ::String

The Python script to transform.

Returns

GetDataflowGraphResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_dev_endpoint
get_dev_endpoint([::AWSConfig], arguments::Dict)
get_dev_endpoint([::AWSConfig]; EndpointName=)

using AWSCore.Services.glue
glue([::AWSConfig], "GetDevEndpoint", arguments::Dict)
glue([::AWSConfig], "GetDevEndpoint", EndpointName=)

GetDevEndpoint Operation

Retrieves information about a specified DevEndpoint.

Arguments

EndpointName = ::String – Required

Name of the DevEndpoint for which to retrieve information.

Returns

GetDevEndpointResponse

Exceptions

EntityNotFoundException, InternalServiceException, OperationTimeoutException or InvalidInputException.

See also: AWS API Documentation

using AWSSDK.Glue.get_dev_endpoints
get_dev_endpoints([::AWSConfig], arguments::Dict)
get_dev_endpoints([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetDevEndpoints", arguments::Dict)
glue([::AWSConfig], "GetDevEndpoints", <keyword arguments>)

GetDevEndpoints Operation

Retrieves all the DevEndpoints in this AWS account.

Arguments

MaxResults = ::Int

The maximum size of information to return.

NextToken = ::String

A continuation token, if this is a continuation call.

Returns

GetDevEndpointsResponse

Exceptions

EntityNotFoundException, InternalServiceException, OperationTimeoutException or InvalidInputException.

See also: AWS API Documentation

using AWSSDK.Glue.get_job
get_job([::AWSConfig], arguments::Dict)
get_job([::AWSConfig]; JobName=)

using AWSCore.Services.glue
glue([::AWSConfig], "GetJob", arguments::Dict)
glue([::AWSConfig], "GetJob", JobName=)

GetJob Operation

Retrieves an existing job definition.

Arguments

JobName = ::String – Required

The name of the job to retrieve.

Returns

GetJobResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_job_run
get_job_run([::AWSConfig], arguments::Dict)
get_job_run([::AWSConfig]; JobName=, RunId=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetJobRun", arguments::Dict)
glue([::AWSConfig], "GetJobRun", JobName=, RunId=, <keyword arguments>)

GetJobRun Operation

Retrieves the metadata for a given job run.

Arguments

JobName = ::String – Required

Name of the job being run.

RunId = ::String – Required

The ID of the job run.

PredecessorsIncluded = ::Bool

A list of the predecessor runs to return as well.

Returns

GetJobRunResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_job_runs
get_job_runs([::AWSConfig], arguments::Dict)
get_job_runs([::AWSConfig]; JobName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetJobRuns", arguments::Dict)
glue([::AWSConfig], "GetJobRuns", JobName=, <keyword arguments>)

GetJobRuns Operation

Retrieves metadata for all runs of a given job.

Arguments

JobName = ::String – Required

The name of the job for which to retrieve all job runs.

NextToken = ::String

A continuation token, if this is a continuation call.

MaxResults = ::Int

The maximum size of the response.

Returns

GetJobRunsResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_jobs
get_jobs([::AWSConfig], arguments::Dict)
get_jobs([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetJobs", arguments::Dict)
glue([::AWSConfig], "GetJobs", <keyword arguments>)

GetJobs Operation

Retrieves all current jobs.

Arguments

NextToken = ::String

A continuation token, if this is a continuation call.

MaxResults = ::Int

The maximum size of the response.

Returns

GetJobsResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_mapping
get_mapping([::AWSConfig], arguments::Dict)
get_mapping([::AWSConfig]; Source=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetMapping", arguments::Dict)
glue([::AWSConfig], "GetMapping", Source=, <keyword arguments>)

GetMapping Operation

Creates mappings.

Arguments

Source = [ ... ] – Required

Specifies the source table.

 Source = [
        "DatabaseName" => <required> ::String,
        "TableName" => <required> ::String
    ]

Sinks = [[ ... ], ...]

A list of target tables.

 Sinks = [[
        "DatabaseName" => <required> ::String,
        "TableName" => <required> ::String
    ], ...]

Location = [ ... ]

Parameters for the mapping.

 Location = [
        "Jdbc" =>  [[
            "Name" => <required> ::String,
            "Value" => <required> ::String,
            "Param" =>  ::Bool
        ], ...],
        "S3" =>  [[
            "Name" => <required> ::String,
            "Value" => <required> ::String,
            "Param" =>  ::Bool
        ], ...]
    ]

Returns

GetMappingResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_partition
get_partition([::AWSConfig], arguments::Dict)
get_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionValues=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetPartition", arguments::Dict)
glue([::AWSConfig], "GetPartition", DatabaseName=, TableName=, PartitionValues=, <keyword arguments>)

GetPartition Operation

Retrieves information about a specified partition.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partition in question resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the partition resides.

TableName = ::String – Required

The name of the partition's table.

PartitionValues = [::String, ...] – Required

The values that define the partition.

Returns

GetPartitionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_partitions
get_partitions([::AWSConfig], arguments::Dict)
get_partitions([::AWSConfig]; DatabaseName=, TableName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetPartitions", arguments::Dict)
glue([::AWSConfig], "GetPartitions", DatabaseName=, TableName=, <keyword arguments>)

GetPartitions Operation

Retrieves information about the partitions in a table.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partitions in question reside. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the partitions reside.

TableName = ::String – Required

The name of the partitions' table.

Expression = ::String

An expression filtering the partitions to be returned.

NextToken = ::String

A continuation token, if this is not the first call to retrieve these partitions.

Segment = [ ... ]

The segment of the table's partitions to scan in this request.

 Segment = [
        "SegmentNumber" => <required> ::Int,
        "TotalSegments" => <required> ::Int
    ]

MaxResults = ::Int

The maximum number of partitions to return in a single response.

Returns

GetPartitionsResponse

Exceptions

EntityNotFoundException, InvalidInputException, OperationTimeoutException or InternalServiceException.

See also: AWS API Documentation

using AWSSDK.Glue.get_plan
get_plan([::AWSConfig], arguments::Dict)
get_plan([::AWSConfig]; Mapping=, Source=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetPlan", arguments::Dict)
glue([::AWSConfig], "GetPlan", Mapping=, Source=, <keyword arguments>)

GetPlan Operation

Gets a Python script to perform a specified mapping.

Arguments

Mapping = [[ ... ], ...] – Required

The list of mappings from a source table to target tables.

 Mapping = [[
        "SourceTable" =>  ::String,
        "SourcePath" =>  ::String,
        "SourceType" =>  ::String,
        "TargetTable" =>  ::String,
        "TargetPath" =>  ::String,
        "TargetType" =>  ::String
    ], ...]

Source = [ ... ] – Required

The source table.

 Source = [
        "DatabaseName" => <required> ::String,
        "TableName" => <required> ::String
    ]

Sinks = [[ ... ], ...]

The target tables.

 Sinks = [[
        "DatabaseName" => <required> ::String,
        "TableName" => <required> ::String
    ], ...]

Location = [ ... ]

Parameters for the mapping.

 Location = [
        "Jdbc" =>  [[
            "Name" => <required> ::String,
            "Value" => <required> ::String,
            "Param" =>  ::Bool
        ], ...],
        "S3" =>  [[
            "Name" => <required> ::String,
            "Value" => <required> ::String,
            "Param" =>  ::Bool
        ], ...]
    ]

Returns

GetPlanResponse

Exceptions

InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_table
get_table([::AWSConfig], arguments::Dict)
get_table([::AWSConfig]; DatabaseName=, Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetTable", arguments::Dict)
glue([::AWSConfig], "GetTable", DatabaseName=, Name=, <keyword arguments>)

GetTable Operation

Retrieves the Table definition in a Data Catalog for a specified table.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the table resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the database in the catalog in which the table resides.

Name = ::String – Required

The name of the table for which to retrieve the definition.

Returns

GetTableResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_table_versions
get_table_versions([::AWSConfig], arguments::Dict)
get_table_versions([::AWSConfig]; DatabaseName=, TableName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetTableVersions", arguments::Dict)
glue([::AWSConfig], "GetTableVersions", DatabaseName=, TableName=, <keyword arguments>)

GetTableVersions Operation

Retrieves a list of strings that identify available versions of a specified table.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the tables reside. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The database in the catalog in which the table resides.

TableName = ::String – Required

The name of the table.

NextToken = ::String

A continuation token, if this is not the first call.

MaxResults = ::Int

The maximum number of table versions to return in one response.

Returns

GetTableVersionsResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_tables
get_tables([::AWSConfig], arguments::Dict)
get_tables([::AWSConfig]; DatabaseName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetTables", arguments::Dict)
glue([::AWSConfig], "GetTables", DatabaseName=, <keyword arguments>)

GetTables Operation

Retrieves the definitions of some or all of the tables in a given Database.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the tables reside. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The database in the catalog whose tables to list.

Expression = ::String

A regular expression pattern. If present, only those tables whose names match the pattern are returned.

NextToken = ::String

A continuation token, included if this is a continuation call.

MaxResults = ::Int

The maximum number of tables to return in a single response.

Returns

GetTablesResponse

Exceptions

EntityNotFoundException, InvalidInputException, OperationTimeoutException or InternalServiceException.

See also: AWS API Documentation

using AWSSDK.Glue.get_trigger
get_trigger([::AWSConfig], arguments::Dict)
get_trigger([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "GetTrigger", arguments::Dict)
glue([::AWSConfig], "GetTrigger", Name=)

GetTrigger Operation

Retrieves the definition of a trigger.

Arguments

Name = ::String – Required

The name of the trigger to retrieve.

Returns

GetTriggerResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_triggers
get_triggers([::AWSConfig], arguments::Dict)
get_triggers([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetTriggers", arguments::Dict)
glue([::AWSConfig], "GetTriggers", <keyword arguments>)

GetTriggers Operation

Gets all the triggers associated with a job.

Arguments

NextToken = ::String

A continuation token, if this is a continuation call.

DependentJobName = ::String

The name of the job for which to retrieve triggers.

MaxResults = ::Int

The maximum size of the response.

Returns

GetTriggersResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_user_defined_function
get_user_defined_function([::AWSConfig], arguments::Dict)
get_user_defined_function([::AWSConfig]; DatabaseName=, FunctionName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetUserDefinedFunction", arguments::Dict)
glue([::AWSConfig], "GetUserDefinedFunction", DatabaseName=, FunctionName=, <keyword arguments>)

GetUserDefinedFunction Operation

Retrieves a specified function definition from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the function to be retrieved is located. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the function is located.

FunctionName = ::String – Required

The name of the function.

Returns

GetUserDefinedFunctionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.get_user_defined_functions
get_user_defined_functions([::AWSConfig], arguments::Dict)
get_user_defined_functions([::AWSConfig]; DatabaseName=, Pattern=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "GetUserDefinedFunctions", arguments::Dict)
glue([::AWSConfig], "GetUserDefinedFunctions", DatabaseName=, Pattern=, <keyword arguments>)

GetUserDefinedFunctions Operation

Retrieves a multiple function definitions from the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the functions to be retrieved are located. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the functions are located.

Pattern = ::String – Required

An optional function-name pattern string that filters the function definitions returned.

NextToken = ::String

A continuation token, if this is a continuation call.

MaxResults = ::Int

The maximum number of functions to return in one response.

Returns

GetUserDefinedFunctionsResponse

Exceptions

EntityNotFoundException, InvalidInputException, OperationTimeoutException or InternalServiceException.

See also: AWS API Documentation

using AWSSDK.Glue.import_catalog_to_glue
import_catalog_to_glue([::AWSConfig], arguments::Dict)
import_catalog_to_glue([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "ImportCatalogToGlue", arguments::Dict)
glue([::AWSConfig], "ImportCatalogToGlue", <keyword arguments>)

ImportCatalogToGlue Operation

Imports an existing Athena Data Catalog to AWS Glue

Arguments

CatalogId = ::String

The ID of the catalog to import. Currently, this should be the AWS account ID.

Returns

ImportCatalogToGlueResponse

Exceptions

InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.reset_job_bookmark
reset_job_bookmark([::AWSConfig], arguments::Dict)
reset_job_bookmark([::AWSConfig]; JobName=)

using AWSCore.Services.glue
glue([::AWSConfig], "ResetJobBookmark", arguments::Dict)
glue([::AWSConfig], "ResetJobBookmark", JobName=)

ResetJobBookmark Operation

Resets a bookmark entry.

Arguments

JobName = ::String – Required

The name of the job in question.

Returns

ResetJobBookmarkResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.start_crawler
start_crawler([::AWSConfig], arguments::Dict)
start_crawler([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "StartCrawler", arguments::Dict)
glue([::AWSConfig], "StartCrawler", Name=)

StartCrawler Operation

Starts a crawl using the specified Crawler, regardless of what is scheduled. If the Crawler is already running, does nothing.

Arguments

Name = ::String – Required

Name of the Crawler to start.

Returns

StartCrawlerResponse

Exceptions

EntityNotFoundException, CrawlerRunningException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.start_crawler_schedule
start_crawler_schedule([::AWSConfig], arguments::Dict)
start_crawler_schedule([::AWSConfig]; CrawlerName=)

using AWSCore.Services.glue
glue([::AWSConfig], "StartCrawlerSchedule", arguments::Dict)
glue([::AWSConfig], "StartCrawlerSchedule", CrawlerName=)

StartCrawlerSchedule Operation

Changes the schedule state of the specified crawler to SCHEDULED, unless the crawler is already running or the schedule state is already SCHEDULED.

Arguments

CrawlerName = ::String – Required

Name of the crawler to schedule.

Returns

StartCrawlerScheduleResponse

Exceptions

EntityNotFoundException, SchedulerRunningException, SchedulerTransitioningException, NoScheduleException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.start_job_run
start_job_run([::AWSConfig], arguments::Dict)
start_job_run([::AWSConfig]; JobName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "StartJobRun", arguments::Dict)
glue([::AWSConfig], "StartJobRun", JobName=, <keyword arguments>)

StartJobRun Operation

Runs a job.

Arguments

JobName = ::String – Required

The name of the job to start.

JobRunId = ::String

The ID of the job run to start.

Arguments = ::Dict{String,String}

Specific arguments for this job run.

AllocatedCapacity = ::Int

The infrastructure capacity to allocate to this job.

Returns

StartJobRunResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException, OperationTimeoutException, ResourceNumberLimitExceededException or ConcurrentRunsExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.start_trigger
start_trigger([::AWSConfig], arguments::Dict)
start_trigger([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "StartTrigger", arguments::Dict)
glue([::AWSConfig], "StartTrigger", Name=)

StartTrigger Operation

Starts an existing trigger.

Arguments

Name = ::String – Required

The name of the trigger to start.

Returns

StartTriggerResponse

Exceptions

InvalidInputException, InternalServiceException, EntityNotFoundException, OperationTimeoutException, ResourceNumberLimitExceededException or ConcurrentRunsExceededException.

See also: AWS API Documentation

using AWSSDK.Glue.stop_crawler
stop_crawler([::AWSConfig], arguments::Dict)
stop_crawler([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "StopCrawler", arguments::Dict)
glue([::AWSConfig], "StopCrawler", Name=)

StopCrawler Operation

If the specified Crawler is running, stops the crawl.

Arguments

Name = ::String – Required

Name of the Crawler to stop.

Returns

StopCrawlerResponse

Exceptions

EntityNotFoundException, CrawlerNotRunningException, CrawlerStoppingException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.stop_crawler_schedule
stop_crawler_schedule([::AWSConfig], arguments::Dict)
stop_crawler_schedule([::AWSConfig]; CrawlerName=)

using AWSCore.Services.glue
glue([::AWSConfig], "StopCrawlerSchedule", arguments::Dict)
glue([::AWSConfig], "StopCrawlerSchedule", CrawlerName=)

StopCrawlerSchedule Operation

Sets the schedule state of the specified crawler to NOT_SCHEDULED, but does not stop the crawler if it is already running.

Arguments

CrawlerName = ::String – Required

Name of the crawler whose schedule state to set.

Returns

StopCrawlerScheduleResponse

Exceptions

EntityNotFoundException, SchedulerNotRunningException, SchedulerTransitioningException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.stop_trigger
stop_trigger([::AWSConfig], arguments::Dict)
stop_trigger([::AWSConfig]; Name=)

using AWSCore.Services.glue
glue([::AWSConfig], "StopTrigger", arguments::Dict)
glue([::AWSConfig], "StopTrigger", Name=)

StopTrigger Operation

Stops a specified trigger.

Arguments

Name = ::String – Required

The name of the trigger to stop.

Returns

StopTriggerResponse

Exceptions

InvalidInputException, InternalServiceException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_classifier
update_classifier([::AWSConfig], arguments::Dict)
update_classifier([::AWSConfig]; <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateClassifier", arguments::Dict)
glue([::AWSConfig], "UpdateClassifier", <keyword arguments>)

UpdateClassifier Operation

Modifies an existing Classifier.

Arguments

GrokClassifier = [ ... ]

A GrokClassifier object with updated fields.

 GrokClassifier = [
        "Name" => <required> ::String,
        "Classification" =>  ::String,
        "GrokPattern" =>  ::String,
        "CustomPatterns" =>  ::String
    ]

Returns

UpdateClassifierResponse

Exceptions

InvalidInputException, VersionMismatchException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_connection
update_connection([::AWSConfig], arguments::Dict)
update_connection([::AWSConfig]; Name=, ConnectionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateConnection", arguments::Dict)
glue([::AWSConfig], "UpdateConnection", Name=, ConnectionInput=, <keyword arguments>)

UpdateConnection Operation

Updates a connection definition in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the connection resides. If none is supplied, the AWS account ID is used by default.

Name = ::String – Required

The name of the connection definition to update.

ConnectionInput = [ ... ] – Required

A ConnectionInput object that redefines the connection in question.

 ConnectionInput = [
        "Name" =>  ::String,
        "Description" =>  ::String,
        "ConnectionType" =>  "JDBC" or "SFTP",
        "MatchCriteria" =>  [::String, ...],
        "ConnectionProperties" =>  ::Dict{String,String},
        "PhysicalConnectionRequirements" =>  [
            "SubnetId" =>  ::String,
            "SecurityGroupIdList" =>  [::String, ...],
            "AvailabilityZone" =>  ::String
        ]
    ]

Returns

UpdateConnectionResponse

Exceptions

InvalidInputException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_crawler
update_crawler([::AWSConfig], arguments::Dict)
update_crawler([::AWSConfig]; Name=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateCrawler", arguments::Dict)
glue([::AWSConfig], "UpdateCrawler", Name=, <keyword arguments>)

UpdateCrawler Operation

Updates a Crawler. If a Crawler is running, you must stop it using StopCrawler before updating it.

Arguments

Name = ::String – Required

Name of the new Crawler.

Role = ::String

The IAM role (or ARN of an IAM role) used by the new Crawler to access customer resources.

DatabaseName = ::String

The Glue Database where results will be stored, such as: arn:aws:daylight:us-east-1::database/sometable/*.

Description = ::String

A description of the new Crawler.

Targets = [ ... ]

A list of collection of targets to crawl.

 Targets = [
        "S3Targets" =>  [[
            "Path" =>  ::String,
            "Exclusions" =>  [::String, ...]
        ], ...],
        "JdbcTargets" =>  [[
            "ConnectionName" =>  ::String,
            "Path" =>  ::String,
            "Exclusions" =>  [::String, ...]
        ], ...]
    ]

Schedule = ::String

A cron expression used to specify the schedule (see Time-Based Schedules for Jobs and Crawlers. For example, to run something every day at 12:15 UTC, you would specify: cron(15 12 * * ? *).

Classifiers = [::String, ...]

A list of custom Classifier names that the user has registered. By default, all AWS classifiers are included in a crawl, but these custom classifiers always override the default classifiers for a given classification.

TablePrefix = ::String

The table prefix used for catalog tables created.

SchemaChangePolicy = [ ... ]

Policy for the crawler's update and deletion behavior.

 SchemaChangePolicy = [
        "UpdateBehavior" =>  "LOG" or "UPDATE_IN_DATABASE",
        "DeleteBehavior" =>  "LOG", "DELETE_FROM_DATABASE" or "DEPRECATE_IN_DATABASE"
    ]

Returns

UpdateCrawlerResponse

Exceptions

InvalidInputException, VersionMismatchException, EntityNotFoundException, CrawlerRunningException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_crawler_schedule
update_crawler_schedule([::AWSConfig], arguments::Dict)
update_crawler_schedule([::AWSConfig]; CrawlerName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateCrawlerSchedule", arguments::Dict)
glue([::AWSConfig], "UpdateCrawlerSchedule", CrawlerName=, <keyword arguments>)

UpdateCrawlerSchedule Operation

Updates the schedule of a crawler using a Cron expression.

Arguments

CrawlerName = ::String – Required

Name of the crawler whose schedule to update.

Schedule = ::String

The updated cron expression used to specify the schedule (see Time-Based Schedules for Jobs and Crawlers. For example, to run something every day at 12:15 UTC, you would specify: cron(15 12 * * ? *).

Returns

UpdateCrawlerScheduleResponse

Exceptions

EntityNotFoundException, InvalidInputException, VersionMismatchException, SchedulerTransitioningException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_database
update_database([::AWSConfig], arguments::Dict)
update_database([::AWSConfig]; Name=, DatabaseInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateDatabase", arguments::Dict)
glue([::AWSConfig], "UpdateDatabase", Name=, DatabaseInput=, <keyword arguments>)

UpdateDatabase Operation

Updates an existing database definition in a Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog in which the metadata database resides. If none is supplied, the AWS account ID is used by default.

Name = ::String – Required

The name of the metadata database to update in the catalog.

DatabaseInput = [ ... ] – Required

A DatabaseInput object specifying the new definition of the metadata database in the catalog.

 DatabaseInput = [
        "Name" => <required> ::String,
        "Description" =>  ::String,
        "LocationUri" =>  ::String,
        "Parameters" =>  ::Dict{String,String}
    ]

Returns

UpdateDatabaseResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_dev_endpoint
update_dev_endpoint([::AWSConfig], arguments::Dict)
update_dev_endpoint([::AWSConfig]; EndpointName=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateDevEndpoint", arguments::Dict)
glue([::AWSConfig], "UpdateDevEndpoint", EndpointName=, <keyword arguments>)

UpdateDevEndpoint Operation

Updates a specified DevEndpoint.

Arguments

EndpointName = ::String – Required

The name of the DevEndpoint to be updated.

PublicKey = ::String

The public key for the DevEndpoint to use.

CustomLibraries = [ ... ]

Custom Python or Java libraries to be loaded in the DevEndpoint.

 CustomLibraries = [
        "ExtraPythonLibsS3Path" =>  ::String,
        "ExtraJarsS3Path" =>  ::String
    ]

UpdateEtlLibraries = ::Bool

True if the list of custom libraries to be loaded in the development endpoint needs to be updated, or False otherwise.

Returns

UpdateDevEndpointResponse

Exceptions

EntityNotFoundException, InternalServiceException, OperationTimeoutException, InvalidInputException or ValidationException.

See also: AWS API Documentation

using AWSSDK.Glue.update_job
update_job([::AWSConfig], arguments::Dict)
update_job([::AWSConfig]; JobName=, JobUpdate=)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateJob", arguments::Dict)
glue([::AWSConfig], "UpdateJob", JobName=, JobUpdate=)

UpdateJob Operation

Updates an existing job definition.

Arguments

JobName = ::String – Required

Name of the job definition to update.

JobUpdate = [ ... ] – Required

Specifies the values with which to update the job.

 JobUpdate = [
        "Description" =>  ::String,
        "LogUri" =>  ::String,
        "Role" =>  ::String,
        "ExecutionProperty" =>  ["MaxConcurrentRuns" =>  ::Int],
        "Command" =>  [
            "Name" =>  ::String,
            "ScriptLocation" =>  ::String
        ],
        "DefaultArguments" =>  ::Dict{String,String},
        "Connections" =>  ["Connections" =>  [::String, ...]],
        "MaxRetries" =>  ::Int,
        "AllocatedCapacity" =>  ::Int
    ]

Returns

UpdateJobResponse

Exceptions

InvalidInputException, EntityNotFoundException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_partition
update_partition([::AWSConfig], arguments::Dict)
update_partition([::AWSConfig]; DatabaseName=, TableName=, PartitionValueList=, PartitionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdatePartition", arguments::Dict)
glue([::AWSConfig], "UpdatePartition", DatabaseName=, TableName=, PartitionValueList=, PartitionInput=, <keyword arguments>)

UpdatePartition Operation

Updates a partition.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the partition to be updated resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which the table in question resides.

TableName = ::String – Required

The name of the table where the partition to be updated is located.

PartitionValueList = [::String, ...] – Required

A list of the values defining the partition.

PartitionInput = [ ... ] – Required

The new partition object to which to update the partition.

 PartitionInput = [
        "Values" =>  [::String, ...],
        "LastAccessTime" =>  timestamp,
        "StorageDescriptor" =>  [
            "Columns" =>  [[
                "Name" => <required> ::String,
                "Type" =>  ::String,
                "Comment" =>  ::String
            ], ...],
            "Location" =>  ::String,
            "InputFormat" =>  ::String,
            "OutputFormat" =>  ::String,
            "Compressed" =>  ::Bool,
            "NumberOfBuckets" =>  ::Int,
            "SerdeInfo" =>  [
                "Name" =>  ::String,
                "SerializationLibrary" =>  ::String,
                "Parameters" =>  ::Dict{String,String}
            ],
            "BucketColumns" =>  [::String, ...],
            "SortColumns" =>  [[
                "Column" => <required> ::String,
                "SortOrder" => <required> ::Int
            ], ...],
            "Parameters" =>  ::Dict{String,String},
            "SkewedInfo" =>  [
                "SkewedColumnNames" =>  [::String, ...],
                "SkewedColumnValues" =>  [::String, ...],
                "SkewedColumnValueLocationMaps" =>  ::Dict{String,String}
            ],
            "StoredAsSubDirectories" =>  ::Bool
        ],
        "Parameters" =>  ::Dict{String,String},
        "LastAnalyzedTime" =>  timestamp
    ]

Returns

UpdatePartitionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_table
update_table([::AWSConfig], arguments::Dict)
update_table([::AWSConfig]; DatabaseName=, TableInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateTable", arguments::Dict)
glue([::AWSConfig], "UpdateTable", DatabaseName=, TableInput=, <keyword arguments>)

UpdateTable Operation

Updates a metadata table in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the table resides. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database in which the table resides.

TableInput = [ ... ] – Required

An updated TableInput object to define the metadata table in the catalog.

 TableInput = [
        "Name" => <required> ::String,
        "Description" =>  ::String,
        "Owner" =>  ::String,
        "LastAccessTime" =>  timestamp,
        "LastAnalyzedTime" =>  timestamp,
        "Retention" =>  ::Int,
        "StorageDescriptor" =>  [
            "Columns" =>  [[
                "Name" => <required> ::String,
                "Type" =>  ::String,
                "Comment" =>  ::String
            ], ...],
            "Location" =>  ::String,
            "InputFormat" =>  ::String,
            "OutputFormat" =>  ::String,
            "Compressed" =>  ::Bool,
            "NumberOfBuckets" =>  ::Int,
            "SerdeInfo" =>  [
                "Name" =>  ::String,
                "SerializationLibrary" =>  ::String,
                "Parameters" =>  ::Dict{String,String}
            ],
            "BucketColumns" =>  [::String, ...],
            "SortColumns" =>  [[
                "Column" => <required> ::String,
                "SortOrder" => <required> ::Int
            ], ...],
            "Parameters" =>  ::Dict{String,String},
            "SkewedInfo" =>  [
                "SkewedColumnNames" =>  [::String, ...],
                "SkewedColumnValues" =>  [::String, ...],
                "SkewedColumnValueLocationMaps" =>  ::Dict{String,String}
            ],
            "StoredAsSubDirectories" =>  ::Bool
        ],
        "PartitionKeys" =>  [[
            "Name" => <required> ::String,
            "Type" =>  ::String,
            "Comment" =>  ::String
        ], ...],
        "ViewOriginalText" =>  ::String,
        "ViewExpandedText" =>  ::String,
        "TableType" =>  ::String,
        "Parameters" =>  ::Dict{String,String}
    ]

Returns

UpdateTableResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException, OperationTimeoutException or ConcurrentModificationException.

See also: AWS API Documentation

using AWSSDK.Glue.update_trigger
update_trigger([::AWSConfig], arguments::Dict)
update_trigger([::AWSConfig]; Name=, TriggerUpdate=)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateTrigger", arguments::Dict)
glue([::AWSConfig], "UpdateTrigger", Name=, TriggerUpdate=)

UpdateTrigger Operation

Updates a trigger definition.

Arguments

Name = ::String – Required

The name of the trigger to update.

TriggerUpdate = [ ... ] – Required

The new values with which to update the trigger.

 TriggerUpdate = [
        "Name" =>  ::String,
        "Description" =>  ::String,
        "Schedule" =>  ::String,
        "Actions" =>  [[
            "JobName" =>  ::String,
            "Arguments" =>  ::Dict{String,String}
        ], ...],
        "Predicate" =>  [
            "Logical" =>  "AND",
            "Conditions" =>  [[
                "LogicalOperator" =>  "EQUALS",
                "JobName" =>  ::String,
                "State" =>  "STARTING", "RUNNING", "STOPPING", "STOPPED", "SUCCEEDED" or "FAILED"
            ], ...]
        ]
    ]

Returns

UpdateTriggerResponse

Exceptions

InvalidInputException, InternalServiceException, EntityNotFoundException or OperationTimeoutException.

See also: AWS API Documentation

using AWSSDK.Glue.update_user_defined_function
update_user_defined_function([::AWSConfig], arguments::Dict)
update_user_defined_function([::AWSConfig]; DatabaseName=, FunctionName=, FunctionInput=, <keyword arguments>)

using AWSCore.Services.glue
glue([::AWSConfig], "UpdateUserDefinedFunction", arguments::Dict)
glue([::AWSConfig], "UpdateUserDefinedFunction", DatabaseName=, FunctionName=, FunctionInput=, <keyword arguments>)

UpdateUserDefinedFunction Operation

Updates an existing function definition in the Data Catalog.

Arguments

CatalogId = ::String

The ID of the Data Catalog where the function to be updated is located. If none is supplied, the AWS account ID is used by default.

DatabaseName = ::String – Required

The name of the catalog database where the function to be updated is located.

FunctionName = ::String – Required

The name of the function.

FunctionInput = [ ... ] – Required

A FunctionInput object that re-defines the function in the Data Catalog.

 FunctionInput = [
        "FunctionName" =>  ::String,
        "ClassName" =>  ::String,
        "OwnerName" =>  ::String,
        "OwnerType" =>  "USER", "ROLE" or "GROUP",
        "ResourceUris" =>  [[
            "ResourceType" =>  "JAR", "FILE" or "ARCHIVE",
            "Uri" =>  ::String
        ], ...]
    ]

Returns

UpdateUserDefinedFunctionResponse

Exceptions

EntityNotFoundException, InvalidInputException, InternalServiceException or OperationTimeoutException.

See also: AWS API Documentation