Configurare una tabella incrementale

Questo documento illustra come utilizzare Dataform core per configurare un'istanza una tabella incrementale.

Informazioni su una tabella incrementale

Dataform aggiorna le tabelle in modo diverso in base al tipo. Durante ogni esecuzione di una tabella o di una vista, Dataform ricrea l'intero una tabella o una visualizzazione da zero.

Quando definisci una tabella incrementale, Dataform crea una tabella da zero solo per la prima volta. Durante le esecuzioni successive, Dataform inserisce o unisce solo nuove righe nella tabella incrementale in base alle condizioni configurate.

Dataform inserisce nuove righe solo nelle colonne già esistenti nel una tabella incrementale. Se apporti modifiche alla definizione della tabella incrementale query (ad esempio, aggiungi una nuova colonna) devi ricreare la tabella da zero. Per farlo, la prossima volta attivare l'esecuzione della tabella, seleziona l'opzione Esegui con aggiornamento completo.

Ecco alcuni casi d'uso comuni per le tabelle incrementali:

Ottimizzazione delle prestazioni

Per alcuni tipi di dati, come i log web o i dati di analisi, potrebbe essere utile solo i nuovi record, invece di rielaborare l'intera tabella.

Riduzione della latenza

Puoi utilizzare tabelle incrementali per eseguire flussi di lavoro rapidamente ma di frequente, riducendo la latenza downstream delle tabelle di output.

Istantanee giornaliere

Puoi configurare una tabella incrementale per creare snapshot giornalieri dei dati di tabelle, ad esempio per l'analisi longitudinale delle impostazioni utente memorizzate in un database di produzione.

Prima di iniziare

1. Nella console Google Cloud, vai alla pagina Dataform.

   Vai alla pagina Dataform

2. Seleziona o crea un repository.

3. Seleziona o crea un'area di lavoro di sviluppo.

4. Crea una tabella del tipo di tabella incremental.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per configurare una tabella incrementale, chiedi all'amministratore di concederti Ruolo IAM dell'editor Dataform (roles/dataform.editor) nelle aree di lavoro. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite la ruoli o altri ruoli predefiniti ruoli.

Elabora un sottoinsieme di righe in una tabella incrementale

a determinare un sottoinsieme di righe che Dataform elaborerà durante ogni dell'esecuzione, aggiungi una clausola WHERE condizionale alla tabella incrementale SQLX file di definizione. Nella clausola WHERE, puoi specificare una condizione incrementale e una non incrementale. Dataform applica la condizione incrementale durante l'esecuzione della tabella senza un aggiornamento completo e la condizione non incrementale durante l'esecuzione con un aggiornamento completo.

Per configurare una tabella incrementale:

1. Vai all'area di lavoro di sviluppo.
2. Nel riquadro File, espandi definitions/.
3. Apri un file SQLX di definizione della tabella incrementale.

4. Inserisci una clausola WHERE nel seguente formato:

   config { type: "incremental" }
   
   SELECT_STATEMENT
   
   ${when(incremental(), `WHERE INCREMENTAL_CONDITION`, `WHERE NON_INCREMENTAL_CONDITION`) }
   

   Sostituisci quanto segue:

   • SELECT_STATEMENT: l'istruzione SELECT che definisce la tabella

   • INCREMENTAL_CONDITION: la condizione specificata in WHERE per selezionare le righe che Dataform elaborerà durante l'esecuzione della tabella senza un aggiornamento completo.

   • NON_INCREMENTAL_CONDITION: la condizione specificata nel Clausola WHERE per selezionare le righe che Dataform elaborerà durante la tabella con un aggiornamento completo.

5. (Facoltativo) Fai clic su Formato.

Il seguente esempio di codice mostra una tabella incrementale che in modo incrementale elabora righe della tabella productiondb.logs:

config { type: "incremental" }

SELECT timestamp, message FROM ${ref("productiondb", "logs")}

${when(incremental(),
   `WHERE date > (SELECT MAX(date) FROM ${self()}) AND country = "UK"`,
   `WHERE country = "UK"`)}

L'esempio di codice seguente mostra una tabella incrementale che crea uno snapshot della tabella productiondb.customers:

config { type: "incremental" }

SELECT CURRENT_DATE() AS snapshot_date, customer_id, name, account_settings FROM ${ref("productiondb", "customers")}

${when(incremental(), `WHERE snapshot_date > (SELECT MAX(snapshot_date) FROM ${self()})`) }

Unisci le righe in una tabella incrementale

Per garantire che una tabella incrementale contenga solo una riga corrispondente a un combinazione di colonne selezionata, imposta le colonne selezionate come uniqueKey su unisci righe che hanno lo stesso uniqueKey. Quando aggiorni la tabella, Dataform unisce le righe con uniqueKey anziché aggiungerle.

Per configurare l'unione in una tabella incrementale:

1. Vai all'area di lavoro di sviluppo.
2. Nel riquadro File, espandi definitions/.
3. Seleziona un file SQLX di definizione della tabella incrementale

4. Nel blocco config, imposta le colonne selezionate come uniqueKey nel seguente formato:

   uniqueKey: ["COLUMN_NAME"]
   

   Sostituisci COLUMN_NAME con il nome di una colonna selezionata.

