Kurz: Místní vytváření, spouštění a testování modelů dbt

Tento kurz vás provede místně vytvářením, spouštěním a testováním modelů dbt. Projekty dbt můžete také spouštět jako úlohy v jobech Azure Databricks. Další informace najdete v tématu Použití transformací dbt v úlohách Lakeflow.

Než začnete

Abyste mohli postupovat podle tohoto kurzu, musíte nejprve připojit pracovní prostor Azure Databricks k dbt Core. Další informace najdete v tématu Připojení k dbt Core.

Krok 1: Vytvoření a spuštění modelů

V tomto kroku pomocí oblíbeného textového editoru vytvoříte modely, což jsou select příkazy, které vytvoří nové zobrazení (výchozí) nebo novou tabulku v databázi na základě existujících dat ve stejné databázi. Tento postup vytvoří model založený na ukázkové diamonds tabulce z ukázkových datových sad.

Návod

Pokud má váš pracovní prostor pro Unity Catalog povolený bezserverový sklad SQL, Databricks doporučuje materializovat produkční modely, které musí být průběžně aktuální, jako materializované pohledy nebo streamingové tabulky, nikoli jako tabulky nebo pohledy. Tyto materializace se obnovují postupně místo toho, aby se při každém spuštění přepočítaval celý výsledek. Viz Krok 4: Udržujte modely aktuální pomocí materializovaných pohledů a streamovacích tabulek.

K vytvoření této tabulky použijte následující kód.

DROP TABLE IF EXISTS diamonds;

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

V adresáři projektu models vytvořte soubor s názvem diamonds_four_cs.sql s následujícím příkazem SQL. Tento příkaz vybere z tabulky diamonds pro každý diamant pouze údaje o karátu, brusu, barvě a čistotě. Blok config dává dbt pokyn k vytvoření tabulky v databázi na základě tohoto příkazu.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Návod

