Ansluta till dbt Cloud

dbt (data build tool) är en utvecklingsmiljö som gör att dataanalytiker och datatekniker kan transformera data bara genom att skriva select-instruktioner. dbt omvandlar dessa select-instruktioner till tabeller och vyer. dbt kompilerar koden till rå SQL och kör sedan koden på den angivna databasen i Azure Databricks. dbt stöder kodningsmönster för samarbete och metodtips som versionskontroll, dokumentation och modularitet.

dbt extraherar eller läser inte in data. dbt fokuserar endast på transformeringssteget med hjälp av en arkitektur för "transformera efter inläsning". dbt förutsätter att du redan har en kopia av dina data i databasen.

Den här artikeln fokuserar på dbt Cloud. dbt Cloud har nyckelfärdigt stöd för schemaläggning av jobb, CI/CD, dokumentation, övervakning och aviseringar samt en integrerad utvecklingsmiljö (IDE).

En lokal version av dbt med namnet dbt Core är också tillgänglig. Med dbt Core kan du skriva dbt-kod i valfri textredigerare eller IDE på den lokala utvecklingsdatorn och sedan köra dbt från kommandoraden. dbt Core innehåller dbt-kommandoradsgränssnittet (CLI). Dbt CLI är kostnadsfritt att använda och har öppen källkod. Mer information finns i Ansluta till dbt Core.

Eftersom dbt Cloud och dbt Core kan använda värdbaserade git-lagringsplatser (till exempel på GitHub, GitLab eller BitBucket) kan du använda dbt Cloud för att skapa ett dbt-projekt och sedan göra det tillgängligt för dina dbt Cloud- och dbt Core-användare. Mer information finns i Skapa ett dbt-projekt och Använda ett befintligt projekt på dbt-webbplatsen.

En allmän översikt över dbt finns i följande YouTube-video (26 minuter).

Ansluta till dbt Cloud med Partner Connect

I det här avsnittet beskrivs hur du ansluter ett Databricks SQL-lager till dbt Cloud med Partner Connect och sedan ger dbt Cloud läsåtkomst till dina data.

Skillnader mellan standardanslutningar och dbt Cloud

För att ansluta till dbt Cloud med "Partner Connect" följer du stegen i Anslut till dataförberedelsepartner med "Partner Connect". Dbt Cloud-anslutningen skiljer sig från standardanslutningar för dataförberedelse och transformering på följande sätt:

Förutom tjänstens huvudnamn och en personlig åtkomsttoken skapar Partner Connect ett SQL-lager (tidigare SQL-slutpunkt) med namnet DBT_CLOUD_ENDPOINT som standard.

Steg för att ansluta

Gör följande för att ansluta till dbt Cloud med Partner Connect:

Anslut till dataförberedelsepartner med Partner Connect.
När du har anslutit till dbt Cloud visas din dbt Cloud-instrumentpanel. Om du vill utforska ditt dbt Cloud-projekt går du till menyraden bredvid dbt-logotypen och väljer ditt dbt-kontonamn från den första listrutan om det inte visas och väljer sedan projektet Databricks Partner Connect Trial i den andra listrutan om det inte visas.

Dricks

Om du vill visa inställningarna för projektet klickar du på menyn "tre ränder" eller "hamburger", klickar på Projekt för kontoinställningar >och klickar på projektets namn. Om du vill visa anslutningsinställningarna klickar du på länken bredvid Anslutning. Om du vill ändra inställningar klickar du på Redigera.

Om du vill visa information om personlig åtkomsttoken för Azure Databricks för det här projektet klickar du på ikonen "person" på menyraden, klickar på Profilautentiseringsuppgifter >> Databricks Partner Connect-utvärderingsversion och klickar på projektets namn. Om du vill göra en ändring klickar du på Redigera.

Steg för att ge dbt Cloud läsåtkomst till dina data

