Tabellen erstellen

In Dataform ist eine Tabelle eine der Objekttypen, aus denen ein Workflow besteht. Sie können Tabellen erstellen, die auf Daten aus den für Ihren Workflow deklarierten Datenquellen oder aus anderen Tabellen in Ihrem Workflow verweisen. Dataform kompiliert Ihre Tabellendefinitionen in Echtzeit in SQL. Wenn Sie die Ausführung auslösen, führt Dataform den SQL-Code aus und erstellt die definierten Tabellen in BigQuery.

In einer type: "table"-SQLX-Datei können Sie die folgenden Tabellentypen erstellen:

Sie können auch Tabellenpartitionen und ‑cluster definieren.

Wenn Sie den Zweck einer Tabelle oder ihre Beziehung zu anderen Tabellen in Ihrem Workflow festhalten möchten, können Sie der Tabelle oder den ausgewählten Spalten Dokumentation hinzufügen.

Wenn Sie die Daten in einer Tabelle anhand bestimmter Bedingungen testen möchten, können Sie Testabfragen für die Datenqualität erstellen, die als Assertions bezeichnet werden. Dataform führt jedes Mal, wenn der Workflow aktualisiert wird, Prüfungen durch und benachrichtigt Sie, wenn Prüfungen fehlschlagen.

Wenn Sie die Standardtabelleneinstellungen wie database oder schema überschreiben und die Tabellenerstellung deaktivieren oder eine SQL-Anweisung vor oder nach der Tabellenerstellung ausführen möchten, können Sie zusätzliche Tabelleneinstellungen konfigurieren.

Sie können zusätzliche Tabelleneinstellungen konfigurieren, um Folgendes zu tun:

  • Standardeinstellungen für Tabellen überschreiben, z. B. database oder schema
  • Deaktivieren Sie das Erstellen von Tabellen.
  • Führen Sie eine SQL-Anweisung vor oder nach der Tabellenerstellung aus.

Wenn Sie Ihre Tabellen in BigQuery nach der Ausführung organisieren möchten, können Sie BigQuery-Labels hinzufügen. Weitere Informationen finden Sie unter Einführung in Labels.

Wenn Sie den Datenzugriff auf Tabellenspaltenebene einschränken möchten, können Sie BigQuery-Richtlinien-Tags hinzufügen. Weitere Informationen finden Sie unter Einführung in die Zugriffssteuerung auf Spaltenebene.

Sie können nicht nur Tabellen in einer type: "table"-SQLX-Datei definieren, sondern auch leere Tabellen erstellen, indem Sie eine benutzerdefinierte SQL-Abfrage in einer type: "operations"-SQLX-Datei definieren. Sie können eine leere Tabelle erstellen, damit ein anderer Dienst sie mit Daten füllen kann.

Hinweise

  1. Öffnen Sie in der Google Cloud Console die Seite Dataform.

    Zu Dataform

  2. Erstellen und initialisieren Sie einen Entwicklungsarbeitsbereich in Ihrem Repository.

  3. Optional: Erkläre eine Datenquelle.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Dataform Editor (roles/dataform.editor) für Arbeitsbereiche zu gewähren, um die Berechtigungen zu erhalten, die Sie für die Durchführung der Aufgaben in diesem Dokument benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Tabelle erstellen

In diesem Abschnitt erfahren Sie, wie Sie in Dataform Tabellen mit dem Dataform-Kern erstellen.

Tabellendefinitionen

Um eine Tabelle zu definieren, müssen Sie den Tabellentyp definieren und eine SELECT-Anweisung in einer type: "table"-SQLX-Datei schreiben. Dataform kompiliert dann den Dataform-Kerncode in SQL, führt den SQL-Code aus und erstellt die definierten Tabellen in BigQuery.

In einer Dataform-SELECT-Kernanweisung definieren Sie die Tabellenstruktur und verweisen auf andere Objekte Ihres Workflows.

Sie können nicht nur Tabellen in einer type: "table"-SLQX-Datei definieren, sondern auch leere Tabellen erstellen, indem Sie eine benutzerdefinierte SQL-Abfrage in einer type: "operations"-SQLX-Datei definieren. Weitere Informationen finden Sie unter Leere Tabelle erstellen.

