Connettersi a dbt Cloud

Articolo
07/05/2024

dbt (data build tool) è un ambiente di sviluppo che consente agli analisti dei dati e ai data engineer di trasformare i dati semplicemente scrivendo istruzioni select. dbt gestisce la trasformazione di queste istruzioni select in tabelle e viste. dbt compila il codice in SQL non elaborato e quindi esegue tale codice nel database specificato in Azure Databricks. dbt supporta modelli di scrittura del codice collaborativi e procedure consigliate, ad esempio il controllo della versione, la documentazione e la modularità.

dbt non estrae o carica i dati. dbt è incentrato solo sul passaggio di trasformazione, usando un'architettura "transform after load". dbt presuppone che nel database sia già presente una copia dei dati.

Questo articolo è incentrato su dbt Cloud. dbt Cloud è dotato di supporto chiavi in mano per la pianificazione di processi, CI/CD, documentazione, monitoraggio e avvisi e un ambiente di sviluppo integrato (IDE).

È disponibile anche una versione locale di dbt denominata dbt Core. dbt Core consente di scrivere codice dbt nell'editor di testo o nell'IDE di propria scelta nel computer di sviluppo locale e quindi eseguire dbt dalla riga di comando. dbt Core include l'interfaccia della riga di comando dbt. L'interfaccia della riga di comando di dbt può essere usata gratuitamente ed è open source. Per altre informazioni, vedere Connettersi a dbt Core.

Poiché dbt Cloud e dbt Core possono usare repository Git ospitati (ad esempio, in GitHub, GitLab o BitBucket), è possibile usare dbt Cloud per creare un progetto dbt e renderlo disponibile per gli utenti dbt Cloud e dbt Core. Per altre informazioni, vedere Creazione di un progetto dbt e Uso di un progetto esistente nel sito Web dbt.

Per una panoramica generale di dbt, guardare il video di YouTube seguente (26 minuti).

Connettersi a dbt Cloud tramite Partner Connect

Questa sezione descrive come connettere un databricks SQL warehouse a dbt Cloud tramite Partner Connect, quindi concedere a dbt Cloud l'accesso in lettura ai dati.

Differenze tra connessioni standard e dbt Cloud

Per connettersi a dbt Cloud tramite Partner Connect, seguire la procedura descritta in Connettersi ai partner di preparazione dei dati tramite Partner Connect. La connessione dbt Cloud è diversa dalla preparazione dei dati standard e dalle connessioni di trasformazione nei modi seguenti:

Oltre a un'entità servizio e a un token di accesso personale, Partner Connect crea un archivio SQL (in precedenza endpoint SQL) denominato DBT_CLOUD_ENDPOINT per impostazione predefinita.

Passaggi per la connessione

Per connettersi a dbt Cloud tramite Partner Connect, eseguire le operazioni seguenti:

Connettersi ai partner di preparazione dei dati usando Partner Connect.
Dopo la connessione a dbt Cloud, viene visualizzato il dashboard dbt Cloud. Per esplorare il progetto dbt Cloud, nella barra dei menu accanto al logo dbt selezionare il nome dell'account dbt dal primo elenco a discesa se non viene visualizzato e quindi selezionare il progetto Databricks Partner Connect Trial dal secondo menu a discesa se non viene visualizzato.

Suggerimento

Per visualizzare le impostazioni del progetto, fare clic sul menu "tre strisce" o "hamburger", fare clic su Progetti impostazioni > account e fare clic sul nome del progetto. Per visualizzare le impostazioni di connessione, fare clic sul collegamento accanto a Connessione. Per modificare le impostazioni, fare clic su Modifica.

Per visualizzare le informazioni sul token di accesso personale di Azure Databricks per questo progetto, fare clic sull'icona "persona" sulla barra dei menu, fare clic su Profilo > credenziali > Databricks Partner Connect Trial e fare clic sul nome del progetto. Per apportare una modifica, fare clic su Modifica.

Passaggi per concedere a dbt Cloud l'accesso in lettura ai dati

Partner Connect concede l'autorizzazione di sola creazione all'entità servizio DBT_CLOUD_USER solo nel catalogo predefinito. Seguire questa procedura nell'area di lavoro di Azure Databricks per concedere all'entità servizio di DBT_CLOUD_USER l'accesso in lettura ai dati scelti.

Avviso

È possibile adattare questi passaggi per concedere a dbt Cloud l'accesso aggiuntivo tra cataloghi, database e tabelle all'interno dell'area di lavoro. Tuttavia, come procedura consigliata per la sicurezza, Databricks consiglia vivamente di concedere l'accesso solo alle singole tabelle di cui è necessaria l'DBT_CLOUD_USER'entità servizio per usare e solo l'accesso in lettura a tali tabelle.