Partner Connect ger endast skapa-behörighet till tjänstehuvudnamnet DBT_CLOUD_USER endast i standardkatalogen. Följ de här stegen på din Azure Databricks-arbetsyta för att ge DBT_CLOUD_USER tjänstens huvudkonto läsåtkomst till de data som du väljer.

Varning

Du kan anpassa de här stegen för att ge dbt Cloud ytterligare åtkomst mellan kataloger, databaser och tabeller på din arbetsyta. Men som en säkerhetsbästa praxis rekommenderar Databricks starkt att du endast ger åtkomst till de enskilda tabeller som tjänstens säkerhetsansvariga DBT_CLOUD_USER behöver arbeta med och endast läsåtkomst till dessa tabeller.

Klicka på Katalog i sidofältet.
Välj SQL-lagret (DBT_CLOUD_ENDPOINT) i listrutan längst upp till höger.
1. Under Katalogutforskaren väljer du katalogen som innehåller databasen för tabellen.
2. Välj den databas som innehåller tabellen.
3. Välj din tabell.
Dricks

Om du inte ser katalogen, databasen eller tabellen i listan anger du någon del av namnet i rutorna Välj katalog, Välj databas eller Filtrera tabeller för att begränsa listan.
Klicka på Behörigheter.
Klicka på Bevilja.
För Typ för att lägga till flera användare eller grupper väljer du DBT_CLOUD_USER. Det här är tjänstens huvudnamn för Azure Databricks som Partner Connect skapade åt dig i föregående avsnitt.

Dricks

Om du inte ser DBT_CLOUD_USER börjar du DBT_CLOUD_USER skriva i rutan Typ för att lägga till flera användare eller grupper tills den visas i listan och välj den.
Bevilja endast läsåtkomst genom att välja SELECT och READ METADATA.
Klicka på OK.

Upprepa steg 4–9 för varje ytterligare tabell som du vill ge dbt Cloud läsbehörighet till.

Felsöka dbt Cloud-anslutningen

Om någon tar bort projektet i dbt Cloud för det här kontot och du klickar på dbt-panelen visas ett felmeddelande som anger att projektet inte kan hittas. Åtgärda detta genom att klicka på Ta bort anslutning och sedan börja från början av den här proceduren för att skapa anslutningen igen.

Ansluta till dbt Cloud manuellt

Det här avsnittet beskriver hur du ansluter ett Azure Databricks-kluster eller ett Databricks SQL-lager på din Azure Databricks-arbetsyta till dbt Cloud.

Viktigt!

Databricks rekommenderar att du ansluter till ett SQL-lager. Om du inte har behörigheten Databricks SQL-åtkomst, eller om du vill köra Python-modeller, kan du ansluta till ett kluster i stället.

Krav

Ett kluster eller SQL-lager på din Azure Databricks-arbetsyta.
- Referens för beräkningskonfiguration.
- Skapa ett SQL-lager.
Anslutningsinformationen för ditt kluster eller SQL-lager, särskilt värden för servervärdnamn, port och HTTP-sökväg .
- Hämta anslutningsinformation för en Azure Databricks-beräkningsresurs.
En personlig åtkomsttoken för Azure Databricks eller en Microsoft Entra ID-token (tidigare Azure Active Directory). Om du vill skapa en personlig åtkomsttoken följer du stegen i Skapa personliga åtkomsttoken för arbetsyteanvändare.

Kommentar

När du autentiserar med automatiserade verktyg, system, skript och appar rekommenderar Databricks att du använder personliga åtkomsttoken som tillhör tjänstens huvudnamn i stället för arbetsyteanvändare. Information om hur du skapar token för tjänstens huvudnamn finns i Hantera token för tjänstens huvudnamn.

För att ansluta dbt Cloud till data som hanteras av Unity Catalog, dbt version 1.1 eller senare.

Stegen i den här artikeln skapar en ny miljö som använder den senaste dbt-versionen. Information om hur du uppgraderar dbt-versionen för en befintlig miljö finns i Uppgradera till den senaste versionen av dbt i molnet i dbt-dokumentationen.

