Nawiązywanie połączenia z usługą dbt Cloud

dbt (narzędzie do tworzenia danych) to środowisko programistyczne, które umożliwia analitykom danych i inżynierom danych przekształcanie danych przez proste pisanie instrukcji. Dbt obsługuje przekształcanie tych instrukcji select w tabele i widoki. Dbt kompiluje kod w nieprzetworzonym języku SQL, a następnie uruchamia ten kod w określonej bazie danych w usłudze Azure Databricks. Usługa dbt obsługuje wzorce kodowania współpracy i najlepsze rozwiązania, takie jak kontrola wersji, dokumentacja i modułowość.

dbt nie wyodrębnia ani nie ładuje danych. dbt koncentruje się wyłącznie na etapie transformacji, wykorzystując architekturę „transformacji po załadowaniu danych”. Dbt zakłada, że masz już kopię danych w bazie danych.

Ten artykuł koncentruje się na usłudze dbt Cloud. dbt Cloud oferuje gotowe funkcje planowania zadań, CI/CD, udostępniania dokumentacji, monitorowania i alertowania oraz zintegrowane środowisko programistyczne (IDE).

Dostępna jest również lokalna wersja bazy danych o nazwie dbt Core. Dbt Core umożliwia pisanie kodu dbt w edytorze tekstów lub środowisku IDE wybranego na lokalnym komputerze deweloperskim, a następnie uruchamianie dbt z wiersza polecenia. Dbt Core zawiera interfejs wiersza polecenia dbt. dbt CLI jest bezpłatny i ma otwarty kod źródłowy. Aby uzyskać więcej informacji, zobacz Nawiązywanie połączenia z bazą danych dbt Core.

Ponieważ dbt Cloud i dbt Core mogą używać hostowanych repozytoriów git (na przykład w usłudze GitHub, GitLab lub BitBucket), możesz użyć usługi dbt Cloud do utworzenia projektu dbt, a następnie udostępnienia go użytkownikom dbt Cloud i dbt Core. Aby uzyskać więcej informacji, zobacz Tworzenie projektu dbt i Używanie istniejącego projektu w witrynie internetowej dbt.

Aby uzyskać ogólne informacje o dbt, obejrzyj poniższy film na YouTube (26 minut).

Nawiązywanie połączenia z usługą dbt Cloud przy użyciu programu Partner Connect

W tej sekcji opisano, jak połączyć usługę Databricks SQL Warehouse z usługą dbt Cloud przy użyciu programu Partner Connect, a następnie przyznać usłudze dbt Cloud dostęp do odczytu danych.

Różnice między połączeniami standardowymi i dbt Cloud

Aby nawiązać połączenie z usługą dbt Cloud przy użyciu programu Partner Connect, wykonaj kroki opisane w artykule Nawiązywanie połączenia z partnerami przygotowywania danych przy użyciu programu Partner Connect. Połączenie dbt Cloud różni się od standardowych połączeń przygotowywania i przekształcania danych w następujący sposób:

• Oprócz jednostki usługi głównej i osobistego tokenu dostępu Partner Connect domyślnie tworzy magazyn SQL o nazwie DBT_CLOUD_ENDPOINT (wcześniej nazywany punktem końcowym SQL).

Kroki nawiązywania połączenia

Aby nawiązać połączenie z usługą dbt Cloud przy użyciu programu Partner Connect, wykonaj następujące czynności:

1. Połącz się z partnerami przygotowywania danych przy użyciu programu Partner Connect.

2. Po nawiązaniu połączenia z usługą dbt Cloud pojawi się pulpit nawigacyjny usługi dbt Cloud. Aby eksplorować projekt dbt Cloud, na pasku menu obok logo dbt wybierz nazwę konta dbt z pierwszej listy rozwijanej, jeśli nie jest wyświetlana, a następnie wybierz projekt Databricks Partner Connect Trial z drugiego menu rozwijanego, jeśli nie jest wyświetlany.

   Wskazówka

   Aby wyświetlić ustawienia projektu, kliknij menu "trzy paski" lub "hamburger", kliknij pozycję Projekty ustawień > konta i kliknij nazwę projektu. Aby wyświetlić ustawienia połączenia, kliknij link obok pozycji Połączenie. Aby zmienić ustawienia, kliknij przycisk Edytuj.

   Aby wyświetlić informacje o osobistym tokenie dostępu usługi Azure Databricks dla tego projektu, kliknij ikonę "person" na pasku menu, kliknij pozycję Profile > Credentials > Databricks Partner Connect Trial i kliknij nazwę projektu. Aby wprowadzić zmianę, kliknij pozycję Edytuj.

