YALineo
FR
Installer

Trouver les tables Databricks inutilisées

Une table sans lecture observée coûte encore son rafraîchissement et son stockage. Le lineage d'Unity Catalog permet de les repérer. Voici comment, ce que ce signal vaut, et ce que fait YALineo.

Mis à jour le 6 novembre 2026 · Abdouramane Youssouf

Ce qu'une table sans lecteur coûte encore

Une table sans lecteur coûte encore tant que rien ne l'arrête. Le job ou le pipeline qui l'écrit tourne toujours, et chaque exécution est facturée. Ses fichiers occupent du stockage.

Le rafraîchissement est dans system.billing.usage, au nom du job ou du pipeline, et au nom de la table seulement pour une vue matérialisée. Il faut donc le partager entre les tables écrites, comme l'explique le guide sur le coût d'une table. Le stockage d'une table placée dans votre compte cloud est facturé par votre fournisseur cloud, hors de system.billing.usage. Le stockage par défaut d'un workspace serverless est facturé par Databricks (produit DEFAULT_STORAGE), agrégé au niveau du metastore et donc pas table par table.

Une table ni lue ni écrite ne coûte que son stockage. Celle qui est réécrite chaque jour pour personne coûte les deux : c'est elle qu'il faut trouver d'abord.

Les tables système à lire

Deux sources suffisent, toutes deux en lecture :

SourceCe qu'elle apporte
system.access.table_lineageUne ligne par lecture ou écriture qu'Unity Catalog a pu tracer : source, cible, direct_access, event_date
system.information_schema.tablesLes tables de tous les catalogues du metastore que vous avez le droit de voir, avec table_type, table_owner et last_altered

Sauf si vous êtes administrateur du compte et du metastore, un administrateur doit vous accorder USE CATALOG sur le catalogue system, puis USE SCHEMA et SELECT sur ses schémas.

Étape 1 : les lectures de chaque table

Une table est lue quand elle est la source d'une ligne du lineage (source_table_full_name). Selon la documentation, une source sans cible est une lecture seule, une source avec une cible est une lecture qui écrit autre chose : les deux sont des usages.

direct_access vaut false quand la source a été trouvée en développant une vue : une requête sur une vue laisse une ligne pour la vue et une pour chaque table sous elle. Gardez ces lignes pour savoir si une table sert, sinon une table lue seulement à travers une vue paraîtra oubliée. Gardez les lignes directes pour compter des lectures sans doublon. Filtrez toujours sur event_date, la colonne de partition :

SELECT source_table_full_name AS table_lue,
       COUNT_IF(coalesce(direct_access, true)) AS lectures_directes,
       COUNT_IF(direct_access = false) AS lignes_par_une_vue,
       MAX(event_date) AS derniere_lecture
FROM system.access.table_lineage
WHERE event_date >= date_sub(current_date(), 90)
  AND source_table_full_name IS NOT NULL
GROUP BY ALL

Étape 2 : les tables sans aucune lecture

On part ensuite de l'inventaire et on garde les tables qui ne sont la source d'aucune ligne, avec leur dernière écriture observée et leurs jours d'écriture :

WITH lineage AS (
  SELECT source_table_full_name, target_table_full_name, event_date, event_time
  FROM system.access.table_lineage
  WHERE event_date >= date_sub(current_date(), 90)
),
lues AS (
  SELECT DISTINCT source_table_full_name AS nom
  FROM lineage
  WHERE source_table_full_name IS NOT NULL
),
ecrites AS (
  SELECT target_table_full_name AS nom,
         MAX(event_time) AS derniere_ecriture,
         COUNT(DISTINCT event_date) AS jours_ecrits
  FROM lineage
  WHERE target_table_full_name IS NOT NULL
  GROUP BY ALL
)
SELECT t.table_catalog, t.table_schema, t.table_name, t.table_type, t.table_owner,
       e.derniere_ecriture, e.jours_ecrits
FROM system.information_schema.tables AS t
LEFT JOIN lues AS l
  ON l.nom = concat_ws('.', t.table_catalog, t.table_schema, t.table_name)
LEFT JOIN ecrites AS e
  ON e.nom = concat_ws('.', t.table_catalog, t.table_schema, t.table_name)
WHERE l.nom IS NULL
  AND t.table_type <> 'VIEW'
  AND t.table_catalog <> 'system'
  AND t.table_schema <> 'information_schema'
