Clonare una tabella in Azure Databricks

Clonare una tabella Delta Lake o Apache Iceberg usando il CLONE comando per creare una copia indipendente in una versione specifica. I cloni profondi copiano sia i dati che i metadati. I cloni superficiali copiano solo i metadati e fanno riferimento ai file di dati di origine, usando meno risorse di calcolo e archiviazione rispetto ai cloni profondi.

Azure Databricks supporta anche la clonazione di tabelle Parquet e Apache Iceberg. Vedi Clonare in modo incrementale tabelle Parquet e Apache Iceberg in Delta Lake e Clonare una tabella Iceberg gestita.

Per informazioni dettagliate sull'uso di clone con Unity Catalog, vedere Clone superficiale per le tabelle del Catalogo Unity.

Tipi di clonazione

Sono disponibili i tipi di clone seguenti:

I metadati clonati includono: schema, informazioni di partizionamento, invarianti, valori Null e TBLPROPERTIES. Solo per i cloni profondi, vengono clonati anche i metadati di flusso e COPY INTO. I metadati non clonati sono la descrizione della tabella, i metadati di commit definiti dall'utente, la cronologia delle tabelle Delta Lake e le proprietà del catalogo Unity, ad esempio i tag.

Metriche di clonazione

CLONE segnala le metriche seguenti come singolo dataframe di riga al termine dell'operazione:

• source_table_size: dimensione della tabella di origine clonata in byte.
• source_num_of_files: numero di file nella tabella di origine.
• num_removed_files: Se la tabella viene sostituita, quanti file vengono rimossi dalla tabella corrente?
• num_copied_files: numero di file copiati dall'origine (0 per cloni superficiali).
• removed_files_size: dimensioni in byte dei file da rimuovere dalla tabella corrente.
• copied_files_size: dimensioni in byte dei file copiati nella tabella.

Autorizzazioni

È necessario configurare le autorizzazioni per il controllo di accesso alle tabelle di Azure Databricks e il provider di servizi cloud.

Controllo di accesso alle tabelle

Per i cloni profondi e superficiali sono necessarie le autorizzazioni seguenti:

• SELECT autorizzazione per la tabella di origine.
• Se si usa CLONE per creare una nuova tabella, è necessaria l'autorizzazione CREATE sul database in cui si sta creando la tabella.
• Se usi CLONE per sostituire una tabella, devi avere il permesso MODIFY sulla tabella.

Autorizzazioni del provider di servizi cloud

Gli utenti che leggono un clone profondo devono disporre dell'accesso in lettura alla directory del clone. Gli autori devono disporre dell'accesso in scrittura alla directory del clone.

I lettori di un clone superficiale necessitano dell'accesso in lettura ai file di dati della tabella di origine e alla directory del clone, perché i file di dati rimangono nell'origine. Gli autori devono disporre dell'accesso in scrittura alla directory del clone.

Esempi

Creare cloni profondi o superficiali

Gli esempi di codice seguenti illustrano come creare cloni profondi e superficiali:

SQL

Crea un clone completo:

CREATE TABLE target_table CLONE source_table;

Sostituire una destinazione esistente:

CREATE OR REPLACE TABLE target_table CLONE source_table;

Crea un clone profondo o salta se la destinazione esiste già:

CREATE TABLE IF NOT EXISTS target_table CLONE source_table;

Creare un clone superficiale alla versione più recente, a una versione specifica o a un timestamp specifico. Il timestamp può essere una stringa di data come '2019-01-01' o un'espressione come date_sub(current_date(), 1).

CREATE TABLE target_table SHALLOW CLONE source_table;

CREATE TABLE target_table SHALLOW CLONE source_table VERSION AS OF version;

CREATE TABLE target_table SHALLOW CLONE source_table TIMESTAMP AS OF timestamp_expression;

Python

L'API Python DeltaTable è specifica di Delta Lake.

Clona il sorgente all'ultima versione:

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "source_table")
deltaTable.clone(target="target_table", isShallow=True, replace=False)

Clonare il sorgente a una versione specifica:

deltaTable.cloneAtVersion(version=1, target="target_table", isShallow=True, replace=False)