Kroki umożliwiające przyznanie usłudze dbt Cloud dostępu do danych w trybie tylko do odczytu

Partner Connect nadaje nazwie głównej usługi DBT_CLOUD_USER uprawnienie wyłącznie do tworzenia tylko w domyślnym katalogu. Wykonaj następujące kroki w obszarze roboczym usługi Azure Databricks, aby przyznać jednostce usługi DBT_CLOUD_USER dostęp do odczytu do danych, które wybierzesz.

Ostrzeżenie

Te kroki można dostosować, aby zapewnić usłudze dbt Cloud dodatkowy dostęp do katalogów, baz danych i tabel w obszarze roboczym. Jednak zgodnie z najlepszymi praktykami w zakresie bezpieczeństwa Databricks zdecydowanie zaleca przyznawanie dostępu wyłącznie do tych pojedynczych tabel, z którymi podmiot usługi DBT_CLOUD_USER ma pracować, oraz przyznawanie do nich wyłącznie uprawnień do odczytu.

1. Kliknij Wykaz na pasku bocznym.

2. Wybierz magazyn SQL (DBT_CLOUD_ENDPOINT) z listy rozwijanej w prawym górnym rogu.

   

   1. W obszarze Eksplorator wykazu wybierz wykaz zawierający bazę danych dla tabeli.
   2. Wybierz bazę danych zawierającą tabelę.
   3. Wybierz swoją tabelę.

   Wskazówka

   Jeśli nie widzisz katalogu, bazy danych ani tabeli na liście, wprowadź dowolną część nazwy w polach Wybierz wykaz, Wybierz bazę danych lub Filtruj tabele , aby zawęzić listę.

   tabele filtru

3. Kliknij pozycję Uprawnienia.

4. Kliknij Grant.

5. W polu Typ, aby dodać wielu użytkowników lub grup, wybierz pozycję DBT_CLOUD_USER. Jest to jednostka usługi Azure Databricks, którą program Partner Connect utworzył dla Ciebie w poprzedniej sekcji.

   Wskazówka

   Jeśli nie widzisz DBT_CLOUD_USER, zacznij wpisywać tekst DBT_CLOUD_USER w polu Typ, aby dodać wielu użytkowników lub grupy , dopóki nie pojawi się on na liście, a następnie wybierz go.

6. Udziel dostępu tylko do odczytu, wybierając pozycję SELECT i READ METADATA.

7. Kliknij przycisk OK.

Powtórz kroki od 4 do 9 dla każdej dodatkowej tabeli, do której chcesz przyznać usłudze dbt Cloud dostęp do odczytu.

Rozwiązywanie problemów z połączeniem z chmurą dbt

Jeśli ktoś usunie projekt w usłudze dbt Cloud dla tego konta i klikniesz kafelek dbt , zostanie wyświetlony komunikat o błędzie z informacją, że nie można odnaleźć projektu. Aby rozwiązać ten problem, kliknij przycisk Usuń połączenie, a następnie rozpocznij od początku tej procedury, aby ponownie utworzyć połączenie.

Ręczne nawiązywanie połączenia z usługą dbt Cloud

W tej sekcji opisano sposób łączenia klastra usługi Azure Databricks lub magazynu SQL usługi Databricks w obszarze roboczym usługi Azure Databricks z usługą dbt Cloud.

Ważne

Databricks zaleca połączenie z magazynem SQL. Jeśli nie masz uprawnień dostępu sql usługi Databricks lub chcesz uruchamiać modele języka Python, możesz zamiast tego nawiązać połączenie z klastrem.

Wymagania

