Verbinden zu dbt Cloud

dbt (Data Build Tool) ist eine Entwicklungsumgebung, mit der Datenanalysten und Datentechniker Daten einfach transformieren können, indem sie select-Anweisungen schreiben. dbt übernimmt dann das Umwandeln dieser select-Anweisungen in Tabellen und Sichten. dbt kompiliert Ihren Code in unformatiertes SQL und führt diesen Code dann in der angegebenen Datenbank in Azure Databricks aus. dbt unterstützt Muster für das gemeinsame Schreiben von Code und bewährte Methoden wie Versionskontrolle, Dokumentation und Modularität.

dbt extrahiert oder lädt keine Daten. dbt befasst sich nur mit dem Transformationsschritt und verwendet eine „Transformation nach dem Laden“-Architektur. dbt geht davon aus, dass Sie bereits über eine Kopie Ihrer Daten in Ihrer Datenbank verfügen.

Im vorliegenden Artikel liegt der Schwerpunkt auf der dbt Cloud. dbt Cloud bietet sofort einsatzbereiten Support für die Planung von Aufträgen, CI/CD, Bereitstellung von Dokumentation, Überwachung und Warnungen sowie eine integrierte Entwicklungsumgebung (Integrated Development Environment, IDE).

Eine lokale Version von dbt namens dbt Core ist ebenfalls verfügbar. Mit dbt Core können Sie dbt-Code in dem Text-Editor oder der IDE Ihrer Wahl auf Ihrem lokalen Entwicklungscomputer schreiben und dann über die Befehlszeile dbt ausführen. dbt Core beinhaltet die dbt-Befehlszeilenschnittstelle (CLI). Die dbt-CLI kann kostenlos verwendet werden und ist Open Source. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit dbt Core.

Da dbt Cloud und dbt Core gehostete Git-Repositorys verwenden können (z. B. auf GitHub, GitLab oder BitBucket), können Sie dbt Cloud verwenden, um ein dbt-Projekt zu erstellen, und es dann ihren dbt Cloud- und dbt Core-Benutzern zur Verfügung stellen. Weitere Informationen finden Sie in den Artikeln zum Erstellen eines dbt-Projekts und zum Verwenden eines vorhandenen Projekts auf der dbt-Website.

Eine allgemeine Übersicht über dbt finden Sie im folgenden YouTube-Video (26 Minuten).

Herstellen einer Verbindung mit dbt Cloud mithilfe von Partner Connect

In diesem Abschnitt wird beschrieben, wie Sie ein Databricks SQL-Warehouse mithilfe von Partner Connect mit dbt Cloud verbinden und dann dbt Cloud Lesezugriff auf Ihre Daten gewähren.

Unterschiede zwischen Standardverbindungen und dbt Cloud

Folgen Sie den Schritten unter Herstellen einer Verbindung mit einem Partner für die Datenaufbereitung mithilfe von Partner Connect, wenn Sie mithilfe von Partner Connect eine Verbindung mit dbt Cloud herstellen möchten. Die dbt Cloud-Verbindung unterscheidet sich von standardbasierten Datenaufbereitungs- und Transformationsverbindungen auf folgende Weise:

• Zusätzlich zu einem Dienstprinzipal und einem persönlichen Zugriffstoken erstellt Partner Connect standardmäßig ein SQL-Warehouse (ehemals SQL-Endpunkt) namens DBT_CLOUD_ENDPOINT.

Schritte zum Herstellen einer Verbindung

Gehen Sie wie folgt vor, um mithilfe von Partner Connect eine Verbindung mit dbt Cloud herzustellen:

1. Herstellen einer Verbindung mit einem Partner für die Datenaufbereitung mithilfe von Partner Connect.

2. Nachdem Sie eine Verbindung mit dbt Cloud hergestellt haben, wird Ihr dbt Cloud-Dashboard angezeigt. Wenn Sie Ihr dbt Cloud-Projekt in der Menüleiste neben dem dbt-Logo erkunden möchten, wählen Sie ihren dbt-Kontonamen aus dem ersten Dropdown aus, wenn sie nicht angezeigt wird, und wählen Sie dann das Databricks Partner-Projekt Verbinden Testprojekt aus dem zweiten Dropdownmenü aus, wenn sie nicht angezeigt wird.

   Tipp

   Um die Einstellungen Ihres Projekts anzuzeigen, klicken Sie auf das Menü Drei Streifen oder Hamburger, dann auf Kontoeinstellungen > Projekte und schließlich auf den Namen des Projekts. Klicken Sie zum Anzeigen der Verbindungseinstellungen auf den Link neben Verbindung. Um Einstellungen zu ändern, klicken Sie auf Bearbeiten.

   Zum Anzeigen der persönlichen Azure Databricks-Zugriffstokeninformationen für dieses Projekt klicken Sie auf das Symbol Person auf der Menüleiste, klicken Sie auf Profilanmeldeinformationen >> Partner Verbinden Testversion, und klicken Sie auf den Namen des Projekts. Klicken Sie auf Bearbeiten (Edit), um eine Änderung vorzunehmen.

Schritte zum Gewähren des Lesezugriff auf Ihre Daten für dbt Cloud

