Se connecter à dbt Cloud
dbt (data build tool) est un environnement de développement qui permet aux data analysts et aux data engineers de transformer des données en écrivant simplement des instructions de sélection. dbt convertit ces instructions de sélection 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 Databricks. dbt prend en charge les modèles de codage collaboratifs et les meilleures pratiques telles que le contrôle de version, la documentation et la modularité.
dbt n'extrait ni ne charge de données. dbt se concentre uniquement sur l'étape des transformations, en utilisant une architecture « transformer après le chargement ». dbt suppose que vous avez déjà une copie de vos données dans votre base de données.
Cet article se concentre sur dbt Cloud. dbt Cloud est équipé d'une prise en charge clé en main pour la planification des Jobs, le CI/CD, la diffusion de la documentation, le monitoring et les alertes, ainsi que d'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 machine de développement locale, puis d’exécuter dbt à partir de la ligne de commande. dbt Core inclut l’interface de ligne de commande (CLI) de dbt. Le CLI dbt est gratuit et open source. Pour plus d’information, consultez Se connecter à dbt Core.
Puisque dbt Cloud et dbt Core peuvent utiliser des repositories 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, voir Création d'un projet dbt et Utilisation d'un projet existant sur le site web de dbt.
Pour un aperçu général de dbt, regardez la vidéo YouTube suivante (26 minutes).
Connectez-vous à dbt Cloud à l'aide de Partner Connect
Cette section explique comment connecter un warehouse Databricks SQL à dbt Cloud à l’aide de Partner Connect, puis comment 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, suivez les étapes de la section Connectez-vous aux Partenaires de préparation des données à l’aide de Partner Connect. La connexion dbt Cloud diffère des connexions standard de préparation des données et de Transformations des façons suivantes :
- En plus d’un Service Principal et d’un jeton d’accès personnel, Partner Connect crée par default un SQL Warehouse (anciennement SQL Endpoint) nommé DBT_CLOUD_ENDPOINT .
Étapes pour se connecter
Pour vous connecter à dbt Cloud en utilisant Partner Connect, procédez comme suit :
-
Connectez-vous aux partenaires de préparation de données à l'aide de Partner Connect.
-
Après vous être connecté à dbt Cloud, votre tableau de bord dbt Cloud apparaît. Dans la barre de menus, à côté du logo dbt, sélectionnez le nom de votre compte dbt dans le premier menu déroulant s'il n'est pas affiché, puis sélectionnez le projet **Databricks Partner Connect Trial** dans le deuxième menu déroulant s'il n'est pas affiché. Pour explorer votre projet dbt Cloud, dans la barre de menus, à côté 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 **Databricks Partner Connect Trial** dans la deuxième liste déroulante s'il n'est pas affiché.
Pour afficher les paramètres de votre projet, cliquez sur le menu « trois barres » ou « hamburger », cliquez sur Paramètres du compte > Projets , puis cliquez sur le nom du projet. Pour afficher les paramètres de connexion, cliquez sur le Link à côté de Connexion . Pour modifier n'importe quel paramètre, cliquez sur Modifier .
Pour afficher les informations du jeton d'accès personnel Databricks pour ce projet, cliquez sur l'icône « personne » dans la barre de menus, cliquez sur Profil > Identifiants > Essai Databricks Partner Connect , puis cliquez sur le nom du projet. Pour apporter une modification, cliquez sur Modifier .
Étapes pour donner à dbt Cloud un accès en lecture à vos données
Partner Connect accorde une autorisation de création uniquement au Service Principal DBT_CLOUD_USER sur le catalogue default. Suivez ces étapes dans votre workspace Databricks pour donner au Service Principal DBT_CLOUD_USER l'accès en lecture aux données que vous choisissez.
Vous pouvez adapter ces étapes pour donner à dbt Cloud un accès supplémentaire aux catalogues, bases de données et tables au sein de votre Workspace. Toutefois, par bonne pratique de sécurité, Databricks vous recommande fortement de n'accorder l'accès qu'aux tables individuelles avec lesquelles le Service Principal DBT_CLOUD_USER doit travailler et uniquement l'accès en lecture à ces tables.
-
Cliquez sur
Catalogue dans la barre latérale. -
Sélectionnez le SQL Warehouse ( DBT_CLOUD_ENDPOINT ) dans la liste déroulante en haut à droite.
- Sous Explorateur de catalogues , sélectionnez le catalogue qui contient la base de données pour votre table.
- Sélectionnez la base de données qui contient votre table.
- Sélectionnez votre table.
Si vous ne voyez pas votre catalogue, votre base de données ou votre table listé(e), saisissez 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 Accorder .
-
Pour Saisir plusieurs utilisateurs ou groupes , sélectionnez DBT_CLOUD_USER . Il s'agit du Service Principal Databricks que Partner Connect a créé pour vous dans la section précédente.
Si vous ne voyez pas DBT_CLOUD_USER , commencez à taper DBT_CLOUD_USER dans la zone Saisissez 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
SELECTetREAD METADATA. -
Cliquez sur **OK**.
Répétez les étapes 4 à 9 pour chaque table supplémentaire à laquelle vous souhaitez donner un accès en lecture à dbt Cloud.
Dépanner la 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 apparaît, indiquant que le projet est introuvable. Pour résoudre ce problème, cliquez sur **« Supprimer la connexion »**, puis start la procédure depuis le début pour créer à nouveau la connexion.
Se connecter manuellement à dbt Cloud
Cette section décrit comment connecter un cluster Databricks ou un Databricks SQL warehouse dans votre Workspace Databricks à dbt Cloud.
Databricks recommande de se connecter à un SQL warehouse. Si vous n'avez pas le droit d'accès à Databricks SQL, ou si vous souhaitez exécuter des modèles Python, vous pouvez vous connecter à un cluster à la place.
Exigences
-
Un cluster ou un SQL Warehouse dans votre Databricks Workspace.
-
Les détails de connexion de votre cluster ou SQL Warehouse, plus précisément les valeurs Hostname du serveur , Port et Chemin HTTP .
-
Un jeton d'accès personnel Databricks. Pour créer un jeton d'accès personnel, suivez les étapes de Créer des jetons d'accès personnels pour les utilisateurs de Workspace.
En tant que bonne pratique de sécurité lorsque vous vous authentifiez avec des outils, des systèmes, des scripts et des applications automatisés, Databricks vous recommande d'utiliser des jetons OAuth.
Si vous utilisez l'authentification par jeton d'accès personnel, Databricks recommande d'utiliser des jetons d'accès personnels appartenant aux Service Principal plutôt qu'aux utilisateurs du Workspace. Pour créer des jetons pour les Service Principals, consultez Gérer les jetons pour un Service Principal.
-
Pour connecter dbt Cloud aux données gérées par Unity Catalog, version dbt 1,1 ou supérieure.
Les étapes de cet article créent un nouvel environnement qui utilise la dernière version de dbt. Pour obtenir des informations sur la mise à niveau de la version dbt pour un environnement existant, consultez Mise à niveau vers la dernière version de dbt dans le cloud dans la documentation dbt.
Étape 1 : Inscrivez-vous à dbt Cloud
Accédez à dbt Cloud - Inscription et saisissez votre e-mail, votre nom et les informations de votre entreprise. Créez un mot de passe et cliquez sur 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 Databricks ou à un SQL warehouse, un repository qui contient votre code source, et un ou plusieurs environnements (tels que des environnements de test et de production).
-
Cliquez sur l’icône des paramètres, puis cliquez sur Paramètres du compte .
-
Cliquez sur Nouveau projet .
-
Pour Nom , saisissez un nom unique pour votre projet, puis cliquez sur Continuer .
-
Sélectionnez une connexion de compute Databricks dans le menu déroulant Choisir une connexion ou créez une nouvelle connexion :
-
Cliquez sur **Ajouter une nouvelle connexion**.
L'assistant **Ajouter une nouvelle connexion** s'ouvre dans un nouveau tab.
-
Cliquez sur Databricks , puis cliquez sur Suivant .
-
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 « default ». Pour migrer un projet existant vers dbt-databricks, consultez Migration de dbt-spark vers dbt-databricks dans la documentation dbt.
-
Sous Paramètres , pour Hostname du serveur , entrez la valeur du hostname du serveur des exigences.
-
Pour Chemin HTTP, saisissez la valeur du chemin HTTP des exigences.
-
Si votre workspace est compatible avec Unity Catalog, sous Paramètres facultatifs , saisissez le nom du catalogue à utiliser pour dbt.
-
Cliquez sur Enregistrer .
-
Retournez à l'assistant Nouveau projet et sélectionnez la connexion que vous venez de créer dans le menu déroulant Connexion .
-
Sous Informations d'identification de développement , pour Jeton , saisissez le jeton d'accès personnel des exigences.
-
Pour le schéma , saisissez le nom du schéma où vous souhaitez que dbt crée les tables et les vues.
-
Cliquez sur Test de la connexion .
-
Si le test se termine avec succès, cliquez sur Enregistrer .
Pour plus d'informations, consultez Connexion à Databricks ODBC sur le site web de dbt.
Pour afficher ou modifier les paramètres de ce projet, ou pour supprimer le projet entièrement, cliquez sur l'icône des paramètres, cliquez sur Paramètres du compte > Projets , et cliquez sur le nom du projet. Pour modifier les paramètres, cliquez sur Modifier . Pour supprimer le projet, cliquez sur **Modifier > Supprimer le projet**.
Pour afficher ou modifier la valeur de votre jeton d'accès personnel Databricks pour ce projet, cliquez sur l'icône « personne », cliquez sur Profil > Identifiants , puis cliquez sur le nom du projet. Pour apporter une modification, cliquez sur Modifier .
Après vous être connecté à un cluster Databricks ou à un warehouse Databricks SQL, suivez les instructions à l'écran pour Configurer un Repository , puis cliquez sur Continuer .
Après avoir configuré le repository, suivez les instructions à l'écran pour inviter les utilisateurs, puis cliquez sur **Terminer**. Ou cliquez sur Ignorer et terminer .
Didacticiel
Dans cette section, vous utilisez votre projet dbt Cloud pour travailler avec des données d'exemple. Cette section suppose 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 default) soit une nouvelle table dans une base de données, basée sur les données existantes dans cette même base de données. Cette procédure crée un modèle basé sur la table diamonds d’exemple des Exemples de datasets.
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 workspace.
-
Le projet étant ouvert, cliquez sur Développer en haut de l'interface utilisateur.
-
Cliquez sur **Initialize dbt project**.
-
Cliquez sur Commit et synchroniser , saisissez un message de commit, puis cliquez sur Commit .
-
Cliquez sur Créer une Branch , saisissez un nom pour votre Branch, puis cliquez sur Soumettre .
-
Créer le premier modèle : Cliquez sur **Créer un nouveau fichier**.
-
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Cette instruction sélectionne uniquement les détails du carat, de la taille, de la couleur et de la clarté pour chaque diamant de la table
diamonds. Le blocconfigdemande à dbt de créer une table dans la base de données basée sur cette instruction.{{ config(
materialized='table',
file_format='delta'
) }}SQLselect carat, cut, color, clarity
from diamonds
Pour des options config supplémentaires telles que la stratégie incrémentielle merge, consultez les configurations Databricks dans la documentation dbt.
-
Cliquez sur **Enregistrer sous**.
-
Pour le nom du fichier, entrez
models/diamonds_four_cs.sql, puis cliquez sur Créer . -
Créez un second modèle : cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Cette instruction sélectionne les valeurs uniques de la colonne
colorsdans la tablediamonds_four_cs, en triant les résultats par ordre alphabétique, du premier au dernier. Comme il n'y a pas de blocconfig, ce modèle demande à dbt de créer une vue dans la base de données basée sur cette déclaration.SQLselect distinct color
from diamonds_four_cs
sort by color asc -
Cliquez sur **Enregistrer sous**.
-
Pour le nom du fichier, saisissez
models/diamonds_list_colors.sql, puis cliquez sur Créer . -
Créez un 3e modèle : Cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Cette déclaration 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 indique à dbt de créer une vue dans la base de données basée sur cette instruction.
SQLselect 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.sqlet cliquez sur Créer . -
Exécutez les modèles : Sur la ligne de commande, exécutez la commande
dbt runavec les chemins des trois fichiers précédents. Dans la base de donnéesdefault, dbt crée une table nomméediamonds_four_cset deux vues nomméesdiamonds_list_colorsetdiamonds_prices. dbt obtient ces noms de vues et de tables à partir des noms de fichiers.sqlassociés.Bashdbt run --model models/diamonds_four_cs.sql models/diamonds_list_colors.sql models/diamonds_prices.sqlConsole...
... | 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 obtenir des informations sur les nouvelles vues et pour 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 qui est attaché au cluster, en spécifiant SQL comme langue par default pour le notebook. Si vous vous connectez à un SQL Warehouse, vous pouvez exécuter ce code SQL à partir d'une query.
SQLSHOW views IN defaultConsole+-----------+----------------------+-------------+
| namespace | viewName | isTemporary |
+===========+======================+=============+
| default | diamonds_list_colors | false |
+-----------+----------------------+-------------+
| default | diamonds_prices | false |
+-----------+----------------------+-------------+SQLSELECT * FROM diamonds_four_csConsole+-------+---------+-------+---------+
| carat | cut | color | clarity |
+=======+=========+=======+=========+
| 0.23 | Ideal | E | SI2 |
+-------+---------+-------+---------+
| 0.21 | Premium | E | SI1 |
+-------+---------+-------+---------+
...SQLSELECT * FROM diamonds_list_colorsConsole+-------+
| color |
+=======+
| D |
+-------+
| E |
+-------+
...SQLSELECT * FROM diamonds_pricesConsole+-------+---------+
| 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 connexes. Ces tables de données contiennent des informations sur une ligue sportive fictive de trois équipes disputant 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.
Si vous vous connectez à un cluster, vous pouvez exécuter ce code SQL à partir d'un notebook qui est attaché au cluster, en spécifiant SQL comme langue par default pour le notebook. Si vous vous connectez à un SQL Warehouse, vous pouvez exécuter ce code SQL à partir d'une query.
Les tables et les vues de cette étape start par
zzz_pour les aider à les identifier dans le cadre de cet exemple. Vous n'avez pas besoin de suivre ce modèle pour vos propres tables et vues.SQLDROP 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
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Cette instruction crée une table qui fournit les détails de chaque partie, tels que les noms d’équipe et les scores. Le bloc
configdemande à dbt de créer une table dans la base de données basée sur cette instruction.SQL-- 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'
) }}SQL-- 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 du fichier, entrez
models/zzz_game_details.sql, puis cliquez sur Créer . -
Créez un second modèle : cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Cette instruction crée une vue qui répertorie les bilans victoires-défaites des équipes pour la saison.
SQL-- 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 du 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 runavec les chemins d'accès aux deux fichiers précédents. Dans la base de donnéesdefault(tel que spécifié dans les paramètres de votre projet), dbt crée une table nomméezzz_game_detailset une vue nomméezzz_win_loss_records. dbt obtient ces noms de vues et de tables à partir de leurs noms de fichiers.sqlassociés.Bashdbt run --model models/zzz_game_details.sql models/zzz_win_loss_records.sqlConsole...
... | 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 lister les informations concernant la nouvelle vue et pour sélectionner toutes les lignes de la table et de la vue.
Si vous vous connectez à un cluster, vous pouvez exécuter ce code SQL à partir d'un notebook qui est attaché au cluster, en spécifiant SQL comme langue par default pour le notebook. Si vous vous connectez à un SQL Warehouse, vous pouvez exécuter ce code SQL à partir d'une query.
SQLSHOW VIEWS FROM default LIKE 'zzz_win_loss_records';Console+-----------+----------------------+-------------+
| namespace | viewName | isTemporary |
+===========+======================+=============+
| default | zzz_win_loss_records | false |
+-----------+----------------------+-------------+SQLSELECT * FROM zzz_game_details;Console+---------+---------------+---------------+------------+---------------+---------------+------------+
| 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 |
+---------+---------------+---------------+------------+---------------+---------------+------------+SQLSELECT * FROM zzz_win_loss_records;Console+---------------+------+--------+
| team | wins | losses |
+===============+======+========+
| Amsterdam | 3 | 1 |
+---------------+------+--------+
| San Francisco | 2 | 2 |
+---------------+------+--------+
| Seattle | 1 | 3 |
+---------------+------+--------+
Étape 3 : Créez et exécutez des tests
Dans cette étape, vous créez des tests , qui sont des assertions que vous faites concernant 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 passent pas une assertion. Lorsque ce nombre est nul, 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 retourner zéro enregistrement pour réussir.
-
Créez les tests de schéma : cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez le contenu suivant. Ce fichier inclut des tests de schéma qui déterminent si les colonnes spécifiées ont des valeurs uniques, ne sont pas nulles, ont uniquement les valeurs spécifiées ou une combinaison.
YAMLversion: 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 du fichier, saisissez
models/schema.yml, puis cliquez sur Créer . -
Créer le premier test de données : Cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Ce fichier contient un test de données pour déterminer si des parties ont eu lieu en dehors de la saison régulière.
SQL-- 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 du fichier, saisissez
tests/zzz_game_details_check_dates.sql, puis cliquez sur Créer . -
Créer un deuxième test de données : Cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Ce fichier comprend un test de données pour déterminer si des scores étaient négatifs ou si des parties étaient à égalité.
SQL-- 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 du fichier, saisissez
tests/zzz_game_details_check_scores.sql, puis cliquez sur Créer . -
Créez un troisième test de données : cliquez sur
( Créer un nouveau fichier ) dans le coin supérieur droit. -
Dans l'éditeur de texte, saisissez l'instruction SQL suivante. Ce fichier inclut un test de données pour déterminer si des équipes avaient des bilans de victoires ou de défaites négatifs, avaient plus de victoires ou de défaites que de matchs joués, ou ont joué plus de matchs qu'il n'était autorisé.
SQL-- 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 du fichier, saisissez
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 : Nettoyage
Vous pouvez supprimer les tables et les vues que vous avez créées pour cet exemple en exécutant le code SQL suivant.
Si vous vous connectez à un cluster, vous pouvez exécuter ce code SQL à partir d'un notebook qui est attaché au cluster, en spécifiant SQL comme langue par default pour le notebook. Si vous vous connectez à un SQL Warehouse, vous pouvez exécuter ce code SQL à partir d'une query.
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
- En savoir plus sur les modèles dbt.
- Découvrez comment tester vos projets dbt.
- Apprenez à utiliser Jinja, un langage de templating, pour programmer SQL dans vos projets dbt.
- Découvrez les bonnes pratiques dbt.