• Klaster lub magazyn SQL w obszarze roboczym usługi Azure Databricks.

  • Informacje o konfiguracji obliczeń.
  • Utwórz usługę SQL Warehouse.

• Szczegóły połączenia dla klastra lub magazynu SQL, w szczególności: nazwa hosta serwera , port , oraz ścieżka HTTP .

  • Uzyskaj szczegóły połączenia dla zasobu obliczeniowego usługi Azure Databricks.

• Token dostępu osobistego usługi Azure Databricks lub token Microsoft Entra ID (dawniej Azure Active Directory).. Aby utworzyć osobisty token dostępu, wykonaj kroki opisane w artykule Tworzenie osobistych tokenów dostępu dla użytkowników obszaru roboczego.

  Uwaga

  Zgodnie z najlepszymi praktykami w zakresie bezpieczeństwa podczas uwierzytelniania za pomocą zautomatyzowanych narzędzi, systemów, skryptów i aplikacji Databricks zaleca używanie tokenów osobistego dostępu przypisanych do jednostek usługi zamiast do użytkowników obszaru roboczego. Aby utworzyć tokeny dla jednostek usługi, zobacz Zarządzanie tokenami dla jednostki usługi.

• Aby połączyć dbt Cloud z danymi zarządzanymi przez Unity Catalog, wymagana jest wersja dbt 1.1 lub nowsza.

  Kroki przedstawione w tym artykule tworzą nowe środowisko korzystające z najnowszej wersji dbt. Aby uzyskać informacje na temat uaktualniania wersji bazy danych dla istniejącego środowiska, zobacz Uaktualnianie do najnowszej wersji bazy danych dbt w chmurze w dokumentacji bazy danych.

Krok 1. Tworzenie konta w usłudze dbt Cloud

Przejdź do usługi dbt Cloud — zarejestruj się i wprowadź swoje dane e-mail, imię i nazwisko oraz informacje o firmie. Utwórz hasło i kliknij pozycję Utwórz moje konto.

Krok 2. Tworzenie projektu dbt

W tym kroku utworzysz projekt dbt zawierający połączenie z klastrem usługi Azure Databricks lub usługą SQL Warehouse, repozytorium zawierające kod źródłowy i co najmniej jedno środowisko (takie jak środowiska testowe i produkcyjne).

1. Zaloguj się do usługi dbt Cloud.

2. Kliknij ikonę ustawień, a następnie kliknij pozycję Ustawienia konta.

3. Kliknij Nowy projekt.

4. W polu Nazwa wprowadź unikatową nazwę projektu, a następnie kliknij przycisk Kontynuuj.

5. Wybierz połączenie obliczeniowe usługi Azure Databricks z menu rozwijanego Wybierz połączenie lub utwórz nowe połączenie:

   1. Kliknij pozycję Dodaj nowe połączenie.

      Kreator dodawania nowego połączenia zostanie otwarty na nowej karcie.

   2. Kliknij Databricks, a następnie kliknij Dalej.

      Uwaga

      Databricks zaleca używanie dbt-databricks, które obsługuje Unity Catalog, zamiast dbt-spark. Domyślnie nowe projekty korzystają z dbt-databricks. Aby przeprowadzić migrację istniejącego projektu do dbt-databricks, zobacz Migrowanie z dbt-spark do dbt-databricks w dokumentacji dbt.

   3. W obszarze Ustawienia w polu Nazwa hosta serwera wprowadź wartość nazwy hosta serwera z wymagań.

   4. W polu Ścieżka HTTP wprowadź wartość ścieżki HTTP z wymagań.

   5. Jeśli Twój obszar roboczy ma włączoną funkcję Unity Catalog, w obszarze Opcjonalne ustawieniawprowadź nazwę katalogu, którego ma używać dbt.

   6. Kliknij Zapisz.

   7. Wróć do kreatora Nowy projekt i wybierz połączenie utworzone właśnie z menu rozwijanego Połączenie.

6. W obszarze Poświadczenia deweloperskie, w polu Token, wprowadź token dostępu osobistego lub token Microsoft Entra ID określony w wymaganiach.

7. Dla schematu wprowadź nazwę schematu, w którym dbt ma utworzyć tabele i widoki.

