Dynamische Tabellen erstellen¶

Einschränkungen und Hinweise zur Verwendung von Iceberg-Tabellen¶

Alle Einschränkungen für reguläre dynamische Tabellen und dynamische Iceberg-Tabellen gelten weiterhin.

Außerdem:

• Alle Einschränkungen für Iceberg-Basistabellen gelten. Weitere Informationen dazu finden Sie unter Hinweise und Einschränkungen.

• Sie können eine dynamische Tabelle erstellen, die aus nativen Snowflake-Tabellen, aus Snowflake verwalteten Iceberg-Tabellen und aus extern verwalteten Iceberg-Tabellen liest.

• Dynamische Tabellen verfolgen Änderungen auf Dateiebene für extern verwaltete Iceberg-Basistabellen, im Gegensatz zu anderen Basistabellen, die Änderungen auf Zeilenebene verfolgen. Häufige Kopieren-auf-Schreiben-Operationen (z. B. Aktualisierungen oder Löschungen) auf extern verwalteten Iceberg-Tabellen können sich auf die Leistung von inkrementellen Aktualisierungen auswirken.

Beispiele für die Verwendung von Unveränderlichkeitseinschränkungen¶

Im folgenden Beispiel wird eine dynamische Tabelle erstellt und mithilfe des Parameters IMMUTABLE WHERE als unveränderlich festgelegt.

CREATE DYNAMIC TABLE my_dynamic_table (id1 INT)
  TARGET_LAG = '20 minutes'
  WAREHOUSE = mywh
  IMMUTABLE WHERE ( <expr> )
  AS
    SELECT id AS id1 FROM staging_table;

Spalten, auf die in der IMMUTABLE WHERE-Bedingung verwiesen wird, müssen Spalten in der dynamischen Tabelle sein, keine Spalten aus der Basistabelle. Beispiel: Der Ausdruck IMMUTABLE WHERE im obigen Beispiel kann nur id1 verwenden, nicht id.

Sie können nur eine einzige IMMUTABLE WHERE-Bedingung für eine dynamische Tabelle festlegen. Um ein vorhandenes Prädikat zu ersetzen, verwenden Sie den Befehl ALTER DYNAMIC TABLE, wie im folgenden Beispiel gezeigt:

-- Set or replace an existing predicate:
ALTER DYNAMIC TABLE my_dynamic_table SET IMMUTABLE WHERE ( <expr> );

-- Remove an existing predicate:
ALTER DYNAMIC TABLE my_dynamic_table UNSET IMMUTABLE;

Um die Unveränderlichkeitseinschränkungen für Ihre dynamischen Tabellen anzuzeigen, führen Sie den Befehl SHOW DYNAMIC TABLES aus. Die Spalte immutable_where zeigt die Einschränkung IMMUTABLE WHERE an, die für die Tabelle festgelegt wurde, oder NULL, wenn keine festgelegt ist.

Weitere Informationen zu Computekosten finden Sie unter Computekosten für Unveränderlichkeitseinschränkungen.

CREATE DYNAMIC TABLE joined_data
  TARGET_LAG = '1 minute'
  WAREHOUSE = mywh
  IMMUTABLE WHERE (timestamp_col < CURRENT_TIMESTAMP() - INTERVAL '1 day')
  AS
    SELECT F.primary_key primary_key, F.timestamp_col timestamp_col, D.value dim_value
    FROM fact_table F
    LEFT OUTER JOIN dimension_table D USING (primary_key);

CREATE TABLE staging_data (raw TEXT, ts TIMESTAMP);

CREATE DYNAMIC TABLE parsed_data
  TARGET_LAG = '1 minute'
  WAREHOUSE = mywh
  IMMUTABLE WHERE (ts < CURRENT_TIMESTAMP() - INTERVAL '7 days')
  AS
    SELECT parse_json(raw):event_id::string event_id, parse_json(raw):name::string name, parse_json(raw):region::string region, ts
    FROM staging_data WHERE region = 'US';

-- Delete old staging data using Task
CREATE TASK delete_old_staging_data
  WAREHOUSE = mywh
  SCHEDULE = '24 hours'
  AS
    DELETE FROM staging_data WHERE ts < CURRENT_TIMESTAMP() - INTERVAL '30 days';

CREATE FUNCTION my_udtf(x varchar)
  RETURNS TABLE (output VARCHAR)
  LANGUAGE PYTHON
  AS $$ ... $$;

CREATE DYNAMIC TABLE udtf_dt
  TARGET_LAG = '1 hour'
  WAREHOUSE = mywh
  REFRESH_MODE = FULL
  IMMUTABLE WHERE (ts < current_timestamp() - interval '1 day')
  AS
    SELECT ts, data, output, join_key FROM input_table, TABLE(my_udtf(data));

CREATE DYNAMIC TABLE incremental_join_dt
  TARGET_LAG = '1 hour'
  WAREHOUSE = mywh
  REFRESH_MODE = INCREMENTAL
  IMMUTABLE WHERE (ts < current_timestamp() - interval '1 day')
  AS
    SELECT * FROM udtf_dt JOIN dim_table USING (join_key);

