Se connecter à dbt Cloud

Article
09/04/2024

dbt (data build tool) est un environnement de développement qui permet aux analystes et ingénieurs de données de transformer les données en écrivant simplement des instructions select. dbt se charge de transformer ces instructions select en tables et en vues. dbt compile votre code en SQL brut, puis exécute ce code sur la base de données spécifiée dans Azure Databricks. dbt prend en charge les modèles de codage collaboratif et les meilleures pratiques, telles que la gestion de version, la documentation et la modularité.

dbt n’extrait ni ne charge les données. dbt se concentre uniquement sur l’étape de transformation, en utilisant une architecture de type « transformation après chargement ». dbt part du principe que vous disposez déjà d’une copie de vos données dans votre base de données.

Cet article concerne dbt Cloud. dbt Cloud est fourni avec la prise en charge clé en main pour la planification des travaux, l’intégration continue et livraison continue (CI/CD), la documentation, le monitoring et la génération d’alertes, ainsi qu’un environnement de développement intégré (IDE).

Une version locale de dbt appelée dbt Core est également disponible. dbt Core vous permet d’écrire du code dbt dans l’éditeur de texte ou l’IDE de votre choix sur votre ordinateur local de développement, puis d’exécuter dbt à partir de la ligne de commande. dbt Core comprend l’interface de ligne de commande (CLI) dbt. L’interface CLI dbt est libre d’utilisation et open source. Pour plus d’informations, consultez Se connecter à dbt Core.

Comme dbt Cloud et dbt Core peuvent utiliser des référentiels git hébergés (par exemple, sur GitHub, GitLab ou BitBucket), vous pouvez utiliser dbt Cloud pour créer un projet dbt et le mettre ensuite à la disposition de vos utilisateurs dbt Cloud et dbt Core. Pour plus d’informations, consultez les sections Creating a dbt project et Using an existing project sur le site web de dbt.

Pour une présentation générale de dbt, regardez la vidéo YouTube suivante (26 minutes).

Se connecter à dbt Cloud l’aide de Partner Connect

Cette section décrit comment connecter un entrepôt Databricks SQL à dbt Cloud à l’aide de Partner Connect, puis accorder à dbt Cloud un accès en lecture à vos données.

Différences entre les connexions standard et dbt Cloud

Pour vous connecter à dbt Cloud à l’aide de Partner Connect, vous suivez les étapes décrites dans Connectez-vous à des partenaires de préparation des données à l’aide de Partner Connect. La connexion dbt Cloud est différente des connexions standard de préparation et de transformation des données des manières suivantes :

En plus d’un principal de service et d’un jeton d’accès personnel, Partner Connect crée un entrepôt SQL (anciennement point de terminaison SQL) nommé DBT_CLOUD_ENDPOINT par défaut.

Étapes de connexion

Pour vous connecter à dbt Cloud à l’aide de Partner Connect, procédez comme suit :

Connectez-vous à des partenaires de préparation des données à l’aide de Partner Connect.
Une fois que vous vous êtes connecté à dbt Cloud, votre tableau de bord dbt Cloud s’affiche. Pour explorer votre projet dbt Cloud, dans la barre de menus, en regard du logo dbt, sélectionnez le nom de votre compte dbt dans la première liste déroulante s’il n’est pas affiché, puis sélectionnez le projet Essai de Databricks Partner Connect dans le deuxième menu déroulant s’il n’est pas affiché.

Conseil

Pour afficher les paramètres de votre projet, cliquez sur le menu trois bandes, puis sur Paramètres du compte > Projets et sur le nom du projet. Pour afficher les paramètres de connexion, cliquez sur le lien en regard de Connexion. Pour modifier des paramètres, cliquez sur Modifier.

Pour afficher les informations de jeton d’accès personnel Azure Databricks pour ce projet, cliquez sur l’icône « personne » dans la barre de menus, cliquez sur Profil > Informations d’identification > Essai de Databricks Partner Connect, puis cliquez sur le nom du projet. Pour apporter une modification, cliquez sur Edit (Modifier).

Étapes pour donner à dbt Cloud un accès en lecture à vos données

Partner Connect accorde l’autorisation de création uniquement au principal de service DBT_CLOUD_USER uniquement sur le catalogue par défaut. Suivez ces étapes dans votre espace de travail Azure Databricks pour donner au principal de service DBT_CLOUD_USER l’accès en lecture aux données que vous choisissez.