8. Kliknij pozycję Testuj połączenie.

9. Jeśli test zakończy się pomyślnie, kliknij pozycję Zapisz.

Aby uzyskać więcej informacji, zobacz Nawiązywanie połączenia z usługą Databricks ODBC w witrynie internetowej dbt.

Wskazówka

Aby wyświetlić lub zmienić ustawienia tego projektu lub całkowicie usunąć projekt, kliknij ikonę ustawień, kliknij pozycję > ustawień konta i kliknij nazwę projektu. Aby zmienić ustawienia, kliknij przycisk Edytuj. Aby usunąć projekt, kliknij pozycję Edytuj > usuń projekt.

Aby wyświetlić lub zmienić wartość tokenu dostępu osobistego usługi Azure Databricks dla tego projektu, kliknij ikonę „Osoba”, kliknij pozycję Poświadczenia profilu >, a następnie kliknij nazwę projektu. Aby wprowadzić zmianę, kliknij pozycję Edytuj.

Po nawiązaniu połączenia z klastrem usługi Azure Databricks lub usłudze Databricks SQL Warehouse postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby skonfigurować repozytorium, a następnie kliknij przycisk Kontynuuj.

Po skonfigurowaniu repozytorium postępuj zgodnie z instrukcjami wyświetlanymi na ekranie, aby zaprosić użytkowników, a następnie kliknij przycisk Zakończ. Lub kliknij Pomiń i zakończ.

Samouczek

W tej sekcji użyjesz projektu dbt Cloud do pracy z przykładowymi danymi. W tej sekcji założono, że projekt został już utworzony i masz otwarte środowisko IDE dbt Cloud dla tego projektu.

Krok 1. Tworzenie i uruchamianie modeli

W tym kroku użyjesz środowiska IDE dbt Cloud do tworzenia i uruchamiania modeli, które są select instrukcjami, które tworzą nowy widok (wartość domyślna) lub nową tabelę w bazie danych na podstawie istniejących danych w tej samej bazie danych. Ta procedura tworzy model na podstawie przykładowej tabeli diamonds z Przykładowych zestawów danych.

Użyj poniższego kodu, aby utworzyć tę tabelę.

DROP TABLE IF EXISTS diamonds;

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

Ta procedura zakłada, że tabela default została już utworzona w bazie danych obszaru roboczego.

1. Po otwarciu projektu kliknij pozycję Opracuj w górnej części interfejsu użytkownika.

2. Kliknij pozycję Zainicjuj projekt dbt.

3. Kliknij pozycję Zatwierdź i zsynchronizuj, wprowadź komunikat zatwierdzenia, a następnie kliknij przycisk Zatwierdź.

4. Kliknij pozycję Utwórz gałąź, wprowadź nazwę gałęzi, a następnie kliknij przycisk Prześlij.

5. Utwórz pierwszy model: kliknij pozycję Utwórz nowy plik.

6. W edytorze tekstów wprowadź następującą instrukcję SQL. To zapytanie wybiera tylko karat, szlif, kolor i czystość dla każdego diamentu z tabeli diamonds. Blok config instruuje dbt utworzenie tabeli w bazie danych na podstawie tej instrukcji.

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

   select carat, cut, color, clarity
   from diamonds
   

   Wskazówka

   Aby poznać dodatkowe opcje config, takie jak strategia przyrostowa merge, zobacz sekcję konfiguracje Databricks w dokumentacji dbt.

7. Kliknij przycisk Zapisz jako.

8. Wprowadź nazwę pliku, models/diamonds_four_cs.sql a następnie kliknij przycisk Utwórz.

9. Utwórz drugi model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

10. W edytorze tekstów wprowadź następującą instrukcję SQL. Ta instrukcja wybiera unikatowe wartości z kolumny colors w tabeli diamonds_four_cs, posortując wyniki w kolejności alfabetycznej od początku do ostatniego. Ponieważ nie ma bloku config, ten model instruuje dbt, aby utworzył widok w bazie danych na podstawie tej instrukcji.

    select distinct color
    from diamonds_four_cs
    sort by color asc
    

11. Kliknij przycisk Zapisz jako.