Gå till dbt Cloud – Registrera dig och ange din e-post, ditt namn och din företagsinformation. Skapa ett lösenord och klicka på Skapa mitt konto.

Steg 2: Skapa ett dbt-projekt

I det här steget skapar du ett dbt-projekt som innehåller en anslutning till ett Azure Databricks-kluster eller ett SQL-lager, en lagringsplats som innehåller källkoden och en eller flera miljöer (till exempel test- och produktionsmiljöer).

Logga in på dbt Cloud.
Klicka på inställningsikonen och klicka sedan på Kontoinställningar.
Klicka på Nytt projekt.
Som Namn anger du ett unikt namn för projektet och klickar sedan på Fortsätt.
Välj en Azure Databricks-beräkningsanslutning i listrutan Välj en anslutning eller skapa en ny anslutning:
1. Klicka på Lägg till ny anslutning.
  
  Guiden Lägg till ny anslutning öppnas på en ny flik.
2. Klicka på Databricks och sedan på Nästa.
  
  Kommentar
  
  Databricks rekommenderar att du använder dbt-databricks, som stöder Unity Catalog, i stället för dbt-spark. Som standard använder dbt-databricksnya projekt . Information om hur du migrerar ett befintligt projekt till dbt-databricksfinns i Migrera från dbt-spark till dbt-databricks i dbt-dokumentationen .
3. Under Inställningar för ServerVärdnamn anger du värdet för serverns värdnamn från kraven.
4. För HTTP-sökväg anger du värdet för HTTP-sökvägen från kraven.
5. Om din arbetsyta är Unity Catalog-aktiverad anger du namnet på katalogen som dbt ska använda under Valfria inställningar.
6. Klicka på Spara.
7. Gå tillbaka till guiden Nytt projekt och välj den anslutning som du nyss skapade på den nedrullningsbara menyn Anslutning .
Under Autentiseringsuppgifter för utveckling, ange Token, den personliga åtkomsttoken eller en Microsoft Entra ID-token enligt kraven.
För Schema anger du namnet på schemat där du vill att dbt ska skapa tabellerna och vyerna.
Klicka på Testa anslutning.
Om testet har slutförts klickar du på Spara.

Mer information finns i Ansluta till Databricks ODBC på dbt-webbplatsen.

Dricks

Om du vill visa eller ändra inställningarna för projektet, eller om du vill ta bort projektet helt och hållet, klickar du på inställningsikonen, klickar på > för kontoinställningar och klickar på projektets namn. Om du vill ändra inställningarna klickar du på Redigera. Om du vill ta bort projektet klickar du på Redigera ta > bort projekt.

Om du vill visa eller ändra värdet för din personliga åtkomsttoken för Azure Databricks för det här projektet klickar du på ikonen "person", klickar på Profilautentiseringsuppgifter >och klickar på namnet på projektet. Om du vill göra en ändring klickar du på Redigera.

När du har anslutit till ett Azure Databricks-kluster eller ett Databricks SQL-lager följer du anvisningarna på skärmen för att konfigurera en lagringsplats och klickar sedan på Fortsätt.

När du har konfigurerat lagringsplatsen följer du anvisningarna på skärmen för att bjuda in användare och klickar sedan på Slutför. Eller klicka på Hoppa över och slutför.

Självstudie

I det här avsnittet använder du ditt dbt Cloud-projekt för att arbeta med exempeldata. Det här avsnittet förutsätter att du redan har skapat projektet och har dbt Cloud IDE öppet för projektet.

Steg 1: Skapa och köra modeller

I det här steget använder du dbt Cloud IDE för att skapa och köra modeller, som är select instruktioner som skapar antingen en ny vy (standard) eller en ny tabell i en databas, baserat på befintliga data i samma databas. Den här proceduren skapar en modell baserat på exempeltabellen diamonds från exempeldatauppsättningarna.

Använd följande kod för att skapa den här tabellen.

DROP TABLE IF EXISTS diamonds;

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

Den här proceduren förutsätter att den här tabellen redan har skapats i arbetsytans default databas.

