dbt-Schnellansicht: Ein umfassendes Tutorial

dbt (Data Build Tool) ist ein echt starkes Tool, das von Datenanalysten und -ingenieuren verwendet wird, um Daten im modernen Datenstack zu transformieren, zu testen und zu dokumentieren. 

Obwohl es vor allem für seine Modellierungsfunktionen bekannt ist, gibt's noch eine weitere wichtige Funktion: dbt Snapshot. Damit kannst du langsam wechselnde Dimensionen (SCD) in deinem Data Warehouse erfassen.

In diesem Tutorial erfährst du alles über dbt-Snapshots, wofür man sie benutzt und wie man sie einsetzt. Ich werde:

• Erkläre, was dbt-Snapshots sind.
• Erkläre, wann und warum man Snapshots verwendet.
• Mach einen Snapshot Schritt für Schritt.
• Visualisiere Momentaufnahmen von Daten.
• Teile ein paar bewährte Methoden und Herausforderungen.

Wenn du mehr über dbt erfahren möchtest, schau dir unbedingt unseren Leitfaden „ “ an . Was ist dbt? Eine praktische Einführung für Dateningenieure „ “ und unser Kurs „Einführung in dbt“.

Was sind dbt-Snapshots?

Ein dbt-Snapshot ist ein Mechanismus, um Änderungen in Datensätzen im Laufe der Zeit zu verfolgen, vor allem für Tabellen, in denen historische Änderungen standardmäßig nicht gespeichert werden. Snapshots werden hauptsächlich verwendet, um langsam wechselnde Dimensionen (SCD) vom Typ 2. Sie speichern Versionen von Zeilen, wenn sich verfolgte Spalten ändern. 

Anwendungsfälle sind zum Beispiel:

• Verfolgen von Änderungen in Kundenprofilen im Laufe der Zeit.
• Überwachung von Statusänderungen in Betriebsdaten.
• Aufzeichnung der Entwicklung von Dimensionsattributen für eine genaue historische Berichterstattung.

Warum dbt-Snapshots verwenden? Vorteile und Anwendungsfälle

dbt-Snapshots sind super, weil sie Datenänderungen im Laufe der Zeit aufzeichnen und so historische Analysen und Compliance-Berichte ermöglichen.

Vorteile

Hier sind ein paar Vorteile, die du mit Snapshots hast:

• Trendanalyse: Versteh, wie sich das Verhalten, die Eigenschaften oder der Status von Kunden entwickeln.
• Auditierung und Compliance-: Zeig den Prüfern oder Aufsichtsbehörden, wie die Daten in der Vergangenheit waren.
• Debugging von Datenpipelines: Finde raus, wann ein Datensatz unerwartet geändert wurde, um Probleme zu verfolgen.

Häufige Anwendungsfälle

Snapshots können in bestimmten Situationen nützlich sein, zum Beispiel:

• Mitgliedschafts-Upgrades in Treueprogrammen verfolgen.
• Aufzeichnung der Preisentwicklung für Produkte im Einzelhandel.
• Änderungen der Abteilungen von Mitarbeitern in HR-Systemen erfassen.

Architektonische Grundlagen

Snapshots lassen sich nahtlos in das Ökosystem von dbt integrieren und nutzen dessen Konfigurations- und Ausführungsmanagement, um historische Tabellen effizient zu erstellen.

Schauen wir uns mal die Arten von Modellen an, die in Daten verwendet werden.

Für die Daten gibt's zwei Modelle:

• Standardmodelle: Daten umwandeln, um Tabellen mit dem aktuellen Stand zu erstellen.
• Snapshot-Modelle: Erstell versionsierte Tabellen, um historische Änderungen im Lernpfad zu verfolgen.

Diese beiden Modelle unterscheiden sich in ihrem Zweck, ihrer Speichermethode und ihren Anwendungsbereichen.

Hier eine kurze Zusammenfassung der Unterschiede:

So funktionieren dbt-Snapshots

Snapshots folgen normalerweise einem strukturierten Ablauf, der sicherstellt, dass alle Änderungen systematisch erfasst werden. Dabei sind folgende Schritte zu beachten:

1. Konfigurations: Leg fest, wie du Snapshots machst, welche Schlüssel einzigartig sein sollen und welche Spalten auf Änderungen überprüft werden sollen.
2. Ausführung: Führ „ dbt snapshot “ aus, um die aktuellen Daten mit den vorhandenen Snapshots zu vergleichen.
3. Speicherung: dbt fügt neue Datensätze für erkannte Änderungen ein und aktualisiert die Gültigkeitszeitstempel.