12. W polu nazwa pliku wprowadź ciąg models/diamonds_list_colors.sql, a następnie kliknij przycisk Utwórz.

13. Utwórz trzeci model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

14. W edytorze tekstów wprowadź następującą instrukcję SQL. To stwierdzenie określa średnie ceny diamentów według koloru, sortując wyniki według średniej ceny od najwyższej do najniższej. Ten model instruuje dbt, aby utworzyć widok w bazie danych na podstawie tej instrukcji.

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

15. Kliknij przycisk Zapisz jako.

16. W polu nazwa pliku wprowadź models/diamonds_prices.sql i kliknij przycisk Utwórz.

17. Uruchom modele: w wierszu polecenia uruchom dbt run polecenie ze ścieżkami do trzech poprzednich plików. W bazie danych default dbt tworzy jedną tabelę o nazwie diamonds_four_cs oraz dwa widoki o nazwach diamonds_list_colors i diamonds_prices. dbt pobiera nazwy tych widoków i tabel z ich powiązanych nazw plików .sql.

    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. Uruchom następujący kod SQL, aby wyświetlić listę informacji o nowych widokach i wybrać wszystkie wiersze z tabeli i widoków.

    Jeśli łączysz się z klastrem, możesz uruchomić ten kod SQL z notesu dołączonego do klastra, określając język SQL jako domyślny język notesu. Jeśli nawiązujesz połączenie z usługą SQL Warehouse, możesz uruchomić ten kod SQL z zapytania.

    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 |
    +-------+---------+
    ...
    

Krok 2. Tworzenie i uruchamianie bardziej złożonych modeli

W tym kroku utworzysz bardziej złożone modele dla zestawu powiązanych tabel danych. Te tabele danych zawierają informacje o fikcyjnej lidze sportowej trzech drużyn rozgrywających sezon sześciu meczów. Ta procedura tworzy tabele danych, tworzy modele i uruchamia modele.

1. Uruchom następujący kod SQL, aby utworzyć niezbędne tabele danych.

   Jeśli łączysz się z klastrem, możesz uruchomić ten kod SQL z notesu dołączonego do klastra, określając język SQL jako domyślny język notesu. Jeśli nawiązujesz połączenie z usługą SQL Warehouse, możesz uruchomić ten kod SQL z zapytania.

   Tabele i widoki w tym kroku zaczynają się od zzz_, aby ułatwić ich identyfikację w ramach tego przykładu. Nie musisz przestrzegać tego wzorca dla własnych tabel i widoków.

   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. Utwórz pierwszy model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

3. W edytorze tekstów wprowadź następującą instrukcję SQL. Ta instrukcja tworzy tabelę zawierającą szczegółowe informacje o każdej grze, takie jak nazwy zespołów i wyniki. Blok config instruuje dbt utworzenie tabeli w bazie danych na podstawie tej instrukcji.

   -- 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. Kliknij przycisk Zapisz jako.

5. Wprowadź nazwę pliku, models/zzz_game_details.sql a następnie kliknij przycisk Utwórz.

6. Utwórz drugi model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

7. W edytorze tekstów wprowadź następującą instrukcję SQL. To stwierdzenie tworzy widok, który wyświetla listę rekordów wygranej zespołu w sezonie.

   -- 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. Kliknij przycisk Zapisz jako.

9. Wprowadź nazwę pliku, models/zzz_win_loss_records.sql a następnie kliknij przycisk Utwórz.

10. Uruchom modele: w wierszu polecenia uruchom dbt run polecenie ze ścieżkami do dwóch poprzednich plików. W bazie danych default (zgodnie z ustawieniami projektu) dbt tworzy tabelę o nazwie zzz_game_details oraz widok o nazwie zzz_win_loss_records. dbt pobiera nazwy tych widoków i tabel z ich powiązanych nazw plików .sql.

    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. Uruchom następujący kod SQL, aby wyświetlić listę informacji o nowym widoku i wybrać wszystkie wiersze z tabeli i widoku.

    Jeśli łączysz się z klastrem, możesz uruchomić ten kod SQL z notesu dołączonego do klastra, określając język SQL jako domyślny język notesu. Jeśli nawiązujesz połączenie z usługą SQL Warehouse, możesz uruchomić ten kod SQL z zapytania.

    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      |
    +---------------+------+--------+
    