Einschränkungen und Hinweise zum Festlegen von Unveränderlichkeitseinschränkungen¶

Alle Einschränkungen von regulären dynamischen Tabellen gelten weiterhin.

Außerdem:

• Es kann nur ein einziges IMMUTABLE WHERE-Prädikat für eine dynamische Tabelle geben. Das Festlegen eines weiteren mit einem ALTER DYNAMIC TABLE … SET IMMUTABLE WHERE-Befehl ersetzt jedes vorhandene Prädikat.

• IMMUTABLE WHERE-Einschränkungen können die folgenden Elemente nicht enthalten:

  • Unterabfragen

  • Nicht deterministische Funktionen, mit Ausnahme von Zeitstempelfunktionen wie CURRENT_TIMESTAMP() oder CURRENT_DATE(). Wenn Sie Zeitstempelfunktionen verwenden, müssen Sie diese so verwenden, dass der unveränderliche Bereich mit der Zeit größer wird. Beispiel, bei dem dies nicht zutrifft: TIMESTAMP_COL < CURRENT_TIMESTAMP() is allowed but TIMESTAMP_COL > CURRENT_TIMESTAMP().

  • Benutzerdefinierte oder externe Funktionen

  • Spalten für Metadaten, zum Beispiel solche, die mit METADATA$ beginnen.

  • Spalten, die das Ergebnis von Aggregaten, Fensterfunktionen oder nicht deterministischen Funktionen sind, oder Spalten, die über einen Fensterfunktionsoperator übergeben werden In den folgenden dynamischen Tabellen kann nur col3 in IMMUTABLE WHERE-Prädikaten verwendet werden:

    CREATE DYNAMIC TABLE aggregates TARGET_LAG = '1 minute' WAREHOUSE = mywh
      AS SELECT col1, SUM(col2) AS col2 FROM input_table
      GROUP BY col3;
    
    CREATE DYNAMIC TABLE window_fns TARGET_LAG = '1 minute' WAREHOUSE = mywh
      AS SELECT col3, SUM(col4) OVER (PARTITION BY col3 ORDER BY col4) AS col2, col5 FROM input_table;
    

    Copy

IMMUTABLE WHERE-Einschränkungen werden beim Klonen und Replizieren ohne Einschränkungen kopiert.

Beispiele für die Verwendung von Backfilling¶

Die folgenden Beispiele zeigen, wie Sie neue dynamische Tabellen aus Tabellen mit durch Backfilling aufgefüllten Daten erstellen können.

Jeder Spaltenname muss in der Backfilling-Tabelle mit kompatiblen Datentypen vorhanden sein und muss in derselben Reihenfolge wie die Backfilling-Tabelle vorliegen. Tabelleneigenschaften und Berechtigungen werden nicht aus der Backfilling-Tabelle kopiert.

Wenn Time-Travel-Parameter AT | BEFORE angegeben werden, werden die Daten aus der Backfilling-Tabelle zur angegebenen Zeit kopiert.

CREATE DYNAMIC TABLE my_dynamic_table (day TIMESTAMP, totalSales NUMBER)
  IMMUTABLE WHERE (day < '2025-01-01')
  BACKFILL FROM my_backfill_table
  TARGET_LAG = '20 minutes'
  WAREHOUSE = 'mywh'
  AS SELECT DATE_TRUNC('day', ts) AS day, sum(price)
    FROM my_base_table
    GROUP BY day;

CREATE OR REPLACE TABLE sales(item_id INT, ts TIMESTAMP, sales_price FLOAT);

INSERT INTO sales VALUES (1, '2025-05-01 01:00:00', 10.0), (1, '2025-05-01 02:00:00', 15.0), (1, '2025-05-01 03:00:00', 11.0);
INSERT INTO sales VALUES (1, '2025-05-02 00:00:00', 11.0), (1, '2025-05-02 05:00:00', 13.0);


CREATE DYNAMIC TABLE my_dynamic_table
  TARGET_LAG = 'DOWNSTREAM'
  WAREHOUSE = mywh
  INITIALIZE = on_create
  IMMUTABLE WHERE (day <= '2025-05-01')
  AS
    SELECT item_id, date_trunc('DAY', ts) day, count(sales_price) AS sales_count FROM sales
    GROUP BY item_id, day;

SELECT item_id, to_char(day, 'YYYY-MM-DD') AS day, sales_count FROM my_dynamic_table;

+---------+------------+-------------+
| ITEM_ID | DAY        | SALES_COUNT |
|---------+------------+-------------|
| 1       | 2025-05-01 | 3           |
| 1       | 2025-05-02 | 2           |
|---------+-------------+------------|

DELETE FROM sales WHERE ts < '2025-05-02';

ALTER DYNAMIC TABLE my_dynamic_table REFRESH;

