YALineo
FR
Installer

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.

Mis à jour le 6 novembre 2026 · Abdouramane Youssouf

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èmeCe qu'elle apporte
system.billing.usageLa consommation de chaque charge, ligne par ligne, avec son exécution (job_run_id, dlt_update_id)
system.billing.list_pricesLe prix catalogue de chaque SKU à chaque date ; la clé effective_list contient le prix utilisé pour calculer le coût
system.access.table_lineageQuelle requête, quelle exécution de job ou de pipeline lit ou écrit quelle table
system.query.historyLe 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 :

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

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.