Abhängigkeiten mit ref referenzieren

Wenn Sie in einer SELECT-Anweisung auf ein Workflowobjekt verweisen und es automatisch als Abhängigkeit hinzufügen möchten, verwenden Sie die Funktion ref. Dataform führt Abhängigkeiten vor Tabellen aus, die davon abhängen, um die richtige Pipeline-Reihenfolge zu gewährleisten.

Die Funktion ref ist eine integrierte Dataform-Kernfunktion, die für die Abhängigkeitsverwaltung in Dataform entscheidend ist. Mit der Funktion ref können Sie auf die folgenden in Ihrem Dataform-Workflow definierten Objekte verweisen und automatisch darauf verweisen, anstatt die Schema- und Tabellennamen hartzucodieren:

Dataform verwendet die Funktion ref, um einen Abhängigkeitsbaum aller Tabellen zu erstellen, die erstellt oder aktualisiert werden sollen.

Nach der Kompilierung fügt Dataform der SQL-Anweisung Boilerplate-Anweisungen wie CREATE, REPLACE, INSERT oder MERGE hinzu.

Das folgende Codebeispiel zeigt eine Tabellendefinition mit der Funktion ref:

config { type: "table" }

SELECT
  order_date AS date,
  order_id AS order_id,
  order_status AS order_status,
  SUM(item_count) AS item_count,
  SUM(amount) AS revenue

FROM ${ref("store_clean")}

GROUP BY 1, 2

In der ref-Funktion geben Sie den Namen der Tabellen- oder Datenquellendeklaration an, von der Sie abhängig sein möchten. Dies ist in der Regel der Dateiname der SQLX-Datei, in der die Deklaration der Tabelle oder Datenquelle definiert ist.

Wenn ein Tabellenname überschrieben wurde, verwenden Sie den überschriebenen Namen in der ref-Funktion. Beispiel: Eine Tabelle mit config { name: "overridden_name" } wird als ref("overridden_name") bezeichnet. Weitere Informationen zum Überschreiben von Tabellennamen finden Sie unter Zusätzliche Tabelleneinstellungen konfigurieren.

Wenn Sie mehrere Tabellen mit demselben Namen in verschiedenen Schemas haben, können Sie auf eine bestimmte Tabelle verweisen, indem Sie der ref-Funktion zwei Argumente übergeben: den Schemanamen und den Tabellennamen.

Das folgende Codebeispiel zeigt die Funktion ref mit zwei Argumenten, um eine Tabelle in einem bestimmten Schema anzugeben:

config { type: "table" }
SELECT * FROM ${ref("schema", "store_clean")}

Sie können dem config-Block auch manuell Tabellenabhängigkeiten für Tabellen, Behauptungen, Datenquellendeklarationen oder benutzerdefinierte SQL-Vorgänge hinzufügen, auf die in der SELECT-Anweisung nicht in einer ref-Funktion verwiesen wird. Dataform führt diese Abhängigkeiten vor den abhängigen Tabellen aus.

Das folgende Codebeispiel zeigt eine Tabellenabhängigkeit im Block config:

config { dependencies: [ "unreferenced_table" ] }
SELECT * FROM ...

Weitere Informationen zur Abhängigkeitsverwaltung in Ihrem Workflow finden Sie unter Abhängigkeiten deklarieren.

Mit resolve auf andere Tabellen verweisen

Mit der resolve-Funktion können Sie in einer SELECT-Anweisung wie der ref-Funktion auf eine Tabellen- oder Datenquellendeklaration verweisen. Die Referenz wird jedoch nicht als Abhängigkeit hinzugefügt. Das bedeutet, dass das Objekt, auf das mit der resolve-Funktion verwiesen wird, die Ausführung der Tabelle, in der die resolve-Funktion verwendet wird, nicht beeinflusst.

Weitere Informationen zu den integrierten Kernfunktionen von Dataform finden Sie unter Dataform-Referenz.

SQLX-Datei für eine Tabellendefinition erstellen

