Glue / Client / update_job

update_job#

Glue.Client.update_job(**kwargs)#

Updates an existing job definition. The previous job definition is completely overwritten by this information.

Request Syntax

response = client.update_job(
    JobName='string',
    JobUpdate={
        'Description': 'string',
        'LogUri': 'string',
        'Role': 'string',
        'ExecutionProperty': {
            'MaxConcurrentRuns': 123
        },
        'Command': {
            'Name': 'string',
            'ScriptLocation': 'string',
            'PythonVersion': 'string'
        },
        'DefaultArguments': {
            'string': 'string'
        },
        'NonOverridableArguments': {
            'string': 'string'
        },
        'Connections': {
            'Connections': [
                'string',
            ]
        },
        'MaxRetries': 123,
        'AllocatedCapacity': 123,
        'Timeout': 123,
        'MaxCapacity': 123.0,
        'WorkerType': 'Standard'|'G.1X'|'G.2X'|'G.025X'|'G.4X'|'G.8X',
        'NumberOfWorkers': 123,
        'SecurityConfiguration': 'string',
        'NotificationProperty': {
            'NotifyDelayAfter': 123
        },
        'GlueVersion': 'string',
        'CodeGenConfigurationNodes': {
            'string': {
                'AthenaConnectorSource': {
                    'Name': 'string',
                    'ConnectionName': 'string',
                    'ConnectorName': 'string',
                    'ConnectionType': 'string',
                    'ConnectionTable': 'string',
                    'SchemaName': 'string',
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'JDBCConnectorSource': {
                    'Name': 'string',
                    'ConnectionName': 'string',
                    'ConnectorName': 'string',
                    'ConnectionType': 'string',
                    'AdditionalOptions': {
                        'FilterPredicate': 'string',
                        'PartitionColumn': 'string',
                        'LowerBound': 123,
                        'UpperBound': 123,
                        'NumPartitions': 123,
                        'JobBookmarkKeys': [
                            'string',
                        ],
                        'JobBookmarkKeysSortOrder': 'string',
                        'DataTypeMapping': {
                            'string': 'DATE'|'STRING'|'TIMESTAMP'|'INT'|'FLOAT'|'LONG'|'BIGDECIMAL'|'BYTE'|'SHORT'|'DOUBLE'
                        }
                    },
                    'ConnectionTable': 'string',
                    'Query': 'string',
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'SparkConnectorSource': {
                    'Name': 'string',
                    'ConnectionName': 'string',
                    'ConnectorName': 'string',
                    'ConnectionType': 'string',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'CatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'RedshiftSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'RedshiftTmpDir': 'string',
                    'TmpDirIAMRole': 'string'
                },
                'S3CatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'PartitionPredicate': 'string',
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123
                    }
                },
                'S3CsvSource': {
                    'Name': 'string',
                    'Paths': [
                        'string',
                    ],
                    'CompressionType': 'gzip'|'bzip2',
                    'Exclusions': [
                        'string',
                    ],
                    'GroupSize': 'string',
                    'GroupFiles': 'string',
                    'Recurse': True|False,
                    'MaxBand': 123,
                    'MaxFilesInBand': 123,
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123,
                        'EnableSamplePath': True|False,
                        'SamplePath': 'string'
                    },
                    'Separator': 'comma'|'ctrla'|'pipe'|'semicolon'|'tab',
                    'Escaper': 'string',
                    'QuoteChar': 'quote'|'quillemet'|'single_quote'|'disabled',
                    'Multiline': True|False,
                    'WithHeader': True|False,
                    'WriteHeader': True|False,
                    'SkipFirst': True|False,
                    'OptimizePerformance': True|False,
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3JsonSource': {
                    'Name': 'string',
                    'Paths': [
                        'string',
                    ],
                    'CompressionType': 'gzip'|'bzip2',
                    'Exclusions': [
                        'string',
                    ],
                    'GroupSize': 'string',
                    'GroupFiles': 'string',
                    'Recurse': True|False,
                    'MaxBand': 123,
                    'MaxFilesInBand': 123,
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123,
                        'EnableSamplePath': True|False,
                        'SamplePath': 'string'
                    },
                    'JsonPath': 'string',
                    'Multiline': True|False,
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3ParquetSource': {
                    'Name': 'string',
                    'Paths': [
                        'string',
                    ],
                    'CompressionType': 'snappy'|'lzo'|'gzip'|'uncompressed'|'none',
                    'Exclusions': [
                        'string',
                    ],
                    'GroupSize': 'string',
                    'GroupFiles': 'string',
                    'Recurse': True|False,
                    'MaxBand': 123,
                    'MaxFilesInBand': 123,
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123,
                        'EnableSamplePath': True|False,
                        'SamplePath': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'RelationalCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'DynamoDBCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'JDBCConnectorTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'ConnectionName': 'string',
                    'ConnectionTable': 'string',
                    'ConnectorName': 'string',
                    'ConnectionType': 'string',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'SparkConnectorTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'ConnectionName': 'string',
                    'ConnectorName': 'string',
                    'ConnectionType': 'string',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'CatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string'
                },
                'RedshiftTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string',
                    'RedshiftTmpDir': 'string',
                    'TmpDirIAMRole': 'string',
                    'UpsertRedshiftOptions': {
                        'TableLocation': 'string',
                        'ConnectionName': 'string',
                        'UpsertKeys': [
                            'string',
                        ]
                    }
                },
                'S3CatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Table': 'string',
                    'Database': 'string',
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG'
                    }
                },
                'S3GlueParquetTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Path': 'string',
                    'Compression': 'snappy'|'lzo'|'gzip'|'uncompressed'|'none',
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG',
                        'Table': 'string',
                        'Database': 'string'
                    }
                },
                'S3DirectTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Path': 'string',
                    'Compression': 'string',
                    'Format': 'json'|'csv'|'avro'|'orc'|'parquet'|'hudi'|'delta',
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG',
                        'Table': 'string',
                        'Database': 'string'
                    }
                },
                'ApplyMapping': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Mapping': [
                        {
                            'ToKey': 'string',
                            'FromPath': [
                                'string',
                            ],
                            'FromType': 'string',
                            'ToType': 'string',
                            'Dropped': True|False,
                            'Children': {'... recursive ...'}
                        },
                    ]
                },
                'SelectFields': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Paths': [
                        [
                            'string',
                        ],
                    ]
                },
                'DropFields': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Paths': [
                        [
                            'string',
                        ],
                    ]
                },
                'RenameField': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'SourcePath': [
                        'string',
                    ],
                    'TargetPath': [
                        'string',
                    ]
                },
                'Spigot': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Path': 'string',
                    'Topk': 123,
                    'Prob': 123.0
                },
                'Join': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'JoinType': 'equijoin'|'left'|'right'|'outer'|'leftsemi'|'leftanti',
                    'Columns': [
                        {
                            'From': 'string',
                            'Keys': [
                                [
                                    'string',
                                ],
                            ]
                        },
                    ]
                },
                'SplitFields': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Paths': [
                        [
                            'string',
                        ],
                    ]
                },
                'SelectFromCollection': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Index': 123
                },
                'FillMissingValues': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'ImputedPath': 'string',
                    'FilledPath': 'string'
                },
                'Filter': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'LogicalOperator': 'AND'|'OR',
                    'Filters': [
                        {
                            'Operation': 'EQ'|'LT'|'GT'|'LTE'|'GTE'|'REGEX'|'ISNULL',
                            'Negated': True|False,
                            'Values': [
                                {
                                    'Type': 'COLUMNEXTRACTED'|'CONSTANT',
                                    'Value': [
                                        'string',
                                    ]
                                },
                            ]
                        },
                    ]
                },
                'CustomCode': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Code': 'string',
                    'ClassName': 'string',
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'SparkSQL': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'SqlQuery': 'string',
                    'SqlAliases': [
                        {
                            'From': 'string',
                            'Alias': 'string'
                        },
                    ],
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'DirectKinesisSource': {
                    'Name': 'string',
                    'WindowSize': 123,
                    'DetectSchema': True|False,
                    'StreamingOptions': {
                        'EndpointUrl': 'string',
                        'StreamName': 'string',
                        'Classification': 'string',
                        'Delimiter': 'string',
                        'StartingPosition': 'latest'|'trim_horizon'|'earliest',
                        'MaxFetchTimeInMs': 123,
                        'MaxFetchRecordsPerShard': 123,
                        'MaxRecordPerRead': 123,
                        'AddIdleTimeBetweenReads': True|False,
                        'IdleTimeBetweenReadsInMs': 123,
                        'DescribeShardInterval': 123,
                        'NumRetries': 123,
                        'RetryIntervalMs': 123,
                        'MaxRetryIntervalMs': 123,
                        'AvoidEmptyBatches': True|False,
                        'StreamArn': 'string',
                        'RoleArn': 'string',
                        'RoleSessionName': 'string',
                        'AddRecordTimestamp': 'string',
                        'EmitConsumerLagMetrics': 'string'
                    },
                    'DataPreviewOptions': {
                        'PollingTime': 123,
                        'RecordPollingLimit': 123
                    }
                },
                'DirectKafkaSource': {
                    'Name': 'string',
                    'StreamingOptions': {
                        'BootstrapServers': 'string',
                        'SecurityProtocol': 'string',
                        'ConnectionName': 'string',
                        'TopicName': 'string',
                        'Assign': 'string',
                        'SubscribePattern': 'string',
                        'Classification': 'string',
                        'Delimiter': 'string',
                        'StartingOffsets': 'string',
                        'EndingOffsets': 'string',
                        'PollTimeoutMs': 123,
                        'NumRetries': 123,
                        'RetryIntervalMs': 123,
                        'MaxOffsetsPerTrigger': 123,
                        'MinPartitions': 123,
                        'IncludeHeaders': True|False,
                        'AddRecordTimestamp': 'string',
                        'EmitConsumerLagMetrics': 'string'
                    },
                    'WindowSize': 123,
                    'DetectSchema': True|False,
                    'DataPreviewOptions': {
                        'PollingTime': 123,
                        'RecordPollingLimit': 123
                    }
                },
                'CatalogKinesisSource': {
                    'Name': 'string',
                    'WindowSize': 123,
                    'DetectSchema': True|False,
                    'Table': 'string',
                    'Database': 'string',
                    'StreamingOptions': {
                        'EndpointUrl': 'string',
                        'StreamName': 'string',
                        'Classification': 'string',
                        'Delimiter': 'string',
                        'StartingPosition': 'latest'|'trim_horizon'|'earliest',
                        'MaxFetchTimeInMs': 123,
                        'MaxFetchRecordsPerShard': 123,
                        'MaxRecordPerRead': 123,
                        'AddIdleTimeBetweenReads': True|False,
                        'IdleTimeBetweenReadsInMs': 123,
                        'DescribeShardInterval': 123,
                        'NumRetries': 123,
                        'RetryIntervalMs': 123,
                        'MaxRetryIntervalMs': 123,
                        'AvoidEmptyBatches': True|False,
                        'StreamArn': 'string',
                        'RoleArn': 'string',
                        'RoleSessionName': 'string',
                        'AddRecordTimestamp': 'string',
                        'EmitConsumerLagMetrics': 'string'
                    },
                    'DataPreviewOptions': {
                        'PollingTime': 123,
                        'RecordPollingLimit': 123
                    }
                },
                'CatalogKafkaSource': {
                    'Name': 'string',
                    'WindowSize': 123,
                    'DetectSchema': True|False,
                    'Table': 'string',
                    'Database': 'string',
                    'StreamingOptions': {
                        'BootstrapServers': 'string',
                        'SecurityProtocol': 'string',
                        'ConnectionName': 'string',
                        'TopicName': 'string',
                        'Assign': 'string',
                        'SubscribePattern': 'string',
                        'Classification': 'string',
                        'Delimiter': 'string',
                        'StartingOffsets': 'string',
                        'EndingOffsets': 'string',
                        'PollTimeoutMs': 123,
                        'NumRetries': 123,
                        'RetryIntervalMs': 123,
                        'MaxOffsetsPerTrigger': 123,
                        'MinPartitions': 123,
                        'IncludeHeaders': True|False,
                        'AddRecordTimestamp': 'string',
                        'EmitConsumerLagMetrics': 'string'
                    },
                    'DataPreviewOptions': {
                        'PollingTime': 123,
                        'RecordPollingLimit': 123
                    }
                },
                'DropNullFields': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'NullCheckBoxList': {
                        'IsEmpty': True|False,
                        'IsNullString': True|False,
                        'IsNegOne': True|False
                    },
                    'NullTextList': [
                        {
                            'Value': 'string',
                            'Datatype': {
                                'Id': 'string',
                                'Label': 'string'
                            }
                        },
                    ]
                },
                'Merge': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Source': 'string',
                    'PrimaryKeys': [
                        [
                            'string',
                        ],
                    ]
                },
                'Union': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'UnionType': 'ALL'|'DISTINCT'
                },
                'PIIDetection': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PiiType': 'RowAudit'|'RowMasking'|'ColumnAudit'|'ColumnMasking',
                    'EntityTypesToDetect': [
                        'string',
                    ],
                    'OutputColumnName': 'string',
                    'SampleFraction': 123.0,
                    'ThresholdFraction': 123.0,
                    'MaskValue': 'string'
                },
                'Aggregate': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Groups': [
                        [
                            'string',
                        ],
                    ],
                    'Aggs': [
                        {
                            'Column': [
                                'string',
                            ],
                            'AggFunc': 'avg'|'countDistinct'|'count'|'first'|'last'|'kurtosis'|'max'|'min'|'skewness'|'stddev_samp'|'stddev_pop'|'sum'|'sumDistinct'|'var_samp'|'var_pop'
                        },
                    ]
                },
                'DropDuplicates': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Columns': [
                        [
                            'string',
                        ],
                    ]
                },
                'GovernedCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Table': 'string',
                    'Database': 'string',
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG'
                    }
                },
                'GovernedCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'PartitionPredicate': 'string',
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123
                    }
                },
                'MicrosoftSQLServerCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'MySQLCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'OracleSQLCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'PostgreSQLCatalogSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string'
                },
                'MicrosoftSQLServerCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string'
                },
                'MySQLCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string'
                },
                'OracleSQLCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string'
                },
                'PostgreSQLCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Database': 'string',
                    'Table': 'string'
                },
                'DynamicTransform': {
                    'Name': 'string',
                    'TransformName': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Parameters': [
                        {
                            'Name': 'string',
                            'Type': 'str'|'int'|'float'|'complex'|'bool'|'list'|'null',
                            'ValidationRule': 'string',
                            'ValidationMessage': 'string',
                            'Value': [
                                'string',
                            ],
                            'ListType': 'str'|'int'|'float'|'complex'|'bool'|'list'|'null',
                            'IsOptional': True|False
                        },
                    ],
                    'FunctionName': 'string',
                    'Path': 'string',
                    'Version': 'string'
                },
                'EvaluateDataQuality': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Ruleset': 'string',
                    'Output': 'PrimaryInput'|'EvaluationResults',
                    'PublishingOptions': {
                        'EvaluationContext': 'string',
                        'ResultsS3Prefix': 'string',
                        'CloudWatchMetricsEnabled': True|False,
                        'ResultsPublishingEnabled': True|False
                    },
                    'StopJobOnFailureOptions': {
                        'StopJobOnFailureTiming': 'Immediate'|'AfterDataLoad'
                    }
                },
                'S3CatalogHudiSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'AdditionalHudiOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'CatalogHudiSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'AdditionalHudiOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3HudiSource': {
                    'Name': 'string',
                    'Paths': [
                        'string',
                    ],
                    'AdditionalHudiOptions': {
                        'string': 'string'
                    },
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123,
                        'EnableSamplePath': True|False,
                        'SamplePath': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3HudiCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Table': 'string',
                    'Database': 'string',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG'
                    }
                },
                'S3HudiDirectTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'Path': 'string',
                    'Compression': 'gzip'|'lzo'|'uncompressed'|'snappy',
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Format': 'json'|'csv'|'avro'|'orc'|'parquet'|'hudi'|'delta',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG',
                        'Table': 'string',
                        'Database': 'string'
                    }
                },
                'DirectJDBCSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'ConnectionName': 'string',
                    'ConnectionType': 'sqlserver'|'mysql'|'oracle'|'postgresql'|'redshift',
                    'RedshiftTmpDir': 'string'
                },
                'S3CatalogDeltaSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'AdditionalDeltaOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'CatalogDeltaSource': {
                    'Name': 'string',
                    'Database': 'string',
                    'Table': 'string',
                    'AdditionalDeltaOptions': {
                        'string': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3DeltaSource': {
                    'Name': 'string',
                    'Paths': [
                        'string',
                    ],
                    'AdditionalDeltaOptions': {
                        'string': 'string'
                    },
                    'AdditionalOptions': {
                        'BoundedSize': 123,
                        'BoundedFiles': 123,
                        'EnableSamplePath': True|False,
                        'SamplePath': 'string'
                    },
                    'OutputSchemas': [
                        {
                            'Columns': [
                                {
                                    'Name': 'string',
                                    'Type': 'string'
                                },
                            ]
                        },
                    ]
                },
                'S3DeltaCatalogTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Table': 'string',
                    'Database': 'string',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG'
                    }
                },
                'S3DeltaDirectTarget': {
                    'Name': 'string',
                    'Inputs': [
                        'string',
                    ],
                    'PartitionKeys': [
                        [
                            'string',
                        ],
                    ],
                    'Path': 'string',
                    'Compression': 'uncompressed'|'snappy',
                    'Format': 'json'|'csv'|'avro'|'orc'|'parquet'|'hudi'|'delta',
                    'AdditionalOptions': {
                        'string': 'string'
                    },
                    'SchemaChangePolicy': {
                        'EnableUpdateCatalog': True|False,
                        'UpdateBehavior': 'UPDATE_IN_DATABASE'|'LOG',
                        'Table': 'string',
                        'Database': 'string'
                    }
                }
            }
        },
        'ExecutionClass': 'FLEX'|'STANDARD',
        'SourceControlDetails': {
            'Provider': 'GITHUB'|'AWS_CODE_COMMIT',
            'Repository': 'string',
            'Owner': 'string',
            'Branch': 'string',
            'Folder': 'string',
            'LastCommitId': 'string',
            'AuthStrategy': 'PERSONAL_ACCESS_TOKEN'|'AWS_SECRETS_MANAGER',
            'AuthToken': 'string'
        }
    }
)


**Parameters**
::

    # This section is too large to render.
    # Please see the AWS API Documentation linked below.

`AWS API Documentation <https://docs.aws.amazon.com/goto/WebAPI/glue-2017-03-31/UpdateJob>`_

Return type:

dict

Returns:

Response Syntax

{
    'JobName': 'string'
}

Response Structure

(dict) –
- JobName (string) –
  
  Returns the name of the updated job definition.

Exceptions

Glue.Client.exceptions.InvalidInputException
Glue.Client.exceptions.EntityNotFoundException
Glue.Client.exceptions.InternalServiceException
Glue.Client.exceptions.OperationTimeoutException
Glue.Client.exceptions.ConcurrentModificationException