← points de vue
20 janvier 2026

Les exposures dbt générées depuis le TMDL

Le graphe de dépendances s’arrête à la dernière table, alors que la question posée en réunion porte sur ce qui vient après. Un dépôt unique et un format texte suffisent pour le prolonger, à condition que ce prolongement soit généré et jamais écrit à la main.

La question revient à chaque évolution : si je retire cette colonne, qu’est-ce qui ne fonctionnera plus ? L’outil de transformation répond avec précision pour ses propres modèles, mais s’arrête à la dernière table. Ce qui lit cette table ensuite (un rapport, une mesure, un tableau de bord consulté chaque lundi par une direction) n’apparaît pas dans son graphe. La réponse exacte serait « je ne sais pas », et la réponse donnée est en général « je ne crois pas ».

Les exposures servent à cela : déclarer ce qui consomme un modèle sans être produit par lui. Elles ont la réputation d’être inutiles, et pour une raison simple : écrites à la main, elles sont périmées au bout d’un mois. Quelqu’un ajoute une mesure, personne ne met le fichier à jour, et le graphe affiche alors des dépendances fausses. Une lignée fausse est plus dangereuse qu’une lignée absente, parce qu’on s’appuie dessus pour décider.

01Ce que le dépôt unique rend possible

Tant que le modèle sémantique est un fichier binaire rangé dans l’espace personnel de quelqu’un, il n’y a rien à analyser. Depuis qu’il peut être écrit au format texte, c’est une source comme une autre, et s’il est dans le même dépôt que le projet de transformation, un script peut lire les deux en une seule passe. C’est la seule condition, et elle relève de l’organisation du dépôt plus que de la technique.

text
warehouse/
├── dbt/
│   ├── models/marts/fct_sales.sql
│   └── models/marts/_marts.yml        # generated exposures land here
└── semantic/
    └── Sales.SemanticModel/
        └── definition/tables/Sales.tmdl

Une mesure contient tout ce qu’il faut : son nom d’affichage, son expression, et la description que son auteur a bien voulu écrire. Les tables qu’elle interroge se lisent dans l’expression elle-même.

text
/// Revenue excluding tax, at invoice date. Excludes cancelled orders.
measure 'Revenue ex tax' =
    CALCULATE (
        SUMX ( Sales, Sales[quantity] * Sales[unit_price] ),
        Sales[status] <> "cancelled"
    )
    formatString: #,##0 €
    displayFolder: Measures\Sales
02Générer, et deux pièges du schéma

Le script tient en une page : lire les mesures, retrouver les tables citées dans chaque expression, écrire un fichier d’exposures. Deux contraintes du schéma déterminent la forme du résultat, et les découvrir à l’exécution coûte une heure chacune.

python
import re
from pathlib import Path

import yaml

MEASURE = re.compile(
    r"(?:^///(?P<doc>.*)$
)?"      # the /// description line, when there is one
    r"^s*measures+'(?P<name>[^']+)'s*=s*(?P<dax>.*?)(?=^s*(?:measure|table|Z))",
    re.M | re.S,
)

def slug(label: str) -> str:
    # An exposure name accepts letters, digits and underscores only, so a measure
    # called 'Revenue ex tax' cannot be one. The real name goes to label.
    return re.sub(r"[^a-z0-9]+", "_", label.lower()).strip("_")

def exposures(tmdl_dir: Path, models: set[str]) -> list[dict]:
    found = []
    for path in tmdl_dir.rglob("*.tmdl"):
        for m in MEASURE.finditer(path.read_text(encoding="utf-8")):
            dax = m.group("dax").strip()
            # Tables cited in the expression, kept only when dbt actually builds one
            # of that name — anything else is a calculated table, not a dependency.
            cited = {t.lower() for t in re.findall(r"([A-Za-z_]w*)s*[", dax)}
            depends = sorted(cited & models)
            if not depends:
                continue
            found.append({
                "name": slug(m.group("name")),
                "label": m.group("name"),
                "type": "dashboard",
                # description is markdown, which is the whole trick: a fenced block
                # puts the DAX itself into the generated documentation site.
                "description": f"{(m.group('doc') or '').strip()}

```dax
{dax}
```",
                "depends_on": [f"ref('{d}')" for d in depends],
                "config": {"meta": {"source_file": str(path)}},
            })
    return found

Première contrainte : le nom d’une exposure n’accepte que des lettres, des chiffres et des tirets bas. Une mesure nommée « Revenue ex tax » ne peut donc pas garder son nom. Il faut le translittérer et placer le nom réel dans `label`, sans quoi la génération échoue sur la moitié du modèle.

La seconde contrainte est aussi le principal intérêt de la démarche. Le champ `description` accepte du markdown, donc un bloc de code, et c’est par ce champ que l’expression DAX arrive dans le site de documentation généré. Personne n’a eu à rédiger quoi que ce soit : la documentation d’une mesure est sa propre définition, toujours à jour, affichée à côté du modèle qui l’alimente.

yaml
exposures:
  - name: revenue_ex_tax
    label: Revenue ex tax
    type: dashboard
    description: |
      Revenue excluding tax, at invoice date. Excludes cancelled orders.

      ```dax
      CALCULATE (
          SUMX ( Sales, Sales[quantity] * Sales[unit_price] ),
          Sales[status] <> "cancelled"
      )
      ```
    depends_on:
      - ref('fct_sales')
    config:
      meta:
        source_file: semantic/Sales.SemanticModel/definition/tables/Sales.tmdl
03Ce que ça change en revue

La génération s’exécute dans la chaîne d’intégration, et le fichier produit est versionné. La documentation n’est qu’un bénéfice secondaire. Le principal est que la pull request qui retire une colonne fait apparaître dans son propre diff la disparition des exposures qui en dépendaient. La question de ce qui ne fonctionnera plus n’a plus à être posée en réunion, puisque la réponse figure dans la relecture.

04Les limites du script

Analyser l’expression avec une expression régulière est une méthode grossière : elle retrouve les tables citées, sans comprendre le DAX. Une mesure qui en appelle une autre sans nommer de table produit une exposure sans dépendance, que le script ignore sans avertir. C’est le défaut à surveiller. Un véritable analyseur syntaxique existe, mais il demande bien plus qu’une page de code, et je ne l’ai pas jugé rentable à cette échelle.

Je ne traite pas non plus du sens inverse, qui consisterait à pousser les descriptions des modèles vers les mesures. C’est faisable, mais je m’en méfie : un fichier généré deviendrait la source d’un fichier relu en revue de code, et le jour où les deux divergent, plus personne ne sait lequel fait référence.