Glue / Client / update_table

update_table¶

Glue.Client.update_table(**kwargs)¶

Updates a metadata table in the Data Catalog.

Request Syntax

response = client.update_table(
    CatalogId='string',
    DatabaseName='string',
    Name='string',
    TableInput={
        'Name': 'string',
        'Description': 'string',
        'Owner': 'string',
        'LastAccessTime': datetime(2015, 1, 1),
        'LastAnalyzedTime': datetime(2015, 1, 1),
        'Retention': 123,
        'StorageDescriptor': {
            'Columns': [
                {
                    'Name': 'string',
                    'Type': 'string',
                    'Comment': 'string',
                    'Parameters': {
                        'string': 'string'
                    }
                },
            ],
            'Location': 'string',
            'AdditionalLocations': [
                'string',
            ],
            'InputFormat': 'string',
            'OutputFormat': 'string',
            'Compressed': True|False,
            'NumberOfBuckets': 123,
            'SerdeInfo': {
                'Name': 'string',
                'SerializationLibrary': 'string',
                'Parameters': {
                    'string': 'string'
                }
            },
            'BucketColumns': [
                'string',
            ],
            'SortColumns': [
                {
                    'Column': 'string',
                    'SortOrder': 123
                },
            ],
            'Parameters': {
                'string': 'string'
            },
            'SkewedInfo': {
                'SkewedColumnNames': [
                    'string',
                ],
                'SkewedColumnValues': [
                    'string',
                ],
                'SkewedColumnValueLocationMaps': {
                    'string': 'string'
                }
            },
            'StoredAsSubDirectories': True|False,
            'SchemaReference': {
                'SchemaId': {
                    'SchemaArn': 'string',
                    'SchemaName': 'string',
                    'RegistryName': 'string'
                },
                'SchemaVersionId': 'string',
                'SchemaVersionNumber': 123
            }
        },
        'PartitionKeys': [
            {
                'Name': 'string',
                'Type': 'string',
                'Comment': 'string',
                'Parameters': {
                    'string': 'string'
                }
            },
        ],
        'ViewOriginalText': 'string',
        'ViewExpandedText': 'string',
        'TableType': 'string',
        'Parameters': {
            'string': 'string'
        },
        'TargetTable': {
            'CatalogId': 'string',
            'DatabaseName': 'string',
            'Name': 'string',
            'Region': 'string'
        },
        'ViewDefinition': {
            'IsProtected': True|False,
            'Definer': 'string',
            'Representations': [
                {
                    'Dialect': 'REDSHIFT'|'ATHENA'|'SPARK',
                    'DialectVersion': 'string',
                    'ViewOriginalText': 'string',
                    'ValidationConnection': 'string',
                    'ViewExpandedText': 'string'
                },
            ],
            'SubObjects': [
                'string',
            ]
        }
    },
    SkipArchive=True|False,
    TransactionId='string',
    VersionId='string',
    ViewUpdateAction='ADD'|'REPLACE'|'ADD_OR_REPLACE'|'DROP',
    Force=True|False,
    UpdateOpenTableFormatInput={
        'UpdateIcebergInput': {
            'UpdateIcebergTableInput': {
                'Updates': [
                    {
                        'Schema': {
                            'SchemaId': 123,
                            'IdentifierFieldIds': [
                                123,
                            ],
                            'Type': 'struct',
                            'Fields': [
                                {
                                    'Id': 123,
                                    'Name': 'string',
                                    'Type': {...}|[...]|123|123.4|'string'|True|None,
                                    'Required': True|False,
                                    'Doc': 'string'
                                },
                            ]
                        },
                        'PartitionSpec': {
                            'Fields': [
                                {
                                    'SourceId': 123,
                                    'Transform': 'string',
                                    'Name': 'string',
                                    'FieldId': 123
                                },
                            ],
                            'SpecId': 123
                        },
                        'SortOrder': {
                            'OrderId': 123,
                            'Fields': [
                                {
                                    'SourceId': 123,
                                    'Transform': 'string',
                                    'Direction': 'asc'|'desc',
                                    'NullOrder': 'nulls-first'|'nulls-last'
                                },
                            ]
                        },
                        'Location': 'string',
                        'Properties': {
                            'string': 'string'
                        }
                    },
                ]
            }
        }
    }
)