Další možnosti config, například použití formátu souborů Delta a merge inkrementální strategie, najdete v dokumentaci dbt v části Konfigurace Databricks.
V adresáři projektu models vytvořte druhý soubor s názvem diamonds_list_colors.sql s následujícím příkazem SQL. Tento příkaz vybere jedinečné hodnoty ze colors sloupce v diamonds_four_cs tabulce a seřadí výsledky podle abecedy jako první po poslední. Vzhledem k tomu, že neexistuje žádný config blok, tento model dává dbt pokyn k vytvoření zobrazení v databázi na základě tohoto příkazu.
```
select distinct color
from {{ ref('diamonds_four_cs') }}
sort by color asc
```
V adresáři projektu models vytvořte třetí soubor s názvem diamonds_prices.sql s následujícím příkazem SQL. Tento výpis zprůměruje ceny diamantů podle barvy a výsledky seřadí podle průměrné ceny od nejvyšší po nejnižší. Tento model dává dbt pokyn k vytvoření zobrazení v databázi na základě tohoto příkazu.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```

Když je virtuální prostředí aktivované, spusťte dbt run příkaz s cestami ke třem předchozím souborům. default V databázi (jak je uvedeno v profiles.yml souboru), dbt vytvoří jednu tabulku s názvem diamonds_four_cs a dvě zobrazení s názvem diamonds_list_colors a diamonds_prices. Dbt získá tyto názvy zobrazení a tabulky z jejich souvisejících .sql názvů souborů.

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

Spuštěním následujícího kódu SQL zobrazte informace o nových zobrazeních a vyberte všechny řádky z tabulky a zobrazení.

Pokud se připojujete ke clusteru, můžete tento kód SQL spustit z poznámkového bloku , který je připojený ke clusteru, a zadat SQL jako výchozí jazyk poznámkového bloku. Pokud se připojujete ke službě SQL Warehouse, můžete tento kód SQL spustit z dotazu.

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: Vytvoření a spuštění složitějších modelů

V tomto kroku vytvoříte složitější modely pro sadu souvisejících tabulek dat. Tyto datové tabulky obsahují informace o fiktivní sportovní lize tří týmů, které hrají sezónu šesti her. Tento postup vytvoří tabulky dat, vytvoří modely a spustí modely.

Spuštěním následujícího kódu SQL vytvořte potřebné tabulky dat.

Tabulky a pohledy v tomto kroku začínají znakem zzz_, aby bylo možné je identifikovat jako součást tohoto příkladu. Tento vzor nemusíte dodržovat pro vlastní tabulky a zobrazení.

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

V adresáři projektu models vytvořte soubor s názvem zzz_game_details.sql s následujícím příkazem SQL. Tento příkaz vytvoří tabulku, která obsahuje podrobnosti o jednotlivých hrách, jako jsou názvy týmů a skóre. Blok config dává dbt pokyn k vytvoření tabulky v databázi na základě tohoto příkazu.

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

V adresáři projektu models vytvořte soubor s názvem zzz_win_loss_records.sql s následujícím příkazem SQL. Tento příkaz vytvoří zobrazení, které vypisuje bilanci výher a proher týmu za sezónu.

-- 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 {{ ref('zzz_game_details') }}
)
group by winner
order by wins desc

Když je virtuální prostředí aktivované, spusťte dbt run příkaz s cestami ke dvěma předchozím souborům. default V databázi (jak je uvedeno v profiles.yml souboru), dbt vytvoří jednu tabulku s názvem zzz_game_details a jedno zobrazení s názvem zzz_win_loss_records. Dbt získá tyto názvy zobrazení a tabulky z jejich souvisejících .sql názvů souborů.

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

Spuštěním následujícího kódu SQL zobrazte informace o novém zobrazení a vyberte všechny řádky z tabulky a zobrazení.

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: Vytvoření a spuštění testů

V tomto kroku vytvoříte testy, což jsou tvrzení, která formulujete o svých modelech. Když tyto testy spustíte, dbt vám řekne, jestli každý test v projektu projde nebo selže.

Existují dva typy testů. Testy schématu použité v jazyce YAML vracejí počet záznamů, které nesplňují dané tvrzení. Je-li toto číslo nulové, projdou všechny záznamy, a tím pádem projdou i testy. Datové testy jsou specifické dotazy, které musí vrátit žádné záznamy, aby prošly.

V adresáři projektu models vytvořte soubor s názvem schema.yml s následujícím obsahem. Tento soubor obsahuje testy schématu, které určují, zda zadané sloupce mají jedinečné hodnoty, nemají hodnotu null, mají pouze zadané hodnoty nebo kombinaci.

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

V adresáři projektu tests vytvořte soubor s názvem zzz_game_details_check_dates.sql s následujícím příkazem SQL. Tento soubor obsahuje datový test, který určuje, jestli se některé hry nestaly mimo pravidelnou sezónu.
```
-- 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 {{ ref('zzz_game_details') }}
where date < '2020-12-12'
or date > '2021-02-06'
```

V adresáři projektu tests vytvořte soubor s názvem zzz_game_details_check_scores.sql s následujícím příkazem SQL. Tento soubor obsahuje datový test, který určuje, jestli byly nějaké skóre záporné nebo jakékoli hry byly svázané.

-- 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 {{ ref('zzz_game_details') }}
where home_score < 0
or visitor_score < 0
or home_score = visitor_score

V adresáři projektu tests vytvořte soubor s názvem zzz_win_loss_records_check_records.sql s následujícím příkazem SQL. Tento soubor obsahuje datový test, který určuje, jestli některé týmy měly negativní záznamy o výhrách nebo ztrátách, měly více záznamů o výhrách nebo ztrátách než hry, nebo hrály více her, než bylo povoleno.
```
-- Each team participated in 4 games this season.
-- For this test to pass, this query must return no results.