Aber wie werden Änderungen in dbt verfolgt?

Alle Änderungen werden in der Tabelle „Ausgabe-Snapshot“ festgehalten.

Wenn eine Änderung gefunden wird, aktualisiert dbt das Feld „ dbt_valid_to “ für die vorherige Version mit dem aktuellen Zeitstempel und fügt eine neue Zeile mit dem Feld „ dbt_valid_from “ als aktuellen Zeitstempel ein.

Snapshot-Strategien in dbt

Snapshots nutzen zwei Hauptstrategien, um Änderungen zu erkennen.

1. Zeitstempel-Strategie

• Definition: Verwendet ein Zeitstempelfeld, um Änderungen zu erkennen.
• Wann sollte man „ “ verwenden? Die Quelltabelle hat zuverlässige Zeitstempel für die Daten updated_at.

2. Strategie überprüfen

• Definition: Vergleicht die angegebenen Spalten direkt miteinander.
• Wann sollte man „ “ verwenden? Die Quelltabelle hat keine zuverlässigen Zeitstempel, aber die Änderungen an den Attributen müssen verfolgt werden.

Hard Deletes

Datenänderungen, wie zum Beispiel Löschungen, können auch verfolgt werden, aber nicht standardmäßig. Es gibt aber eine Möglichkeit, das zu ändern, um solche endgültigen Löschungen zu überwachen.

• Problem-: Snapshots verfolgen standardmäßig keine gelöschten Zeilen.
• Lösungs-: Setz „ invalidate_hard_deletes=True “, um gelöschte Zeilen mit dem Wert „ dbt_valid_to “ zu markieren und ihren letzten Status zu behalten.

Hier ist ein Beispiel für eine Prüfstrategie, die unter Berücksichtigung von endgültigen Löschungen umgesetzt wird:

{%
  snapshot customers_snapshot %}

{%
  set config(
    target_schema='snapshots',
    unique_key='customer_id',
    strategy='check',
    check_cols=['tier'],
    invalidate_hard_deletes=True
  )
%}

SELECT * FROM {{ source('customers') }}

{% endsnapshot %}

Implementierungsleitfaden für dbt-Snapshots

Jetzt, wo wir wissen, wie dbt-Snapshots funktionieren, schauen wir uns an, wie man sie einsetzt. 

1. Beispieldatensatz für das Snapshot-Tutorial

Um Snapshots zu üben, erstellen wir eine Beispieltabelle „Kunden“, die ein echtes Mitgliedersystem nachahmt. Das gibt uns ein paar konkrete Daten, um gängige Snapshot-Strategien zu testen.

import csv
from datetime import datetime

# Define the data
customers_data = [
    ["customer_id", "name", "tier", "updated_at"],  # header row
    [1, "Alice Tan", "Silver", "2025-07-01 10:00:00"],
    [2, "Bob Lee", "Gold", "2025-07-01 10:00:00"],
    [3, "Cheryl Lim", "Silver", "2025-07-01 10:00:00"]
]

# Write data to customers.csv
with open("customers.csv", mode="w", newline="", encoding="utf-8") as file:
    writer = csv.writer(file)
    writer.writerows(customers_data)

2. Einrichten deines dbt-Projekts

Bevor du Snapshots machen kannst, musst du dein dbt-Projekt richtig einrichten. So stellst du sicher, dass deine Umgebung so eingerichtet ist, dass Modelle, Snapshots, Tests und Dokumentation auf strukturierte und skalierbare Weise verwaltet werden können.

Was du schon wissen solltest

• Stell sicher, dass du Python 3.7+ installiert hast.
• Installiere dbt mit pip:

pip install dbt

Ersetz „dbt-postgres” durch deinen Warehouse-Adapter, z. B. „dbt-snowflake” oder „dbt-bigquery”, je nachdem, was du benutzt.

Schritt-für-Schritt-Anleitung zur Einrichtung

1. Geh zum Projektordner, den du brauchst.

Hier speicherst du deine Analyse- oder ELT-Projekte. In diesem Fall speichern wir alle zugehörigen Dateien in diesem dbt-Projektordner.

cd ~/dbt-snapshot-project

2. Starte ein neues dbt-Projekt.

Erstell eine Konfigurationsdatei namens dbt_project.yml:

Füge das Folgende in deine Projektdatei ein:

name: dbt_snapshots_project
version: '1.0'
profile: austinchia

seeds:
  dbt_snapshots_project:
    +quote_columns: false

3. Teste deine Verbindung.

dbt debug

Das sollte die Ausgabe des Befehls sein:

4. Lade die Samen in eine lokale Datenbank.

Führ den folgenden Befehl aus:

dbt seed

Das sollte die Ausgabe des Befehls sein:

5. Mach deine Datenbank-Verbindungseinstellungen fertig

In der Datei „profiles.yml“, die normalerweise unter ~/.dbt/profiles.yml zu finden ist.

Hier ist, was in meiner Profil-Datei steht:

austinchia:
  target: dev
  outputs:
    dev:
      type: sqlite
      threads: 1
      database: ./dbt_snapshots_project.db
      schema: main
      schema_directory: ./schemas
      schemas_and_paths:
        main: ./dbt_snapshots_project.db
      extensions:
        - "C:/sqlean/crypto.dll"

Wenn du eine SQLite-Datenbank wie ich, musst du das SQLean .

6. Lade deine Daten in die dbt-Staging-Modelle:

Mach einen neuen Ordner namens „models“. Erstell in diesem Ordner eine Datei mit dem Namen „ stg_customers.sql “.

Kopiere den folgenden Code in die Datei:

SELECT
  *
FROM {{ ref('customers') }}

7. Erstell Staging-Modelle mit dem folgenden Befehl in dbt.

dbt run --select stg_customers

Das sollte die Ausgabe des Befehls sein:

3. Konfigurieren von dbt Snapshot

1. Mach ein Verzeichnis namens „snapshots/“.
2. Schreib deine Snapshot-SQL-Datei mit der richtigen Konfiguration.

Für dieses Beispiel kannst du den folgenden Code verwenden, um einen Snapshot mit Zeitstempelstrategie durchzuführen.

{% snapshot customers_snapshot %}

{{
  config(
    target_schema='snapshots',
    unique_key='customer_id',
    strategy='timestamp',
    updated_at='updated_at'
  )
}}

select * from {{ ref('customers') }}

{% endsnapshot %}

4. dbt Snapshot ausführen

Ausführen:

dbt snapshot

In diesem Befehl erstellt dbt die Snapshot-Tabelle, falls sie noch nicht vorhanden ist. Außerdem werden neue Zeilen für gefundene Änderungen eingefügt.

Das sollte die Ausgabe des Befehls sein:

5. Snapshot-Tabellen überprüfen

Nachdem du den Snapshot erstellt hast, sollte eine neue Datei namens „ snapshot.db “ in deinem Projektverzeichnis erstellt worden sein.

Ich hab das in VSCode geöffnet, um zu sehen, wie die Datei aussieht:

Wie du sehen kannst, gibt's da noch ein paar Spalten, wie zum Beispiel „ dbt_updated_at “ und so weiter. Diese sind entscheidend, um festzustellen, ob und wann Änderungen an den Daten vorgenommen wurden.

Weitere praktische Anleitungen zu dbt findest du in unserem Semantic Layer mit dbt.

Beispiel: Verfolgen von Datenänderungen mit dbt-Snapshots

Mit Snapshots können Teams einen vollständigen Prüfpfad aller Änderungen an beliebigen Attributen in einer Tabelle im Laufe der Zeit erfassen, was sie für Compliance, Fehlerbehebung und Analysen sehr nützlich macht.

1. Erstell eine Beispiel- customers -Tabelle mit den relevanten Feldern. Dazu gehören die Kunden-ID, der Name, die E-Mail-Adresse und der Zeitstempel „updated_at“, um zu verfolgen, wann Änderungen vorgenommen wurden.

CREATE TABLE customers (
    customer_id INTEGER PRIMARY KEY,
    name VARCHAR(100),
    email VARCHAR(100),
    updated_at TIMESTAMP
);

2. Gib die ersten Daten ein, um einen Ausgangswert zu simulieren.

Verwende den folgenden Code, um Daten in die Tabelle einzufügen. Diese Daten werden für die Originaldaten vor der Änderung verwendet.

INSERT INTO customers VALUES 
(1, 'Alice Tan', 'alice@example.com', '2025-07-01 10:00:00'),
(2, 'Bob Lee', 'bob.lee@example.com', '2025-07-01 10:00:00');