När projektet är öppet klickar du på Utveckla överst i användargränssnittet.
Klicka på Initiera dbt-projekt.
Klicka på Checka in och synkronisera, ange ett incheckningsmeddelande och klicka sedan på Checka in.
Klicka på Skapa gren, ange ett namn för din gren och klicka sedan på Skicka.
Skapa den första modellen: Klicka på Skapa ny fil.
I textredigeraren anger du följande SQL-instruktion. Den här instruktionen väljer endast karats-, klipp-, färg- och tydlighetsinformation för varje romb från diamonds-tabellen. Blocket config instruerar dbt att skapa en tabell i databasen baserat på den här instruktionen.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Dricks

Ytterligare config alternativ, till exempel den merge inkrementella strategin, finns i Databricks-konfigurationer i dbt-dokumentationen.
Klicka på Spara som.
För filnamnet anger du models/diamonds_four_cs.sql och klickar sedan på Skapa.
Skapa en andra modell: Klicka på (Skapa ny fil) i det övre högra hörnet.
I textredigeraren anger du följande SQL-instruktion. Den här instruktionen väljer unika värden från kolumnen colors i tabellen diamonds_four_cs och sorterar resultatet i alfabetisk ordning först till sist. Eftersom det inte finns något config block instruerar den här modellen dbt att skapa en vy i databasen baserat på den här instruktionen.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Klicka på Spara som.
För filnamnet anger du models/diamonds_list_colors.sqloch klickar sedan på Skapa.
Skapa en tredje modell: Klicka på (Skapa ny fil) i det övre högra hörnet.
I textredigeraren anger du följande SQL-instruktion. Den här instruktionen beräknar rombpriserna efter färg och sorterar resultatet efter genomsnittligt pris från högsta till lägsta. Den här modellen instruerar dbt att skapa en vy i databasen baserat på den här instruktionen.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
Klicka på Spara som.
För filnamnet anger du models/diamonds_prices.sql och klickar på Skapa.

Kör modellerna: På kommandoraden dbt run kör du kommandot med sökvägarna till de tre föregående filerna. default I databasen skapar dbt en tabell med namnet diamonds_four_cs och två vyer med namnet diamonds_list_colors och diamonds_prices. dbt hämtar dessa vy- och tabellnamn från deras relaterade .sql filnamn.

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

Kör följande SQL-kod för att visa information om de nya vyerna och för att välja alla rader från tabellen och vyerna.

Om du ansluter till ett kluster kan du köra den här SQL-koden från en notebook-fil som är ansluten till klustret och ange SQL som standardspråk för notebook-filen. Om du ansluter till ett SQL-lager kan du köra den här SQL-koden från en fråga.

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

Steg 2: Skapa och köra mer komplexa modeller

I det här steget skapar du mer komplexa modeller för en uppsättning relaterade datatabeller. Dessa datatabeller innehåller information om en fiktiv sportliga med tre lag som spelar en säsong med sex matcher. Den här proceduren skapar datatabellerna, skapar modellerna och kör modellerna.

Kör följande SQL-kod för att skapa nödvändiga datatabeller.

Tabellerna och vyerna i det här steget börjar med zzz_ för att identifiera dem som en del av det här exemplet. Du behöver inte följa det här mönstret för dina egna tabeller och vyer.

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

Skapa den första modellen: Klicka på (Skapa ny fil) i det övre högra hörnet.

I textredigeraren anger du följande SQL-instruktion. Den här instruktionen skapar en tabell som innehåller information om varje spel, till exempel lagnamn och poäng. Blocket config instruerar dbt att skapa en tabell i databasen baserat på den här instruktionen.

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

Klicka på Spara som.
För filnamnet anger du models/zzz_game_details.sql och klickar sedan på Skapa.
Skapa en andra modell: Klicka på (Skapa ny fil) i det övre högra hörnet.

I textredigeraren anger du följande SQL-instruktion. Den här instruktionen skapar en vy som listar lagets vinst-förlust-poster för säsongen.

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