Speichern Sie SQLX-Dateien für die Tabellendefinition im Verzeichnis definitions/. So erstellen Sie eine neue SQLX-Datei im Verzeichnis definitions/:

  1. Öffnen Sie in der Google Cloud Console die Seite Dataform.

    Zu Dataform

  2. Klicken Sie auf den Namen eines Repositorys, um es zu öffnen.

  3. Klicken Sie auf den Namen des Entwicklungsarbeitsbereichs, um ihn zu öffnen.

  4. Klicken Sie im Bereich Dateien neben definitions/ auf das Dreipunkt-Menü Mehr.

  5. Klicken Sie auf Datei erstellen.

  6. Geben Sie im Feld Dateipfad hinzufügen den Namen der Datei ein und fügen Sie nach definitions/ die Zahl .sqlx hinzu. Beispiel: definitions/my-table.sqlx

    Dateinamen dürfen nur Ziffern, Buchstaben, Bindestriche und Unterstriche enthalten.

  7. Klicken Sie auf Datei erstellen.

Tabellentyp definieren

So erstellen Sie eine neue Definition für den Tabellentyp:

  1. Maximieren Sie im Bereich Dateien Ihres Entwicklungsbereichs das Verzeichnis definitions/.
  2. Wählen Sie die SQLX-Datei für die Tabellendefinition aus, die Sie bearbeiten möchten.

  3. Geben Sie in die Datei das folgende Code-Snippet ein:

    config { type: "TABLE_TYPE" }

    Ersetzen Sie TABLE_TYPE durch einen der folgenden Tabellentypen:

    • table
    • incremental
    • view

  4. Optional: Wenn Sie eine materialisierte Ansicht definieren möchten, geben Sie die Eigenschaft materialized unter type: "view" im folgenden Format ein:

    config {
  type: "view",
  materialized: true
}

    Weitere Informationen finden Sie unter ITableConfig.

  5. Optional: Klicken Sie auf Formatieren.

Tabellenstruktur und Abhängigkeiten definieren

So schreiben Sie eine SELECT-Anweisung für die Tabellendefinition und definieren die Tabellenstruktur und Abhängigkeiten:

  1. Maximieren Sie im Bereich Dateien Ihres Entwicklungsbereichs das Verzeichnis definitions/.
  2. Wählen Sie die SQLX-Datei für die Tabellendefinition aus, die Sie bearbeiten möchten.
  3. Schreiben Sie unter dem config-Block eine SELECT-Beschreibung.
  4. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine Tabellendefinition mit einer SELECT-Anweisung und der Funktion ref:

config { type: "table" }
SELECT
  customers.id AS id,
  customers.first_name AS first_name,
  customers.last_name AS last_name,
  customers.email AS email,
  customers.country AS country,
  COUNT(orders.id) AS order_count,
  SUM(orders.amount) AS total_spent
FROM
  dataform-samples.dataform_sample.crm_customers AS customers
  LEFT JOIN ${ref('order_stats')} orders
    ON customers.id = orders.customer_id

WHERE
  customers.id IS NOT NULL
  AND customers.first_name <> 'Internal account'
  AND country IN ('UK', 'US', 'FR', 'ES', 'NG', 'JP')

GROUP BY 1, 2, 3, 4, 5

Manuelle Tabellenabhängigkeiten hinzufügen

So fügen Sie Tabellenabhängigkeiten hinzu, auf die in der SELECT-Anweisung nicht verwiesen wird, die aber vor der aktuellen Tabelle ausgeführt werden müssen:

  1. Maximieren Sie im Bereich Dateien Ihres Entwicklungsbereichs das Verzeichnis definitions/.
  2. Wählen Sie die SQLX-Datei für die Tabellendefinition aus, die Sie bearbeiten möchten.

  3. Geben Sie in den Block config der Tabelle das folgende Code-Snippet ein:

    dependencies: [ "DEPENDENCY_TABLE", ]

    Ersetzen Sie DEPENDENCY_TABLE durch den Dateinamen der Tabelle, die Sie als Abhängigkeit hinzufügen möchten. Sie können mehrere Dateinamen eingeben.

  4. Optional: Klicken Sie auf Formatieren.

Im folgenden Codebeispiel sind zwei Tabellen zu sehen, die dem config-Block einer Tabellendefinitionsdatei als manuelle Tabellenabhängigkeiten hinzugefügt wurden:

