Gérer l'historique des tables
Pour les tables Apache Iceberg et Delta Lake, chaque opération qui modifie une table crée une nouvelle version de table. Utilisez les informations d'historique pour auditer les opérations, restaurer une table ou query une table à un point précis dans le temps en utilisant le time travel.
Databricks ne recommande pas d'utiliser l'historique des tables comme solution de sauvegarde à long terme pour l'archivage des données. Utilisez uniquement les 7 derniers jours pour les opérations de time travel, sauf si vous avez défini les configurations de conservation des données et des logs à une valeur plus élevée.
Récupérer l'historique de la table
Exécutez la commande DESCRIBE HISTORY pour récupérer des informations, notamment les opérations, l’utilisateur et le Timestamp de chaque écriture dans une table. Les opérations sont renvoyées dans l'ordre chronologique inverse.
La rétention de l'historique des tables est déterminée par le paramètre de table logRetentionDuration, qui est 30 jours by default.
Le time travel et l'historique des tables sont régis par différents seuils de rétention. See time travel.
DESCRIBE HISTORY table_name -- get the full history of the table
DESCRIBE HISTORY table_name LIMIT 1 -- get the last operation only
Pour plus de détails sur la syntaxe Spark SQL, consultez DESCRIBE HISTORY.
Pour plus de détails sur la syntaxe Scala, Java et Python, consultez la documentation de l’API Delta Lake.
Catalog Explorer shows table history visually on the History tab.
Schéma d'historique
La sortie de l'opération history comporte les colonnes suivantes.
Colonne | Type | Description |
|---|---|---|
Version |
| La version de table générée par l'opération. |
Horodatage |
| Lorsque cette version a été validée. |
ID utilisateur |
| L'ID de l'utilisateur qui a exécuté l'opération. |
Nom d'utilisateur |
| Le nom de l’utilisateur qui a exécuté l’Opération. |
Opérations |
| Le nom de l'opération. |
Paramètres d'opération |
| Les paramètres de l'opération (par exemple, les prédicats). Pour les opérations |
Job |
| Les détails du LakeFlow Job qui a exécuté l'opération. Est renseigné uniquement pour les commits écrits à partir d'un LakeFlow Job. Sinon, |
Notebook |
| Les détails du Notebook Databricks à partir duquel l'opération a été exécutée. Renseigné uniquement pour les commits écrits à partir d'un Notebook Databricks. Sinon, |
ID de cluster |
| L'ID du cluster sur lequel l'opération a été exécutée. |
readVersion |
| La version de la table qui a été lue pour effectuer l'opération d'écriture. |
isolationLevel |
| Le niveau d'isolation utilisé pour cette opération. |
isBlindAppend |
| Si cette opération a ajouté des données. |
operationMetrics |
| Les métriques de l'opération (par exemple, le nombre de lignes et de fichiers modifiés). |
userMetadata |
| Les métadonnées de commit définies par l'utilisateur si elles ont été spécifiées. |
+-------+-------------------+------+--------+---------+--------------------+----+--------+---------+-----------+-----------------+-------------+--------------------+
|version| timestamp|userId|userName|operation| operationParameters| job|notebook|clusterId|readVersion| isolationLevel|isBlindAppend| operationMetrics|
+-------+-------------------+------+--------+---------+--------------------+----+--------+---------+-----------+-----------------+-------------+--------------------+
| 5|2019-07-29 14:07:47| ###| ###| DELETE|[predicate -> ["(...|null| ###| ###| 4|WriteSerializable| false|[numTotalRows -> ...|
| 4|2019-07-29 14:07:41| ###| ###| UPDATE|[predicate -> (id...|null| ###| ###| 3|WriteSerializable| false|[numTotalRows -> ...|
| 3|2019-07-29 14:07:29| ###| ###| DELETE|[predicate -> ["(...|null| ###| ###| 2|WriteSerializable| false|[numTotalRows -> ...|
| 2|2019-07-29 14:06:56| ###| ###| UPDATE|[predicate -> (id...|null| ###| ###| 1|WriteSerializable| false|[numTotalRows -> ...|
| 1|2019-07-29 14:04:31| ###| ###| DELETE|[predicate -> ["(...|null| ###| ###| 0|WriteSerializable| false|[numTotalRows -> ...|
| 0|2019-07-29 14:01:40| ###| ###| WRITE|[mode -> ErrorIfE...|null| ###| ###| null|WriteSerializable| true|[numFiles -> 2, n...|
+-------+-------------------+------+--------+---------+--------------------+----+--------+---------+-----------+-----------------+-------------+--------------------+
-
Si vous écrivez dans une table en utilisant les méthodes suivantes, certaines colonnes ne sont pas disponibles :
-
Les colonnes ajoutées ultérieurement seront toujours ajoutées après la dernière colonne.
Comprendre partitionBy dans les paramètres d'Opérations
Le champ partitionBy dans l'historique de la table n'est pertinent que pour les opérations CREATE et OVERWRITE qui définissent ou modifient le schéma de partition d'une table.
Pour les opérations d'ajout aux tables existantes (APPEND, INSERT, UPDATE, DELETE, MERGE), ce champ peut afficher un tableau vide [] ou des colonnes de partition selon la méthode d'écriture utilisée (.save() vs .saveAsTable()).
Cette incohérence est un comportement attendu et n'affecte pas la façon dont les données sont écrites dans les partitions. Vous ne devriez pas l'utiliser pour valider les opérations d'ajout.
Exemple
Considérez une table partitionnée par la colonne date. Lorsque vous créez la table, partitionBy est rempli :
df.write.format("delta") \
.partitionBy("date") \
.saveAsTable("sales_data")
L'opération CREATE dans l'historique affiche :
operationParameters: {
"mode": "ErrorIfExists",
"partitionBy": "[\"date\"]"
}
Lorsque vous ajoutez des données à cette table, partitionBy affiche un tableau vide :
new_df.write.format("delta") \
.mode("append") \
.saveAsTable("sales_data")
L'opération APPEND affiche :
operationParameters: {
"mode": "Append",
"partitionBy": "[]"
}
La valeur vide de partitionBy est attendue. Les données sont toujours écrites dans les partitions correctes, basées sur le schéma de partition existant de la table. Notez que .save() vers un chemin d'accès pourrait afficher des colonnes de partition dans ce champ, mais cette différence est un détail d'implémentation et n'affecte pas le comportement d'écriture.
Métriques des opérations
L’opération history renvoie une collection de métriques d’opérations dans le mappage de colonnes operationMetrics.
Les tableaux suivants répertorient les définitions des clés de mappage par opération.
WRITE, CREATE TABLE AS SELECT, REPLACE TABLE AS SELECT, COPY INTO
Les métriques suivantes sont disponibles pour ces opérations :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers écrits. |
| La taille en octets du contenu écrit. |
| Le nombre de lignes écrites. |
STREAMING UPDATE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers ajoutés. |
| Le nombre de fichiers supprimés. |
| Le nombre de lignes écrites. |
| La taille d'écriture en octets. |
DELETE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers ajoutés. Non fourni lorsque les partitions de la table sont supprimées. |
| Le nombre de fichiers supprimés. |
| Le nombre de lignes supprimées. Non fourni lorsque les partitions de la table sont supprimées. |
| Le nombre de lignes copiées lors du processus de suppression de fichiers. |
| Le temps nécessaire pour exécuter l'opération dans son intégralité. |
| Le temps nécessaire pour analyser les fichiers à la recherche de correspondances. |
| Le temps nécessaire pour réécrire les fichiers correspondants. |
TRUNCATE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers supprimés. |
| Le temps nécessaire pour exécuter l'opération dans son intégralité. |
MERGE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de lignes dans le DataFrame source. |
| Le nombre de lignes insérées dans la table cible. |
| Le nombre de lignes mises à jour dans la table cible. |
| Le nombre de lignes supprimées dans la table cible. |
| Le nombre de lignes cibles copiées. |
| Le nombre total de lignes écrites. |
| Le nombre de fichiers ajoutés à la cible (sink). |
| Le nombre de fichiers supprimés du récepteur (cible). |
| Le temps nécessaire pour exécuter l'opération dans son intégralité. |
| Le temps nécessaire pour analyser les fichiers à la recherche de correspondances. |
| Le temps nécessaire pour réécrire les fichiers correspondants. |
UPDATE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers ajoutés. |
| Le nombre de fichiers supprimés. |
| Le nombre de lignes mises à jour. |
| Le nombre de lignes juste copiées lors du processus de mise à jour des fichiers. |
| Le temps nécessaire pour exécuter l'opération dans son intégralité. |
| Le temps nécessaire pour analyser les fichiers à la recherche de correspondances. |
| Le temps nécessaire pour réécrire les fichiers correspondants. |
FSCK
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers supprimés. |
CONVERT
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers Parquet qui ont été convertis. |
OPTIMIZE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers ajoutés. |
| Le nombre de fichiers optimisés. |
| Le nombre d'octets ajoutés après l'optimisation de la table. |
| Le nombre d'octets supprimés. |
| La taille du plus petit fichier après l’optimisation de la table. |
| La taille du fichier du 25e percentile après l'optimisation de la table. |
| La taille médiane du fichier après l’optimisation de la table. |
| La taille du fichier du 75e centile après l'optimisation de la table. |
| La taille du fichier le plus grand après l'optimisation de la table. |
CLONE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| La taille en octets de la table source à la version clonée. |
| Le nombre de fichiers dans la table source à la version clonée. |
| Le nombre de fichiers supprimés de la table cible si une table précédente a été remplacée. |
| La taille totale en octets des fichiers supprimés de la table cible si une table précédente a été remplacée. |
| Le nombre de fichiers qui ont été copiés vers le nouvel emplacement. 0 pour les clones superficiels. |
| La taille totale en octets des fichiers qui ont été copiés vers le nouvel emplacement. 0 pour les clones superficiels. |
RESTORE
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| La taille de la table en octets après restauration. |
| Le nombre de fichiers dans la table après la restauration. |
| Le nombre de fichiers supprimés par l'opération de restauration. |
| Le nombre de fichiers qui ont été ajoutés suite à la restauration. |
| La taille en octets des fichiers supprimés par la restauration. |
| La taille en octets des fichiers ajoutés par la restauration. |
VACUUM
Les métriques suivantes sont disponibles pour cette opération :
Nom de la métrique | Description |
|---|---|
| Le nombre de fichiers supprimés. |
| Le nombre de répertoires vacuum. |
| Le nombre de fichiers à supprimer. |
Identifier le type d'OPTIMIZE opération
Le compactage automatique, le clustering fluide et le Z-ordering apparaissent tous dans l'historique de la table comme des opérations OPTIMIZE. Pour déterminer celle qui s'est exécutée, inspectez la colonne operationParameters.
Pour classifier chaque opération OPTIMIZE dans l'historique d'une table, exécutez ce qui suit :
SELECT
version,
timestamp,
CASE
WHEN operationParameters.clusterBy IS NOT NULL AND operationParameters.clusterBy <> '[]' THEN 'Liquid clustering'
WHEN operationParameters.zOrderBy IS NOT NULL AND operationParameters.zOrderBy <> '[]' THEN 'Z-ordering'
WHEN operationParameters.auto = 'true' THEN 'Auto compaction'
ELSE 'Manual OPTIMIZE'
END AS optimize_type,
operationParameters.auto AS is_auto_compaction,
operationParameters.clusterBy AS cluster_by,
operationParameters.zOrderBy AS z_order_by,
operationMetrics.numRemovedFiles AS files_compacted,
operationMetrics.numAddedFiles AS files_added,
operationMetrics.numRemovedBytes AS bytes_removed,
operationMetrics.numAddedBytes AS bytes_added
FROM (DESCRIBE HISTORY table_name)
WHERE operation = 'OPTIMIZE'
ORDER BY version DESC;
Les sections suivantes décrivent chaque valeur operationParameters en détail.
Compactage automatique
Le compactage automatique définit le paramètre auto à true. Databricks Trigger automatiquement le compactage automatique après une écriture. Lorsque auto est false, un utilisateur ou un Job planifié a exécuté la commande OPTIMIZE.
Par exemple, une opération de compactage automatique affiche ce qui suit :
operationParameters: {
"auto": "true"
}
Pour plus d'informations sur le compactage automatique, consultez Compactage automatique.
Clustering fluide
Le clustering fluide remplit le parameter clusterBy avec les noms de colonne du clustering. Un tableau clusterBy vide ([]) indique uniquement le compactage de fichier.
Par exemple, une opération qui a regroupé les données par les colonnes date et region affiche ce qui suit :
operationParameters: {
"clusterBy": "[\"date\",\"region\"]"
}
Pour plus d'informations sur le clustering fluide, consultez Utiliser le clustering fluide pour les tables.
Z-ordering
Le Z-ordering remplit le paramètre zOrderBy avec les noms de colonne de l'ordre Z. Un tableau zOrderBy vide ([]) indique que l'opération n'a pas appliqué le Z-ordering.
Par exemple, une opération qui a appliqué le Z-ordering sur la colonne date affiche ce qui suit :
operationParameters: {
"zOrderBy": "[\"date\"]"
}
Portée de l'opération
Le predicate parameter indique si l'opération a été exécutée sur la table complète ou seulement sur une partie de celle-ci :
- Un tableau
predicatevide ([]) signifie que l'opération s'est exécutée sur la table entière. - Un tableau
predicaterenseigné signifie qu'une commandeOPTIMIZE table_name WHERE <partition_predicate>ciblée s'est exécutée uniquement sur les partitions qui correspondent au prédicat.
Par exemple, une opération ciblant les partitions qui correspondent à year = 2024 affiche ce qui suit :
operationParameters: {
"predicate": "[\"'year = 2024\"]"
}
time travel
Le voyage dans le temps prend en charge l’interrogation des versions précédentes des tables en fonction de l’horodatage ou de la version de la table (tel qu’enregistré dans le journal des transactions). Vous pouvez utiliser le time travel pour des applications telles que les suivantes :
- Recréer des analyses, des rapports ou des résultats, tels que le résultat d'un Modèle de machine learning. Ceci pourrait être utile pour le debugging ou l'audit, en particulier dans les secteurs d'activité réglementés.
- Rédaction de queries temporelles complexes.
- Correction des erreurs dans vos données.
- Fournir l'isolation d'instantanés pour un ensemble de query pour les tables à modification rapide.
Dans Databricks Runtime 18.0 et versions supérieures, les requêtes time travel sont bloquées si elles demandent une version antérieure à la propriété de table deletedFileRetentionDuration (7 jours par default). Pour les tables gérées par Unity Catalog, cela s'applique à Databricks Runtime 12.2 et versions ultérieures.
Syntaxe Time travel
Vous query une table avec time travel en ajoutant une clause après la spécification du nom de la table.
-
timestamp_expressionpeut être l'un des suivants :'2018-10-18T22:15:12.013Z', c'est-à-dire une chaîne qui peut être convertie en Timestampcast('2018-10-18 13:36:32 CEST' as timestamp)'2018-10-18', c'est-à-dire, une chaîne de datescurrent_timestamp() - interval 12 hoursdate_sub(current_date(), 1)- Toute autre expression qui est ou peut être castée en Timestamp
-
versionest une valeur longue qui peut être obtenue à partir de la sortie deDESCRIBE HISTORY table_spec.
Ni timestamp_expression ni version ne peuvent être des sous-requêtes.
Seules les chaînes de date ou de Timestamp sont acceptées. Par exemple, "2019-01-01" et "2019-01-01T00:00:00.000Z". Consultez le code suivant pour un exemple de syntaxe :
- SQL
- Python
SELECT * FROM people10m TIMESTAMP AS OF '2018-10-18T22:15:12.013Z';
SELECT * FROM people10m VERSION AS OF 123;
df1 = spark.read.option("timestampAsOf", "2019-01-01").table("people10m")
df2 = spark.read.option("versionAsOf", 123).table("people10m")
Vous pouvez également utiliser la syntaxe @ pour spécifier le Timestamp ou la version dans le nom de la table. Le Timestamp doit être au format yyyyMMddHHmmssSSS. Vous pouvez spécifier une version avec @v. Consultez le code suivant pour un exemple de syntaxe :
- SQL
- Python
-- Timestamp version
SELECT * FROM people10m@20190101000000000
-- Version number
SELECT * FROM people10m@v123
# Timestamp version
spark.read.table("people10m@20190101000000000")
# Version number
spark.read.table("people10m@v123")
Configurez la conservation des données pour les queries en time travel
Pour interroger une version précédente de table, vous devez conserver à la fois les logs et les fichiers de données pour cette version :
- Les fichiers de données sont supprimés lorsque
VACUUMs'exécute sur une table. - Les fichiers logs sont automatiquement supprimés après la mise en œuvre de points de contrôle des versions de table.
Pour augmenter le threshold de rétention des données pour les tables, vous devez configurer les propriétés de table suivantes, en remplaçant <format> par delta ou iceberg:
-
<format>.logRetentionDuration = "interval <interval>": contrôle la durée de conservation de l'historique d'une table. La default estinterval 30 days.- Dans Databricks Runtime 18.0 et versions ultérieures,
logRetentionDurationdoit être supérieur ou égal àdeletedFileRetentionDuration. Pour les tables gérées par Unity Catalog, cela s'applique à Databricks Runtime 12.2 et versions ultérieures.
- Dans Databricks Runtime 18.0 et versions ultérieures,
-
<format>.deletedFileRetentionDuration = "interval <interval>": détermine le threshold queVACUUMutilise pour supprimer les fichiers de données qui ne sont plus référencés dans la version actuelle de la table. The default estinterval 7 days.
Par exemple, pour accéder à 30 jours de données historiques, définissez delta.deletedFileRetentionDuration = "interval 30 days", ce qui correspond au default pour delta.logRetentionDuration.
L'augmentation du threshold de rétention des données peut entraîner une augmentation de vos coûts de stockage, car davantage de fichiers de données sont conservés.
Vous pouvez spécifier les propriétés de la table lors de la création de la table ou les définir avec une instruction ALTER TABLE. Consultez la référence des propriétés de table.
Exemples de time travel
Pour corriger les suppressions accidentelles d’une table pour l’utilisateur 111:
INSERT INTO my_table
SELECT * FROM my_table TIMESTAMP AS OF date_sub(current_date(), 1)
WHERE userId = 111
Pour corriger les mises à jour incorrectes accidentelles d'une table :
MERGE INTO my_table target
USING my_table TIMESTAMP AS OF date_sub(current_date(), 1) source
ON source.userId = target.userId
WHEN MATCHED THEN UPDATE SET *
Pour query le nombre de nouveaux clients ajoutés au cours de la dernière semaine :
SELECT
(
SELECT count(distinct userId)
FROM my_table
)
-
(
SELECT count(distinct userId)
FROM my_table TIMESTAMP AS OF date_sub(current_date(), 7)
) AS new_customers
Points de contrôle du log des transactions
Le journal des transactions enregistre les versions de table en tant que fichiers JSON dans le répertoire du journal des transactions, à côté des données de la table.
Pour optimiser l'interrogation des points de contrôle, les versions de table sont agrégées dans des fichiers Parquet de point de contrôle, ce qui améliore les performances en évitant la nécessité de lire toutes les versions JSON de l'historique de la table. Les utilisateurs n'ont pas besoin d'interagir directement avec les points de contrôle.
Databricks optimise la fréquence des points de contrôle en fonction de la taille des données et de la charge de travail. La fréquence du point de contrôle est susceptible d'être modifiée sans préavis.
Restaurer une table à un état antérieur
Utilisez la commande RESTORE pour restaurer une table à une version ou un Timestamp précédent, y compris pour les scénarios suivants :
- Vous pouvez restaurer une table déjà restaurée.
- Vous pouvez restaurer une table clonée.
Considérez les exigences suivantes :
- Pour restaurer une table, vous devez disposer de l'autorisation
MODIFYpour cette table. - Une fois les fichiers de données supprimés, manuellement ou par
VACUUM, vous ne pouvez pas restaurer une table vers une version antérieure qui référence ces fichiers. La restauration partielle à cette version est toujours possible sispark.sql.files.ignoreMissingFilesest défini surtrue. - Pour restaurer par Timestamp, utilisez les formats
yyyy-MM-dd HH:mm:ssouyyyy-MM-dd.
RESTORE TABLE target_table TO VERSION AS OF <version>;
RESTORE TABLE target_table TO TIMESTAMP AS OF <timestamp>;
Pour plus de détails sur la syntaxe, consultez RESTORE.
Comportement de streaming
La restauration est une opération de modification des données et pourrait entraîner des données dupliquées pour les charges de travail en aval. Les entrées de logs ajoutées par la commande RESTORE contiennent dataChange défini sur vrai.
Pour les charges de travail en aval, comme un job de streaming structuré qui traite les mises à jour d'une table, les entrées de journal de modification de données ajoutées par l'opération de restauration sont considérées comme de nouvelles mises à jour de données, et leur traitement peut entraîner des données dupliquées.
Par exemple :
Version de table | Opérations | Mises à jour des logs | Mises à jour des enregistrements dans le log des modifications des données |
|---|---|---|---|
0 |
|
| (name = Viktor, age = 29), (name = George, age = 55) |
1 |
|
| (nom = George, âge = 39) |
2 |
|
| Aucun enregistrement. La compaction |
3 |
|
| (nom = Viktor, âge = 29), (nom = George, âge = 55), (nom = George, âge = 39) |
Dans l'exemple précédent, la commande RESTORE entraîne des mises à jour qui avaient été vues précédemment lors de la lecture des versions 0 et 1 de la table. Si une query de streaming lit à nouveau cette table, ces fichiers sont considérés comme des données nouvellement ajoutées et sont traités à nouveau.
Restaurer les métriques
Une fois terminé, RESTORE signale les métriques suivantes sous la forme d'un DataFrame à une seule ligne :
-
table_size_after_restore: La taille de la table après restauration. -
num_of_files_after_restore: Le nombre de fichiers dans la table après la restauration. -
num_removed_files: Nombre de fichiers supprimés (logiquement) de la table. -
num_restored_files: Nombre de fichiers restaurés en raison d'un retour en arrière. -
removed_files_size: Taille totale en octets des fichiers qui sont supprimés de la table. -
restored_files_size: Taille totale en octets des fichiers restaurés.
Recherchez la dernière version de commit
Pour obtenir le numéro de version du dernier commit écrit par le SparkSession actuel sur tous les threads et toutes les tables, interrogez la configuration SQL spark.databricks.<format>.lastCommitVersionInSession. Remplacez <format> par delta ou iceberg, selon le format de votre table.
Par exemple :
- SQL
- Python
- Scala
SET spark.databricks.delta.lastCommitVersionInSession
spark.conf.get("spark.databricks.delta.lastCommitVersionInSession")
spark.conf.get("spark.databricks.delta.lastCommitVersionInSession")
Si aucun commit n'a été effectué par le SparkSession, l'interrogation de la clé renvoie une valeur vide.
Si vous partagez le même SparkSession sur plusieurs threads, c'est similaire au partage d'une variable sur plusieurs threads. Vous pourriez rencontrer des conditions de concurrence pour les mises à jour simultanées de la valeur de configuration.