Partner Verbinden gibt nur die Berechtigung Create-only für den DBT_CLOUD_USER Dienstprinzipal nur im Standardkatalog. Führen Sie die folgenden Schritte in Ihrem Azure Databricks-Arbeitsbereich aus, um dem DBT_CLOUD_USER Dienstprinzipal Lesezugriff auf die von Ihnen ausgewählten Daten zu gewähren.

Warnung

Sie können diese Schritte anpassen, um dbt Cloud zusätzlichen Zugriff auf Kataloge, Datenbanken und Tabellen innerhalb Ihres Arbeitsbereichs zu gewähren. Als bewährte Sicherheitspraxis empfiehlt Databricks jedoch dringend, dass Sie nur zugriff auf die einzelnen Tabellen gewähren, mit denen Sie den DBT_CLOUD_USER Dienstprinzipal verwenden müssen, um mit diesen Tabellen zu arbeiten und nur lesezugriff auf diese Tabellen zu erhalten.

1. Klicken Sie in der Seitenleiste auf Katalog.

2. Wählen Sie rechts oben in der Dropdownliste das SQL-Warehouse (DBT_CLOUD_ENDPOINT) aus.

   

   1. Wählen Sie unter Katalog-Explorer den Katalog aus, der die Datenbank für Ihre Tabelle enthält.
   2. Wählen Sie die Datenbank aus, die Ihre Tabelle enthält.
   3. Auswählen der Tabelle.

   Tipp

   Wenn Ihr Katalog, Die Datenbank oder die Tabelle nicht angezeigt wird, geben Sie einen Teil des Namens im Feld Katalog auswählen,Datenbank auswählen oderTabellen filternein, um die Liste einzugrenzen.

   

3. Klicken Sie auf Berechtigungen.

4. Klicken Sie auf Erteilen.

5. Wenn Sie mehrere Benutzer oder Gruppen hinzufügen möchten, wählen Sie DBT_CLOUD_USER aus. Dies ist der Azure Databricks-Dienstprinzipal, den Partner Verbinden für Sie im vorherigen Abschnitt erstellt hat.

   Tipp

   Wenn DBT_CLOUD_USER nicht angezeigt wird, beginnen Sie mit der Eingabe DBT_CLOUD_USER im Feld Typ, um mehrere Benutzer oder Gruppen hinzuzufügen, bis sie in der Liste angezeigt wird, und wählen Sie ihn dann aus.

6. Gewähren Sie schreibgeschützten Zugriff nur durch Auswahl von SELECT und READ METADATA.

7. Klicken Sie auf OK.

Wiederholen Sie die Schritte 4-9 für jede zusätzliche Tabelle, die Sie dbt Cloud-Lesezugriff gewähren möchten.

Problembehandlung bei der dbt Cloud-Verbindung

Wenn jemand das Projekt in dbt Cloud für dieses Konto löscht, und Sie auf die dbt-Kachel klicken, wird eine Fehlermeldung angezeigt, die besagt, dass das Projekt nicht gefunden werden kann. Um dies zu beheben, klicken Sie auf Verbindung löschen, und beginnen Sie dann am Anfang dieser Prozedur, um die Verbindung erneut zu erstellen.

Manuelles Herstellen einer Verbindung mit dbt Cloud

In diesem Abschnitt wird beschrieben, wie ein Azure Databricks-Cluster oder ein Databricks SQL-Warehouse in Ihrem Azure Databricks-Arbeitsbereich mit dbt Cloud verbunden wird.

Wichtig

Databricks empfiehlt, eine Verbindung mit einem SQL-Warehouse herzustellen. Wenn Sie nicht über die Databricks SQL-Zugriffsberechtigung verfügen oder Python-Modelle ausführen möchten, können Sie stattdessen eine Verbindung mit einem Cluster herstellen.

Anforderungen

• Ein Cluster oder SQL-Warehouse in Ihrem Azure Databricks-Arbeitsbereich

  • Computekonfigurationsreferenz.
  • Erstellen eines SQL-Warehouse

• Die Verbindungsdetails für Ihren Cluster oder Ihr SQL-Warehouse, insbesondere die Werte Serverhostname, Hafen und HTTP-Pfad

  • Abrufen von Verbindungsdetails für eine Azure Databricks-Computeressource.