config { dependencies: [ "some_table", "some_other_table" ] }

Tabellenpartitionen und Cluster erstellen

In diesem Abschnitt erfahren Sie, wie Sie mit Dataform Core Tabellenpartitionen und ‑cluster erstellen. BigQuery unterstützt partitionierte Tabellen und das Clustering von Tabellen. Weitere Informationen finden Sie unter Einführung in partitionierte Tabellen und Geclusterte Tabellen erstellen und verwenden.

Tabellenpartition erstellen

So erstellen Sie eine Tabellenpartition:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Öffnen Sie eine SQLX-Datei mit einer Tabellendefinition.

  4. Fügen Sie im Block config den Block bigquery unter der Deklaration des Tabellentyps im folgenden Format hinzu:

    config {
  type: "table",
  bigquery: {
  }
}

  5. Geben Sie in den Block bigquery das folgende Code-Snippet ein:

        partitionBy: "PARTITION_EXPRESSION"

    Ersetzen Sie PARTITION_EXPRESSION durch einen Ausdruck zum Partitionieren der Tabelle.

  6. Optional: Klicken Sie auf Formatieren.

Im folgenden Codebeispiel wird eine Tabelle in einer SQLX-Datei für die Tabellendefinition nach Stunde partitioniert:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATETIME_TRUNC(<timestamp_column>, HOUR)"
  }
}

Im folgenden Codebeispiel wird die Partitionierung einer Tabelle nach einem Ganzzahlwert in einer SQLX-Datei für die Tabellendefinition veranschaulicht:

config {
  type: "table",
  bigquery: {
    partitionBy: "RANGE_BUCKET(<integer_column>, GENERATE_ARRAY(0, 1000000, 1000))"
  }
}

Partitionsfilter festlegen

So legen Sie einen Partitionsfilter fest:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Öffnen Sie eine SQLX-Datei mit der Definition einer partitionierten Tabelle.

  4. Geben Sie in den Block bigquery das folgende Code-Snippet ein:

    requirePartitionFilter : true

  5. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt einen Partitionsfilter, der im Block bigquery einer SQLX-Datei für eine partitionierte Tabelle festgelegt ist:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    requirePartitionFilter : true
  }
}
SELECT CURRENT_TIMESTAMP() AS ts

Weitere Informationen zum Partitionsfilter in BigQuery finden Sie unter Erforderliches Partitionsfilterattribut für partitionierte Tabelle festlegen.

Aufbewahrungsdauer für Partitionen festlegen

So steuern Sie die Aufbewahrung aller Partitionen in einer partitionierten Tabelle:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Öffnen Sie eine SQLX-Datei mit der Definition einer partitionierten Tabelle.

  4. Geben Sie in den Block bigquery das folgende Code-Snippet ein:

    partitionExpirationDays: NUMBER_OF_DAYS

    Ersetzen Sie NUMBER_OF_DAYS durch die Anzahl der Tage, für die die Partitionen aufbewahrt werden sollen.

  5. Optional: Klicken Sie auf Formatieren.

Im folgenden Codebeispiel ist eine Aufbewahrungsdauer für Partitionen zu sehen, die im Block bigquery einer SQLX-Datei für partitionierte Tabellen auf 14 Tage festgelegt ist:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    partitionExpirationDays: 14,
  }
}
SELECT CURRENT_TIMESTAMP() AS ts

Tabellencluster erstellen

So erstellen Sie einen Tabellencluster:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Öffnen Sie eine SQLX-Datei mit einer Tabellendefinition.

  4. Geben Sie in den Block bigquery das folgende Code-Snippet ein:

        clusterBy: ["CLUSTER_COLUMN"]

    Ersetzen Sie CLUSTER_COLUMN durch den Namen der Spalte, nach der Sie die Tabelle clustern möchten. Weitere Informationen finden Sie unter clustering_column_list.

  5. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine partitionierte Tabelle, die nach den Spalten name und revenue geclustert ist:

config {
  type: "table",
  bigquery: {
    partitionBy: "DATE(ts)",
    clusterBy: ["name", "revenue"]
  }
}
SELECT CURRENT_TIMESTAMP() as ts, name, revenue