3. Schreib eine dbt-Snapshot-Konfiguration, um E-Mail-Änderungen auf einem Lernpfad zu verfolgen:

{% snapshot customers_email_snapshot %}

{%
  set config(
    target_schema='snapshots',
    unique_key='customer_id',
    strategy='check',
    check_cols=['email'],
    invalidate_hard_deletes=True
  )
%}

SELECT * FROM {{ source('customers') }}

{% endsnapshot %}

4. Starte „ dbt snapshot “, um den Anfangszustand zu speichern.

dbt snapshot

5. Simuliere eine E-Mail-Aktualisierung in der Quelltabelle.

Als Nächstes aktualisieren wir unsere ursprüngliche Tabelle, indem wir die Informationen eines Kunden ändern, um eine Datenänderung zu simulieren.

UPDATE customers
SET email = 'alice.tan@example.com', updated_at = '2025-07-02 09:00:00'
WHERE customer_id = 1;

6. Starte „ dbt snapshot “ nochmal, um die Änderung zu speichern.

dbt snapshot

7. Frag die Snapshot-Tabelle ab.

Um die Unterschiede und Änderungen an den Daten zu sehen, musst du die Snapshot-Tabelle abfragen. Die Tabelle sollte beide Versionen der E-Mail-Adresse mit ihren jeweiligen Gültigkeitszeiträumen zeigen:

SELECT customer_id, email, dbt_valid_from, dbt_valid_to
FROM snapshots.customers_email_snapshot
ORDER BY customer_id, dbt_valid_from;

Dieser Prozess stellt sicher, dass du einen vollständigen Änderungsverlauf für E-Mail-Updates behältst, was für DSGVO-Audits, die Nachverfolgung des Kontakthistorien oder die Analyse des Kundensupports super wichtig ist.

Erweiterte Konfiguration und Verwaltung

Mit einem guten Konfigurationsmanagement können Teams Snapshot-Implementierungen nahtlos über Projekte und Umgebungen hinweg skalieren.

1. Konfiguration auf Projekt- und Ressourcenebene

• Projektbezogene Konfiguration: Mit „ dbt_project.yml “ kannst du Standardkonfigurationen für Snapshots festlegen, wie zum Beispiel das Zielschema oder Materialisierungen, die für alle Snapshots gelten sollen.
• Konfiguration auf Ressourcenebene: Überschreib die Einstellungen in einzelnen Snapshot-SQL-Dateien für bestimmte Anforderungen, um flexibel zu bleiben.

2. Metadatenfelder anpassen

Standardmäßig erstellt dbt die Felder „ dbt_valid_from “ und „ dbt_valid_to “. Du kannst diese mit den Konfigurationsoptionen „ valid_from “ und „ valid_to “ umbenennen, wenn dein Team aus Gründen der Übersichtlichkeit in BI- oder Datenverwaltungs-Tools andere Namenskonventionen braucht.

3. Alte Snapshot-Konfigurationen verschieben

Migrationen können zu Problemen führen, wenn sie nicht richtig gemacht werden. Hier sind ein paar Punkte, auf die du bei der Migration deiner Snapshot-Konfigurationen achten solltest:

1. Identifiziere alte Snapshot-Definitionen mit veralteten Konfigurationsblockstilen.
2. Umstellung auf YAML-basierte Konfigurationen , wenn du moderne dbt-Versionen verwendest, um alles einheitlich zu halten.
3. Richtigheit überprüfen:
• Mach mal Schnappschüsse in Testumgebungen.
• Vergleich die Ergebnisse, bevor du alte Snapshots löschst.
4. Stilllegung: Entferne alte Snapshot-Dateien und passe die Dokumentation entsprechend an.

4. Mit anderen Tools zusammenarbeiten

Datenänderungen können mit dbt-Snapshots verfolgt werden. 

Zum Beispiel:

• BI-Tools (z. B. Power BI, Tableau): Erstell zeitliche Visualisierungen, die zeigen, wie sich Attribute im Laufe der Zeit ändern.
• Plattformen für Beobachtbarkeit (z. B. Monte Carlo, Datafold): Überprüfe, ob die Daten aktuell und historisch korrekt sind.
• Datenkataloge (z. B. Alation, Collibra): Füge Tabellen mit dem Verlauf von Momentaufnahmen als dokumentierte Abstammungsartefakte für die Compliance hinzu.

Tipps für die Umsetzung in der Produktion

Die Implementierung von dbt-Snapshots in der Produktion erfordert ein durchdachtes Design, um Leistung, Wartbarkeit und Geschäftswert sicherzustellen.