Fare clic su Catalogo nella barra laterale.
Selezionare SQL Warehouse (DBT_CLOUD_ENDPOINT) nell'elenco a discesa in alto a destra.
1. In Esplora cataloghi selezionare il catalogo che contiene il database per la tabella.
2. Selezionare il database che contiene la tabella.
3. Seleziona la tabella.
Suggerimento

Se il catalogo, il database o la tabella non sono elencati, immettere una parte del nome nelle caselle Seleziona catalogo, Seleziona database o Filtra tabelle rispettivamente per restringere l'elenco.
Fare clic su Autorizzazioni.
Fare clic su Concedi.
Per Tipo per aggiungere più utenti o gruppi, selezionare DBT_CLOUD_USER. Si tratta dell'entità servizio di Azure Databricks creata automaticamente da Partner Connect nella sezione precedente.

Suggerimento

Se non viene visualizzato DBT_CLOUD_USER, iniziare a digitare DBT_CLOUD_USER nella casella Tipo per aggiungere più utenti o gruppi fino a quando non viene visualizzato nell'elenco e quindi selezionarlo.
Concedere l'accesso in lettura solo selezionando SELECT e READ METADATA.
Fare clic su OK.

Ripetere i passaggi da 4 a 9 per ogni tabella aggiuntiva a cui si vuole concedere l'accesso in lettura dbt Cloud.

Risolvere i problemi relativi alla connessione dbt Cloud

Se un utente elimina il progetto in dbt Cloud per questo account e si fa clic sul riquadro dbt , viene visualizzato un messaggio di errore che informa che non è possibile trovare il progetto. Per risolvere il problema, fare clic su Elimina connessione e quindi iniziare dall'inizio di questa procedura per creare di nuovo la connessione.

Connettersi manualmente a dbt Cloud

Questa sezione descrive come connettere un cluster Di Azure Databricks o un databricks SQL Warehouse nell'area di lavoro di Azure Databricks a dbt Cloud.

Importante

Databricks consiglia di connettersi a un'istanza di SQL Warehouse. Se non si ha il diritto di accesso a Databricks SQL o se si vogliono eseguire modelli Python, è invece possibile connettersi a un cluster.

Fabbisogno

Un cluster o sql warehouse nell'area di lavoro di Azure Databricks.
- Informazioni di riferimento sulla configurazione di calcolo.
- Creare un'istanza di SQL Warehouse.
I dettagli di connessione per il cluster o sql warehouse, in particolare i valori Nome host server, Porta e Percorso HTTP.
- Ottenere i dettagli di connessione per una risorsa di calcolo di Azure Databricks.
Un token di accesso personale di Azure Databricks o un token di Microsoft Entra ID (in precedenza Azure Active Directory). Per creare un token di accesso personale, eseguire le operazioni seguenti:
1. Nell'area di lavoro di Azure Databricks fare clic sul nome utente di Azure Databricks nella barra superiore e quindi selezionare Impostazioni nell'elenco a discesa.
2. Fare clic su Sviluppatore.
3. Accanto a Token di accesso fare clic su Gestisci.
4. Fare clic su Generare nuovi token.
5. (Facoltativo) Immettere un commento che consente di identificare questo token in futuro e modificare la durata predefinita del token di 90 giorni. Per creare un token senza durata (scelta non consigliata), lasciare vuota la casella Durata (giorni) (vuota).
6. Fare clic su Genera.
7. Copiare il token visualizzato in un percorso sicuro e quindi fare clic su Fine.
Nota

Assicurarsi di salvare il token copiato in un percorso sicuro. Non condividere il token copiato con altri utenti. Se si perde il token copiato, non è possibile rigenerare lo stesso token esatto. È invece necessario ripetere questa procedura per creare un nuovo token. Se si perde il token copiato o si ritiene che il token sia stato compromesso, Databricks consiglia vivamente di eliminare immediatamente il token dall'area di lavoro facendo clic sull'icona del cestino (Revoca) accanto al token nella pagina Token di accesso.

Se non è possibile creare o usare token nell'area di lavoro, questo potrebbe essere dovuto al fatto che l'amministratore dell'area di lavoro ha disabilitato i token o non ha concesso l'autorizzazione per creare o usare token. Vedere l'amministratore dell'area di lavoro o quanto segue:
- Abilitare o disabilitare l'autenticazione del token di accesso personale per l'area di lavoro
- Autorizzazioni del token di accesso personale
Nota