Inkrementelle Tabelle konfigurieren

In diesem Abschnitt erfahren Sie, wie Sie mit Dataform Core eine inkrementelle Tabelle konfigurieren.

Inkrementelle Tabellen

Je nach Tabellentyp werden Tabellen in Dataform unterschiedlich aktualisiert. Bei jeder Ausführung einer Tabelle oder Ansicht erstellt Dataform die gesamte Tabelle oder Ansicht neu.

Wenn Sie eine inkrementelle Tabelle definieren, wird sie in Dataform nur beim ersten Mal neu erstellt. Bei nachfolgenden Ausführungen fügt Dataform nur dann neue Zeilen in die Inkrementtabelle ein oder fügt sie zusammen, wenn die von Ihnen konfigurierten Bedingungen erfüllt sind.

Mit Dataform werden neue Zeilen nur in Spalten eingefügt, die bereits in der inkrementellen Tabelle vorhanden sind. Wenn Sie Änderungen an der Abfrage zur Definition der inkrementellen Tabelle vornehmen, z. B. eine neue Spalte hinzufügen, müssen Sie die Tabelle neu erstellen. Wählen Sie dazu beim nächsten Ausführen der Tabelle die Option Mit vollständiger Aktualisierung ausführen aus.

Hier sind einige gängige Anwendungsfälle für inkrementelle Tabellen:

Leistungsoptimierung
Bei einigen Datentypen, z. B. Webprotokollen oder Analysedaten, möchten Sie möglicherweise nur neue Einträge verarbeiten, anstatt die gesamte Tabelle noch einmal zu verarbeiten.
Latenzreduzierung
Mit inkrementellen Tabellen können Sie Workflows schnell, aber häufig ausführen und so die Downstream-Latenz der Ausgabetabellen verringern.
Tägliche Snapshots
Sie können eine inkrementelle Tabelle so konfigurieren, dass tägliche Snapshots der Tabellendaten erstellt werden, z. B. für eine Längsschnittanalyse der Nutzereinstellungen, die in einer Produktionsdatenbank gespeichert sind.

Teilmenge der Zeilen in einer inkrementellen Tabelle verarbeiten

Wenn Sie festlegen möchten, welche Zeilen bei jeder Ausführung von Dataform verarbeitet werden sollen, fügen Sie der SQLX-Definitionsdatei der inkrementellen Tabelle eine bedingte WHERE-Klausel hinzu. In der WHERE-Klausel können Sie eine inkrementelle und eine nicht inkrementelle Bedingung angeben. In Dataform wird die Inkrementelle Bedingung bei der Tabellenausführung ohne vollständige Aktualisierung und die Nichtinkrementelle Bedingung bei der Ausführung mit vollständiger Aktualisierung angewendet.

So konfigurieren Sie eine inkrementelle Tabelle:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Öffnen Sie eine SQLX-Datei mit einer inkrementellen Tabellendefinition.

  4. Geben Sie eine WHERE-Klausel im folgenden Format ein:

    config { type: "incremental" }

SELECT_STATEMENT

${when(incremental(), `WHERE INCREMENTAL_CONDITION`, `WHERE NON_INCREMENTAL_CONDITION`) }

    Ersetzen Sie Folgendes:

    • SELECT_STATEMENT: Die SELECT-Anweisung, die die Tabelle definiert.
    • INCREMENTAL_CONDITION: Die Bedingung, die Sie in der WHERE-Klausel angeben, um Zeilen für die Verarbeitung durch Dataform während der Tabellenausführung ohne vollständige Aktualisierung auszuwählen.
    • NON_INCREMENTAL_CONDITION: Die Bedingung, die Sie in der WHERE-Klausel angeben, um Zeilen für die Verarbeitung durch Dataform während der Tabellenausführung mit einer vollständigen Aktualisierung auszuwählen.

  5. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine Inkrementtabelle, in der Zeilen der Tabelle productiondb.logs inkrementell verarbeitet werden:

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"`)}