Klicka på Spara som.
För filnamnet anger du models/zzz_win_loss_records.sql och klickar sedan på Skapa.

Kör modellerna: På kommandoraden dbt run kör du kommandot med sökvägarna till de två föregående filerna. default I databasen (enligt dina projektinställningar) skapar dbt en tabell med namnet zzz_game_details och en vy med namnet zzz_win_loss_records. dbt hämtar dessa vy- och tabellnamn från deras relaterade .sql filnamn.

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

Kör följande SQL-kod för att visa information om den nya vyn och markera alla rader i tabellen och vyn.

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

Steg 3: Skapa och köra tester

I det här steget skapar du tester, vilket är påståenden som du gör om dina modeller. När du kör de här testerna anger dbt om varje test i projektet godkänns eller misslyckas.

Det finns två typer av tester. Schematester, skrivna i YAML, returnerar antalet poster som inte uppfyller ett villkor. När det här talet är noll godkänns alla poster, och därför godkänns testerna. Datakontroller är specifika sökningar som måste returnera noll poster för att godkännas.

Skapa schematesterna: Klicka på (Skapa ny fil) i det övre högra hörnet.

I textredigeraren anger du följande innehåll. Den här filen innehåller schematester som avgör om de angivna kolumnerna har unika värden, inte är null, bara har de angivna värdena eller en kombination.

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

Klicka på Spara som.
För filnamnet anger du models/schema.ymloch klickar sedan på Skapa.
Skapa det första datatestet: Klicka på (Skapa ny fil) i det övre högra hörnet.

I textredigeraren anger du följande SQL-instruktion. Den här filen innehåller ett datatest för att avgöra om några spel har inträffat utanför grundserien.

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

Klicka på Spara som.
För filnamnet anger du tests/zzz_game_details_check_dates.sqloch klickar sedan på Skapa.
Skapa ett andra datatest: Klicka på (Skapa ny fil) i det övre högra hörnet.

I textredigeraren anger du följande SQL-instruktion. Den här filen innehåller ett datatest för att avgöra om några poäng var negativa eller om några spel var bundna.

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

Klicka på Spara som.
För filnamnet anger du tests/zzz_game_details_check_scores.sqloch klickar sedan på Skapa.
Skapa ett tredje datatest: Klicka på (Skapa ny fil) i det övre högra hörnet.
I textredigeraren anger du följande SQL-instruktion. Den här filen innehåller ett datatest för att avgöra om några lag hade negativa vinst- eller förlustposter, hade fler vinst- eller förlustrekord än matcher som spelades eller spelade fler matcher än vad som var tillåtet.
```
-- 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
```
Klicka på Spara som.
För filnamnet anger du tests/zzz_win_loss_records_check_records.sqloch klickar sedan på Skapa.
Kör testerna: Kör kommandot på kommandoraden dbt test .

Steg 4: Rensa

Du kan ta bort de tabeller och vyer som du skapade för det här exemplet genom att köra följande SQL-kod.

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ästa steg

Läs mer om dbt-modeller.
Lär dig hur du testar dina dbt-projekt.
Lär dig hur du använder Jinja, ett mallspråk, för att programmera SQL i dina dbt-projekt.
Lär dig mer om metodtips för dbt.

Ytterligare resurser

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-04-30

Dela via

Ansluta till dbt Cloud

Ansluta till dbt Cloud med Partner Connect

Skillnader mellan standardanslutningar och dbt Cloud

Steg för att ansluta

Steg för att ge dbt Cloud läsåtkomst till dina data

Felsöka dbt Cloud-anslutningen

Ansluta till dbt Cloud manuellt

Krav

Steg 1: Registrera dig för dbt Cloud

Steg 2: Skapa ett dbt-projekt

Självstudie

Steg 1: Skapa och köra modeller

Steg 2: Skapa och köra mer komplexa modeller

Steg 3: Skapa och köra tester

Steg 4: Rensa

Nästa steg

Ytterligare resurser

Feedback

Ytterligare resurser