ORDER BY e.jours_ecrits DESC NULLS LAST

Les vues ne stockent rien et sont écartées, comme le catalogue system et les schémas information_schema. En tête viennent les tables écrites le plus souvent sans lecteur. Sans dernière écriture, la table n'a été ni lue ni écrite sur la fenêtre, ou elle a été écrite hors du lineage.

Étape 3 : la dernière écriture, et pourquoi last_altered n'en est pas une

La dernière écriture observée est l'instant le plus récent où la table est la cible d'une ligne du lineage. Une écriture que le lineage ne capte pas n'y figure pas.

La documentation définit last_altered comme le moment où la définition de la relation a été modifiée pour la dernière fois. Lire une table ne change pas sa définition : cette date ne dit rien des lectures. La page ne dit pas non plus qu'une écriture de données la met à jour. YALineo la traite comme une date de définition.

Ce que ce signal prouve et ne prouve pas

Une table absente des sources du lineage n'a eu, sur la fenêtre, aucune lecture qu'Unity Catalog ait pu tracer. La requête n'établit rien de plus.

Avant de supprimer une table

  1. Élargissez la fenêtre jusqu'à l'usage périodique le plus long : clôture mensuelle, comité trimestriel, rapport annuel. Au-delà des 395 jours, Catalog Explorer et l'API de lineage gardent le lineage capté depuis le 1er septembre 2024.
  2. Cherchez les lectures invisibles : un source_path qui pointe vers le dossier de la table, un outil qui lit le stockage sans passer par Databricks.
  3. Confirmez avec le propriétaire (table_owner) et les équipes qui consomment ses données.
  4. Prévoyez une période de dépréciation. Annoncez une date, marquez la table par un commentaire ou un tag, puis arrêtez son rafraîchissement en gardant ses données. Un lecteur oublié peut alors se manifester sans rien perdre. Supprimez après un cycle complet de l'usage le plus long.
  5. Sachez revenir en arrière. UNDROP TABLE récupère une table supprimée pendant 7 jours par défaut. Pour une table externe, seules les métadonnées sont retirées : les fichiers restent dans votre stockage, et leur coût aussi.

Ce que fait YALineo

YALineo lit le lineage et la facturation dans votre navigateur, avec vos droits Databricks, en lecture seule, sans serveur YALineo.

Une table est « sans lecture observée » quand son rafraîchissement sur la période dépasse zéro et qu'aucune lecture n'y est vue, ni directe ni à travers une vue. Une vue n'entre jamais dans cette liste. La période va de 7 à 365 jours, ou entre deux dates (filtres).

Ce montant est le rafraîchissement seul : le stockage facturé par le cloud n'est pas dans les totaux de YALineo. C'est un coût attribué selon la méthode de calcul, à vérifier avec le propriétaire, et il ne devient une économie qu'une fois le rafraîchissement arrêté. La dernière écriture vient du lineage, jamais de last_altered (fraîcheur). Les limites du compte des lectures sont dans les limites connues, le pas à pas dans le tutoriel.

Questions fréquentes

Une table lue seulement à travers une vue compte-t-elle comme lue ?

Oui. Le lineage note la table sous la vue avec direct_access = false, et YALineo compte la lecture de la vue une fois pour chacune de ses sources.

Un outil de BI branché sur un SQL warehouse laisse-t-il une trace ?

Oui, quand le lineage peut être déduit. Une requête JDBC laisse une ligne dont entity_metadata est vide, faute d'objet Databricks associé, mais la lecture y est. Un outil qui lit les fichiers du stockage directement n'en laisse aucune.

La popularité de Catalog Explorer suffit-elle ?

L'onglet Insights d'une table montre son usage des 30 derniers jours, et sa popularité reflète la fréquence de ses requêtes sur cette durée. C'est un bon contrôle pour une table précise. Selon la page, la popularité compte les lectures interactives de la table, y compris par JDBC, l'API d'exécution SQL, les connecteurs SQL et les clics sur l'échantillon dans Catalog Explorer ; la page ne dit pas exactement comment ce nombre est calculé, ni si une lecture à travers une vue compte pour les tables de la vue. Il peut différer beaucoup du compte du lineage (ce que Databricks montre).

Sources

Documentation lue le 6 novembre 2026.