Das folgende Codebeispiel zeigt eine inkrementelle Tabelle, mit der ein Snapshot der Tabelle productiondb.customers erstellt wird:

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()})`) }

Zeilen in einer inkrementellen Tabelle zusammenführen

Damit eine inkrementelle Tabelle nur eine Zeile enthält, die einer ausgewählten Kombination von Spalten entspricht, legen Sie die ausgewählten Spalten als uniqueKey fest, um Zeilen mit demselben uniqueKey-Wert zusammenzuführen. Beim Aktualisieren der Tabelle werden in Dataform Zeilen mit demselben uniqueKey-Wert zusammengeführt, anstatt sie anzuhängen.

So konfigurieren Sie das Zusammenführen in einer inkrementellen Tabelle:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. SQLX-Datei mit inkrementeller Tabellendefinition auswählen

  4. Legen Sie im Block config die ausgewählten Spalten als uniqueKey im folgenden Format fest:

    uniqueKey: ["COLUMN_NAME"]

    Ersetzen Sie COLUMN_NAME durch den Namen einer ausgewählten Spalte.

  5. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine inkrementelle Tabelle, in der die Spalte transaction_id auf uniqueKey festgelegt ist, damit sie immer eine Zeile enthält:

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

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

Zeilen in einer inkrementellen Tabelle filtern

Wenn Sie in einer inkrementell partitionierten Tabelle verhindern möchten, dass Dataform die gesamte Tabelle nach übereinstimmenden Zeilen durchsucht, legen Sie mit updatePartitionFilter fest, dass nur ein Teil der Datensätze berücksichtigt werden soll.

Das folgende Codebeispiel zeigt eine inkrementell partitionierte Tabelle mit Zusammenführen, die durch Festlegen der Eigenschaften uniqueKey und updatePartitionFilter konfiguriert wurde:

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()})`) }

Vollständige Tabellenscans beim Aufnehmen aus einer partitionierten Tabelle vermeiden

Wenn Sie eine inkrementelle Tabelle erstellen, die auf eine partitionierte Tabelle verweist, sollten Sie Ihre Tabellenabfrage so erstellen, dass bei jeder inkrementellen Aktualisierung keine vollständigen Tabellenscans der partitionierten Tabelle durchgeführt werden.

Sie können die Anzahl der Partitionen begrenzen, die BigQuery zum Aktualisieren der inkrementellen Tabelle scannt. Verwenden Sie dazu einen konstanten Ausdruck in Ihrer Tabellenabfrage. Wenn Sie einen Wert aus der partitionierten Tabelle in einen konstanten Ausdruck umwandeln möchten, deklarieren Sie den Wert mit BigQuery-Scripting als Variable im pre_operations-Block. Verwenden Sie die Variable dann als konstanten Ausdruck in einer WHERE-Klausel in der SELECT-Abfrage.

Bei dieser Konfiguration aktualisiert Dataform die inkrementelle Tabelle anhand der neuesten Partitionen der referenzierten partitionierten Tabelle, ohne die gesamte Tabelle zu scannen.

So konfigurieren Sie eine inkrementelle Tabelle, die auf eine partitionierte Tabelle verweist und vollständige Tabellenscans verhindert:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. SQLX-Datei mit Definition der inkrementellen Tabelle auswählen
  4. Deklarieren Sie im Block pre_operations eine Variable mit BigQuery-Scripting.
  5. Filtern Sie die SELECT-Anweisung, die die Tabelle definiert, mit einer WHERE-Klausel, die auf die deklarierte Variable verweist.
  6. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine inkrementelle Tabelle, in der die referenzierte Tabelle raw_events nach event_timestamp partitioniert ist:

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

Im vorherigen Codebeispiel ist die Variable event_timestamp_checkpoint im Block pre_operations definiert. Die Variable event_timestamp_checkpoint wird dann als konstanter Ausdruck in der WHERE-Klausel verwendet.

Inkrementelle Tabelle mit vollständiger Aktualisierung neu erstellen

Sie können eine inkrementelle Tabelle entweder über die Befehlszeile mit der Option --full-refresh oder über die Option Mit vollständiger Aktualisierung ausführen neu erstellen, wenn Sie eine Workflowausführung auslösen.