Parameters:

CatalogId (string) – The ID of the Data Catalog where the table resides. If none is provided, the Amazon Web Services account ID is used by default.
DatabaseName (string) –
[REQUIRED]

The name of the catalog database in which the table resides. For Hive compatibility, this name is entirely lowercase.
Name (string) – The unique identifier for the table within the specified database that will be created in the Glue Data Catalog.
TableInput (dict) –
An updated TableInput object to define the metadata table in the catalog.
- Name (string) – [REQUIRED]
  
  The table name. For Hive compatibility, this is folded to lowercase when it is stored.
- Description (string) –
  
  A description of the table.
- Owner (string) –
  
  The table owner. Included for Apache Hive compatibility. Not used in the normal course of Glue operations.
- LastAccessTime (datetime) –
  
  The last time that the table was accessed.
- LastAnalyzedTime (datetime) –
  
  The last time that column statistics were computed for this table.
- Retention (integer) –
  
  The retention time for this table.
- StorageDescriptor (dict) –
  
  A storage descriptor containing information about the physical storage of this table.
  - Columns (list) –
    
    A list of the Columns in the table.
    - (dict) –
      
      A column in a Table.
      - Name (string) – [REQUIRED]
        
        The name of the Column.
      - Type (string) –
        
        The data type of the Column.
      - Comment (string) –
        
        A free-form text comment.
      - Parameters (dict) –
        
        These key-value pairs define properties associated with the column.
        
        (string) –
        
        (string) –
  - Location (string) –
    
    The physical location of the table. By default, this takes the form of the warehouse location, followed by the database location in the warehouse, followed by the table name.
  - AdditionalLocations (list) –
    
    A list of locations that point to the path where a Delta table is located.
    - (string) –
  - InputFormat (string) –
    
    The input format: SequenceFileInputFormat (binary), or TextInputFormat, or a custom format.
  - OutputFormat (string) –
    
    The output format: SequenceFileOutputFormat (binary), or IgnoreKeyTextOutputFormat, or a custom format.
  - Compressed (boolean) –
    
    True if the data in the table is compressed, or False if not.
  - NumberOfBuckets (integer) –
    
    Must be specified if the table contains any dimension columns.
  - SerdeInfo (dict) –
    
    The serialization/deserialization (SerDe) information.
    - Name (string) –
      
      Name of the SerDe.
    - SerializationLibrary (string) –
      
      Usually the class that implements the SerDe. An example is org.apache.hadoop.hive.serde2.columnar.ColumnarSerDe.
    - Parameters (dict) –
      
      These key-value pairs define initialization parameters for the SerDe.
      - (string) –
        
        (string) –
  - BucketColumns (list) –
    
    A list of reducer grouping columns, clustering columns, and bucketing columns in the table.
    - (string) –
  - SortColumns (list) –
    
    A list specifying the sort order of each bucket in the table.
    - (dict) –
      
      Specifies the sort order of a sorted column.
      - Column (string) – [REQUIRED]
        
        The name of the column.
      - SortOrder (integer) – [REQUIRED]
        
        Indicates that the column is sorted in ascending order ( == 1), or in descending order ( ==0).
  - Parameters (dict) –
    
    The user-supplied properties in key-value form.
    - (string) –
      - (string) –
  - SkewedInfo (dict) –
    
    The information about values that appear frequently in a column (skewed values).
    - SkewedColumnNames (list) –
      
      A list of names of columns that contain skewed values.
      - (string) –
    - SkewedColumnValues (list) –
      
      A list of values that appear so frequently as to be considered skewed.
      - (string) –
    - SkewedColumnValueLocationMaps (dict) –
      
      A mapping of skewed values to the columns that contain them.
      - (string) –
        
        (string) –
  - StoredAsSubDirectories (boolean) –
    
    True if the table data is stored in subdirectories, or False if not.
  - SchemaReference (dict) –
    
    An object that references a schema stored in the Glue Schema Registry.
    
    When creating a table, you can pass an empty list of columns for the schema, and instead use a schema reference.
    - SchemaId (dict) –
      
      A structure that contains schema identity fields. Either this or the SchemaVersionId has to be provided.
      - SchemaArn (string) –
        
        The Amazon Resource Name (ARN) of the schema. One of SchemaArn or SchemaName has to be provided.
      - SchemaName (string) –
        
        The name of the schema. One of SchemaArn or SchemaName has to be provided.
      - RegistryName (string) –
        
        The name of the schema registry that contains the schema.
    - SchemaVersionId (string) –
      
      The unique ID assigned to a version of the schema. Either this or the SchemaId has to be provided.
    - SchemaVersionNumber (integer) –
      
      The version number of the schema.
