Macros dbt : Un guide complet

Dans le domaine de l'ingénierie analytique, les macros dbt (data build tool) macros offrent un moyen puissant d'écrire une logique SQL dynamique et réutilisable grâce à des blocs de code réutilisables.

Dans ce tutoriel, nous explorerons les principes fondamentaux des macros dbt, comment les créer à l'aide de Jinja, les meilleures pratiques en matière de maintenabilité et les applications concrètes, le tout accompagné d'exemples de code.

Que sont les macros dbt ?

Les macros dbt sont des blocs de code réutilisables écrits à l'aide du langage de modélisation Jinja dans dbt, qui vous permettent de générer des modèles de données personnalisés. SQL de manière dynamique. Ils contribuent à réduire les répétitions et à centraliser la logique de transformation. 

Ces macros fonctionnent de la même manière que les fonctions dans les langages de programmation traditionnels.

Par exemple, si vous devez calculer une métrique spécifique sur plusieurs modèles, une macro peut encapsuler ce calcul, ce qui facilite sa maintenance et sa mise à jour.

Les macros peuvent également être stockées dans des paquets, tels que dbt-utils.

Pourquoi utiliser les macros dbt ?

Les macros offrent plusieurs avantages, notamment :

• Réduire la redondance : Vous pouvez créer un bloc logique une seule fois et le réutiliser partout.
• Cohérence : Appliquer la même logique de transformation à tous les modèles sans duplication manuelle.
• Flexibilité : Les macros prennent en charge les paramètres, ce qui les rend adaptables à diverses entrées.
• Partage entre projets : Les macros bien conçues peuvent être partagées sous forme de paquets.

Ces avantages permettent d'obtenir des bases de code plus propres, plus faciles à maintenir et plus évolutives.

Concepts fondamentaux des macros dbt

Afin de vous aider à comprendre le fonctionnement des macros dans dbt, examinons quelques concepts clés.

1. Réutilisabilité

Les macros vous permettent de définir une logique SQL une seule fois et de la réutiliser dans plusieurs modèles, tests ou même d'autres macros.

2. Moteur de modèles Jinja

L'intégration de Jinja à dbt permet d'insérer des variables, d'appliquer des conditions et d'effectuer des boucles sur des listes, tout cela avant que votre SQL n'atteigne la base de données. dbt compile ce modèle en SQL brut, rendant les macros indépendantes de la base de données.

3. Présentation des techniques de programmation

Les macros peuvent transformer le langage SQL en un cadre programmable. Ils permettent d'utiliser la logique, les boucles et les conditions, des éléments courants que le SQL standard ne peut pas gérer de manière aussi flexible.

Tout comme les fonctions, les macros dans dbt peuvent accepter des arguments (paramètres) et peuvent être appelées avec différentes entrées pour produire différents résultats. Ils contribuent à simplifier les transformations complexes en les décomposant en unités plus petites et réutilisables. 

Création de macros avec Jinja

Ensuite, examinons comment nous pouvons créer des macros pour notre usage personnel.

Jinja est le moteur de modèles qui alimente les macros dbt, vous permettant de traiter le SQL comme du texte dynamique et programmable. 

Constructions de modèles et délimiteurs

Pour utiliser Jinja, il est nécessaire d'employer des constructions de modèles et des délimiteurs spécifiques.

Voici quelques constructions et délimiteurs courants :

