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ę tylko na kroku transformacji przy użyciu architektury "transformacji po załadowaniu". Dbt zakłada, że masz już kopię danych w bazie danych.

Ten artykuł koncentruje się na usłudze dbt Cloud. Usługa dbt Cloud jest wyposażona w gotową obsługę planowania zadań, ciągłej integracji/ciągłego wdrażania, obsługi dokumentacji, monitorowania i alertów oraz zintegrowanego środowiska projektowego (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. Interfejs wiersza polecenia dbt jest bezpłatny do użycia i open source. 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 omówienie bazy danych, obejrzyj następujący film wideo w serwisie 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 i osobistego tokenu dostępu program Partner Connect domyślnie tworzy magazyn SQL Warehouse (dawniej punkt końcowy SQL) o nazwie DBT_CLOUD_ENDPOINT .

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:

Połącz się z partnerami przygotowywania danych przy użyciu programu Partner Connect.
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.

Napiwek

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 uzyskanie dostępu do odczytu w chmurze dbt do danych

Program Partner Connect daje uprawnienie tylko do tworzenia dla jednostki usługi DBT_CLOUD_USER tylko w katalogu domyślnym. 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 rozwiązaniami w zakresie zabezpieczeń usługa Databricks zdecydowanie zaleca udzielenie dostępu tylko do poszczególnych tabel, z którymi potrzebujesz DBT_CLOUD_USER jednostki usługi do pracy i tylko do odczytu do tych tabel.

Kliknij Wykaz na pasku bocznym.
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. Wybieranie tabeli.
Napiwek

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
Kliknij pozycję Uprawnienia.
Kliknij Grant.
W polu Typ, aby dodać wielu użytkowników lub grup, wybierz pozycję DBT_CLOUD_USER. Jest to jednostka usługi Azure Databricks utworzona przez program Partner Connect w poprzedniej sekcji.

Napiwek

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.
Udziel dostępu tylko do odczytu, wybierając pozycję SELECT i READ METADATA.
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

Usługa Databricks zaleca nawiązywanie połączenia z usługą SQL Warehouse. 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.
- Dokumentacja konfiguracji obliczeniowej.
- 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.
Osobisty token dostępu 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

Najlepszym rozwiązaniem w zakresie zabezpieczeń w przypadku uwierzytelniania za pomocą zautomatyzowanych narzędzi, systemów, skryptów i aplikacji usługa Databricks zaleca używanie osobistych tokenów dostępu należących do jednostek usługi zamiast użytkowników obszaru roboczego. Aby utworzyć tokeny dla jednostek usługi, zobacz Zarządzanie tokenami dla jednostki usługi.

Aby połączyć usługę dbt Cloud z danymi zarządzanymi przez wykaz aparatu Unity, dbt w wersji 1.1 lub nowszej.

Kroki opisane w tym artykule umożliwiają utworzenie nowego środowiska korzystającego z najnowszej wersji bazy danych. 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.

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

Zaloguj się do usługi dbt Cloud.
Kliknij ikonę ustawień, a następnie kliknij pozycję Ustawienia konta.
Kliknij Nowy projekt.
W polu Nazwa wprowadź unikatową nazwę projektu, a następnie kliknij przycisk Kontynuuj.
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
  
  Usługa Databricks zaleca używanie elementu dbt-databricks, który obsługuje katalog aparatu Unity, zamiast dbt-spark. Domyślnie nowe projekty używają polecenia dbt-databricks. Aby przeprowadzić migrację istniejącego projektu do dbt-databricksusługi , zobacz Migrating from dbt-spark to dbt-databricks (Migrowanie z bazy danych dbt-spark do usługi dbt-databricks ) w dokumentacji bazy danych.
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.
W obszarze Poświadczenia programistyczne w polu Token wprowadź osobisty token dostępu lub token identyfikatora Entra firmy Microsoft z wymagań.
Dla schematu wprowadź nazwę schematu, w którym dbt ma utworzyć tabele i widoki.
Kliknij pozycję Testuj połączenie.
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.

Napiwek

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ść osobistego tokenu dostępu usługi Azure Databricks dla tego projektu, kliknij ikonę "person", kliknij pozycję > profilu i 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 pozycję 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.

Po otwarciu projektu kliknij pozycję Opracuj w górnej części interfejsu użytkownika.
Kliknij pozycję Zainicjuj projekt dbt.
Kliknij pozycję Zatwierdź i zsynchronizuj, wprowadź komunikat zatwierdzenia, a następnie kliknij przycisk Zatwierdź.
Kliknij pozycję Utwórz gałąź, wprowadź nazwę gałęzi, a następnie kliknij przycisk Prześlij.
Utwórz pierwszy model: kliknij pozycję Utwórz nowy plik.
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
```
Napiwek

Aby uzyskać dodatkowe config opcje, takie jak merge strategia przyrostowa, zobacz Konfiguracje usługi Databricks w dokumentacji bazy danych.
Kliknij przycisk Zapisz jako.
Wprowadź nazwę pliku, models/diamonds_four_cs.sql a następnie kliknij przycisk Utwórz.
Utwórz drugi model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.
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 config ma bloku, ten model nakazuje dbt utworzenie widoku w bazie danych na podstawie tej instrukcji.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź ciąg models/diamonds_list_colors.sql, a następnie kliknij przycisk Utwórz.
Utwórz trzeci model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.
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
```
Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź models/diamonds_prices.sql i kliknij przycisk Utwórz.

Uruchom modele: w wierszu polecenia uruchom dbt run polecenie ze ścieżkami do trzech poprzednich plików. default W bazie danych dbt tworzy jedną tabelę o nazwie i dwa widoki o nazwie diamonds_four_csdiamonds_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

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.

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

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

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

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

Kliknij przycisk Zapisz jako.
Wprowadź nazwę pliku, models/zzz_game_details.sql a następnie kliknij przycisk Utwórz.
Utwórz drugi model: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

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

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

Uruchom modele: w wierszu polecenia uruchom dbt run polecenie ze ścieżkami do dwóch poprzednich plików. default W bazie danych (zgodnie z ustawieniami projektu) dbt tworzy jedną tabelę o nazwie i jeden widok o nazwie zzz_game_detailszzz_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

Uruchom następujący kod SQL, aby wyświetlić listę informacji o nowym widoku i wybrać wszystkie wiersze z tabeli i widoku.

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. Jeśli ta liczba jest równa zero, wszystkie rekordy przechodzą, dlatego testy przechodzą pomyślnie. Testy danych to konkretne zapytania, które muszą zwracać zero rekordów do przekazania.

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

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

Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź ciąg models/schema.yml, a następnie kliknij przycisk Utwórz.
Utwórz pierwszy test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

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'

Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź ciąg tests/zzz_game_details_check_dates.sql, a następnie kliknij przycisk Utwórz.
Utwórz drugi test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.

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

Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź ciąg tests/zzz_game_details_check_scores.sql, a następnie kliknij przycisk Utwórz.
Utwórz trzeci test danych: kliknij pozycję (Utwórz nowy plik) w prawym górnym rogu.
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
```
Kliknij przycisk Zapisz jako.
W polu nazwa pliku wprowadź ciąg tests/zzz_win_loss_records_check_records.sql, a następnie kliknij przycisk Utwórz.
Uruchom testy: w wierszu polecenia uruchom dbt test polecenie .

Krok 4. Czyszczenie

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

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 przetestować projekty dbt.
Dowiedz się, jak używać języka Jinja, języka tworzenia szablonów na potrzeby programowania sql w projektach dbt.
Dowiedz się więcej o najlepszych rozwiązaniach dotyczących bazy danych.

Dodatkowe zasoby

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-04-30