Clona la sorgente a una marca temporale specifica:

deltaTable.cloneAtTimestamp(timestamp="2019-01-01", target="target_table", isShallow=True, replace=False)

Scala

L'API Scala DeltaTable è specifica di Delta Lake.

Clona il sorgente nell'ultima versione:

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "source_table")
deltaTable.clone(target="target_table", isShallow=true, replace=false)

Clonare l'origine in una versione specifica:

deltaTable.cloneAtVersion(version=1, target="target_table", isShallow=true, replace=false)

Clona la sorgente a una marca temporale specifica:

deltaTable.cloneAtTimestamp(timestamp="2019-01-01", target="target_table", isShallow=true, replace=false)

Per informazioni dettagliate sulla sintassi, vedere CREATE TABLE CLONE.

Controllare i metadati copiati durante CLONE

Questo esempio mostra i metadati che vengono e non vengono copiati durante le operazioni CLONE, in particolare TBLPROPERTIES, i tag di Unity Catalog e la cronologia di Delta Lake.

Creare una tabella di origine con una proprietà personalizzata e una durata di conservazione dei log non predefinita, quindi inserire i dati per generare la cronologia tabelle:

CREATE OR REPLACE TABLE test_clone_source (id INT, val STRING)
TBLPROPERTIES ('my.custom.prop' = 'hello', 'delta.logRetentionDuration' = '12 days');

ALTER TABLE test_clone_source SET TAGS ('team' = 'data-eng', 'env' = 'prod');
INSERT INTO test_clone_source VALUES (1, 'a');
INSERT INTO test_clone_source VALUES (2, 'b');

Creare un clone profondo e un clone superficiale:

CREATE OR REPLACE TABLE test_clone_deep DEEP CLONE test_clone_source;

CREATE TABLE test_clone_shallow SHALLOW CLONE test_clone_source;

Verificare che TBLPROPERTIES siano stati copiati in entrambi i cloni:

SHOW TBLPROPERTIES test_clone_source;
SHOW TBLPROPERTIES test_clone_deep;
SHOW TBLPROPERTIES test_clone_shallow;

Verificare che i tag del catalogo Unity non vengano copiati nei cloni:

SELECT catalog_name, schema_name, table_name, tag_name, tag_value FROM information_schema.table_tags WHERE table_name = 'test_clone_source';
SELECT catalog_name, schema_name, table_name, tag_name, tag_value FROM information_schema.table_tags WHERE table_name = 'test_clone_deep';
SELECT catalog_name, schema_name, table_name, tag_name, tag_value FROM information_schema.table_tags WHERE table_name = 'test_clone_shallow';

Verificare che la cronologia di Delta Lake non sia copiata nei cloni:

DESCRIBE HISTORY test_clone_source;
DESCRIBE HISTORY test_clone_deep;
DESCRIBE HISTORY test_clone_shallow;

Pulizia

DROP TABLE IF EXISTS test_clone_shallow;
DROP TABLE IF EXISTS test_clone_source;
DROP TABLE IF EXISTS test_clone_deep;

Archiviazione dati

È possibile usare la clonazione profonda per mantenere lo stato di una tabella in un determinato momento a scopo di archiviazione. È possibile sincronizzare i cloni profondi in modo incrementale per mantenere lo stato aggiornato di una tabella di origine per il ripristino di emergenza.

Eseguire il comando seguente una volta al mese per sincronizzare l'archivio:

CREATE OR REPLACE TABLE archive_table CLONE my_prod_table

Riproduzione del modello ML

Per i casi d'uso di Machine Learning, è possibile archiviare una versione di una tabella usata per eseguire il training di un modello di Machine Learning. I modelli futuri possono essere testati usando questo set di dati archiviato. Per archiviare una versione del set di dati con CLONE, eseguire le operazioni seguenti:

Ad esempio, per archiviare la versione di una tabella usata per eseguire il training di un modello alla versione 15:

CREATE TABLE model_dataset CLONE entire_dataset VERSION AS OF 15

Esperimenti a breve termine in una tabella di produzione