5. (Facoltativo) Fai clic su Formato.

Il seguente esempio di codice mostra una tabella incrementale con transaction_id colonna impostata su uniqueKey per garantire che contenga sempre una sola riga:

config {
  type: "incremental",
  uniqueKey: ["transaction_id"]
}

SELECT timestamp, action FROM weblogs.user_actions
${ when(incremental(), `WHERE timestamp > (SELECT MAX(timestamp) FROM ${self()})`) }

Filtrare le righe in una tabella incrementale

In una tabella partizionata incrementale, per evitare che Dataform analizzi il l'intera tabella per trovare le righe corrispondenti, imposta updatePartitionFilter in modo da considerare solo un sottoinsieme di record.

Il seguente esempio di codice mostra una tabella partizionata incrementale con unione configurate impostando le proprietà uniqueKey e updatePartitionFilter:

config {
  type: "incremental",
  uniqueKey: ["transaction_id"],
  bigquery: {
    partitionBy: "DATE(timestamp)",
    updatePartitionFilter:
        "timestamp >= timestamp_sub(current_timestamp(), interval 24 hour)"
  }
}

SELECT timestamp, action FROM weblogs.user_actions
${ when(incremental(), `WHERE timestamp > (SELECT MAX(timestamp) FROM ${self()})`) }

Evita scansioni complete delle tabelle durante l'importazione da una tabella partizionata

Quando crei una tabella incrementale che fa riferimento a una tabella partizionata, ti consigliamo di creare una query sulla tabella per evitare scansioni complete la tabella partizionata durante ogni aggiornamento incrementale.

Puoi limitare il numero di partizioni che BigQuery analizza per l'aggiornamento la tabella incrementale utilizzando un'espressione costante una query standard. a trasformare un valore della tabella partizionata in una costante , utilizzare lo scripting BigQuery dichiarare il valore come variabile nel blocco pre_operations. Poi, utilizza la variabile come espressione costante in una clausola WHERE in la query SELECT.

Con questa configurazione, Dataform aggiorna la tabella incrementale in base sulle partizioni più recenti della tabella partizionata a cui viene fatto riferimento senza dover analizzare l'intera tabella.

Per configurare una tabella incrementale che fa riferimento a una tabella partizionata evitando scansioni complete delle tabelle, segui questi passaggi:

1. Vai all'area di lavoro di sviluppo.
2. Nel riquadro File, espandi definitions/.
3. Seleziona un file SQLX di definizione della tabella incrementale
4. Nel blocco pre_operations, dichiarare una variabile con lo scripting BigQuery.
5. Filtra l'istruzione SELECT che definisce la tabella con una clausola WHERE che fa riferimento alla variabile dichiarata.
6. (Facoltativo) Fai clic su Formato.

Il seguente esempio di codice mostra una tabella incrementale in cui gli elementi di riferimento La tabella raw_events è partizionata per event_timestamp:

config {
  type: "incremental",
}

pre_operations {
  DECLARE event_timestamp_checkpoint DEFAULT (
    ${when(incremental(),
    `SELECT max(event_timestamp) FROM ${self()}`,
    `SELECT timestamp("2000-01-01")`)}
  )
}

SELECT
  *
FROM
  ${ref("raw_events")}
WHERE event_timestamp > event_timestamp_checkpoint

Nell'esempio di codice precedente, la variabile event_timestamp_checkpoint è definita nel blocco pre_operations. La variabile event_timestamp_checkpoint viene quindi utilizzata come espressione costante nella clausola WHERE.

Ricrea una tabella incrementale da zero con aggiornamento completo

Puoi forzare la ricreazione di una tabella incrementale da zero utilizzando il metodo interfaccia a riga di comando con l'opzione --full-refresh o con l'opzione Esegui con aggiornamento completo quando l'attivazione di un'esecuzione del flusso di lavoro.

Quando selezioni l'opzione di aggiornamento completo, nell'area di lavoro di sviluppo o utilizzando l'interfaccia a riga di comando Dataform, Dataform ignora ${when(incremental(), ... } durante l'esecuzione e ricrea il parametro con un'istruzione CREATE OR REPLACE.

Proteggere una tabella incrementale dall'aggiornamento completo

Per proteggere una tabella incrementale dalla ricreazione da zero e dal rischio perdita di dati, puoi impostare la tabella incrementale su protected. Potresti voler impediscono la ricreazione di una tabella incrementale se l'origine dati è temporanea.

Per contrassegnare una tabella incrementale come protected:

1. Vai all'area di lavoro di sviluppo.
2. Nel riquadro File, espandi definitions/.
3. Seleziona un file SQLX di definizione della tabella incrementale.
4. Nel blocco config, inserisci protected: true.
5. (Facoltativo) Fai clic su Formato.

Il seguente esempio di codice mostra una tabella incrementale contrassegnata come protected:

config {
  type: "incremental",
  protected: true
}
SELECT ...

Passaggi successivi

• Per scoprire come definire una tabella, consulta: Crea una tabella.
• Per scoprire come utilizzare l'interfaccia a riga di comando Dataform, consulta Utilizza l'interfaccia a riga di comando Dataform.
• Per scoprire come attivare manualmente le esecuzioni, consulta Attiva l'esecuzione.