Come procedura consigliata per la sicurezza, quando si esegue l'autenticazione con strumenti automatizzati, sistemi, script e app, Databricks consiglia di usare token di accesso personali appartenenti alle entità servizio anziché agli utenti dell'area di lavoro. Per creare token per le entità servizio, vedere Gestire i token per un'entità servizio.
Per connettere dbt Cloud ai dati gestiti da Unity Catalog, dbt versione 1.1 o successiva.

I passaggi descritti in questo articolo creano un nuovo ambiente che usa la versione dbt più recente. Per informazioni sull'aggiornamento della versione dbt per un ambiente esistente, vedere Aggiornamento alla versione più recente di dbt in Cloud nella documentazione di dbt.

Passare a dbt Cloud - Iscriversi e immettere le informazioni di posta elettronica, nome e società. Creare una password e fare clic su Crea account personale.

Passaggio 2: Creare un progetto dbt

In questo passaggio si crea un progetto dbt che contiene una connessione a un cluster Azure Databricks o a un sql warehouse, un repository che contiene il codice sorgente e uno o più ambienti, ad esempio i test e gli ambienti di produzione.

Accedere a dbt Cloud.
Fare clic sull'icona delle impostazioni e quindi su Impostazioni account.
Fai clic su Nuovo progetto.
In Nome immettere un nome univoco per il progetto e quindi fare clic su Continua.
In Scegliere una connessione fare clic su Databricks e quindi su Avanti.
In Nome immettere un nome univoco per la connessione.
Per Select Adapter (Seleziona adattatore) fare clic su Databricks (dbt-databricks).

Nota

Databricks consiglia di usare dbt-databricks, che supporta Il catalogo unity, anziché dbt-spark. Per impostazione predefinita, i nuovi progetti usano dbt-databricks. Per eseguire la migrazione di un progetto esistente a dbt-databricks, vedere Migrazione da dbt-spark a dbt-databricks nella documentazione di dbt.
In Impostazioni immettere il valore nome host del server in Nome host del server in base ai requisiti.
Per Percorso HTTP immettere il valore del percorso HTTP dai requisiti.
Se l'area di lavoro è abilitata per Unity Catalog, in Impostazioni facoltative immettere il nome del catalogo per dbt Cloud da usare.
In Credenziali di sviluppo immettere il token di accesso personale o il token ID di Microsoft Entra in Base ai requisiti.
Per Schema immettere il nome dello schema in cui si vuole che dbt Cloud crei le tabelle e le viste, ad esempio default.
Fare clic su Verifica connessione.
Se il test ha esito positivo, fare clic su Avanti.

Per altre informazioni, vedere Connessione a Databricks ODBC nel sito Web dbt.

Suggerimento

Per visualizzare o modificare le impostazioni per questo progetto o per eliminare completamente il progetto, fare clic sull'icona delle impostazioni, fare clic su Progetti impostazioni > account e fare clic sul nome del progetto. Per modificare le impostazioni, fare clic su Modifica. Per eliminare il progetto, fare clic su Modifica > elimina progetto.

Per visualizzare o modificare il valore del token di accesso personale di Azure Databricks per questo progetto, fare clic sull'icona "persona", fare clic su Credenziali profilo > e fare clic sul nome del progetto. Per apportare una modifica, fare clic su Modifica.

Dopo la connessione a un cluster Azure Databricks o a un databricks SQL Warehouse, seguire le istruzioni visualizzate per configurare un repository e quindi fare clic su Continua.

Dopo aver configurato il repository, seguire le istruzioni visualizzate per invitare gli utenti e quindi fare clic su Completa. In alternativa, fare clic su Ignora e completa.

Esercitazione

In questa sezione si usa il progetto dbt Cloud per usare alcuni dati di esempio. Questa sezione presuppone che il progetto sia già stato creato e che l'IDE dbt Cloud sia aperto a tale progetto.

Passaggio 1: Creare ed eseguire modelli

In questo passaggio si usa l'IDE dbt Cloud per creare ed eseguire modelli, ovvero select istruzioni che creano una nuova vista (impostazione predefinita) o una nuova tabella in un database, in base ai dati esistenti nello stesso database. Questa procedura crea un modello basato sulla tabella di esempio dei set di dati di esempiodiamonds.

Usare il codice seguente per creare questa tabella.

DROP TABLE IF EXISTS diamonds;

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

Questa procedura presuppone che questa tabella sia già stata creata nel database dell'area di default lavoro.