Am besten hältst du dich an Folgendes:

1. Optimale Anwendungsfälle und Tabellenauswahl

• Priorisieren Sie Dimensionstabellen mit Attributen, die sich nur langsam ändern, wie Kundenprofile, Produktstammdaten und Lieferantenverträge.
• Vermeide Tabellen für Transaktionen (z. B. Bestellpositionen) mit vielen Einfügungen und Aktualisierungen, es sei denn, das schnelle Wachstum des Speicherplatzes macht das notwendig.

2. Techniken zur Leistungsoptimierung

In der Produktion solltest du deine Daten so optimieren, dass Datenänderungen effizient verfolgt werden können, ohne dein Produkt zu beeinträchtigen.

Hier sind ein paar Tipps:

• Indexierung: Füge Indizes für die Spalten „ unique_key “ und „validity“ hinzu, damit die Abfragen schneller gehen.
• Partitionierung: Partitionieren Sie Snapshot-Tabellen nach Datum, um die Scan-Performance zu optimieren.
• Clustering (lagerspezifisch): Verwende Clustering-Schlüssel (z. B. in BigQuery) für Felder mit hoher Kardinalität, um die Geschwindigkeit von Filterabfragen zu verbessern.

3. Wartung und Überwachung

• Terminplanung: Mach Snapshots in Zeiten mit wenig Traffic, um die Auswirkungen auf die Rechenkosten zu minimieren.
• Überwachung: Richte Warnmeldungen für Snapshot-Fehler in dbt Cloud oder deinem Orchestrierungstool ein.
• Überprüfung der Datenaktualität: Benutz dbt-Tests oder Observability-Tools, um zu checken, ob die Snapshot-Daten aktuell sind.
• Speicheranalyse: Überprüfe regelmäßig die Größe der Snapshot-Tabellen und lösche alte Daten, wenn das Geschäft es zulässt.

4. Häufige Fehler

Die Verwendung einer nicht eindeutigen ID „ unique_key “ führt zu falschen Zeilenversionen. Teste die Einzigartigkeitslogik immer vor dem Einsatz. 

Snapshot-Aufblähung kann auch passieren, wenn unnötige historische Änderungen gespeichert werden (z. B. Spalten mit häufigen Aktualisierungen des Zeitstempels), können die Speicherkosten schnell steigen.

Häufige Herausforderungen und Lösungen

Die Verwendung von Snapshots in dbt kann ein paar technische Herausforderungen mit sich bringen:

1. Eindeutige Schlüsselkollisionen

Problem: Doppelte Zeilen im Snapshot, weil die eindeutigen Schlüssel nicht richtig definiert sind.

Lösung:

• Überprüfe die Einzigartigkeit mit dbt-Tests, bevor du den Snapshot bereitstellst.
• Füge mehrere Felder zusammen, um bei Bedarf die Eindeutigkeit von zusammengesetzten Feldern sicherzustellen.

2. Leistung bei zeitbezogenen Abfragen

Problem: Langsame Abfragen bei der Analyse historischer Daten.

Lösung:

• Nutze Lageraufteilung und Clusterbildung richtig.
• Filtere Abfragen immer nach „ dbt_valid_from “ oder Datumsbereichen, um die Menge der gescannten Daten zu reduzieren.

3. Fehler bei der Ausführung von Snapshots beheben

Häufige Probleme sind:

• Schema oder Datenbankberechtigungen sind nicht richtig.
• Änderungen am Schema der Quelltabelle (z. B. gelöschte Spalten) machen Snapshot- SELECT -Anweisungen kaputt.
• Syntaxfehler in Snapshot-Konfigurationsblöcken.

Lösungen:

• Mit „ dbt debug “ kannst du die Verbindung und die Konfiguration checken.
• Führ CI-Tests in dbt durch, um Fehler vor der Bereitstellung zu erkennen.
• Schau dir die dbt-Ausführungsprotokolle an, um genaue Fehlermeldungen zu sehen.

Fazit

Mit dbt-Snapshots können Analyse-Teams mit minimalem Aufwand robuste historische Datensätze erstellen, was Compliance-Analysen möglich macht. Wenn du mehr über DBT erfahren möchtest, schau dir unseren Kurs „ Einführung in dbt. Weitere Informationen und Anleitungen findest du in unserer Einführung in das dbt-utils-Paket und dbt-Tutorial.