- PartitionKeys (list) –
  
  A list of columns by which the table is partitioned. Only primitive types are supported as partition keys.
  
  When you create a table used by Amazon Athena, and you do not specify any partitionKeys, you must at least set the value of partitionKeys to an empty list. For example:
  
  "PartitionKeys": []
  - (dict) –
    
    A column in a Table.
    - Name (string) – [REQUIRED]
      
      The name of the Column.
    - Type (string) –
      
      The data type of the Column.
    - Comment (string) –
      
      A free-form text comment.
    - Parameters (dict) –
      
      These key-value pairs define properties associated with the column.
      - (string) –
        
        (string) –
- ViewOriginalText (string) –
  
  Included for Apache Hive compatibility. Not used in the normal course of Glue operations. If the table is a VIRTUAL_VIEW, certain Athena configuration encoded in base64.
- ViewExpandedText (string) –
  
  Included for Apache Hive compatibility. Not used in the normal course of Glue operations.
- TableType (string) –
  
  The type of this table. Glue will create tables with the EXTERNAL_TABLE type. Other services, such as Athena, may create tables with additional table types.
  
  Glue related table types:
  
  EXTERNAL_TABLE
  
  Hive compatible attribute - indicates a non-Hive managed table.
  
  GOVERNED
  
  Used by Lake Formation. The Glue Data Catalog understands GOVERNED.
- Parameters (dict) –
  
  These key-value pairs define properties associated with the table.
  - (string) –
    - (string) –
- TargetTable (dict) –
  
  A TableIdentifier structure that describes a target table for resource linking.
  - CatalogId (string) –
    
    The ID of the Data Catalog in which the table resides.
  - DatabaseName (string) –
    
    The name of the catalog database that contains the target table.
  - Name (string) –
    
    The name of the target table.
  - Region (string) –
    
    Region of the target table.
- ViewDefinition (dict) –
  
  A structure that contains all the information that defines the view, including the dialect or dialects for the view, and the query.
  - IsProtected (boolean) –
    
    You can set this flag as true to instruct the engine not to push user-provided operations into the logical plan of the view during query planning. However, setting this flag does not guarantee that the engine will comply. Refer to the engine’s documentation to understand the guarantees provided, if any.
  - Definer (string) –
    
    The definer of a view in SQL.
  - Representations (list) –
    
    A list of structures that contains the dialect of the view, and the query that defines the view.
    - (dict) –
      
      A structure containing details of a representation to update or create a Lake Formation view.
      - Dialect (string) –
        
        A parameter that specifies the engine type of a specific representation.
      - DialectVersion (string) –
        
        A parameter that specifies the version of the engine of a specific representation.
      - ViewOriginalText (string) –
        
        A string that represents the original SQL query that describes the view.
      - ValidationConnection (string) –
        
        The name of the connection to be used to validate the specific representation of the view.
      - ViewExpandedText (string) –
        
        A string that represents the SQL query that describes the view with expanded resource ARNs
  - SubObjects (list) –
    
    A list of base table ARNs that make up the view.
    - (string) –