• Ein persönliches Azure Databricks-Zugriffstoken oder ein Microsoft Entra ID-Token (früher Azure Active Directory). Gehen Sie wie folgt vor, um ein persönliches Zugriffstoken zu erstellen:

  1. Klicken Sie in Ihrem Azure Databricks-Arbeitsbereich in der oberen Leiste auf Ihren Azure Databricks-Benutzernamen, und wählen Sie dann im Dropdownmenü die Option Benutzereinstellungen aus.
  2. Klicken Sie auf Entwickler.
  3. Klicken Sie neben Zugriffstoken auf Verwalten.
  4. Klicken Sie auf Neues Token generieren.
  5. (Optional) Geben Sie einen Kommentar ein, durch den Sie dieses Token in Zukunft identifizieren können, und ändern Sie die standardmäßige Lebensdauer des Tokens von 90 Tagen. Wenn Sie ein Token ohne Gültigkeitsdauer erstellen möchten (nicht empfohlen), lassen Sie das Feld Lebensdauer (Tage) leer.
  6. Klicken Sie auf Generate (Generieren) .
  7. Kopieren Sie das angezeigte Token an einen sicheren Speicherort, und klicken Sie auf Fertig.

  Hinweis

  Achten Sie darauf, den kopierten Token an einem sicheren Ort zu speichern. Geben Sie das kopierte Token nicht an andere Personen weiter. Wenn Sie das kopierte Token verlieren, können Sie das gleiche Token nicht erneut generieren. Stattdessen müssen Sie erneut das Verfahren zum Erstellen eines neuen Tokens durchlaufen. Wenn Sie das kopierte Token verlieren oder glauben, dass das Token kompromittiert wurde, empfiehlt Databricks dringend, dass Sie das Token sofort aus Ihrem Arbeitsbereich löschen. Klicken Sie hierzu auf der Seite Zugriffstoken auf das Papierkorbsymbol (Widerrufen) neben dem Token.

  Wenn Sie in Ihrem Arbeitsbereich keine Token erstellen oder verwenden können, liegt dies möglicherweise daran, dass Ihr Arbeitsbereichsadministrator Token deaktiviert hat oder Ihnen keine Berechtigung zum Erstellen oder Verwenden von Token erteilt hat. Wenden Sie sich an Ihren Arbeitsbereichsadministrator oder lesen Sie:

  • Aktivieren oder Deaktivieren der Authentifizierung mit persönlichen Zugriffstoken für den Arbeitsbereich
  • Berechtigungen für persönliche Zugriffstoken

  Hinweis

  Als bewährte Methode für die Sicherheit empfiehlt Databricks, dass Sie bei der Authentifizierung mit automatisierten Tools, Systemen, Skripten und Anwendungen persönliche Zugriffstoken verwenden, die zu Dienstprinzipalen und nicht zu Benutzern des Arbeitsbereichs gehören. Informationen zum Erstellen von Token für Dienstprinzipale finden Sie unter Verwalten von Token für einen Dienstprinzipal.

• Wenn Sie dbt Cloud mit von Unity Catalog verwalteten Daten verbinden möchten – dbt-Version 1.1 oder höher.

  Mit den in diesem Artikel beschriebenen Schritten wird eine neue Umgebung erstellt, die die neueste dbt-Version verwendet. Informationen zum Durchführen eines Upgrades der dbt-Version für eine vorhandene Umgebung finden Sie unter Durchführen eines Upgrades auf die neueste Version von dbt in Cloud in der dbt-Dokumentation.

Schritt 1: Anmeldung für dbt Cloud

Gehen Sie auf dbt Cloud – Registrieren (dbt Cloud – Signup), und geben Sie Ihre E-Mail-Adresse, Ihren Namen und Ihre Unternehmensinformationen ein. Erstellen Sie ein Kennwort, und klicken Sie Mein Konto erstellen (Create my account).

Schritt 2: Erstellen eines dbt-Projekts

In diesem Schritt wird ein dbt-Projekt erstellt, das eine Verbindung mit einem Azure Databricks-Cluster oder einem SQL-Warehouse, ein Repository mit Ihrem Quellcode und mindestens eine Umgebung (z. B. Test- und Produktionsumgebungen) umfasst.

1. Melden Sie sich bei dbt Cloud an.

2. Klicken Sie zunächst auf das Symbol „Einstellungen“ und dann auf Kontoeinstellungen.

3. Klicken Sie auf Neues Projekt.

4. Geben Sie unter Name einen eindeutigen Namen für Ihr Projekt ein, und klicken Sie dann auf Weiter.

5. Klicken Sie bei Choose a connection (Verbindung auswählen) zunächst auf Databricks und dann auf Next (Weiter).

6. Geben Sie einen eindeutigen Namen für diese Verbindung ein.

7. Klicken Sie bei Select Adapter (Adapter auswählen) auf Databricks (dbt-databricks).

   Hinweis

   Databricks empfiehlt die Verwendung von dbt-databricks, da diese Option Unity Catalog anstelle von dbt-spark unterstützt. Standardmäßig wird dbt-databricks für neue Projekte verwendet. Informationen zum Migrieren eines vorhandenen Projekts zu dbt-databricks finden Sie unter Migrieren von dbt-spark zu dbt-databricks in der dbt-Dokumentation.

8. Geben Sie unter Settings (Einstellungen) im Feld Server Hostname den Serverhostnamen aus den Anforderungen ein.

9. Geben Sie unter HTTP-Pfad den Wert für HTTP-Pfad aus den Anforderungen ein.

10. Wenn Ihr Arbeitsbereich Unity Catalog-fähig ist, geben Sie unter Optionale Einstellungen den Namen des Katalogs für dbt Cloud ein.

11. Geben Sie unter Development Credentials (Anmeldeinformationen für die Entwicklung) im Feld Token das persönliche Zugriffstoken oder das Microsoft Entra ID-Token aus den Anforderungen ein.

12. Geben Sie unter Schema den Namen der Schemas ein, in denen dbt Cloud die Tabellen und Ansichten erstellen soll (z. B. default).

13. Klicken Sie auf Verbindung testen.

14. Wenn der Test erfolgreich ist, klicken Sie auf Next (Weiter).

Weitere Informationen finden Sie im Artikel zum Herstellen einer Verbindung mit Databricks ODBC auf der dbt-Website.

Tipp