select wins, losses
from {{ ref('zzz_win_loss_records') }}
where wins < 0 or wins > 4
or losses < 0 or losses > 4
or (wins + losses) > 4
```

Když je virtuální prostředí aktivované, spusťte dbt test příkaz.

dbt test --models zzz_game_details zzz_win_loss_records

...
... | 1 of 19 START test accepted_values_zzz_game_details_home__Amsterdam__San_Francisco__Seattle [RUN]
... | 1 of 19 PASS accepted_values_zzz_game_details_home__Amsterdam__San_Francisco__Seattle [PASS ...]
...
... |
... | Finished running 19 tests ...

Completed successfully

Done. PASS=19 WARN=0 ERROR=0 SKIP=0 TOTAL=19

Krok 4: Udržujte modely aktuální pomocí materializovaných pohledů a streamovacích tabulek

Když musí model zůstat aktuální s novými daty, materializujte jej jako materializovaný pohled nebo streamovanou tabulku místo tabulky či pohledu. Materializovaný pohled postupně obnovuje výsledky svého dotazu, takže Azure Databricks aktualizuje pouze to, co se změnilo, místo aby při každém spuštění přepočítal celý výsledek, což činí materializované pohledy vhodnými pro agregace a data podávaná na dashboardy. Tabulka streamování postupně přijímá pouze připojená nebo streamovaná zdrojová data, například soubory, které přicházejí do cloudového úložiště, aniž by znovu zpracovávala již přečtené řádky. Obě jsou podpořeny potrubími Lakeflow a jsou doporučenými materializacemi pro výrobní transformace, které musí být aktuální.

Note

Tento krok vyžaduje pracovní prostor s povoleným katalogem Unity Catalog a serverless SQL datovým skladem. Materializace materialized_view je zabudována do dbt, zatímco streaming_table je zajištěna dbt-databricks adaptérem.

V adresáři projektu models vytvořte soubor s názvem diamonds_prices_mv.sql s následujícím příkazem SQL. Jedná se o stejnou agregaci jako v pohledu diamonds_prices , ale config blok instruuje dbt, aby vytvořil materializovaný pohled. Na rozdíl od pohledu, který přepočítává každý dotaz, materializovaný pohled předpočítává výsledek a aktualizuje jej postupně.
```
{{ config(
  materialized='materialized_view'
) }}
```
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
V adresáři projektu models vytvořte soubor s názvem diamonds_raw_stream.sql s následujícím příkazem SQL. Blok config instruuje dbt, aby vytvořil streamovací tabulku, která postupně spotřebovává zdrojový diamonds CSV soubor. Funkce read_files s tabulkovou hodnotou čte soubor a klíčové slovo STREAM zpracovává pouze nově příchozí data při každé obnově.
```
{{ config(
  materialized='streaming_table'
) }}
```
```
select * from stream read_files(
  '/databricks-datasets/Rdatasets/data-001/csv/ggplot2/diamonds.csv',
  format => 'csv',
  header => true
)
```
Když je virtuální prostředí aktivované, spusťte dbt run příkaz s cestami ke dvěma předchozím souborům.
```
dbt run --model models/diamonds_prices_mv.sql models/diamonds_raw_stream.sql
```

Při aktualizaci těchto modelů mějte na paměti následující chování:

Změna dotazu streamovací tabulky nezpracuje znovu data, která už byla načtena. DBT používá CREATE OR REFRESH, které aplikuje aktualizovaný dotaz pouze na budoucí řádky. Pro přepracování dostupných zdrojových dat spusťte .--full-refresh
Změna konfigurace materializovaného zobrazení vyžaduje, aby jej dbt odstranil a znovu vytvořil, s výjimkou změn plánu.
Tagy, které nastavíte pomocí databricks_tags, po jejich použití nelze přes dbt odstranit. Pro odstranění tagu použijte přímo Azure Databricks nebo post-hook.

Úplný seznam podporovaných konfigurací, jako jsou plánované obnovy, dělení na oddíly a filtry řádků, najdete v části Materializovaná zobrazení a streamovací tabulky v dokumentaci dbt.

Krok 5: Uklidit

Tabulky a zobrazení, které jste vytvořili v tomto příkladu, můžete odstranit spuštěním následujícího kódu 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 MATERIALIZED VIEW diamonds_prices_mv;
DROP TABLE diamonds_raw_stream;
DROP TABLE diamonds;
DROP TABLE diamonds_four_cs;
DROP VIEW diamonds_list_colors;
DROP VIEW diamonds_prices;

Note

Pokud jste nedokončili krok 4, vynechte příkazy DROP MATERIALIZED VIEW diamonds_prices_mv a DROP TABLE diamonds_raw_stream

Řešení potíží

Informace o běžných problémech při používání dbt Core s Azure Databricks a jejich řešení najdete v tématu Získání nápovědy na webu dbt Labs.

Další kroky

Spouštějte projekty dbt Core jako úlohy v rámci jobů Azure Databricks. Viz Použití transformací dbt v úlohách Lakeflow.
Zjistěte více o materializacích, které udržují vaše data aktuální. Viz Použití samostatných materializovaných zobrazení a použití samostatných streamovacích tabulek.

Další materiály

Projděte si následující zdroje informací na webu dbt Labs:

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-09-14