Con il progetto aperto, fare clic su Sviluppa nella parte superiore dell'interfaccia utente.
Fare clic su Inizializza progetto dbt.
Fare clic su Commit e sincronizzazione, immettere un messaggio di commit e quindi fare clic su Commit.
Fare clic su Crea ramo, immettere un nome per il ramo e quindi fare clic su Invia.
Creare il primo modello: fare clic su Crea nuovo file.
Nell'editor di testo immettere l'istruzione SQL seguente. Questa istruzione seleziona solo i dettagli carat, cut, color e clarity per ogni diamante della diamonds tabella. Il config blocco indica a dbt di creare una tabella nel database in base a questa istruzione.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Suggerimento

Per altre config opzioni, ad esempio la merge strategia incrementale, vedere Configurazioni di Databricks nella documentazione di dbt.
Fare clic su Salva con nome.
Per il nome file immettere models/diamonds_four_cs.sql e quindi fare clic su Crea.
Creare un secondo modello: fare clic su (Crea nuovo file) nell'angolo superiore destro.
Nell'editor di testo immettere l'istruzione SQL seguente. Questa istruzione seleziona valori univoci dalla colors colonna nella diamonds_four_cs tabella, ordinando i risultati in ordine alfabetico prima per ultimo. Poiché non è presente alcun config blocco, questo modello indica a dbt di creare una vista nel database in base a questa istruzione.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Fare clic su Salva con nome.
Per il nome file immettere models/diamonds_list_colors.sqle quindi fare clic su Crea.
Creare un terzo modello: fare clic su (Crea nuovo file) nell'angolo superiore destro.
Nell'editor di testo immettere l'istruzione SQL seguente. Questa affermazione calcola i prezzi dei diamanti in base al colore, ordinando i risultati in base al prezzo medio dal più alto al più basso. Questo modello indica a dbt di creare una vista nel database in base a questa istruzione.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
Fare clic su Salva con nome.
Per il nome file immettere models/diamonds_prices.sql e fare clic su Crea.

Eseguire i modelli: nella riga di comando eseguire il dbt run comando con i percorsi dei tre file precedenti. default Nel database dbt crea una tabella denominata diamonds_four_cs e due viste denominate diamonds_list_colors e diamonds_prices. dbt ottiene questi nomi di vista e tabella dai nomi di file correlati .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

Eseguire il codice SQL seguente per elencare le informazioni sulle nuove viste e selezionare tutte le righe della tabella e delle viste.

Se ci si connette a un cluster, è possibile eseguire questo codice SQL da un notebook collegato al cluster, specificando SQL come linguaggio predefinito per il notebook. Se ci si connette a un'istanza di SQL Warehouse, è possibile eseguire questo codice SQL da una query.

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

Passaggio 2: Creare ed eseguire modelli più complessi

In questo passaggio vengono creati modelli più complessi per un set di tabelle dati correlate. Queste tabelle di dati contengono informazioni su una lega sportiva fittizia di tre squadre che giocano una stagione di sei partite. Questa procedura crea le tabelle dati, crea i modelli ed esegue i modelli.

Eseguire il codice SQL seguente per creare le tabelle di dati necessarie.

Le tabelle e le viste in questo passaggio iniziano con zzz_ per identificarle come parte di questo esempio. Non è necessario seguire questo modello per tabelle e viste personalizzate.

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

Creare il primo modello: fare clic su (Crea nuovo file) nell'angolo superiore destro.

Nell'editor di testo immettere l'istruzione SQL seguente. Questa istruzione crea una tabella che fornisce i dettagli di ogni gioco, ad esempio i nomi e i punteggi della squadra. Il config blocco indica a dbt di creare una tabella nel database in base a questa istruzione.

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

Fare clic su Salva con nome.
Per il nome file immettere models/zzz_game_details.sql e quindi fare clic su Crea.
Creare un secondo modello: fare clic su (Crea nuovo file) nell'angolo superiore destro.

Nell'editor di testo immettere l'istruzione SQL seguente. Questa istruzione crea una visualizzazione che elenca i record di vittoria della squadra per la stagione.

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

Fare clic su Salva con nome.
Per il nome file immettere models/zzz_win_loss_records.sql e quindi fare clic su Crea.

Eseguire i modelli: nella riga di comando eseguire il dbt run comando con i percorsi dei due file precedenti. Nel database (come specificato nelle impostazioni del default progetto), dbt crea una tabella denominata e una vista denominata zzz_game_details zzz_win_loss_records. dbt ottiene questi nomi di vista e tabella dai nomi di file correlati .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