Avertissement

Vous pouvez adapter ces étapes pour accorder à dbt Cloud un accès supplémentaire à des catalogues, des bases de données et des tables au sein de votre espace de travail. Toutefois, en tant que meilleure pratique de sécurité, Databricks recommande vivement d’accorder l’accès uniquement aux tables individuelles dont vous avez besoin pour que le principal de service DBT_CLOUD_USER fonctionne, et uniquement avec l’accès en lecture à ces tables.

Cliquez sur Catalogue dans la barre latérale.
Sélectionnez l’entrepôt SQL (DBT_CLOUD_ENDPOINT) dans la liste déroulante en haut à droite.
1. Sous Explorateur de catalogues, sélectionnez le catalogue qui contient la base de données de votre table.
2. Sélectionnez la base de données qui contient votre table.
3. Sélectionnez votre tableau.
Conseil

Si vous ne voyez pas votre catalogue, base de données ou table, entrez une partie du nom dans les zones Sélectionner un catalogue, Sélectionner une base de données ou Filtrer les tables, respectivement, pour affiner la liste.
Cliquez sur Autorisations.
Cliquez sur Octroyer.
Pour Type pour l’ajout de plusieurs utilisateurs ou groupes, sélectionnez DBT_CLOUD_USER. Il s’agit du principal de service Azure Databricks que Partner Connect a créé pour vous dans la section précédente.

Conseil

Si vous ne voyez pas DBT_CLOUD_USER, commencez à taper DBT_CLOUD_USER dans la zone Type pour l’ajout de plusieurs utilisateurs ou groupes jusqu’à ce qu’il apparaisse dans la liste, puis sélectionnez-le.
Accordez l’accès en lecture uniquement en sélectionnant SELECT et READ METADATA.
Cliquez sur OK.

Répétez les étapes 4-9 pour chaque table supplémentaire à laquelle vous souhaitez accorder l’accès en lecture à dbt Cloud.

Résoudre les problèmes de connexion dbt Cloud

Si quelqu’un supprime le projet dans dbt Cloud pour ce compte et que vous cliquez sur la vignette dbt, un message d’erreur s’affiche, indiquant que le projet est introuvable. Pour résoudre ce problème, cliquez sur Supprimer la connexion, puis commencez à partir du début de cette procédure pour créer à nouveau la connexion.

Se connecter à dbt Cloud manuellement

Cette section décrit comment connecter un cluster Azure Databricks ou un entrepôt Databricks SQL dans votre espace de travail Azure Databricks à dbt Cloud.

Important

Databricks recommande une connexion à un entrepôt SQL. Si vous n’avez pas le droit d’accès à Databricks SQL ou si vous souhaitez exécuter des modèles Python, vous pouvez plutôt vous connecter à un cluster.

Exigences

Un cluster ou un entrepôt SQL dans votre espace de travail Azure Databricks.
- Informations de référence sur la configuration de calcul.
- Créer un entrepôt SQL.
Les détails de connexion pour votre cluster ou votre entrepôt SQL, en particulier les valeurs Nom d’hôte du serveur, Port et Chemin HTTP.
- Obtenir les détails de connexion pour une ressource de calcul Azure Databricks.
Un jeton d’accès personnel Azure Databricks ou un jeton Microsoft Entra ID (anciennement Azure Active Directory). Pour créer un jeton d’accès personnel, suivez les étapes décrites dans Les jetons d’accès personnels Azure Databricks pour les utilisateurs de l’espace de travail.

Remarque

En guise de bonne pratique de sécurité, quand vous vous authentifiez avec des outils, systèmes, scripts et applications automatisés, Databricks recommande d’utiliser des jetons d’accès personnels appartenant à des principaux de service et non des utilisateurs de l’espace de travail. Pour créer des jetons d’accès pour des principaux de service, consultez la section Gérer les jetons pour un principal de service.
Pour connecter dbt Cloud à des données gérées par Unity Catalog, dbt version 1.1 ou ultérieure.

Les étapes décrites dans cet article créent un environnement qui utilise la dernière version de dbt. Pour plus d’informations sur la mise à niveau de la version de dbt pour un environnement existant, consultez Mise à niveau vers la dernière version de dbt dans le cloud dans la documentation dbt.

