Udostępnij przez

Konwertuj tabelę zagraniczną na zewnętrzną tabelę katalogu Unity

Ważne

Ta funkcja jest dostępna w publicznej wersji zapoznawczej i jest obecnie dostępna tylko dla uczestniczących klientów. Aby wziąć udział w wersji zapoznawczej, aplikuj, wypełniając ten formularz. Ta funkcja obsługuje tylko konwertowanie obcych tabel zfederowanych przy użyciu HMS i Glue Federation.

Na tej stronie opisano sposób konwertowania SET EXTERNAL tabeli obcej na tabelę zewnętrzną.

SET EXTERNAL omówienie

Użyj funkcji SET EXTERNAL, aby przekonwertować tabelę zewnętrzną na tabelę Unity Catalog EXTERNAL w usłudze Azure Databricks. SET EXTERNAL oferuje następujące korzyści:

  • Zachowywanie historii tabel
  • Przechowywanie tych samych konfiguracji tabeli, w tym takich samych nazw, ustawień, uprawnień i widoków.

Wymagania wstępne

  • Format danych: format danych tabeli obcej musi być jednym z następujących elementów:
    • Delta
    • Parquet
    • ORC
    • Avro
    • JSON
    • CSV
    • TEKST
  • Typ tabeli: Tabela HMS musi być tabelą zewnętrzną HMS. Polecenie kończy się niepowodzeniem, jeśli tabela jest zarządzaną tabelą HMS.
  • Środowisko uruchomieniowe: Środowisko uruchomieniowe usługi Databricks Runtime w wersji 17.3 lub nowszej
  • Uprawnienia: uprawnienia OWNER lub MANAGE do tabeli oraz uprawnienia CREATE do EXTERNAL LOCATION

Ostrzeżenie

Jednoczesne zapisy do tabeli źródłowej i z Unity Catalog nie są obsługiwane. Odpowiadasz za wyłączenie odczytów i zapisów do tabeli źródłowej w wykazie zewnętrznym i upewnienie się, że obciążenia zostały zmigrowane do nowego wykazu przed przeprowadzeniem konwersji.

Składnia

Aby przekonwertować tabelę obcą Unity Catalog na tabelę zewnętrzną, uruchom następujące polecenie:

ALTER TABLE source_table SET EXTERNAL [DRY RUN]

Parametry

  • source_table

    Istniejąca tabela zewnętrzna w katalogu Unity. Tabele obce zawierają dane i metadane zarządzane przez wykaz zewnętrzny. Przed konwersją, jeśli usuwasz tabelę źródłową w zewnętrznym katalogu, tabela zewnętrzna również zostanie usunięta w Unity Catalog. Po przekonwertowaniu tabeli na zewnętrzną, usunięcie tabeli źródłowej w katalogu zewnętrznym nie ma wpływu na tabelę zewnętrzną Unity Catalog.

  • DRY RUN

    Po określeniu sprawdza, czy tabela źródłowa może zostać uaktualniona bez uaktualniania tabel docelowych. Polecenie zwraca DRY_RUN_SUCCESS, jeśli można uaktualnić tabelę.

Cofnięcie

Aby wycofać migrację tabeli, usuń tabelę, a następnie zostanie ponownie sfederowana jako tabela zewnętrzna w następnej synchronizacji katalogu.

DROP TABLE catalog.schema.my_external_table;

Sprawdzanie konwersji

Możesz potwierdzić, że tabela obca została przekonwertowana na tabelę zewnętrzną, sprawdzając w Eksploratorze katalogu. Przed konwersją tabela jest wyświetlana jako Obce, a po konwersji jest wyświetlana jako Zewnętrzna.

Uwaga / Notatka

Uruchomienie DESCRIBE EXTENDED pokazuje typ tabeli zarówno przed konwersją, jak i po niej. Jest to spowodowane tym, jak działa federacja, ponieważ naśladuje zachowanie uruchamiania tego polecenia w wykazie hive_metastore. Aby dokładnie zweryfikować konwersję, użyj Eksploratora wykazu.

Często zadawane pytania

Czy można tworzyć tabele, a także konwertować tabele w wykazie obcym?

Tak, można tworzyć tabele zewnętrzne lub zarządzane w wykazie obcym. Zachowanie zależy od konfiguracji schematu:

  • W przypadku schematów Glue lub eHMS albo schematów z lokalizacją zarządzaną ustawioną w Unity Catalog: jeśli uruchomisz CREATE TABLE foreign_catalog.schema.table, co spowoduje utworzenie tabeli zarządzanej lub zewnętrznej w Unity Catalog. Tabela nie jest przekazywana ani synchronizowana z katalogiem zewnętrznym.
  • W przypadku schematów z wewnętrznych połączeń magazynu metadanych Hive: jeśli spróbujesz utworzyć tabelę w obcym schemacie, nadal zostanie utworzona tabela obca, a także tabela w hive_metastore.
  • W przypadku starszego magazynu metadanych Hive obszaru roboczego: Ponieważ jest to federacja odczytu i zapisu, jeśli utworzysz tabelę w zewnętrznym katalogu, zostanie również utworzona tabela w wewnętrznym magazynie metadanych Hive.

Co zrobić, jeśli moje tabele obce są w formacie SerDe?

W przypadku tabel Parquet SerDe na platformie AWS Glue należy zmodyfikować metadane tabeli przed przekonwertowaniem na tabelę zewnętrzną. Poniższy skrypt języka Python używa biblioteki AWS boto3 do aktualizowania niezbędnych właściwości:

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!")

Co zrobić, jeśli moje obce tabele są oparte na systemie plików DBFS?

Podczas konwertowania tablicy opartej na DBFS przechowujemy bieżące mapowanie ścieżki DBFS na ścieżkę chmurową jako lokalizację ścieżki chmurowej tabeli zewnętrznej.

Czy mogę dokonać konwersji na poziomie schematu lub wykazu?

Możesz iterować tabele w schematach, aby konwertować pojedynczo, lub użyć projektu discoverx labs do konwertowania całych schematów lub katalogów jednocześnie:

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