• Expressions {{ }}: Insère des expressions.
• Déclarations d'{% %}: Exécute des instructions.
• Commentaires {# #}: Ajoute les commentaires que vous souhaitez que dbt ignore.

Dans les macros, {{ ... }} est utilisé pour les expressions qui doivent renvoyer une valeur (par exemple, les noms de colonnes ou les calculs), tandis que {% ... %} est utilisé pour le contrôle du flux (boucles, instructions if/else, définitions de macros). Les commentaires Jinja utilisent {# ... #} et sont entièrement supprimés lors de la compilation.

Voici un exemple de syntaxe utilisée pour les instructions utilisées dans les macros :

{% macro your_macro_name(your_variable) %}
    select 'Hello, {{ your_variable}}' as greeting
{% endmacro %}

Voici un exemple illustrant comment utiliser des instructions pour créer une macro :

{% macro greet(name) %}
    select 'Hello, {{ name }}' as greeting
{% endmacro %}

Pour exécuter la macro, veuillez utiliser ceci :

dbt run-operation greet(name) --args 'Austin'

Gestion des variables

Vous pouvez transmettre des variables à des macros ou les définir à l'intérieur de celles-ci. Des filtres tels que upper ou lower peuvent transformer des valeurs textuelles.

Voici une implémentation de la fonction upper permettant de convertir toutes les valeurs textuelles en majuscules. 

{% macro to_upper_case(column_name) %}
    upper({{ column_name }})
{% endmacro %}

Pour mettre cela en œuvre, il vous faudrait appeler/référencer la macro nouvellement créée dans votre modèle dbt.

Voici un exemple de code :

SELECT
    id,
    {{ to_upper_case('product_name') }} AS product_name_upper
FROM {{ source('public', 'orders') }}

Structures de contrôle

Ensuite, à l'instar des langages de programmation, les macros dbt peuvent offrir les fonctionnalités suivantes :

• Instructions conditionnelles ({% if %} / {% endif %}) :
• Boucles ({% for %} / {% endfor %}) 

Ces structures vous permettent de créer dynamiquement des clauses SQL ou de générer plusieurs expressions en fonction des entrées.

Cela facilite la gestion des tâches complexes de génération SQL par les macros.

Gestion des paramètres et gestion des erreurs

Les macros peuvent valider les entrées et générer des erreurs lors de la compilation afin d'éviter des problèmes lors de l'exécution.

Les paramètres sont définis dans la déclaration de macro à l'aide de parenthèses d'(), de manière similaire aux définitions de fonction dans les langages de programmation.

Voici un exemple illustrant comment nous pouvons inclure deux paramètres :

{% macro my_macro(param1, param2) %}
    SELECT
        {{ param1 }},
        {{ param2 }}
    FROM my_table
{% endmacro %}

Comme vous pouvez le constater, dans la première ligne, nous avons inclus à la fois param1 et param2.

Pour invoquer la macro dans un modèle dbt, veuillez utiliser les doubles accolades {{ }}. Les paramètres sont transmis en tant qu'arguments entre parenthèses.

SELECT
    id,
    {{ my_macro('column_a', 'column_b') }}
FROM my_source_table

Dans ce cas, nous avons spécifié à la fois column_a et column_b comme paramètres.

Guide de configuration pour l'utilisation des macros dbt

Avant de commencer à créer et à utiliser des macros, veuillez configurer un environnement de travail afin de pouvoir suivre les exemples présentés dans ce tutoriel. 

Cela garantira que dbt est installé, qu'un exemple de jeu de données est chargé et que la structure de dossiers appropriée est en place pour créer des macros.

1. Veuillez installer dbt Core.

Il est nécessaire d'installer dbt Core localement. Si vous utilisez Postgres dans ce tutoriel, veuillez l'installer à l'aide de la commande suivante :

pip install dbt

Si votre projet utilise un entrepôt de données, veuillez exécuter les commandes correspondantes à la place :

pip install dbt-core dbt-postgres

pip install dbt-core dbt-snowflake

pip install dbt-core dbt-bigquery

2. Créer un projet dbt

Avant d'exécuter des commandes dbt, il est nécessaire de configurer un environnement de projet.

Veuillez vous rendre dans le répertoire de projets souhaité.

C'est ici que vous stockerez vos fichiers de projet dbt. Dans ce cas, nous stockerons tous les fichiers associés dans ce dossier de projet dbt.

Pour initialiser un projet dbt, veuillez exécuter :

dbt init

cd ~/dbt-macros-tutorial

Veuillez créer une structure de dossiers dans le format suivant :

macros_tutorial/
  ├─ models/
  ├─ macros/
  ├─ tests/
  ├─ seeds/
  ├─ dbt_project.yml

3. Préparez l'ensemble de données échantillon.

Nous utiliserons Python pour générer un petit ensemble de données de commandes à charger dans Postgres (ou l'entrepôt de votre choix).

import pandas as pd
import random
from datetime import datetime, timedelta
from sqlalchemy import create_engine

# Create sample orders dataframe
random.seed(42)
num_rows = 20
start_date = datetime(2025, 1, 1)

data = []
for i in range(1, num_rows + 1):
    order_date = start_date + timedelta(days=random.randint(0, 30))
    ship_date = order_date + timedelta(days=random.randint(1, 10))
    data.append({
        'order_id': i,
        'customer_id': random.randint(100, 105),
        'order_date': order_date.date(),
        'ship_date': ship_date.date(),
        'status': random.choice(['pending', 'shipped', 'delivered']),
        'revenue': round(random.uniform(50, 500), 2),
        'cost': round(random.uniform(20, 400), 2)
    })

df = pd.DataFrame(data)

# Load into Postgres
engine = create_engine('postgresql://user:password@localhost:5432/dbt_demo')
df.to_sql('orders', engine, if_exists='replace', index=False)

Remarque: Veuillez mettre à jour la chaîne de connexion pour votre base de données.

4. Créer une source dans dbt

Veuillez ajouter ce qui suit à models/src_orders.yml:

version: 2
sources:
  - name: public
schema: public

    tables:
      - name: orders

5. Veuillez vérifier la connexion et la source.

dbt debug

dbt run-operation list_relations --args '{"schema_name": "public"}'

Vous êtes désormais prêt à commencer à écrire des macros qui fonctionnent sur cet ensemble de données.

Comment rédiger et utiliser les macros dbt

Maintenant, essayons de créer nos propres macros.

Définition des macros

Veuillez placer les définitions de macros dans des fichiers .sql situés dans le répertoire macros/.

Lorsque vous nommez des macros, veuillez vous assurer de donner à chacune un nom descriptif qui reflète son objectif, et utilisez des paramètres pour la rendre flexible. L'ajout d'un bref commentaire docstring en haut de la page aide les collègues à comprendre son objectif.

Voici un exemple :

    -- macros/my_macro.sql
    {% macro cents_to_dollars(column_name, precision=2) %}
        ({{ column_name }} / 100.0)::numeric(18, {{ precision }})
    {% endmacro %}

Utilisation de macros dans les modèles

Vous pouvez appeler des macros à l'intérieur des modèles à l'aide de {{ nom_macro(arg1, arg2) }}. Ils peuvent être utilisés dans des clauses SELECT, des filtres WHERE ou même des blocs CTE entiers, ce qui vous permet d'insérer des modèles SQL réutilisables n'importe où.

Voici un exemple :

    -- models/my_model.sql
    SELECT
        order_id,
        {{ cents_to_dollars('amount_in_cents') }} AS amount_in_dollars,
        {{ cents_to_dollars('tax_in_cents', precision=4) }} AS tax_in_dollars
    FROM {{ ref('raw_orders') }}

Utilisation des macros à partir de l'interface CLI

Pour les tâches opérationnelles en dehors de la création de modèles, veuillez utiliser ce format/cette syntaxe :

dbt run-operation macro_name --args '{"param": "value"}'

Cela vous permet d'exécuter des requêtes SQL utilitaires telles que la création de schémas ou le nettoyage de données sans avoir à créer de modèle.

Voici un exemple de commande :

dbt run-operation greet --args '{"name": "Austin"}'

Utilisation des macros provenant de paquets

Les macros peuvent également provenir de paquets dans dbt, tels que dbt-utils.

Lorsque vous installez un paquet via packages.yml, ses macros deviennent immédiatement disponibles. Pour ce faire, veuillez exécuter dbt deps.

Vous pouvez ensuite appeler les nouvelles macros ajoutées avec ce format : package_name.macro_name.

Organisation des fichiers macro

Pour une meilleure organisation, veuillez trier et séparer les macros par fonctionnalité afin d'améliorer la maintenabilité. 

Veuillez regrouper les macros associées dans des fichiers distincts (par exemple, date_utils.sql, string_utils.sql) pour faciliter la maintenance. Cela facilite la localisation et la mise à jour de la logique au fil du temps.

Exemples d'utilisation des macros dbt

Voici quelques exemples d'utilisation plus pratique des macros :

Macro de comparaison de dates

Supposons que vous souhaitiez créer une fonction que vous utiliserez fréquemment pour comparer des dates.

Dans ce cas, vous pouvez utiliser une macro pour calculer les différences en jours entre deux champs de date tout en gérant les différences de dialecte SQL.

Veuillez commencer par créer un nouveau fichier ici : macros/date_utils.sql.

Ensuite, veuillez utiliser le code suivant :

{% macro days_between(start_col, end_col) %}
    {#-- Handle different warehouses --#}
    {% if target.type in ['postgres', 'redshift'] %}
        (DATE_PART('day', {{ end_col }}::timestamp - {{ start_col }}::timestamp))
    {% elif target.type in ['snowflake'] %}
        DATEDIFF('day', {{ start_col }}, {{ end_col }})
    {% elif target.type in ['bigquery'] %}
        DATE_DIFF(CAST({{ end_col }} AS DATE), CAST({{ start_col }} AS DATE), DAY)
    {% else %}
        -- Fallback to ANSI-ish expression; may need adjustment per engine
        CAST({{ end_col }} AS DATE) - CAST({{ start_col }} AS DATE)
    {% endif %}
{% endmacro %}

Nous allons maintenant utiliser cette nouvelle macro d'days_between s dans un modèle.

with src as (
  select * from {{ source('public', 'orders') }}
)
select
  order_id,
  customer_id,
  order_date,
  ship_date,
  {{ days_between('order_date', 'ship_date') }} as days_to_ship
from src

Personnalisé generate_schema_name macro

Par défaut, dbt utilise une macro appelée generate_schema_name. Cette macro est utilisée pour spécifier le nom du schéma dans lequel un modèle doit être construit.

Vous pouvez également remplacer la valeur par défaut de dbt afin de contrôler le schéma utilisé par environnement.

Vous pouvez inclure ce fichier à l'emplacement suivant : macros/generate_schema_name.sql.

`sql
{% macro generate_schema_name(custom_schema_name, node) -%}
    {# Policy:
       - prod:    ANALYTICS
       - nonprod: dev_analytics, ci_analytics, etc.
    #}
    {%- if target.name == 'prod' -%}
        {{ custom_schema_name | trim }}
    {%- else -%}
        {{ (target.name ~ '_' ~ custom_schema_name) | lower | replace(' ', '_') }}
    {%- endif -%}
{%- endmacro %}

Comment cela peut vous aider : Sur dev, les modèles sont placés dans un environnement d'isolement ( dev_analytics ). Sur prod, ils atterrissent sur analytics. Cela permet des déploiements prévisibles et sans conflit.

Exécution de SQL en dehors d'un modèle

Vous pouvez également exécuter des commandes SQL en dehors des modèles pour des opérations telles que le nettoyage de tableaux ou la mise à jour de métadonnées sans créer de modèles.

Vous pouvez créer une macro qui exécute du code SQL brut, puis l'exécuter via dbt run-operation.

Ceci est utile pour les opérations DDL (suppression/création de tableaux) ou les mises à jour de métadonnées qui ne s'intègrent pas dans un modèle.

Voici la macro :

{% macro cleanup_temp_tables() %}
    {% set sql %}
        drop table if exists {{ target.schema }}.temp_table;
        delete from {{ target.schema }}.audit_log where event_type = 'test';
    {% endset %}
    {{ run_query(sql) }}
{% endmacro %}

Ensuite, veuillez exécuter cette opération dans le terminal :

dbt run-operation cleanup_temp_tables

Cela vous permettra d'exécuter des macros sans les inclure dans les modèles.

Exemple de macro paramétrée

Nous pouvons également créer une macro hautement paramétrée, comme dans une fonction. 

Dans cet exemple, nous filtrerons les enregistrements en fonction d'un statut donné, c'est-à-dire lorsque des valeurs sont fournies. Ceci utilise les instructions « if » et « do » pour créer une logique.

{% macro where_orders(status=None, min_date=None, max_date=None) %}
  {%- set clauses = [] -%}
  {%- if status is not none -%}
    {%- do clauses.append("status = '" ~ status ~ "'") -%}
  {%- endif -%}
  {%- if min_date is not none -%}
    {%- do clauses.append("order_date >= '" ~ min_date ~ "'") -%}
  {%- endif -%}
  {%- if max_date is not none -%}
    {%- do clauses.append("order_date < '" ~ max_date ~ "'") -%}
  {%- endif -%}
  {%- if clauses | length > 0 -%}
    where {{ clauses | join(' and ') }}
  {%- endif -%}
{% endmacro %}

Nous appliquons maintenant cette macro dans un modèle :

with src as (
  select * from {{ ref('orders') }}
)
select *
from src
{{ where_orders(status='shipped', min_date='2025-01-05') }}

Cette macro intègre une logique pour les cas où un argument est omis ; ce critère est alors ignoré. Cela permet de maintenir une logique optionnelle ordonnée.

Meilleures pratiques pour les macros dbt

Concevoir des macros performantes ne se limite pas à compiler le code SQL. Les meilleures macros sont faciles à trouver, bien documentées, prévisibles, testables et faciles à déprécier ou à étendre. 

Voici quelques bonnes pratiques à suivre :

1. Conventions de dénomination et conception des paramètres

Tout comme pour le langage SQL et les langages de programmation, il est nécessaire de respecter les conventions de nommage afin de garantir la lisibilité.

Voici quelques conseils pour la dénomination :

• Soyez explicite et axé sur l'action. Privilégiez les verbes ou les intentions claires (par exemple, generate_select_list, where_orders) plutôt que des noms vagues tels que helper.
• Veuillez conserver des noms stables et en minuscules. Veuillez utiliser le format snake_case et des préfixes stables par domaine, par exemple : date_*, string_*, test_*, admin_*.

2. Stratégies de documentation

Il est recommandé de développer des habitudes pour documenter vos créations. La documentation doit être rédigée dans des endroits où les développeurs sont susceptibles de la consulter. 

Par exemple, combinez des chaînes de documentation en ligne avec un document de référence ( macros.yml ou schema.yml) contenant des descriptions et des exemples.

Le contenu de la documentation peut inclure :

• Objectif et résultats attendus (1 à 2 phrases)
• Tableau des paramètres avec les valeurs par défaut et les valeurs autorisées
• Exemple succinct d'invocation dans un modèle et avec run-operation
• Remarques sur le comportement inter-bases de données

Exemple d'extrait d'un fichier de configuration :

version: 2
macros:
  - name: days_between
    description: |
      Return day difference between two date expressions, normalized across warehouses.
    arguments:
      - name: start_col
        type: string
        description: Column/expression for the start date
      - name: end_col
        type: string
        description: Column/expression for the end date
    docs:
      show: true

3. Organisation du code

Votre code devra également être bien organisé, en particulier lorsque vous devez gérer un grand nombre de macros dans votre répertoire.

Veuillez structurer par domaine pour une utilisation plus pratique. Voici quelques exemples illustrant ce principe :

• macros/date_utils.sql
• macros/string_utils.sql
• macros/testing/ (tests personnalisés)
• macros/admin/ (DDL, tâches ménagères)
• macros/compat/ (cales d'entrepôt)

4. Les macros doivent être concises et avoir un seul objectif.

Une macro devrait accomplir une seule tâche de manière efficace. Si vous constatez qu'une macro devient trop volumineuse ou gère des logiques non liées, veuillez la diviser en plusieurs macros plus petites. Cela améliore la réutilisabilité et simplifie les tests.

5. Tester les macros avec des données représentatives

Veuillez utiliser des modèles de test dédiés ou un environnement de préproduction pour valider le comportement des macros. 

Par exemple :

• Veuillez créer un petit ensemble de données de base couvrant les cas limites.
• Veuillez créer un modèle de test qui appelle la macro avec différents paramètres.
• Veuillez utiliser dbt run et vérifier l'exactitude du code SQL compilé.

Conseil de professionnel : Associez les macros à des tests personnalisés d'dbt test s afin de vérifier que les résultats répondent aux contraintes attendues.

Cas d'utilisation et applications courants

Les macros dbt sont polyvalentes et leurs applications s'étendent à de nombreux workflows quotidiens d'ingénierie analytique. 

Voici quelques exemples détaillés et approfondis :

• Normalisation des transformations de données : Les macros permettent de garantir que les mêmes conventions de nommage, les mêmes raccourcissements, le même traitement des valeurs nulles et la même logique de transtypage soient appliqués à plusieurs modèles. Par exemple, vous pouvez créer une macro standardize_customer_name pour nettoyer et formater les noms de manière identique dans tous les magasins.
• Prise en charge des requêtes inter-bases de données : Les entrepôts présentent de subtiles différences de dialecte SQL. Les macros peuvent abstraire ces différences, par exemple en utilisant DATEDIFF sur Snowflake et DATE_DIFF sur BigQuery. Cela rend vos modèles transférables.
• Automatisation des contrôles qualité : Écrivez des macros réutilisables qui génèrent des tests de données, tels que la vérification des identifiants en double, des colonnes critiques nulles ou des valeurs hors limites. Ces derniers peuvent être utilisés dans plusieurs modèles de test.
• Simplification des modèles SQL répétitifs : Les CTE courants, les champs calculés ou les clauses de filtrage peuvent être paramétrés dans des macros. Par exemple, une macro permettant de créer des clauses d'WHERE s dynamiques basées sur des filtres optionnels évite d'avoir à copier-coller une logique complexe.

Techniques avancées et optimisation des performances

Les macros dbt peuvent également être utilisées dans des applications plus avancées. Veuillez examiner ci-dessous deux méthodes courantes.

Modèles récursifs et de méta-programmation

Les macros peuvent également appeler d'autres macros, parcourir les métadonnées ou générer dynamiquement des fragments SQL en fonction de l'inspection du schéma. 

Cela vous permet de :

• Veuillez créer automatiquement des modèles de préparation pour chaque tableau source.
• Générez des requêtes pivot/dé-pivot sans saisir manuellement chaque colonne.
• Créez des requêtes adaptées à l'environnement en parcourant les variables de configuration.

Stratégies d'optimisation des performances

Vous pouvez également procéder à des optimisations supplémentaires afin d'améliorer les performances :

• Réduisez la complexité des requêtes en incluant de manière sélective uniquement les colonnes ou les jointures nécessaires.
• Veuillez ajuster les matérialisations ou les stratégies SQL en fonction du type d'entrepôt.

Intégration avec l'écosystème dbt

Les macros sont conçues pour s'intégrer à l'écosystème dbt, ce qui les rend encore plus performantes lorsqu'elles sont associées à des packages, des fonctionnalités cloud et des outils externes.

Gestion des paquets

De nombreux paquets DBT communautaires, tels que dbt-utils, dbt-date et dbt-expectations, sont essentiellement des collections de macros hautement réutilisables. 

Ces paquets fournissent des transformations, des tests et des aides pré-construits, évitant ainsi de réinventer la roue. 

Compatibilité avec dbt Cloud et les outils de développement

Les macros fonctionnent de manière transparente dans les environnements dbt Cloud, ce qui signifie que votre logique SQL dynamique se comporte de la même manière, qu'elle soit exécutée localement ou dans le cadre d'une tâche cloud planifiée. 

Ils s'intègrent également parfaitement au contrôle de version, aux pipelines CI/CD et aux processus de révision du code, garantissant ainsi que les mises à jour macro sont testées et déployées de manière cohérente.

Stratégies de mise en œuvre dans le monde réel

Le passage des scripts SQL traditionnels à un flux de travail dbt basé sur des macros nécessite à la fois des changements techniques et une adaptation culturelle.

Gestion de la migration et du changement

Lors de la migration, commencez par identifier les modèles SQL récurrents dans les différents modèles. Ensuite, procédez à une refactorisation progressive de ces éléments en macros, en vous assurant que le SQL compilé correspond à l'ancienne logique. 

Veuillez utiliser les indicateurs de fonctionnalité (var()) pour activer ou désactiver la nouvelle logique macro pendant le déploiement, afin de minimiser les perturbations. Il est essentiel que vos parties prenantes soient informées des modifications afin d'éviter toute interruption des requêtes en aval.

Gouvernance et stratégies de déploiement

En matière de gouvernance, veuillez commencer par établir des conventions de nommage claires, des normes de paramétrage et des exigences en matière de documentation pour toutes les macros.

Ensuite, veuillez examiner les modifications macro dans les demandes de modification, tout comme les mises à jour de modèle, en vous assurant qu'elles répondent aux normes de performance et de compatibilité. 

En production, veuillez surveiller les journaux des tâches pour les requêtes générées par des macros afin de vérifier qu'elles s'exécutent comme prévu. Pour les projets comportant un nombre important de macros, veuillez configurer des tableaux de bord d'observabilité afin de suivre les temps de compilation et les performances des requêtes par type de macro.

Conclusion

Les macros dbt constituent un élément essentiel de la productivité et de la maintenabilité dans les équipes d'ingénierie analytique modernes. L'utilisation des modèles dbt avec des macros peut améliorer les résultats des opérations de nettoyage des données.

Souhaitez-vous en savoir plus sur le dbt ? Notre cours d'introduction à la TCD et notre Tutoriel dbt pourraient vous être utiles.