Accédez à la page d’inscription de dbt Cloud et entrez votre adresse e-mail, votre nom et les informations relatives à votre entreprise. Créez un mot de passe et cliquez sur Create my account (Créer mon compte).

Étape 2 : créer un projet dbt

Dans cette étape, vous créez un projet dbt, qui contient une connexion à un cluster Azure Databricks ou à un entrepôt SQL, un référentiel qui contient votre code source et un ou plusieurs environnements (comme des environnements de test et de production).

Connectez-vous à dbt Cloud.
Cliquez sur l’icône Paramètres, puis sur Paramètres du compte.
Cliquez sur Nouveau projet.
Pour Nom, entrez un nom unique pour votre projet, puis cliquez sur Continuer.
Pour Choisir une connexion, cliquez sur Databricks, puis cliquez sur Suivant.
Dans le champ Name (Nom), entrez un nom unique pour cette connexion.
Pour Sélectionner un adaptateur, sélectionnez Databricks (dbt-databricks).

Remarque

Databricks recommande d'utiliser dbt-databricks, qui prend en charge Unity Catalog, au lieu de dbt-spark. Par défaut, les nouveaux projets utilisent dbt-databricks. Pour migrer un projet existant vers dbt-databricks, consultez Migration de dbt-spark vers dbt-databricks dans la documentation dbt.
Sous Paramètres, pour Nom d'hôte du serveur, entrez la valeur du nom d'hôte du serveur à partir des exigences.
Pour Chemin d’accès HTTP, entrez la valeur de chemin d’accès HTTP spécifiée dans la configuration requise.
Si votre espace de travail est activé pour Unity Catalog, sous Paramètres facultatifs, entrez le nom du catalogue à utiliser par dbt Cloud.
Sous Informations d’identification de développement, pour Jeton, entrez le jeton d’accès personnel ou le jeton Microsoft Entra ID des exigences.
Pour Schéma, entrez le nom du schéma dans lequel vous souhaitez que dbt Cloud crée les tables et les vues (par exemple, default).
Cliquez sur Tester la connexion.
Si le test réussit, cliquez sur Suivant.

Pour plus d’informations, consultez la section Connecting to Databricks ODBC sur le site web de dbt.

Conseil

Pour afficher ou modifier les paramètres de ce projet, ou pour supprimer le projet, cliquez sur l’icône Paramètres, sur Paramètres du compte et projets, puis sur le nom du projet. Pour modifier les paramètres, cliquez sur Edit (Modifier). Pour supprimer le projet, cliquez sur Edit (Modifier) > Delete Project (Supprimer le projet).

Pour afficher ou modifier la valeur de votre jeton d’accès personnel Azure Databricks pour ce projet, cliquez sur l’icône représentant une personne, cliquez sur Profile (Profil) > Credentials (Informations d’identification), puis cliquez sur le nom du projet. Pour apporter une modification, cliquez sur Edit (Modifier).

Après vous être connecté à un cluster Azure Databricks ou à un entrepôt Databricks SQL, suivez les instructions à l'écran pour configurer un référentiel, puis cliquez sur Continuer.

Après avoir configuré le référentiel, suivez les instructions à l’écran pour inviter des utilisateurs, puis cliquez sur Complete (Terminer). Ou cliquez sur Ignorer et terminer.

Didacticiel

Dans cette section, vous utilisez votre projet dbt Cloud pour travailler avec des exemples de données. Cette section part du principe que vous avez déjà créé votre projet et que l’IDE dbt Cloud est ouvert sur ce projet.

Étape 1 : créer et exécuter des modèles

Dans cette étape, vous utilisez l’IDE dbt Cloud pour créer et exécuter des modèles, qui sont des instructions select qui créent soit une nouvelle vue (par défaut), soit une nouvelle table dans une base de données, en fonction des données existantes de cette même base de données. Cette procédure crée un modèle basé sur l’exemple de table diamonds des exemples de jeux de données.

Utilisez le code suivant pour créer cette table.

DROP TABLE IF EXISTS diamonds;

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

Cette procédure suppose que cette table a déjà été créée dans la base de données default de votre espace de travail.

