Combien coûte une table Databricks ?
Databricks facture des jobs, des pipelines et des SQL warehouses. Pour connaître le prix d'une table, il faut relier la facture au lineage. Voici comment le faire avec les tables système, où cela s'arrête, et ce que fait YALineo.
Pourquoi la facture ne donne pas le coût d'une table
La consommation de Databricks se lit dans la table système system.billing.usage. Chaque ligne y décrit une période d'usage d'une charge : un job, une mise à jour de pipeline, un SQL warehouse, un notebook serverless, un endpoint. Le champ usage_metadata dit quelle charge a consommé, par exemple job_run_id pour une exécution de job ou dlt_update_id pour une mise à jour de pipeline.
Une table n'y apparaît par son nom que dans un cas : les champs uc_table_catalog, uc_table_schema et uc_table_name ne sont remplis que pour les vues matérialisées. Pour toutes les autres tables, la facture parle de la charge qui les écrit ou qui les lit, jamais de la table elle-même. Un job qui écrit dix tables est facturé une fois, pas dix.
Le coût d'une table est donc toujours le résultat d'une règle de partage : la part d'une dépense mesurée qui revient à cette table. Il n'existe pas de réponse unique, comme en comptabilité analytique. Ce qui compte est que la règle soit écrite, vérifiable, et qu'elle ne perde ni n'invente aucun dollar.
Les tables système à relier
Quatre tables système suffisent, toutes en lecture :
| Table système | Ce qu'elle apporte |
|---|---|
system.billing.usage | La consommation de chaque charge, ligne par ligne, avec son exécution (job_run_id, dlt_update_id) |
system.billing.list_prices | Le prix catalogue de chaque SKU à chaque date ; la clé effective_list contient le prix utilisé pour calculer le coût |
system.access.table_lineage | Quelle requête, quelle exécution de job ou de pipeline lit ou écrit quelle table |
system.query.history | Le temps de calcul de chaque requête (total_task_duration_ms), pour partager une exécution qui écrit plusieurs tables |
Étape 1 : le coût de chaque exécution
Le coût d'une ligne d'usage est sa quantité multipliée par le prix catalogue en vigueur à la fin de cette ligne, comme dans l'exemple de jointure de la documentation Databricks. Par exécution de job, sur les 30 derniers jours :
SELECT u.workspace_id,
u.usage_metadata.job_id,
u.usage_metadata.job_run_id,
SUM(u.usage_quantity * p.pricing.effective_list.default) AS cout_prix_catalogue
FROM system.billing.usage AS u
JOIN system.billing.list_prices AS p
ON u.cloud = p.cloud
AND u.sku_name = p.sku_name
AND u.usage_unit = p.usage_unit
AND u.usage_end_time >= p.price_start_time
AND (p.price_end_time IS NULL OR u.usage_end_time < p.price_end_time)
WHERE u.usage_date >= date_sub(current_date(), 30)
AND u.usage_metadata.job_run_id IS NOT NULL
GROUP BY ALL
Selon la documentation, job_run_id est rempli pour les jobs serverless et les jobs sur un calcul de job, pas pour un job lancé sur un cluster interactif (all-purpose). Ces jobs-là n'ont pas d'exécution à relier.
Étape 2 : les tables écrites par chaque exécution
Le lineage dit, pour chaque écriture, quelle exécution l'a faite, dans entity_metadata :
SELECT workspace_id,
entity_metadata.job_info.job_run_id AS job_run_id,
target_table_full_name
FROM system.access.table_lineage
WHERE event_date >= date_sub(current_date(), 31)
AND target_table_full_name IS NOT NULL
AND entity_metadata.job_info.job_run_id IS NOT NULL
GROUP BY ALL
La fenêtre du lineage commence un jour plus tôt que celle de la facture : une exécution peut écrire la veille du jour où elle est facturée.
Étape 3 : partager chaque exécution entre ses tables
La jointure des deux résultats sur workspace_id et job_run_id (la documentation ne dit pas qu'un identifiant d'exécution est unique d'un workspace à l'autre) donne, pour chaque exécution, son coût et les tables qu'elle a écrites. Reste à partager :
- Une seule table écrite : tout le coût de l'exécution lui revient. C'est le cas le plus sûr après une vue matérialisée facturée à son nom.
-
Plusieurs tables écrites : le temps de calcul de chaque écriture donne la clé de partage. Il se lit dans
system.query.history, relié au lineage parstatement_id. Ce lien n'existe que pour les requêtes exécutées sur un SQL warehouse ou en serverless. - Plusieurs tables sans temps de calcul connu (un cluster classique) : à parts égales, en le disant.
- Une exécution sans écriture dans le lineage (un échec, une écriture que le lineage ne capte pas) : son coût reste non attribué. Le reporter sur les autres tables fausserait leur prix.
Les pipelines suivent la même règle avec dlt_update_id. Un SQL warehouse se partage autrement, heure par heure : le coût de chaque heure va aux requêtes qui ont tourné dans cette heure, au prorata de leur temps de calcul, puis aux tables qu'elles écrivent ou lisent. Une heure facturée sans aucune requête (démarrage, attente avant l'arrêt automatique) ne revient à aucune table.
Étape 4 : vérifier que le total tombe juste
La somme des parts attribuées aux tables, de ce qui reste non attribué et de la capacité sans requête des warehouses doit égaler, au centime, la dépense mesurée. Si l'écart n'est pas nul, une règle a perdu ou compté deux fois une dépense.
Ce que ce calcul ne dit pas
- C'est un prix catalogue, pas la facture. La remise de votre contrat, vos engagements et vos crédits n'y sont pas.
-
Les machines du calcul classique n'y sont pas.
system.billing.usagecontient la consommation Databricks. Pour un cluster classique, la machine virtuelle est facturée par le fournisseur cloud. En serverless, elle est comprise dans le prix Databricks. - Le lineage n'est pas exhaustif. Selon Databricks, ses tables représentent un sous-ensemble des lectures et des écritures, et un événement n'est émis que lorsque le lineage peut être déduit. Une écriture non tracée laisse le coût de la charge non attribué.
- Les données arrivent avec retard. Les lignes d'usage sont en général disponibles sous 12 heures : les derniers jours d'une période peuvent être incomplets.
Ce que fait YALineo
YALineo fait ce calcul dans votre navigateur, avec vos droits Databricks, en lecture seule, sans serveur YALineo. Il relie la facture au lineage exécution par exécution, partage les warehouses heure par heure, et affiche à côté de chaque table le niveau de précision de son prix : facturé, seule table, temps de calcul, parts égales, warehouse ou période. Ce qui ne peut pas être relié reste visible comme non attribué, et le total des coûts retombe au centime sur la dépense mesurée.
Le coût de chaque table s'affiche sur le plan, dans sa fiche, dans la synthèse des coûts (tutoriel), et en badge dans les pages de Databricks (tutoriel). Toutes les règles, avec leurs formules et leurs sources, sont dans la méthode de calcul.
Questions fréquentes
Databricks donne-t-il le coût par table ?
Pas directement, sauf pour une vue matérialisée, dont la ligne d'usage porte le nom. Pour les autres tables, il faut partager le coût des charges qui les écrivent ou les lisent.
Le coût d'une table comprend-il ses lectures ?
YALineo sépare les deux. Le rafraîchissement d'une table est la part des exécutions qui l'écrivent. Ses lectures sont la part des requêtes de SQL warehouse qui la lisent sans rien écrire. Une même requête n'est jamais comptée deux fois.
Et une vue ?
Une vue ne garde pas de données et n'a pas de rafraîchissement à payer. Une lecture à travers une vue compte comme une lecture de la vue, puis une fois pour chacune de ses sources.
Sources
Documentation lue le 6 novembre 2026.
-
Databricks, Billable usage system table reference (page mise à jour le 5 novembre 2026) :
usage_metadata,job_run_id,dlt_update_id, champsuc_table_*, délai de 12 heures. -
Databricks, Pricing system table reference (page mise à jour le 4 février 2025) : la clé
effective_list. - Databricks, Monitor costs using system tables (page mise à jour le 11 septembre 2026) : l'exemple de jointure de l'usage et des prix.
-
Databricks, Lineage system tables reference (page mise à jour le 4 novembre 2026) :
entity_metadata,statement_id, couverture du lineage. -
Databricks, Query history system table reference (page mise à jour le 4 novembre 2026) :
total_task_duration_ms.