Wenn Sie die Option „Vollständige Aktualisierung“ in Ihrem Entwicklungsbereich oder über die Dataform-Befehlszeile auswählen, ignoriert Dataform den Parameter ${when(incremental(), ... } während der Ausführung und erstellt die Tabelle mit einer CREATE OR REPLACE-Anweisung neu.

Inkrementelle Tabelle vor vollständiger Aktualisierung schützen

Wenn Sie eine inkrementelle Tabelle vor dem Neuaufbau und potenziellen Datenverlusten schützen möchten, können Sie sie als protected festlegen. Wenn Ihre Datenquelle temporär ist, können Sie verhindern, dass eine inkrementelle Tabelle neu erstellt wird.

So kennzeichnen Sie eine inkrementelle Tabelle als protected:

  1. Rufen Sie Ihren Entwicklungsarbeitsbereich auf.
  2. Maximieren Sie im Bereich Dateien definitions/.
  3. Wählen Sie eine SQLX-Datei mit einer inkrementellen Tabellendefinition aus.
  4. Geben Sie im Block config den Wert protected: true ein.
  5. Optional: Klicken Sie auf Formatieren.

Das folgende Codebeispiel zeigt eine inkrementelle Tabelle, die als protected gekennzeichnet ist:

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

Tabellendokumentation hinzufügen

In diesem Abschnitt erfahren Sie, wie Sie einer Dataform-Core-SQLX-Datei Beschreibungen für eine Tabelle und ihre Spalten und Einträge hinzufügen.

Sie können allen Tabellentypen in Dataform Beschreibungen für Tabellen, Spalten und Einträge hinzufügen: Tabellen, inkrementelle Tabellen und Ansichten.

Sie sollten Folgendes dokumentieren:

  • Der Zweck der Tabelle.
  • Der Inhalt oder die Rolle von Spalten oder Einträgen in der Tabelle.
  • Die Beziehung zwischen der Tabelle und anderen Aktionen Ihres Workflows, z. B. Tabellen oder Ansichten, die von der aktuellen Tabelle abhängen.
  • Die auf die Tabelle angewendeten Behauptungen.
  • Die Vor- oder Nachverarbeitungen, die auf die Tabelle angewendet werden.
  • Der Inhaber der Tabelle, also der Nutzer, der sie erstellt hat. Diese Informationen können hilfreich sein, wenn mehrere Teammitglieder an einem Workflow arbeiten.

Tabellenbeschreibung hinzufügen

So fügen Sie einer Tabelle in einer SQLX-Datei eine Beschreibung hinzu:

  1. Öffnen Sie in der Google Cloud Console die Seite Dataform.

    Zu Dataform

  2. Wählen Sie ein Repository aus.

  3. Wählen Sie einen Entwicklungsarbeitsbereich aus.

  4. Klicken Sie im Bereich Dateien auf die SQLX-Datei der Tabellendefinition, die Sie bearbeiten möchten.

  5. Geben Sie im Block config der Datei die Tabellenbeschreibung im folgenden Format ein:

    description: "Description of the table",

  6. Optional: Klicken Sie auf Formatieren.

Im folgenden Codebeispiel wird eine Tabellenbeschreibung gezeigt, die dem Block config einer SQLX-Tabellendefinitiondatei hinzugefügt wurde:

config {
  type: "table",
  description: "Description of the table",
 }

Spalten- und Datensatzbeschreibungen hinzufügen

So fügen Sie einer SQLX-Datei Beschreibungen einzelner Spalten und Einträge hinzu:

  1. Geben Sie in der Tabellendefinitionsdatei im Block config den Wert columns: {} ein.

  2. Geben Sie in columns: {} Spaltenbeschreibungen im folgenden Format ein:

    column_name: "Description of the column",

  3. Geben Sie in columns: {} Eintragsbeschreibungen im folgenden Format ein:

      record_name: {
      description: "Description of the record",
      columns: {
        record_column_name: "Description of the record column"
      }
}

  4. Optional: Klicken Sie auf Formatieren.

Im folgenden Codebeispiel sind Tabellen-, Spalten- und Datensatzbeschreibungen im config-Block einer SQLX-Tabellendefinitiondatei zu sehen:

config {
  type: "table",
  description: "Description of the table.",
  columns: {
    column1_name: "Description of the first column",
    column2_name: "Description of the second column",
    column3_name: "Description of the third column",
    record_name: {
      description: "Description of the record.",
      columns: {
       record_column1_name: "Description of the first record column",
       record_column2_name: "Description of the second record column",
      }
    }
  }
}
SELECT
  "first_column_value" AS column_1_name,
  "second_column_value" AS column_2_name,
  "third_column_value" AS column_3_name,
  STRUCT("first" AS record_column1_name,
    "second" AS record_column2_name) AS record_name

Spaltendokumentation mit „Enthält“ wiederverwenden

Sie können Beschreibungen von Spalten in Dataform in Ihrem SQL-Workflow mit JavaScript-Includes wiederverwenden. Sie können die Spaltendokumentation wiederverwenden, wenn Sie in Ihrem SQL-Workflow mehrere Spalten mit demselben Namen und derselben Beschreibung haben.

Sie können eine Konstante mit einer Beschreibung einer einzelnen Spalte oder einer Konstante mit einer Satz- oder Spaltenbeschreibung definieren, um die Beschreibungen aller Spalten in einer Tabelle wiederzuverwenden. Weitere Informationen zum Erstellen und Verwenden von Includes in Dataform finden Sie unter Code in einem einzelnen Repository mit Includes wiederverwenden.

Das folgende Codebeispiel zeigt mehrere Konstanten mit Beschreibungen einzelner Spalten, die in der JavaScript-Datei includes/docs.js definiert sind:


// filename is includes/docs.js

const user_id = `A unique identifier for a user`;
const age = `The age of a user`;
const creation_date = `The date this user signed up`;
const user_tenure = `The number of years since the user's creation date`;
const badge_count = `The all-time number of badges the user has received`;
const questions_and_answer_count = `The all-time number of questions and answers the user has created`;
const question_count = `The all-time number of questions the user has created`;
const answer_count = `The all-time number of answers the user has created`;
const last_badge_received_at = `The time the user received their most recent badge`;
const last_posted_at = `The time the user last posted a question or answer`;
const last_question_posted_at = `The time the user last posted an answer`;
const last_answer_posted_at = `The time the user last posted a question`;

module.exports = {
   user_id,
   age,
   creation_date,
   user_tenure,
   badge_count,
   questions_and_answer_count,
   question_count,
   answer_count,
   last_badge_received_at,
   last_posted_at,
   last_question_posted_at,
   last_answer_posted_at,
};

Das folgende Codebeispiel zeigt die in includes/docs.js definierten Konstanten user_id und age, die in der SQLX-Tabellendefinitiondatei definitions/my_table.sqlx verwendet werden, um Dokumentation für ausgewählte Spalten in der Tabelle zu generieren:

config {
  type: "table",
  description: "Table description.",
  columns: {
    user_id: docs.user_id,
    column2_name: "Description of the second column",
    column3_name: "Description of the third column",
    age: docs.age,
  }
}

SELECT ...

Das folgende Codebeispiel zeigt eine Konstante mit einer Reihe von Spaltenbeschreibungen, die in der JavaScript-Datei includes/docs.js definiert sind:


// filename is includes/docs.js

const columns = {
    user_id = `A unique identifier for a user`,
    age = `The age of a user`,
    creation_date = `The date this user signed up`,
    user_tenure = `The number of years since the user's creation date`,
    badge_count = `The all-time number of badges the user has received`,
    questions_and_answer_count = `The all-time number of questions and answers the user has created`,
    question_count = `The all-time number of questions the user has created`,
    answer_count = `The all-time number of answers the user has created`,
    last_badge_received_at = `The time the user received their most recent badge`,
    last_posted_at = `The time the user last posted a question or answer`,
    last_question_posted_at = `The time the user last posted an answer`,
    last_answer_posted_at = `The time the user last posted a question`,
}


module.exports = {
  columns
};

Das folgende Codebeispiel zeigt die Konstante columns, die in includes/table_docs.js definiert und in der SQLX-Tabellendefinitiondatei definitions/my_table.sqlx verwendet wird, um Dokumentation für alle Spalten in der Tabelle zu generieren:

config { type: "table",
description: "My table description",
columns: docs.columns
}

SELECT 1 AS one

Nächste Schritte