Avec le projet ouvert, cliquez sur Développer en haut de l'interface utilisateur.
Cliquez sur Initialiser le projet dbt.
Cliquez sur Valider et synchroniser, saisissez un message de validation, puis cliquez sur Valider.
Cliquez sur Créer une branche, entrez un nom pour votre branche, puis cliquez sur Soumettre.
Créez le premier modèle : Cliquez sur Créer un nouveau fichier.
Dans l'éditeur de texte, entrez l'instruction SQL suivante. Cette instruction sélectionne uniquement les détails relatifs aux carats, à la taille, à la couleur et à la clarté de chaque diamant dans la table diamonds. Le bloc config indique à dbt de créer une table dans la base de données en fonction de cette instruction.
```
{{ config(
  materialized='table',
  file_format='delta'
) }}
```
```
select carat, cut, color, clarity
from diamonds
```
Conseil

Pour obtenir des options config supplémentaires telles que la stratégie incrémentielle merge, consultez Configurations Databricks dans la documentation dbt.
Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/diamonds_four_cs.sql puis cliquez sur Créer.
Créez un deuxième modèle : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.
Dans l'éditeur de texte, entrez l'instruction SQL suivante. Cette instruction sélectionne des valeurs uniques dans la colonne colors de la table diamonds_four_cs, en triant les résultats par ordre alphabétique du premier au dernier. Étant donné qu’il n’y a aucun bloc config, ce modèle demande à dbt de créer une vue dans la base de données en fonction de cette instruction.
```
select distinct color
from diamonds_four_cs
sort by color asc
```
Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/diamonds_list_colors.sql, puis cliquez sur Créer.
Créez un troisième modèle : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.
Dans l'éditeur de texte, entrez l'instruction SQL suivante. Cette instruction calcule la moyenne des prix des diamants par couleur, en triant les résultats par prix moyen, du plus élevé au plus bas. Ce modèle demande à dbt de créer une vue dans la base de données en fonction de cette instruction.
```
select color, avg(price) as price
from diamonds
group by color
order by price desc
```
Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/diamonds_prices.sql, puis cliquez sur Créer.

Exécutez les modèles : dans la ligne de commande, exécutez la commande dbt run avec les chemins d'accès aux trois fichiers précédents. Dans la base de données default, dbt crée une table nommée diamonds_four_cs et deux vues nommées diamonds_list_colors et diamonds_prices. dbt obtient ces noms de vues et de tables à partir des noms de fichiers .sql correspondants.

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

Exécutez le code SQL suivant pour répertorier les informations relatives aux nouvelles vues et sélectionner toutes les lignes de la table et des vues.

Si vous vous connectez à un cluster, vous pouvez exécuter ce code SQL à partir d’un notebook attaché au cluster, en spécifiant SQL comme langage par défaut pour le notebook. Si vous vous connectez à un entrepôt SQL, vous pouvez exécuter ce code SQL à partir d’une requête.

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

Étape 2 : créer et exécuter des modèles plus complexes

Dans cette étape, vous créez des modèles plus complexes pour un ensemble de tables de données associées. Ces tables de données contiennent des informations sur une ligue sportive fictive composée de trois équipes jouant une saison de six matchs. Cette procédure crée les tables de données, crée les modèles et exécute les modèles.

Exécutez le code SQL suivant pour créer les tables de données nécessaires.

Les tables et les vues de cette étape commencent par zzz_ afin de les identifier comme faisant partie de cet exemple. Vous n’avez pas besoin de suivre ce modèle pour vos propres tables et vues.

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

Créez le premier modèle : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.

Dans l'éditeur de texte, entrez l'instruction SQL suivante. Cette instruction crée une table qui fournit les détails de chaque match, tels que les noms des équipes et les scores. Le bloc config indique à dbt de créer une table dans la base de données en fonction de cette instruction.

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

Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/zzz_game_details.sql puis cliquez sur Créer.
Créez un deuxième modèle : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.

Dans l'éditeur de texte, entrez l'instruction SQL suivante. Cette instruction crée une vue qui répertorie les bilans des victoires et des défaites des équipes pour la saison.

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

Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/zzz_win_loss_records.sql puis cliquez sur Créer.

Exécutez les modèles : dans la ligne de commande, exécutez la commande dbt run avec les chemins d'accès aux deux fichiers précédents. Dans la base de données default (comme spécifié dans les paramètres de votre projet), dbt crée une table nommée zzz_game_details et une vue nommée zzz_win_loss_records. dbt obtient ces noms de vues et de tables à partir des noms de fichiers .sql correspondants.

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

