Dela via

Konvertera en sekundär tabell till en extern Unity Catalog-tabell

Viktigt!

Den här funktionen är i offentlig förhandsversion och är endast tillgänglig för deltagande kunder just nu. För att delta i förhandsvisningen, ansök genom att fylla i det här formuläret. Den här funktionen stöder endast konvertering av utländska tabeller som federerats med HMS och Glue Federation.

Den här sidan beskriver hur du använder SET EXTERNAL för att konvertera en sekundär tabell till en extern tabell.

SET EXTERNAL översikt

Använd funktionen SET EXTERNAL för att konvertera en sekundär tabell till en Unity Catalog-tabell EXTERNAL i Azure Databricks. SET EXTERNAL erbjuder följande fördelar:

  • Behålla tabellhistorik
  • Behålla samma tabellkonfigurationer, inklusive samma namn, inställningar, behörigheter och vyer.

Förutsättningar

  • Dataformat: Den externa tabellens dataformat måste vara något av följande:
    • Delta
    • Parquet
    • ORC
    • Avro
    • JSON
    • CSV
    • Textmeddelande
  • Tabelltyp: HMS-tabelltypen måste vara en extern HMS-tabell. Kommandot misslyckas om tabellen är en hanterad HMS-tabell.
  • Körmiljö: Databricks Runtime 17.3 eller senare
  • Behörigheter: OWNER eller MANAGE behörigheter i tabellen och CREATE behörigheten på EXTERNAL LOCATION

Varning

Samtidiga skrivningar till källtabellen och från Unity Catalog stöds inte. Du ansvarar för att inaktivera läsningar och skrivningar till källtabellen i den externa katalogen och se till att arbetsbelastningarna har migrerats till den nya katalogen innan konverteringen utförs.

Syntax

Om du vill konvertera den externa Unity Catalog-tabellen till Unity Catalog extern kör du följande kommando:

ALTER TABLE source_table SET EXTERNAL [DRY RUN]

Parameterar

  • source_table

    En befintlig extern tabell i Unity Catalog. Utländska tabeller innehåller data och metadata som hanteras av en extern katalog. Om du släpper källtabellen i den externa katalogen tas även den externa tabellen bort i Unity Catalog innan konverteringen. När tabellen har konverterats till en extern tabell, påverkar det inte den externa tabellen i Unity Catalog om källtabellen tas bort från den externa katalogen.

  • DRY RUN

    När du anger det kontrollerar du om källtabellen kan uppgraderas utan att uppgradera måltabellerna. Kommandot returnerar DRY_RUN_SUCCESS om en tabell kan uppgraderas.

Tillbakagång

Om du vill återställa tabellmigreringen, ta bort tabellen, och den återförbinds som extern i nästa katalogsynkronisering.

DROP TABLE catalog.schema.my_external_table;

Kontrollera konvertering

Du kan bekräfta att din utländska tabell har konverterats till en extern tabell genom att kolla i Catalog Explorer. Före konverteringen visas tabellen som Främmande och efter konverteringen visas den som Extern.

Anmärkning

När du kör DESCRIBE EXTENDED visas tabelltypen som EXTERNAL både före och efter konverteringen. Detta beror på hur Federation fungerar eftersom den efterliknar beteendet att köra det här kommandot i hive_metastore katalogen. Om du vill verifiera konverteringen korrekt använder du Catalog Explorer.

Vanliga frågor

Kan jag skapa tabeller och konvertera tabeller i en utländsk katalog?

Ja, du kan skapa externa eller hanterade tabeller i en extern katalog. Beteendet beror på schemakonfigurationen:

  • För Glue- eller eHMS-scheman, eller för scheman med en hanterad plats som angetts i Unity Catalog: Om du kör CREATE TABLE foreign_catalog.schema.table, skapar detta en hanterad eller extern Unity Catalog-tabell. Tabellen skickas inte eller synkroniseras inte till den externa katalogen.
  • För scheman från interna Hive-metaarkivanslutningar: Om du försöker skapa en tabell i ett sekundärschema skapar den fortfarande en sekundär tabell och skapar även en tabell i hive_metastore.
  • För Hive-metastore för äldre arbetsytor: Eftersom det är läs- och skrivfederation skapas även en tabell i den interna Hive-metastore om du skapar en tabell i en extern katalog.