Klicken Sie zunächst zum Anzeigen oder Ändern der Einstellungen für dieses Projekt oder zum vollständigen Löschen des Projekts auf das Symbol „Einstellungen“, dann auf Kontoeinstellungen > Projekte und anschließend auf den Namen des Projekts. Klicken Sie auf Bearbeiten (Edit), um die Einstellungen zu ändern. Klicken Sie auf Bearbeiten (Edit) und Löschen (Delete), um das Projekt zu löschen.

Um den Wert Ihres persönlichen Azure Databricks-Zugriffstokens für dieses Projekt anzuzeigen, klicken Sie auf das Personensymbol. Klicken Sie dann auf Profile und Anmeldeinformationen (Credentials). Klicken Sie auf den Namen des Projekts. Klicken Sie auf Bearbeiten (Edit), um eine Änderung vorzunehmen.

Führen Sie nach dem Herstellen einer Verbindung mit einem Azure Databricks-Cluster oder einem Databricks SQL-Warehouse die Anweisungen auf dem Bildschirm zum Einrichten eines Repositorys aus, und klicken Sie anschließend auf Continue (Weiter).

Nachdem Sie das Repository eingerichtet haben, befolgen Sie die Anweisungen auf dem Bildschirm, um Benutzer einzuladen, und klicken Sie dann auf Abschließen (Complete). Klicken Sie alternativ auf Überspringen und Abschließen.

Lernprogramm

In diesem Abschnitt verwenden Sie Ihr dbt Cloud-Projekt, um mit einigen Beispieldaten zu arbeiten. In diesem Abschnitt wird davon ausgegangen, dass Sie Ihr Projekt bereits erstellt haben und die dbt Cloud IDE für dieses Projekt geöffnet haben.

Schritt 1: Erstellen und Ausführen von Modellen

In diesem Schritt verwenden Sie die dbt Cloud-IDE, um Modelle zu erstellen und auszuführen. Dabei handelt es sich um select-Anweisungen, die entweder eine neue Ansicht (Standardeinstellung) oder eine neue Tabelle in einer Datenbank erstellen, ausgehend von vorhandenen Daten in eben dieser Datenbank. Mit diesem Verfahren wird ein Modell erstellt, das auf der Beispieltabelle diamonds aus den Beispieldatasets basiert.

Verwenden Sie den folgenden Code, um diese Tabelle zu erstellen.

DROP TABLE IF EXISTS diamonds;

CREATE TABLE diamonds USING CSV OPTIONS (path "/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv", header "true")

Bei diesem Verfahren wird davon ausgegangen, dass diese Tabelle bereits in der default-Datenbank Ihres Arbeitsbereichs erstellt wurde.

1. Klicken Sie bei geöffnetem Projekt oben auf der Benutzeroberfläche auf Develop(Entwickeln).

2. Klicken Sie auf Initialize dbt project (Dbt-Projekt initialisieren).

3. Klicken Sie auf Commit and sync (Commit und Sync), geben Sie eine Commitnachricht ein, und klicken Sie dann auf Commit.

4. Klicken Sie auf Create branch (Branch erstellen), geben Sie einen Namen für Ihren Branch ein, und klicken Sie dann auf Submit (Absenden).

5. Erstellen Sie das erste Modell: Klicken Sie auf Create New File (Neue Datei erstellen).

6. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Diese Anweisung wählt nur die Karat-, Schnitt-, Farb- und Reinheits-Details für jeden Diamanten in der diamonds-Tabelle aus. Der config-Block weist dbt an, auf der Grundlage dieser Anweisung eine Tabelle in der Datenbank zu erstellen.

   {{ config(
     materialized='table',
     file_format='delta'
   ) }}
   

   select carat, cut, color, clarity
   from diamonds
   

   Tipp

   Weitere config-Optionen wie die inkrementelle merge-Strategie finden Sie unter Databricks-Konfigurationen in der dbt-Dokumentation.

7. Klicken Sie auf Save As (Speichern unter).

8. Geben Sie als Dateiname models/diamonds_four_cs.sql ein, und klicken Sie dann auf Create (Erstellen).

9. Erstellen Sie das zweite Modell: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

10. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Diese Anweisung wählt eindeutige Werte aus der Spalte colors in der Tabelle diamonds_four_cs aus und sortiert die Ergebnisse in aufsteigender alphabetischer Reihenfolge. Da kein config-Block vorhanden ist, weist dieses Modell dbt an, basierend auf dieser Anweisung eine Sicht in der Datenbank zu erstellen.

    select distinct color
    from diamonds_four_cs
    sort by color asc
    

11. Klicken Sie auf Save As (Speichern unter).

12. Geben Sie als Dateiname models/diamonds_list_colors.sql ein, und klicken Sie dann auf Create (Erstellen).

13. Erstellen Sie das dritte Modell: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

14. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Mit dieser Anweisung werden die Preise der Diamanten nach Farbe gemittelt, und die Ergebnisse werden nach dem Durchschnittspreis vom höchsten zum niedrigsten Preis sortiert. Dieses Modell weist dbt an, auf der Grundlage dieser Anweisung eine Sicht in der Datenbank zu erstellen.

    select color, avg(price) as price
    from diamonds
    group by color
    order by price desc
    

15. Klicken Sie auf Save As (Speichern unter).

16. Geben Sie als Dateiname models/diamonds_prices.sql ein, und klicken Sie dann auf Create (Erstellen).