Exécutez le code SQL suivant pour répertorier les informations relatives à la nouvelle vue et sélectionner toutes les lignes de la table et de la vue.

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

Étape 3 : créer et exécuter des tests

Dans cette étape, vous créez des tests, qui sont des instructions d’assertion que vous faites sur vos modèles. Lorsque vous exécutez ces tests, dbt vous indique si chaque test de votre projet réussit ou échoue.

Il existe deux types de tests. Les tests de schéma, écrits en YAML, renvoient le nombre d’enregistrements qui ne réussissent pas l’instruction d’assertion. Lorsque ce nombre est égal à zéro, tous les enregistrements réussissent. Par conséquent, les tests réussissent. Les tests de données sont des requêtes spécifiques qui doivent renvoyer zéro enregistrement pour réussir.

Créez les tests de schéma : cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.

Dans l'éditeur de texte, entrez le contenu suivant. Ce fichier comprend des tests de schéma qui déterminent si les colonnes spécifiées ont des valeurs uniques, n’ont pas de valeurs Null, ont uniquement les valeurs spécifiées ou une combinaison.

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

Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez models/schema.yml, puis cliquez sur Créer.
Créez le premier test de données : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.

Dans l'éditeur de texte, entrez l'instruction SQL suivante. Ce fichier comprend un test de données permettant de déterminer si des matchs ont eu lieu en dehors de la saison normale.

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

Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez tests/zzz_game_details_check_dates.sql, puis cliquez sur Créer.
Créez un deuxième test de données : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.

Dans l'éditeur de texte, entrez l'instruction SQL suivante. Ce fichier comprend un test de données permettant de déterminer si les scores sont négatifs ou si les matchs sont à égalité.

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

Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez tests/zzz_game_details_check_scores.sql, puis cliquez sur Créer.
Créez un troisième test de données : Cliquez sur l'icône (Créer un nouveau fichier) dans le coin supérieur droit.
Dans l'éditeur de texte, entrez l'instruction SQL suivante. Ce fichier comprend un test de données permettant de déterminer si des équipes ont eu un nombre négatif de victoires ou de défaites, si elles ont eu plus de victoires ou de défaites que de matchs joués ou si elles ont joué plus de matchs qu’elles n’étaient autorisées.
```
-- 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
```
Cliquez sur Enregistrer sous.
Pour le nom de fichier, entrez tests/zzz_win_loss_records_check_records.sql, puis cliquez sur Créer.
Exécutez les tests : dans la ligne de commande, exécutez la commande dbt test.

Étape 4 : nettoyer

Vous pouvez supprimer les tables et les vues que vous avez créées pour cet exemple en exécutant le code SQL suivant.

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;

Étapes suivantes

Apprenez-en davantage sur les modèles dbt.
Apprenez à tester vos projets dbt.
Apprenez à utiliser Jinja, un langage de templating, pour la programmation SQL dans vos projets dbt.
Découvrez les meilleures pratiques de dbt.

Partager via

Se connecter à dbt Cloud

Se connecter à dbt Cloud l’aide de Partner Connect

Différences entre les connexions standard et dbt Cloud

Étapes de connexion

Étapes pour donner à dbt Cloud un accès en lecture à vos données

Résoudre les problèmes de connexion dbt Cloud

Se connecter à dbt Cloud manuellement

Exigences

Étape 2 : créer un projet dbt

Didacticiel

Étape 1 : créer et exécuter des modèles

Étape 2 : créer et exécuter des modèles plus complexes

Étape 3 : créer et exécuter des tests

Étape 4 : nettoyer

Étapes suivantes

Ressources supplémentaires

Commentaires

Ressources supplémentaires

Partager via

Se connecter à dbt Cloud

Se connecter à dbt Cloud l’aide de Partner Connect

Différences entre les connexions standard et dbt Cloud

Étapes de connexion

Étapes pour donner à dbt Cloud un accès en lecture à vos données

Résoudre les problèmes de connexion dbt Cloud

Se connecter à dbt Cloud manuellement

Exigences

Étape 1 : s’inscrire à dbt Cloud

Étape 2 : créer un projet dbt

Didacticiel

Étape 1 : créer et exécuter des modèles

Étape 2 : créer et exécuter des modèles plus complexes

Étape 3 : créer et exécuter des tests

Étape 4 : nettoyer

Étapes suivantes

Ressources supplémentaires

Commentaires

Ressources supplémentaires