SkipArchive (boolean) – By default, UpdateTable always creates an archived version of the table before updating it. However, if skipArchive is set to true, UpdateTable does not create the archived version.
TransactionId (string) – The transaction ID at which to update the table contents.
VersionId (string) – The version ID at which to update the table contents.
ViewUpdateAction (string) – The operation to be performed when updating the view.
Force (boolean) – A flag that can be set to true to ignore matching storage descriptor and subobject matching requirements.
UpdateOpenTableFormatInput (dict) –
Input parameters for updating open table format tables in GlueData Catalog, serving as a wrapper for format-specific update operations such as Apache Iceberg.
- UpdateIcebergInput (dict) –
  
  Apache Iceberg-specific update parameters that define the table modifications to be applied, including schema changes, partition specifications, and table properties.
  - UpdateIcebergTableInput (dict) – [REQUIRED]
    
    The specific update operations to be applied to the Iceberg table, containing a list of updates that define the new state of the table including schema, partitions, and properties.
    - Updates (list) – [REQUIRED]
      
      The list of table update operations that specify the changes to be made to the Iceberg table, including schema modifications, partition specifications, and table properties.
      - (dict) –
        
        Defines a complete set of updates to be applied to an Iceberg table, including schema changes, partitioning modifications, sort order adjustments, location updates, and property changes.
        
        Schema (dict) – [REQUIRED]
        
        The updated schema definition for the Iceberg table, specifying any changes to field structure, data types, or schema metadata.
        
        SchemaId (integer) –
        
        The unique identifier for this schema version within the Iceberg table’s schema evolution history.
        
        IdentifierFieldIds (list) –
        
        The list of field identifiers that uniquely identify records in the table, used for row-level operations and deduplication.
        
        (integer) –
        
        Type (string) –
        
        The root type of the schema structure, typically “struct” for Iceberg table schemas.
        
        Fields (list) – [REQUIRED]
        
        The list of field definitions that make up the table schema, including field names, types, and metadata.
        
        (dict) –
        
        Defines a single field within an Iceberg table schema, including its identifier, name, data type, nullability, and documentation.
        
        Id (integer) – [REQUIRED]
        
        The unique identifier assigned to this field within the Iceberg table schema, used for schema evolution and field tracking.
        
        Name (string) – [REQUIRED]
        
        The name of the field as it appears in the table schema and query operations.
        
        Type (document) – [REQUIRED]
        
        The data type definition for this field, specifying the structure and format of the data it contains.
        
        Required (boolean) – [REQUIRED]
        
        Indicates whether this field is required (non-nullable) or optional (nullable) in the table schema.
        
        Doc (string) –
        
        Optional documentation or description text that provides additional context about the purpose and usage of this field.
        
        PartitionSpec (dict) –
        
        The updated partitioning specification that defines how the table data should be reorganized and partitioned.
        
        Fields (list) – [REQUIRED]
        
        The list of partition fields that define how the table data should be partitioned, including source fields and their transformations.
        
        (dict) –
        
        Defines a single partition field within an Iceberg partition specification, including the source field, transformation function, partition name, and unique identifier.
        
        SourceId (integer) – [REQUIRED]
        
        The identifier of the source field from the table schema that this partition field is based on.
        
        Transform (string) – [REQUIRED]
        
        The transformation function applied to the source field to create the partition, such as identity, bucket, truncate, year, month, day, or hour.
        
        Name (string) – [REQUIRED]
        
        The name of the partition field as it will appear in the partitioned table structure.
        
        FieldId (integer) –
        
        The unique identifier assigned to this partition field within the Iceberg table’s partition specification.
        
        SpecId (integer) –
        
        The unique identifier for this partition specification within the Iceberg table’s metadata history.
        
        SortOrder (dict) –
        
        The updated sort order specification that defines how data should be ordered within partitions for optimal query performance.
        
        OrderId (integer) – [REQUIRED]
        
        The unique identifier for this sort order specification within the Iceberg table’s metadata.
        
        Fields (list) – [REQUIRED]
        
        The list of fields and their sort directions that define the ordering criteria for the Iceberg table data.
        
        (dict) –
        
        Defines a single field within an Iceberg sort order specification, including the source field, transformation, sort direction, and null value ordering.
        
        SourceId (integer) – [REQUIRED]
        
        The identifier of the source field from the table schema that this sort field is based on.
        
        Transform (string) – [REQUIRED]
        
        The transformation function applied to the source field before sorting, such as identity, bucket, or truncate.
        
        Direction (string) – [REQUIRED]
        
        The sort direction for this field, either ascending or descending.
        
        NullOrder (string) – [REQUIRED]
        
        The ordering behavior for null values in this field, specifying whether nulls should appear first or last in the sort order.
        
        Location (string) – [REQUIRED]
        
        The updated S3 location where the Iceberg table data will be stored.
        
        Properties (dict) –
        
        Updated key-value pairs of table properties and configuration settings for the Iceberg table.
        
        (string) –
        
        (string) –

Return type:

dict

Returns:

Response Syntax

{}

Response Structure

(dict) –

update_table¶

Request Syntax

Response Syntax

Response Structure

Exceptions