17. Führen Sie die Modelle aus: Führen Sie in der Befehlszeile den Befehl dbt run mit den Pfaden zu den drei vorherigen Dateien aus. Dbt erstellt in der default-Datenbank eine Tabelle mit dem Namen diamonds_four_cs und zwei Ansichten mit den Namen diamonds_list_colors und diamonds_prices. dbt ruft die Namen dieser Ansichten und Tabellen aus den zugehörigen .sql-Dateinamen ab.

    dbt run --model models/diamonds_four_cs.sql models/diamonds_list_colors.sql models/diamonds_prices.sql
    

    ...
    ... | 1 of 3 START table model default.diamonds_four_cs.................... [RUN]
    ... | 1 of 3 OK created table model default.diamonds_four_cs............... [OK ...]
    ... | 2 of 3 START view model default.diamonds_list_colors................. [RUN]
    ... | 2 of 3 OK created view model default.diamonds_list_colors............ [OK ...]
    ... | 3 of 3 START view model default.diamonds_prices...................... [RUN]
    ... | 3 of 3 OK created view model default.diamonds_prices................. [OK ...]
    ... |
    ... | Finished running 1 table model, 2 view models ...
    
    Completed successfully
    
    Done. PASS=3 WARN=0 ERROR=0 SKIP=0 TOTAL=3
    

18. Führen Sie den folgenden SQL-Code aus, um Informationen zu den neuen Ansichten aufzulisten und alle Zeilen aus der Tabelle und den Ansichten auszuwählen.

    Wenn Sie eine Verbindung mit einem Cluster herstellen, können Sie diesen SQL-Code aus einem Notebook ausführen, das an den Cluster angehängt ist, und dabei SQL als Standardsprache für das Notebook angeben. Wenn Sie eine Verbindung mit einem SQL-Warehouse herstellen, können Sie diesen SQL-Code über eine Abfrage ausführen.

    SHOW views IN default
    

    +-----------+----------------------+-------------+
    | namespace | viewName             | isTemporary |
    +===========+======================+=============+
    | default   | diamonds_list_colors | false       |
    +-----------+----------------------+-------------+
    | default   | diamonds_prices      | false       |
    +-----------+----------------------+-------------+
    

    SELECT * FROM diamonds_four_cs
    

    +-------+---------+-------+---------+
    | carat | cut     | color | clarity |
    +=======+=========+=======+=========+
    | 0.23  | Ideal   | E     | SI2     |
    +-------+---------+-------+---------+
    | 0.21  | Premium | E     | SI1     |
    +-------+---------+-------+---------+
    ...
    

    SELECT * FROM diamonds_list_colors
    

    +-------+
    | color |
    +=======+
    | D     |
    +-------+
    | E     |
    +-------+
    ...
    

    SELECT * FROM diamonds_prices
    

    +-------+---------+
    | color | price   |
    +=======+=========+
    | J     | 5323.82 |
    +-------+---------+
    | I     | 5091.87 |
    +-------+---------+
    ...
    

Schritt 2: Erstellen und Ausführen komplexerer Modelle

In diesem Schritt erstellen Sie komplexere Modelle für einen Satz verknüpfter Datentabellen. Diese Datentabellen enthalten Informationen über eine fiktive Sportliga aus drei Teams, die eine Saison aus sechs Spielen spielen. Dieses Verfahren erstellt die Datentabellen, erstellt die Modelle und führt die Modelle aus.