SELECT item_id, to_char(day, 'YYYY-MM-DD') AS day, sales_count FROM my_dynamic_table;

Einschränkungen und Hinweise beim Erstellen einer dynamischen Tabelle mit durch Backfilling aufgefüllten Daten¶

Alle Einschränkungen von regulären dynamischen Tabellen und die -Unveränderlichkeitseinschränkungen gelten weiterhin.

Es gelten die folgenden zusätzlichen Einschränkungen und Hinweise:

• Derzeit können nur reguläre Tabellen für das Backfilling verwendet werden.

• Sie können in der neuen dynamischen Tabelle keine Richtlinien oder Tags angeben, da diese aus der Backfilling-Tabelle kopiert werden.

• Die Gruppierungsschlüssel in der neuen dynamischen Tabelle und der Backfilling-Tabelle müssen identisch sein.

Pipelines dynamischer Tabellen verketten¶

Wenn Sie eine neue dynamische Tabelle definieren, sollten Sie keine große dynamische Tabelle mit vielen verschachtelten Anweisungen definieren, sondern stattdessen kleine dynamische Tabellen mit Pipelines verwenden.

Sie können eine dynamische Tabelle einrichten, um andere dynamische Tabellen abzufragen. Stellen Sie sich zum Beispiel ein Szenario vor, in dem Ihre Datenpipeline Daten aus einer Staging-Tabelle extrahiert, um verschiedene Dimensionstabellen zu aktualisieren (z. B. customer, product, date und time). Außerdem aktualisiert Ihre Pipeline eine aggregierte sales-Tabelle, die auf den Informationen aus diesen Dimensionstabellen basiert. Indem Sie die Dimensionstabellen so konfigurieren, dass sie die Staging-Tabelle abfragen, und die aggregierte sales-Tabelle so, dass sie die Dimensionstabellen abfragt, erzeugen Sie einen Kaskadeneffekt, ähnlich wie bei einem Task-Graphen.

In diesem Setup wird die Aktualisierung der aggregierten sales-Tabelle erst ausgeführt, nachdem die Aktualisierungen der Dimensionstabellen erfolgreich abgeschlossen wurden. Dies stellt die Konsistenz der Daten und die Einhaltung der Verzögerungsziele sicher. Durch einen automatischen Aktualisierungsprozess lösen alle Änderungen in den Quelltabellen zu den entsprechenden Zeitpunkten Aktualisierungen in allen abhängigen Tabellen aus.

Dynamische „Controller“-Tabelle für komplexe Task-Graphen verwenden¶

Wenn Sie einen komplexen Graphen von dynamischen Tabellen mit vielen Wurzeln und Blättern haben und mit einem einzigen Befehl Operationen (z. B. Änderung der Verzögerung, manuelle Aktualisierung, Aussetzung) am gesamten Task-Graphen ausführen möchten, gehen Sie wie folgt vor:

1. Setzen Sie den Wert für TARGET_LAG für alle Ihre dynamischen Tabellen auf DOWNSTREAM.

2. Erstellen Sie eine dynamische „Controller“-Tabelle, die alle Blätter in Ihrem Task-Graphen ausliest. Um sicherzustellen, dass dieser Controller keine Ressourcen verbraucht, gehen Sie wie folgt vor:

   CREATE DYNAMIC TABLE controller
     TARGET_LAG = <target_lag>
     WAREHOUSE = <warehouse>
     AS
       SELECT 1 A FROM <leaf1>, …, <leafN> LIMIT 0;
   

   Copy

3. Verwenden Sie den Controller, um den gesamten Task-Graphen zu steuern. Beispiel:

• Legen Sie eine neue Zielverzögerung für den Task-Graphen fest.

  ALTER DYNAMIC TABLE controller SET
    TARGET_LAG = <new_target_lag>;
  

  Copy

• Aktualisieren Sie den Task-Graphen manuell.

  ALTER DYNAMIC TABLE controller REFRESH;
  

  Copy

Verwenden Sie transiente dynamische Tabellen, um die Speicherkosten zu reduzieren¶

Transiente dynamische Tabellen halten Daten zuverlässig über die Zeit aufrecht und unterstützen Time Travel innerhalb der Datenaufbewahrungsfrist, bewahren aber keine Daten über die Fail-safe-Frist hinaus auf. Standardmäßig werden die dynamischen Tabellendaten sieben Tage lang im Fail-safe-Speicher aufbewahrt.

Bei dynamischen Tabellen mit hohem Aktualisierungsdurchsatz kann dies den Speicherverbrauch erheblich erhöhen. Daher sollten Sie eine dynamische Tabelle nur dann zu einer transienten Tabelle machen, wenn ihre Daten nicht dasselbe Maß an Datenschutz und Wiederherstellung benötigen, das permanente Tabellen bieten.

Mit der Anweisung CREATE DYNAMIC TABLE können Sie eine transiente dynamische Tabelle erstellen oder bestehende dynamische Tabellen in transiente dynamische Tabellen klonen.