Per testare un flusso di lavoro in una tabella di produzione senza danneggiare la tabella, creare un clone superficiale. I cloni superficiali consentono di eseguire carichi di lavoro nella tabella clonata, che fa riferimento a tutti i dati di produzione, ma non influisce sui carichi di lavoro di produzione.

Creare un clone superficiale della tabella di produzione:

CREATE TABLE my_test SHALLOW CLONE my_prod_table;

Eseguire aggiornamenti e convalide nel clone:

UPDATE my_test WHERE user_id is null SET invalid=true;

Quando si è pronti, eseguire di nuovo il merge delle modifiche. L'unione usa le informazioni di aggiornamento nel clone per eliminare solo i file modificati, se possibile:

MERGE INTO my_prod_table
USING my_test
ON my_test.user_id <=> my_prod_table.user_id
WHEN MATCHED AND my_test.user_id is null THEN UPDATE *;

Elimina il clone al termine:

DROP TABLE my_test;

Sovrascrivere le proprietà della tabella

Le sovrascritture delle proprietà della tabella sono utili per:

• Annotazione di tabelle con informazioni sul proprietario o sull'utente durante la condivisione di dati con business unit diverse.
• Archiviazione di tabelle Delta Lake quando è necessario un viaggio nel tempo nell'archivio. È possibile specificare i periodi di conservazione dei dati e dei log in modo indipendente per la tabella di archiviazione. Per esempio:

SQL

Per una tabella Delta Lake:

CREATE OR REPLACE TABLE archive_table CLONE prod.my_table
TBLPROPERTIES (
delta.logRetentionDuration = '3650 days',
delta.deletedFileRetentionDuration = '3650 days'
)

Per una tabella Iceberg:

CREATE OR REPLACE TABLE archive_table CLONE prod.my_table
TBLPROPERTIES (
iceberg.logRetentionDuration = '3650 days',
iceberg.deletedFileRetentionDuration = '3650 days'
)

Python

L'API DeltaTable Python è specifica di Delta Lake.

dt = DeltaTable.forName(spark, "prod.my_table")
tblProps = {
"delta.logRetentionDuration": "3650 days",
"delta.deletedFileRetentionDuration": "3650 days"
}
dt.clone(target="archive_table", isShallow=False, replace=True, tblProps)

Scala

L'API "DeltaTable" di Scala è specifica di Delta Lake.

val dt = DeltaTable.forName(spark, "prod.my_table")
val tblProps = Map(
"delta.logRetentionDuration" -> "3650 days",
"delta.deletedFileRetentionDuration" -> "3650 days"
)
dt.clone(target="archive_table", isShallow = false, replace = true, properties = tblProps)

Comportamento dell'operazione di clonazione per il metastore Hive legacy

Per una tabella Delta Lake registrata nel metastore Hive o in una raccolta di file non registrati come tabella, il clone presenta i comportamenti seguenti:

• Le modifiche apportate ai cloni profondi o superficiali non influiscono sulla tabella di origine.
• I cloni superficiali fanno riferimento ai file di dati nella directory di origine. Se si esegue VACUUM nella tabella di origine, i client non possono più leggere tali file di dati e genera un oggetto FileNotFoundException. Per riparare, eseguire il comando clone con replace sul clone superficiale. Se questo accade spesso, valuta l'uso di un clone profondo, che non dipende dalla tabella di origine.
• I cloni profondi non dipendono dalla tabella di origine, ma sono costosi da creare perché copiano sia i dati che i metadati.
• La clonazione con replace in una destinazione che contiene già una tabella in quel percorso crea un log Delta se non ne esiste già uno. Eseguire VACUUM per pulire i dati esistenti.
• Per le tabelle Delta Lake esistenti, la clonazione crea un nuovo commit incrementale che include solo nuovi metadati e dati dalla tabella di origine dall'ultimo clone.
• La clonazione di una tabella è diversa da Create Table As Select (CTAS). Un clone copia i metadati della tabella di origine oltre ai dati. Non è necessario specificare il partizionamento, il formato, gli invarianti, i valori Null o altre impostazioni.
• Una tabella clonata ha una cronologia indipendente dalla tabella di origine. Le query di spostamento temporale in una tabella clonata non funzionano con gli stessi input della tabella di origine.