1. Führen Sie den folgenden SQL-Code aus, um die erforderlichen Datentabellen zu erstellen.

   Wenn Sie eine Verbindung mit einem Cluster herstellen, können Sie diesen SQL-Code aus einem Notebook ausführen, das an den Cluster angehängt ist, und dabei SQL als Standardsprache für das Notebook angeben. Wenn Sie eine Verbindung mit einem SQL-Warehouse herstellen, können Sie diesen SQL-Code über eine Abfrage ausführen.

   Die Tabellen und Ansichten in diesem Schritt beginnen mit zzz_, um sie als Teil dieses Beispiels zu identifizieren. Sie brauchen dieses Muster für Ihre eigenen Tabellen und Sichten nicht zu befolgen.

   DROP TABLE IF EXISTS zzz_game_opponents;
   DROP TABLE IF EXISTS zzz_game_scores;
   DROP TABLE IF EXISTS zzz_games;
   DROP TABLE IF EXISTS zzz_teams;
   
   CREATE TABLE zzz_game_opponents (
   game_id INT,
   home_team_id INT,
   visitor_team_id INT
   ) USING DELTA;
   
   INSERT INTO zzz_game_opponents VALUES (1, 1, 2);
   INSERT INTO zzz_game_opponents VALUES (2, 1, 3);
   INSERT INTO zzz_game_opponents VALUES (3, 2, 1);
   INSERT INTO zzz_game_opponents VALUES (4, 2, 3);
   INSERT INTO zzz_game_opponents VALUES (5, 3, 1);
   INSERT INTO zzz_game_opponents VALUES (6, 3, 2);
   
   -- Result:
   -- +---------+--------------+-----------------+
   -- | game_id | home_team_id | visitor_team_id |
   -- +=========+==============+=================+
   -- | 1       | 1            | 2               |
   -- +---------+--------------+-----------------+
   -- | 2       | 1            | 3               |
   -- +---------+--------------+-----------------+
   -- | 3       | 2            | 1               |
   -- +---------+--------------+-----------------+
   -- | 4       | 2            | 3               |
   -- +---------+--------------+-----------------+
   -- | 5       | 3            | 1               |
   -- +---------+--------------+-----------------+
   -- | 6       | 3            | 2               |
   -- +---------+--------------+-----------------+
   
   CREATE TABLE zzz_game_scores (
   game_id INT,
   home_team_score INT,
   visitor_team_score INT
   ) USING DELTA;
   
   INSERT INTO zzz_game_scores VALUES (1, 4, 2);
   INSERT INTO zzz_game_scores VALUES (2, 0, 1);
   INSERT INTO zzz_game_scores VALUES (3, 1, 2);
   INSERT INTO zzz_game_scores VALUES (4, 3, 2);
   INSERT INTO zzz_game_scores VALUES (5, 3, 0);
   INSERT INTO zzz_game_scores VALUES (6, 3, 1);
   
   -- Result:
   -- +---------+-----------------+--------------------+
   -- | game_id | home_team_score | visitor_team_score |
   -- +=========+=================+====================+
   -- | 1       | 4               | 2                  |
   -- +---------+-----------------+--------------------+
   -- | 2       | 0               | 1                  |
   -- +---------+-----------------+--------------------+
   -- | 3       | 1               | 2                  |
   -- +---------+-----------------+--------------------+
   -- | 4       | 3               | 2                  |
   -- +---------+-----------------+--------------------+
   -- | 5       | 3               | 0                  |
   -- +---------+-----------------+--------------------+
   -- | 6       | 3               | 1                  |
   -- +---------+-----------------+--------------------+
   
   CREATE TABLE zzz_games (
   game_id INT,
   game_date DATE
   ) USING DELTA;
   
   INSERT INTO zzz_games VALUES (1, '2020-12-12');
   INSERT INTO zzz_games VALUES (2, '2021-01-09');
   INSERT INTO zzz_games VALUES (3, '2020-12-19');
   INSERT INTO zzz_games VALUES (4, '2021-01-16');
   INSERT INTO zzz_games VALUES (5, '2021-01-23');
   INSERT INTO zzz_games VALUES (6, '2021-02-06');
   
   -- Result:
   -- +---------+------------+
   -- | game_id | game_date  |
   -- +=========+============+
   -- | 1       | 2020-12-12 |
   -- +---------+------------+
   -- | 2       | 2021-01-09 |
   -- +---------+------------+
   -- | 3       | 2020-12-19 |
   -- +---------+------------+
   -- | 4       | 2021-01-16 |
   -- +---------+------------+
   -- | 5       | 2021-01-23 |
   -- +---------+------------+
   -- | 6       | 2021-02-06 |
   -- +---------+------------+
   
   CREATE TABLE zzz_teams (
   team_id INT,
   team_city VARCHAR(15)
   ) USING DELTA;
   
   INSERT INTO zzz_teams VALUES (1, "San Francisco");
   INSERT INTO zzz_teams VALUES (2, "Seattle");
   INSERT INTO zzz_teams VALUES (3, "Amsterdam");
   
   -- Result:
   -- +---------+---------------+
   -- | team_id | team_city     |
   -- +=========+===============+
   -- | 1       | San Francisco |
   -- +---------+---------------+
   -- | 2       | Seattle       |
   -- +---------+---------------+
   -- | 3       | Amsterdam     |
   -- +---------+---------------+
   

2. Erstellen Sie das erste Modell: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

3. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Mit dieser Anweisung wird eine Tabelle erstellt, die die Details der einzelnen Spiele enthält, z. B. Teamnamen und Bewertungen. Der config-Block weist dbt an, auf der Grundlage dieser Anweisung eine Tabelle in der Datenbank zu erstellen.

   -- Create a table that provides full details for each game, including
   -- the game ID, the home and visiting teams' city names and scores,
   -- the game winner's city name, and the game date.
   

   {{ config(
     materialized='table',
     file_format='delta'
   ) }}
   

   -- Step 4 of 4: Replace the visitor team IDs with their city names.
   select
     game_id,
     home,
     t.team_city as visitor,
     home_score,
     visitor_score,
     -- Step 3 of 4: Display the city name for each game's winner.
     case
       when
         home_score > visitor_score
           then
             home
       when
         visitor_score > home_score
           then
             t.team_city
     end as winner,
     game_date as date
   from (
     -- Step 2 of 4: Replace the home team IDs with their actual city names.
     select
       game_id,
       t.team_city as home,
       home_score,
       visitor_team_id,
       visitor_score,
       game_date
     from (
       -- Step 1 of 4: Combine data from various tables (for example, game and team IDs, scores, dates).
       select
         g.game_id,
         go.home_team_id,
         gs.home_team_score as home_score,
         go.visitor_team_id,
         gs.visitor_team_score as visitor_score,
         g.game_date
       from
         zzz_games as g,
         zzz_game_opponents as go,
         zzz_game_scores as gs
       where
         g.game_id = go.game_id and
         g.game_id = gs.game_id
     ) as all_ids,
       zzz_teams as t
     where
       all_ids.home_team_id = t.team_id
   ) as visitor_ids,
     zzz_teams as t
   where
     visitor_ids.visitor_team_id = t.team_id
   order by game_date desc
   