Eseguire il codice SQL seguente per elencare le informazioni sulla nuova vista e selezionare tutte le righe dalla tabella e dalla vista.

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

Passaggio 3: Creare ed eseguire test

In questo passaggio vengono creati test, che sono asserzioni eseguite sui modelli. Quando si eseguono questi test, dbt indica se ogni test del progetto supera o non riesce.

Esistono due tipi di test. I test dello schema, scritti in YAML, restituiscono il numero di record che non superano un'asserzione. Quando questo numero è zero, tutti i record vengono superati, pertanto i test vengono superati. I test dei dati sono query specifiche che devono restituire zero record da passare.

Creare i test dello schema: fare clic su (Crea nuovo file) nell'angolo superiore destro.

Nell'editor di testo immettere il contenuto seguente. Questo file include test dello schema che determinano se le colonne specificate hanno valori univoci, non sono Null, hanno solo i valori specificati o una combinazione.

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

Fare clic su Salva con nome.
Per il nome file immettere models/schema.ymle quindi fare clic su Crea.
Creare il primo test dei dati: fare clic su (Crea nuovo file) nell'angolo superiore destro.

Nell'editor di testo immettere l'istruzione SQL seguente. Questo file include un test di dati per determinare se eventuali partite si sono verificate al di fuori della stagione regolare.

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

Fare clic su Salva con nome.
Per il nome file immettere tests/zzz_game_details_check_dates.sqle quindi fare clic su Crea.
Creare un secondo test di dati: fare clic su (Crea nuovo file) nell'angolo superiore destro.

Nell'editor di testo immettere l'istruzione SQL seguente. Questo file include un test di dati per determinare se i punteggi sono stati negativi o eventuali giochi sono stati legati.

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

Fare clic su Salva con nome.
Per il nome file immettere tests/zzz_game_details_check_scores.sqle quindi fare clic su Crea.
Creare un terzo test di dati: fare clic su (Crea nuovo file) nell'angolo superiore destro.
Nell'editor di testo immettere l'istruzione SQL seguente. Questo file include un test dei dati per determinare se qualsiasi squadra ha avuto record negativi o di perdita, ha avuto più record di vittoria o perdita rispetto ai giochi o ha giocato più partite di quanto consentito.
```
-- 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
```
Fare clic su Salva con nome.
Per il nome file immettere tests/zzz_win_loss_records_check_records.sqle quindi fare clic su Crea.
Eseguire i test: nella riga di comando eseguire il dbt test comando .

Passaggio 4: Pulire

È possibile eliminare le tabelle e le viste create per questo esempio eseguendo il codice SQL seguente.

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;

Passaggi successivi

Altre informazioni sui modelli dbt.
Informazioni su come testare i progetti dbt.
Informazioni su come usare Jinja, un linguaggio di creazione modelli, per la programmazione di SQL nei progetti dbt.
Informazioni sulle procedure consigliate per dbt.

Condividi tramite

Connettersi a dbt Cloud

Connettersi a dbt Cloud tramite Partner Connect

Differenze tra connessioni standard e dbt Cloud

Passaggi per la connessione

Passaggi per concedere a dbt Cloud l'accesso in lettura ai dati

Risolvere i problemi relativi alla connessione dbt Cloud

Connettersi manualmente a dbt Cloud

Fabbisogno

Passaggio 2: Creare un progetto dbt

Esercitazione

Passaggio 1: Creare ed eseguire modelli

Passaggio 2: Creare ed eseguire modelli più complessi

Passaggio 3: Creare ed eseguire test

Passaggio 4: Pulire

Passaggi successivi

Risorse aggiuntive

Commenti e suggerimenti

Risorse aggiuntive

Condividi tramite

Connettersi a dbt Cloud

Connettersi a dbt Cloud tramite Partner Connect

Differenze tra connessioni standard e dbt Cloud

Passaggi per la connessione

Passaggi per concedere a dbt Cloud l'accesso in lettura ai dati

Risolvere i problemi relativi alla connessione dbt Cloud

Connettersi manualmente a dbt Cloud

Fabbisogno

Passaggio 1: Iscriversi a dbt Cloud

Passaggio 2: Creare un progetto dbt

Esercitazione

Passaggio 1: Creare ed eseguire modelli

Passaggio 2: Creare ed eseguire modelli più complessi

Passaggio 3: Creare ed eseguire test

Passaggio 4: Pulire

Passaggi successivi

Risorse aggiuntive

Commenti e suggerimenti

Risorse aggiuntive