Vad händer om mina externa tabeller är i SerDe-format?

För Parquet SerDe-tabeller i AWS Glue måste du ändra tabellmetadata innan du konverterar till en extern tabell. Följande Python-skript använder AWS boto3-biblioteket för att uppdatera de nödvändiga egenskaperna:

import boto3
import json

# Initialize boto3 Glue client with your AWS region
glue_client = boto3.client('glue', region_name='<your-aws-region>')  # Example: 'us-west-2'

# Configure your table details
DATABASE_NAME = '<your-database-name>'  # Example: 'my_database'
TABLE_NAME = '<your-table-name>'  # Example: 'my_parquet_table'
SPARK_PROVIDER = 'PARQUET'
SPARK_PARTITION_PROVIDER = 'filesystem'

# Step 1: Get the current table definition
print(f"Retrieving current table definition for {DATABASE_NAME}.{TABLE_NAME}...")
response = glue_client.get_table(DatabaseName=DATABASE_NAME, Name=TABLE_NAME)

# Extract the table's current definition
table_definition = response['Table']

# Step 2: Verify if the table is a Parquet SerDe
serde_library = table_definition['StorageDescriptor']['SerdeInfo'].get('SerializationLibrary', '')
is_parquet_serde = serde_library == "org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe"

if not is_parquet_serde:
    print(f"The table {TABLE_NAME} does not use a Parquet SerDe. Found: {serde_library}")
else:
    print(f"Table {TABLE_NAME} is using a Parquet SerDe.")

    # Step 3: Extract the S3 path dynamically from the Location field
    s3_path = table_definition['StorageDescriptor']['Location']
    print(f"S3 Path found: {s3_path}")

    # Step 4: Modify the SerDe and table properties
    # Modify SerDe parameters
    if 'SerdeInfo' in table_definition['StorageDescriptor']:
        if 'Parameters' not in table_definition['StorageDescriptor']['SerdeInfo']:
            table_definition['StorageDescriptor']['SerdeInfo']['Parameters'] = {}
        table_definition['StorageDescriptor']['SerdeInfo']['Parameters']['path'] = s3_path

    # Modify table properties
    if 'Parameters' not in table_definition:
        table_definition['Parameters'] = {}

    # Set both spark.sql.sources.provider and spark.sql.partitionProvider
    table_definition['Parameters']['spark.sql.sources.provider'] = SPARK_PROVIDER
    table_definition['Parameters']['spark.sql.partitionProvider'] = SPARK_PARTITION_PROVIDER

    # Remove metadata fields that are not accepted by update_table API
    table_definition.pop('CreateTime', None)
    table_definition.pop('UpdateTime', None)
    table_definition.pop('LastAccessTime', None)
    table_definition.pop('Retention', None)
    table_definition.pop("DatabaseName", None)
    table_definition.pop('CreatedBy', None)
    table_definition.pop('IsRegisteredWithLakeFormation', None)
    table_definition.pop('CatalogId', None)
    table_definition.pop('VersionId', None)

    # Step 5: Update the table with the modified properties
    print(f"Updating the table {TABLE_NAME} in Glue...")
    response = glue_client.update_table(
        DatabaseName=DATABASE_NAME,  # Correct use of DatabaseName
        TableInput=table_definition,
    )

    print(f"Table {TABLE_NAME} updated successfully!")

Vad händer om mina utländska tabeller stödjs av DBFS?

När vi konverterar en DBFS-stödd tabell lagrar vi den aktuella mappningen av DBFS-sökvägen till molnsökvägen som den externa tabellens molnsökvägsläge.

Kan jag konvertera på schema- eller katalognivå?

Du kan iterera genom dina tabeller i dina scheman för att konvertera individuellt, eller använda projektet discoverx labs för att konvertera hela scheman eller kataloger på en gång:

df = (dx.from_tables("prod.*.*")
.with_sql("ALTER TABLE {full_table_name} SET EXTERNAL;")
.apply())  # dry run with .explain()
  • Last updated on