4. Klicken Sie auf Save As (Speichern unter).

5. Geben Sie als Dateiname models/zzz_game_details.sql ein, und klicken Sie dann auf Create (Erstellen).

6. Erstellen Sie das zweite Modell: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

7. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Mit dieser Anweisung wird eine Sicht erstellt, in der Gewonnen-Verloren-Datensätze der Teams für die Saison aufgelistet werden.

   -- Create a view that summarizes the season's win and loss records by team.
   
   -- Step 2 of 2: Calculate the number of wins and losses for each team.
   select
     winner as team,
     count(winner) as wins,
     -- Each team played in 4 games.
     (4 - count(winner)) as losses
   from (
     -- Step 1 of 2: Determine the winner and loser for each game.
     select
       game_id,
       winner,
       case
         when
           home = winner
             then
               visitor
         else
           home
       end as loser
     from zzz_game_details
   )
   group by winner
   order by wins desc
   

8. Klicken Sie auf Save As (Speichern unter).

9. Geben Sie als Dateiname models/zzz_win_loss_records.sql ein, und klicken Sie dann auf Create (Erstellen).

10. Führen Sie die Modelle aus: Führen Sie in der Befehlszeile den Befehl dbt run mit den Pfaden zu den beiden vorherigen Dateien aus. Dbt erstellt in der default-Datenbank (wie in Ihren Projekteinstellungen angegeben) eine Tabelle mit dem Namen zzz_game_details und eine Ansicht mit dem Namen zzz_win_loss_records. dbt ruft die Namen dieser Ansichten und Tabellen aus den zugehörigen .sql-Dateinamen ab.

    dbt run --model models/zzz_game_details.sql models/zzz_win_loss_records.sql
    

    ...
    ... | 1 of 2 START table model default.zzz_game_details.................... [RUN]
    ... | 1 of 2 OK created table model default.zzz_game_details............... [OK ...]
    ... | 2 of 2 START view model default.zzz_win_loss_records................. [RUN]
    ... | 2 of 2 OK created view model default.zzz_win_loss_records............ [OK ...]
    ... |
    ... | Finished running 1 table model, 1 view model ...
    
    Completed successfully
    
    Done. PASS=2 WARN=0 ERROR=0 SKIP=0 TOTAL=2
    

11. Führen Sie den folgenden SQL-Code aus, um Informationen zu der neuen Ansicht aufzulisten und alle Zeilen aus der Tabelle und der Ansicht auszuwählen.

    Wenn Sie eine Verbindung mit einem Cluster herstellen, können Sie diesen SQL-Code aus einem Notebook ausführen, das an den Cluster angehängt ist, und dabei SQL als Standardsprache für das Notebook angeben. Wenn Sie eine Verbindung mit einem SQL-Warehouse herstellen, können Sie diesen SQL-Code über eine Abfrage ausführen.

    SHOW VIEWS FROM default LIKE 'zzz_win_loss_records';
    

    +-----------+----------------------+-------------+
    | namespace | viewName             | isTemporary |
    +===========+======================+=============+
    | default   | zzz_win_loss_records | false       |
    +-----------+----------------------+-------------+
    

    SELECT * FROM zzz_game_details;
    

    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | game_id | home          | visitor       | home_score | visitor_score | winner        | date       |
    +=========+===============+===============+============+===============+===============+============+
    | 1       | San Francisco | Seattle       | 4          | 2             | San Francisco | 2020-12-12 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 2       | San Francisco | Amsterdam     | 0          | 1             | Amsterdam     | 2021-01-09 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 3       | Seattle       | San Francisco | 1          | 2             | San Francisco | 2020-12-19 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 4       | Seattle       | Amsterdam     | 3          | 2             | Seattle       | 2021-01-16 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 5       | Amsterdam     | San Francisco | 3          | 0             | Amsterdam     | 2021-01-23 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    | 6       | Amsterdam     | Seattle       | 3          | 1             | Amsterdam     | 2021-02-06 |
    +---------+---------------+---------------+------------+---------------+---------------+------------+
    

    SELECT * FROM zzz_win_loss_records;
    

    +---------------+------+--------+
    | team          | wins | losses |
    +===============+======+========+
    | Amsterdam     | 3    | 1      |
    +---------------+------+--------+
    | San Francisco | 2    | 2      |
    +---------------+------+--------+
    | Seattle       | 1    | 3      |
    +---------------+------+--------+
    

Schritt 3: Erstellen und Ausführen von Tests

In diesem Schritt erstellen Sie Tests, bei denen es sich um Assertions zu Ihren Modellen handelt. Wenn Sie diese Tests ausführen, teilt dbt Ihnen mit, ob die einzelnen Tests in Ihrem Projekt erfolgreich waren.

Es gibt zwei Arten von Tests. Schematests, die in YAML geschrieben werden, geben die Anzahl der Datensätze zurück, die keine Assertion bestehen. Wenn diese Zahl 0 (null) ist, bestehen alle Datensätze, daher sind die Tests erfolgreich. Datentests sind bestimmte Abfragen, die keine Datensätze zurückgeben dürfen, um erfolgreich zu sein.

1. Erstellen Sie die Schematests: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