Krok 3. Tworzenie i uruchamianie testów

W tym kroku utworzysz testy, które są asercją tworzoną na temat modeli. Po uruchomieniu tych testów dbt informuje, czy każdy test w projekcie przejdzie pomyślnie lub zakończy się niepowodzeniem.

Istnieją dwa typy testów. Testy schematu napisane w języku YAML zwracają liczbę rekordów, które nie przechodzą asercji. Gdy ta liczba wynosi zero, wszystkie rekordy spełniają warunek, a zatem testy kończą się powodzeniem. Testy danych to konkretne zapytania, które muszą zwrócić zero rekordów, aby zakończyć się powodzeniem.

1. Utwórz testy schematu: kliknij ikonę (Utwórz nowy plik) w prawym górnym rogu.

2. W edytorze tekstów wprowadź następującą zawartość. Ten plik zawiera testy schematu, które określają, czy określone kolumny mają unikatowe wartości, nie mają wartości null, mają tylko określone wartości lub kombinację.

   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. Kliknij przycisk Zapisz jako.

4. W polu nazwa pliku wprowadź ciąg models/schema.yml, a następnie kliknij przycisk Utwórz.

5. Utwórz pierwszy test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

6. W edytorze tekstów wprowadź następującą instrukcję SQL. Ten plik zawiera test danych, aby ustalić, czy jakiekolwiek gry miały miejsce poza sezonem regularnym.

   -- 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. Kliknij przycisk Zapisz jako.

8. W polu nazwa pliku wprowadź ciąg tests/zzz_game_details_check_dates.sql, a następnie kliknij przycisk Utwórz.

9. Utwórz drugi test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

10. W edytorze tekstów wprowadź następującą instrukcję SQL. Ten plik zawiera test danych w celu ustalenia, czy jakiekolwiek wyniki były ujemne, czy jakiekolwiek gry zostały powiązane.

    -- 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. Kliknij przycisk Zapisz jako.

12. W polu nazwa pliku wprowadź ciąg tests/zzz_game_details_check_scores.sql, a następnie kliknij przycisk Utwórz.

13. Utwórz trzeci test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

14. W edytorze tekstów wprowadź następującą instrukcję SQL. Ten plik zawiera test danych, aby ustalić, czy jakiekolwiek zespoły miały negatywne rekordy wygranej lub przegranej, miały więcej rekordów wygranej lub przegranej niż gry, czy grały więcej gier niż były dozwolone.

    -- 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. Kliknij przycisk Zapisz jako.

16. W polu nazwa pliku wprowadź ciąg tests/zzz_win_loss_records_check_records.sql, a następnie kliknij przycisk Utwórz.

17. Uruchom testy: w wierszu polecenia uruchom polecenie dbt test.

Krok 4. Czyszczenie

Możesz usunąć tabele i widoki utworzone na potrzeby tego przykładu, uruchamiając następujący kod SQL.

Jeśli łączysz się z klastrem, możesz uruchomić ten kod SQL z notesu dołączonego do klastra, określając język SQL jako domyślny język notesu. Jeśli nawiązujesz połączenie z usługą SQL Warehouse, możesz uruchomić ten kod SQL z zapytania.

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;

Następne kroki

• Dowiedz się więcej o modelach dbt.
• Dowiedz się, jak testować projekty dbt.
• Dowiedz się, jak używać języka Jinja, języka tworzenia szablonów na potrzeby programowania sql w projektach dbt.
• Poznaj najlepsze praktyki dbt.

Dodatkowe zasoby

• Co dokładnie jest dbt?
• Ogólna dokumentacja dbt
• repozytorium dbt-core w serwisie GitHub
• dbt CLI
• dbt — cennik
• Inżynieria analizy dla wszystkich: usługa Databricks w chmurze dbt
• Dbt Cloud overview (Omówienie usługi dbt Cloud)
• Nawiązywanie połączenia z usługą Databricks
• blog dbt
• Pomoc techniczna