2. Geben Sie im Text-Editor den folgenden Inhalt ein. Diese Datei enthält Schematests, die bestimmen, ob die angegebenen Spalten eindeutige Werte aufweisen, nicht NULL sind, nur die angegebenen Werte oder eine Kombination aufweisen.

   version: 2
   
   models:
     - name: zzz_game_details
       columns:
         - name: game_id
           tests:
             - unique
             - not_null
         - name: home
           tests:
             - not_null
             - accepted_values:
                 values: ['Amsterdam', 'San Francisco', 'Seattle']
         - name: visitor
           tests:
             - not_null
             - accepted_values:
                 values: ['Amsterdam', 'San Francisco', 'Seattle']
         - name: home_score
           tests:
             - not_null
         - name: visitor_score
           tests:
             - not_null
         - name: winner
           tests:
             - not_null
             - accepted_values:
                 values: ['Amsterdam', 'San Francisco', 'Seattle']
         - name: date
           tests:
             - not_null
     - name: zzz_win_loss_records
       columns:
         - name: team
           tests:
             - unique
             - not_null
             - relationships:
                 to: ref('zzz_game_details')
                 field: home
         - name: wins
           tests:
             - not_null
         - name: losses
           tests:
             - not_null
   

3. Klicken Sie auf Save As (Speichern unter).

4. Geben Sie als Dateiname models/schema.yml ein, und klicken Sie dann auf Create (Erstellen).

5. Erstellen Sie den ersten Datentest: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

6. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Diese Datei enthält einen Datentest, um zu bestimmen, ob Spiele außerhalb der regulären Saison stattgefunden haben.

   -- This season's games happened between 2020-12-12 and 2021-02-06.
   -- For this test to pass, this query must return no results.
   
   select date
   from zzz_game_details
   where date < '2020-12-12'
   or date > '2021-02-06'
   

7. Klicken Sie auf Save As (Speichern unter).

8. Geben Sie als Dateiname tests/zzz_game_details_check_dates.sql ein, und klicken Sie dann auf Create (Erstellen).

9. Erstellen Sie den zweiten Datentest: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

10. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Diese Datei enthält einen Datentest, um zu bestimmen, ob es negative Punkte gegeben hat oder Spiele unentschieden endeten.

    -- This sport allows no negative scores or tie games.
    -- For this test to pass, this query must return no results.
    
    select home_score, visitor_score
    from zzz_game_details
    where home_score < 0
    or visitor_score < 0
    or home_score = visitor_score
    

11. Klicken Sie auf Save As (Speichern unter).

12. Geben Sie als Dateiname tests/zzz_game_details_check_scores.sql ein, und klicken Sie dann auf Create (Erstellen).

13. Erstellen Sie den dritten Datentest: Klicken Sie oben rechts auf das Symbol (Create New File(Neue Datei erstellen)).

14. Geben Sie im Text-Editor die folgende SQL-Anweisung ein. Diese Datei enthält einen Datentest, um zu bestimmen, ob Teams negative Gewinn- oder Verlustdatensätze hatten, mehr Gewinn- oder Verlustdatensätze als Spiele hatten oder mehr Spiele als zugelassen spielten.

    -- Each team participated in 4 games this season.
    -- For this test to pass, this query must return no results.
    
    select wins, losses
    from zzz_win_loss_records
    where wins < 0 or wins > 4
    or losses < 0 or losses > 4
    or (wins + losses) > 4
    

15. Klicken Sie auf Save As (Speichern unter).

16. Geben Sie als Dateiname tests/zzz_win_loss_records_check_records.sql ein, und klicken Sie dann auf Create (Erstellen).

17. Führen Sie die Tests aus: Führen Sie in der Befehlszeile den Befehl dbt test aus.

Schritt 4: Bereinigung

Sie können die Tabellen und Ansichten löschen, die Sie für dieses Beispiel erstellt haben, indem Sie den folgenden SQL-Code ausführen.

Wenn Sie eine Verbindung mit einem Cluster herstellen, können Sie diesen SQL-Code aus einem Notebook ausführen, das an den Cluster angehängt ist, und dabei SQL als Standardsprache für das Notebook angeben. Wenn Sie eine Verbindung mit einem SQL-Warehouse herstellen, können Sie diesen SQL-Code über eine Abfrage ausführen.

DROP TABLE zzz_game_opponents;
DROP TABLE zzz_game_scores;
DROP TABLE zzz_games;
DROP TABLE zzz_teams;
DROP TABLE zzz_game_details;
DROP VIEW zzz_win_loss_records;

DROP TABLE diamonds;
DROP TABLE diamonds_four_cs;
DROP VIEW diamonds_list_colors;
DROP VIEW diamonds_prices;

Nächste Schritte

• Erfahren Sie mehr über dbt-Modelle.
• Erfahren Sie, wie Sie Ihre dbt-Projekte testen können.
• Erfahren Sie, wie Sie Jinja, eine Vorlagensprache, zum Programmieren von SQL in Ihren dbt-Projekten verwenden.
• Erfahren Sie mehr über bewährte Methoden für dbt.

Zusätzliche Ressourcen

• Was genau ist dbt?
• Allgemeine dbt-Dokumentation
• dbt-core: GitHub-Repository
• dbt CLI
• dbt-Preise
• Analysetechnik für alle: Databricks in dbt Cloud
• dbt Cloud: Übersicht
• Herstellen einer Verbindung mit Databricks
• dbt Discourse-Community
• dbt-Blog
• Unterstützung