Tutoriel : Créer et gérer des tables Delta Lake

Ce tutoriel illustre les opérations courantes de table Delta à l’aide d’exemples de données. Delta Lake est la couche de stockage optimisée qui fournit la base des tables sur Databricks. Sauf indication contraire, toutes les tables de Databricks sont des tables Delta.

Avant de commencer

Pour suivre ce didacticiel, vous avez besoin des éléments suivants :

• Autorisation d’utiliser une ressource de calcul existante ou de créer une ressource de calcul. Voir Calculer.
• Autorisations du catalogue Unity : USE CATALOG, USE SCHEMA, et CREATE TABLE sur le catalogue workspace. Pour définir ces autorisations, contactez votre administrateur Databricks ou consultez Privilèges et objets sécurisables dans Unity Catalog.

Ces exemples s’appuient sur un jeu de données appelé Enregistrements de personne synthétique : 10 000 à 10 Millions d’enregistrements. Ce jeu de données contient des enregistrements fictifs de personnes, y compris leur prénom et leur prénom, leur sexe et leur âge.

Tout d’abord, téléchargez le jeu de données pour ce didacticiel.

1. Visitez la page Enregistrements de personne synthétique : 10 000 à 10 Millions d’enregistrements sur Kaggle.
2. Cliquez sur Télécharger , puis Télécharger le jeu de données en tant que fichier zip. Cela télécharge un fichier nommé archive.zip sur votre ordinateur local.
3. Extrayez le archive dossier du archive.zip fichier.

Ensuite, chargez le person_10000.csv jeu de données dans un volume de catalogue Unity dans votre espace de travail Azure Databricks. Azure Databricks recommande de charger vos données dans un volume Unity Catalog, car les volumes fournissent des fonctionnalités d’accès, de stockage, de gouvernance et d’organisation de fichiers.

1. Ouvrez l’Explorateur de catalogues en cliquant sur Catalogue dans la barre latérale.
2. Dans l’Explorateur de catalogues, cliquez sur Ajouter des données et Créer un volume.
3. Nommez le volume my-volume et sélectionnez Volume managé comme type de volume.
4. Sélectionnez le workspace catalogue et le default schéma, puis cliquez sur Créer.
5. Ouvrez my-volume et cliquez sur Téléverser vers ce volume.
6. Faites glisser-déposer ou parcourez pour sélectionner le fichier person_10000.csv dans le dossier archive sur votre ordinateur local.
7. Cliquez sur Télécharger.

Enfin, créez un bloc-notes pour exécuter l’exemple de code.

1. Cliquez sur Nouvelle dans la barre latérale.
2. Cliquez sur Bloc-notes pour créer un bloc-notes.
3. Choisissez une langue pour le bloc-notes.

Créez une table

Créez une table managée du catalogue Unity nommée workspace.default.people_10k à partir de person_10000.csv. Delta Lake est la valeur par défaut pour toutes les commandes de création, de lecture et d’écriture de table dans Azure Databricks.

Python

from pyspark.sql.types import StructType, StructField, IntegerType, StringType

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

df = spark.read.format("csv").option("header", True).schema(schema).load("/Volumes/workspace/default/my-volume/person_10000.csv")

# Create the table if it does not exist. Otherwise, replace the existing table.
df.writeTo("workspace.default.people_10k").createOrReplace()

# If you know the table does not already exist, you can use this command instead.
# df.write.saveAsTable("workspace.default.people_10k")

# View the new table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Langage de programmation Scala

import org.apache.spark.sql.types._

val schema = StructType(Array(
  StructField("id", IntegerType, true),
  StructField("firstName", StringType, true),
  StructField("lastName", StringType, true),
  StructField("gender", StringType, true),
  StructField("age", IntegerType, true)
))

val df = spark.read
  .format("csv")
  .option("header", true)
  .schema(schema)
  .load("/Volumes/workspace/default/my-volume/person_10000.csv")

// Create the table if it does not exist. Otherwise, replace the existing table.
df.writeTo("workspace.default.people_10k").createOrReplace()

// If you know the table does not already exist, you can use this command instead.
// df.saveAsTable("workspace.default.people_10k")

// View the new table.
val df2 = spark.read.table("workspace.default.people_10k")
display(df2)

SQL

-- Create the table with only the required columns and rename person_id to id.
CREATE OR REPLACE TABLE workspace.default.people_10k AS
SELECT
  person_id AS id,
  firstname,
  lastname,
  gender,
  age
FROM read_files(
  '/Volumes/workspace/default/my-volume/person_10000.csv',
  format => 'csv',
  header => true
);

-- View the new table.
SELECT * FROM workspace.default.people_10k;

Il existe plusieurs manières différentes de créer ou de cloner des tables. Pour plus d’informations, consultez CREATE TABLE.

Dans Databricks Runtime 13.3 LTS et versions ultérieures, vous pouvez utiliser CREATE TABLE LIKE pour créer une table Delta vide qui duplique le schéma et les propriétés de table d’une table Delta source. Cela peut être utile lors de la migration des tables d’un environnement de développement vers la production.

CREATE TABLE workspace.default.people_10k_prod LIKE workspace.default.people_10k

Important

Cette fonctionnalité est disponible en préversion publique.

Utilisez l’API DeltaTableBuilder pour Python et Scala pour créer une table vide. Par rapport à DataFrameWriter et DataFrameWriterV2, l’API DeltaTableBuilder facilite la spécification d’informations supplémentaires telles que les commentaires de colonne, les propriétés de table et les colonnes générées.

Python

from delta.tables import DeltaTable

(
  DeltaTable.createIfNotExists(spark)
    .tableName("workspace.default.people_10k_2")
    .addColumn("id", "INT")
    .addColumn("firstName", "STRING")
    .addColumn("lastName", "STRING", comment="surname")
    .addColumn("gender", "STRING")
    .addColumn("age", "INT")
    .execute()
)

display(spark.read.table("workspace.default.people_10k_2"))

Langage de programmation Scala

import io.delta.tables.DeltaTable

DeltaTable.createOrReplace(spark)
  .tableName("workspace.default.people_10k")
  .addColumn("id", "INT")
  .addColumn("firstName", "STRING")
  .addColumn(
    DeltaTable.columnBuilder("lastName")
      .dataType("STRING")
      .comment("surname")
      .build()
  )
  .addColumn("gender", "STRING")
  .addColumn("age", "INT")
  .execute()

display(spark.read.table("workspace.default.people_10k"))

Faire un upsert vers une table

Modifiez les enregistrements existants dans une table ou ajoutez-en de nouveaux à l’aide d’une opération appelée upsert. Pour fusionner un ensemble de mises à jour et d’insertions dans une table Delta existante, utilisez la DeltaTable.merge méthode en Python et Scala et l’instruction MERGE INTO dans SQL.

Par exemple, fusionnez les données de la table people_10k_updates source vers la table workspace.default.people_10kDelta cible. Lorsqu’il existe une ligne correspondante dans les deux tables, Delta Lake met à jour la colonne de données à l’aide de l’expression donnée. En l’absence de ligne correspondante, Delta Lake ajoute une nouvelle ligne.

Python

from pyspark.sql.types import StructType, StructField, StringType, IntegerType
from delta.tables import DeltaTable

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

data = [
  (10001, 'Billy', 'Luppitt', 'M', 55),
  (10002, 'Mary', 'Smith', 'F', 98),
  (10003, 'Elias', 'Leadbetter', 'M', 48),
  (10004, 'Jane', 'Doe', 'F', 30),
  (10005, 'Joshua', '', 'M', 90),
  (10006, 'Ginger', '', 'F', 16),
]

# Create the source table if it does not exist. Otherwise, replace the existing source table.
people_10k_updates = spark.createDataFrame(data, schema)
people_10k_updates.createOrReplaceTempView("people_10k_updates")

# Merge the source and target tables.
deltaTable = DeltaTable.forName(spark, 'workspace.default.people_10k')

(deltaTable.alias("people_10k")
  .merge(
    people_10k_updates.alias("people_10k_updates"),
    "people_10k.id = people_10k_updates.id")
  .whenMatchedUpdateAll()
  .whenNotMatchedInsertAll()
  .execute()
)

# View the additions to the table.
df = spark.read.table("workspace.default.people_10k")
df_filtered = df.filter(df["id"] >= 10001)
display(df_filtered)

Langage de programmation Scala

import org.apache.spark.sql.types._
import io.delta.tables._

// Define schema
val schema = StructType(Array(
  StructField("id", IntegerType, true),
  StructField("firstName", StringType, true),
  StructField("lastName", StringType, true),
  StructField("gender", StringType, true),
  StructField("age", IntegerType, true)
))

// Create data as Seq of Tuples
val data = Seq(
  (10001, "Billy", "Luppitt", "M", 55),
  (10002, "Mary", "Smith", "F", 98),
  (10003, "Elias", "Leadbetter", "M", 48),
  (10004, "Jane", "Doe", "F", 30),
  (10005, "Joshua", "", "M", 90),
  (10006, "Ginger", "", "F", 16)
)

// Create DataFrame directly from Seq of Tuples
val people_10k_updates = spark.createDataFrame(data).toDF(
  "id", "firstName", "lastName", "gender", "age"
)
people_10k_updates.createOrReplaceTempView("people_10k_updates")

// Merge the source and target tables
val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

deltaTable.as("people_10k")
  .merge(
    people_10k_updates.as("people_10k_updates"),
    "people_10k.id = people_10k_updates.id"
  )
  .whenMatched()
  .updateAll()
  .whenNotMatched()
  .insertAll()
  .execute()

// View the additions to the table.
val df = spark.read.table("workspace.default.people_10k")
val df_filtered = df.filter($"id" >= 10001)
display(df_filtered)

SQL

-- Create the source table if it does not exist. Otherwise, replace the existing source table.
CREATE OR REPLACE TABLE workspace.default.people_10k_updates(
  id INT,
  firstName STRING,
  lastName STRING,
  gender STRING,
  age INT
);
-- Insert new data into the source table.
INSERT INTO workspace.default.people_10k_updates VALUES
  (10001, "Billy", "Luppitt", "M", 55),
  (10002, "Mary", "Smith", "F", 98),
  (10003, "Elias", "Leadbetter", "M", 48),
  (10004, "Jane", "Doe", "F", 30),
  (10005, "Joshua", "", "M", 90),
  (10006, "Ginger", "", "F", 16);

-- Merge the source and target tables.
MERGE INTO workspace.default.people_10k AS people_10k
USING workspace.default.people_10k_updates AS people_10k_updates
ON people_10k.id = people_10k_updates.id
WHEN MATCHED THEN
  UPDATE SET *
WHEN NOT MATCHED THEN
  INSERT *;

-- View the additions to the table.
SELECT * FROM workspace.default.people_10k WHERE id >= 10001

Dans SQL, l’opérateur * met à jour ou insère toutes les colonnes de la table cible, en supposant que la table source possède les mêmes colonnes que la table cible. Si la table cible n’a pas les mêmes colonnes, la requête lève une erreur d’analyse. En outre, vous devez spécifier une valeur pour chaque colonne de votre table lorsque vous effectuez une opération d’insertion. Les valeurs de colonne peuvent être vides, par exemple ''. Lorsque vous effectuez une opération d’insertion, vous n’avez pas besoin de mettre à jour toutes les valeurs.

Lire une table

Utilisez le nom ou le chemin d’accès de la table pour accéder aux données dans les tables Delta. Pour accéder aux tables managées du catalogue Unity, utilisez un nom de table complet. L’accès basé sur le chemin n’est pris en charge que pour les volumes et les tables externes, et non pour les tables managées. Pour plus d’informations, consultez Règles de chemin d’accès et accès dans les volumes du catalogue Unity.

Python

people_df = spark.read.table("workspace.default.people_10k")
display(people_df)

Langage de programmation Scala

val people_df = spark.read.table("workspace.default.people_10k")
display(people_df)

SQL

SELECT * FROM workspace.default.people_10k;

Écrire dans une table

Delta Lake utilise la syntaxe standard pour écrire des données dans des tables. Pour ajouter de nouvelles données à une table Delta existante, utilisez le mode d’ajout. Contrairement à upserting, l’écriture dans une table ne vérifie pas les enregistrements en double.

Python

from pyspark.sql.types import StructType, StructField, StringType, IntegerType
from pyspark.sql.functions import col

schema = StructType([
  StructField("id", IntegerType(), True),
  StructField("firstName", StringType(), True),
  StructField("lastName", StringType(), True),
  StructField("gender", StringType(), True),
  StructField("age", IntegerType(), True)
])

data = [
  (10007, 'Miku', 'Hatsune', 'F', 25)
]

# Create the new data.
df  = spark.createDataFrame(data, schema)

# Append the new data to the target table.
df.write.mode("append").saveAsTable("workspace.default.people_10k")

# View the new addition.
df = spark.read.table("workspace.default.people_10k")
df_filtered = df.filter(df["id"] == 10007)
display(df_filtered)

Langage de programmation Scala

// Create the new data.
val data = Seq(
  (10007, "Miku", "Hatsune", "F", 25)
)

val df = spark.createDataFrame(data)
  .toDF("id", "firstName", "lastName", "gender", "age")

// Append the new data to the target table
df.write.mode("append").saveAsTable("workspace.default.people_10k")

// View the new addition.
val df2 = spark.read.table("workspace.default.people_10k")
val df_filtered = df2.filter($"id" === 10007)
display(df_filtered)

SQL

CREATE OR REPLACE TABLE workspace.default.people_10k_new (
  id INT,
  firstName STRING,
  lastName STRING,
  gender STRING,
  age INT
);

-- Insert the new data.
INSERT INTO workspace.default.people_10k_new VALUES
  (10007, 'Miku', 'Hatsune', 'F', 25);

-- Append the new data to the target table.
INSERT INTO workspace.default.people_10k
SELECT * FROM workspace.default.people_10k_new;

-- View the new addition.
SELECT * FROM workspace.default.people_10k WHERE id = 10007;

Les sorties de cellule de notebook Databricks affichent un maximum de 10 000 lignes ou 2 Mo, selon le moindre des deux. Étant donné que workspace.default.people_10k contient plus de 10 000 lignes, seules les 10 000 premières lignes apparaissent dans la sortie du bloc-notes pour display(df). Les lignes supplémentaires sont présentes dans le tableau, mais ne sont pas rendues dans la sortie du notebook en raison de cette limite. Vous pouvez afficher les lignes supplémentaires en les filtrant spécifiquement.

Pour remplacer toutes les données d’une table, utilisez le mode de remplacement.

Python

df.write.mode("overwrite").saveAsTable("workspace.default.people_10k")

Langage de programmation Scala

df.write.mode("overwrite").saveAsTable("workspace.default.people_10k")

SQL

INSERT OVERWRITE TABLE workspace.default.people_10k SELECT * FROM workspace.default.people_10k_2

Mettre à jour une table

Mettez à jour les données d’une table Delta en fonction d’un prédicat. Par exemple, modifiez les valeurs dans la colonne gender de Female à F, de Male à M, et de Other à O.

Python

from delta.tables import *
from pyspark.sql.functions import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

# Declare the predicate and update rows using a SQL-formatted string.
deltaTable.update(
  condition = "gender = 'Female'",
  set = { "gender": "'F'" }
)

# Declare the predicate and update rows using Spark SQL functions.
deltaTable.update(
  condition = col('gender') == 'Male',
  set = { 'gender': lit('M') }
)

deltaTable.update(
  condition = col('gender') == 'Other',
  set = { 'gender': lit('O') }
)

# View the updated table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Langage de programmation Scala

import io.delta.tables._
import org.apache.spark.sql.functions._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

// Declare the predicate and update rows using a SQL-formatted string.
deltaTable.updateExpr(
  "gender = 'Female'",
  Map("gender" -> "'F'")
)

// Declare the predicate and update rows using Spark SQL functions.
deltaTable.update(
  col("gender") === "Male",
  Map("gender" -> lit("M")));

deltaTable.update(
  col("gender") === "Other",
  Map("gender" -> lit("O")));

// View the updated table.
val df = spark.read.table("workspace.default.people_10k")
display(df)

SQL

-- Declare the predicate and update rows.
UPDATE workspace.default.people_10k SET gender = 'F' WHERE gender = 'Female';
UPDATE workspace.default.people_10k SET gender = 'M' WHERE gender = 'Male';
UPDATE workspace.default.people_10k SET gender = 'O' WHERE gender = 'Other';

-- View the updated table.
SELECT * FROM workspace.default.people_10k;

Supprimer d’une table

Supprimez les données qui correspondent à un prédicat d’une table Delta. Par exemple, le code ci-dessous illustre deux opérations de suppression : la première suppression de lignes dont l’âge est inférieur à 18, puis la suppression de lignes dont l’âge est inférieur à 21.

Python

from delta.tables import *
from pyspark.sql.functions import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

# Declare the predicate and delete rows using a SQL-formatted string.
deltaTable.delete("age < '18'")

# Declare the predicate and delete rows using Spark SQL functions.
deltaTable.delete(col('age') < '21')

# View the updated table.
df = spark.read.table("workspace.default.people_10k")
display(df)

Langage de programmation Scala

import io.delta.tables._
import org.apache.spark.sql.functions._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")

// Declare the predicate and delete rows using a SQL-formatted string.
deltaTable.delete("age < '18'")

// Declare the predicate and delete rows using Spark SQL functions.
deltaTable.delete(col("age") < "21")

// View the updated table.
val df = spark.read.table("workspace.default.people_10k")
display(df)

SQL

-- Delete rows using a predicate.
DELETE FROM workspace.default.people_10k WHERE age < '21';

-- View the updated table.
SELECT * FROM workspace.default.people_10k;

Important

L'effacement supprime les données de la dernière version de la table Delta, mais ne les retire pas du stockage physique tant que les anciennes versions ne sont pas explicitement expurgées. Pour plus d’informations, consultez vide.

Afficher l’historique d’une table

Utilisez la DeltaTable.history méthode en Python et Scala et l’instruction DESCRIBE HISTORY dans SQL pour afficher les informations de provenance pour chaque écriture dans une table.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
display(deltaTable.history())

Langage de programmation Scala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
display(deltaTable.history())

SQL

DESCRIBE HISTORY workspace.default.people_10k

Interroger une version antérieure de la table à l’aide d’un voyage temporel

Interrogez un instantané plus ancien d’une table Delta en utilisant la fonctionnalité de réversion de Delta Lake. Pour interroger une version spécifique, utilisez le numéro de version ou l’horodatage du tableau des données. Par exemple, interrogez la version 0 ou l’horodatage 2026-01-05T23:09:47.000+00:00 depuis l’historique de la table.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaHistory = deltaTable.history()

# Query using the version number.
display(deltaHistory.where("version == 0"))

# Query using the timestamp.
display(deltaHistory.where("timestamp == '2026-01-05T23:09:47.000+00:00'"))

Langage de programmation Scala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
val deltaHistory = deltaTable.history()

// Query using the version number.
display(deltaHistory.where("version == 0"))

// Query using the timestamp.
display(deltaHistory.where("timestamp == '2026-01-05T23:09:47.000+00:00'"))

SQL

-- Query using the version number
SELECT * FROM workspace.default.people_10k VERSION AS OF 0;

-- Query using the timestamp
SELECT * FROM workspace.default.people_10k TIMESTAMP AS OF '2026-01-05T23:09:47.000+00:00';

Pour les horodatages, seules les chaînes de date ou d’horodatage sont acceptées. Par exemple, les chaînes doivent être mises en forme en tant que "2026-01-05T22:43:15.000+00:00" ou "2026-01-05 22:43:15".

Utilisez les options DataFrameReader pour créer un DataFrame à partir d'une table Delta verrouillée sur une version ou un horodatage spécifique de la table.

Python

# Query using the version number.
df = spark.read.option('versionAsOf', 0).table("workspace.default.people_10k")

# Query using the timestamp.
df = spark.read.option('timestampAsOf', '2026-01-05T23:09:47.000+00:00').table("workspace.default.people_10k")

display(df)

Langage de programmation Scala

// Query using the version number.
val dfVersion = spark.read
  .option("versionAsOf", 0)
  .table("workspace.default.people_10k")

// Query using the timestamp.
val dfTimestamp = spark.read
  .option("timestampAsOf", "2026-01-05T23:09:47.000+00:00")
  .table("workspace.default.people_10k")

display(dfVersion)
display(dfTimestamp)

SQL

-- Create a temporary view from version 0 of the table.
CREATE OR REPLACE TEMPORARY VIEW people_10k_v0 AS
SELECT * FROM workspace.default.people_10k VERSION AS OF 0;

-- Create a temporary view from a previous timestamp of the table.
CREATE OR REPLACE TEMPORARY VIEW people_10k_t0 AS
SELECT * FROM workspace.default.people_10k TIMESTAMP AS OF '2026-01-05T23:09:47.000+00:00';

SELECT * FROM people_10k_v0;
SELECT * FROM people_10k_t0;

Pour plus d’informations, consultez Utilisation de l’historique des tables.

Optimiser une table

Plusieurs modifications apportées à une table peuvent créer plusieurs petits fichiers, ce qui ralentit les performances des requêtes de lecture. Utilisez l’opération d’optimisation pour améliorer la vitesse en combinant de petits fichiers en fichiers plus volumineux. Voir OPTIMIZE.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeCompaction()

Langage de programmation Scala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeCompaction()

SQL

OPTIMIZE workspace.default.people_10k

Remarque

Si l’optimisation prédictive est activée, vous n’avez pas besoin d’optimiser manuellement. L’optimisation prédictive gère automatiquement les tâches de maintenance. Pour plus d’informations, consultez Optimisation prédictive pour les tables managées du catalogue Unity.

Organiser les colonnes selon l’ordre de plan

Pour trier les données et améliorer davantage les performances de lecture, spécifiez les colonnes à classer dans l’opération. Par exemple, regroupez par la colonne firstName de cardinalité élevée. Pour plus d’informations sur le z-order, consultez Data Skipping.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeZOrderBy("firstName")

Langage de programmation Scala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.optimize().executeZOrderBy("firstName")

SQL

OPTIMIZE workspace.default.people_10k
ZORDER BY (firstName)

Nettoyer les instantanés avec l’opération de vide

Delta Lake offre une isolation par instantané pour les opérations de lecture, ce qui signifie qu'il est sûr d'exécuter une opération d'optimisation de la performance pendant que d'autres utilisateurs ou tâches interrogent la table. Toutefois, vous devez éventuellement nettoyer les anciens instantanés, car cela réduit les coûts de stockage, améliore les performances des requêtes et garantit la conformité des données. Exécutez l’opération VACUUM pour nettoyer les anciens instantanés. Voir VACUUM.

Python

from delta.tables import *

deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.vacuum()

Langage de programmation Scala

import io.delta.tables._

val deltaTable = DeltaTable.forName(spark, "workspace.default.people_10k")
deltaTable.vacuum()

SQL

VACUUM workspace.default.people_10k

Pour plus d’informations sur l’utilisation efficace de l’opération de vide, consultez Supprimer les fichiers de données inutilisés avec le vide.

Étapes suivantes

• Utiliser le clustering liquide pour les tables
• Bonnes pratiques : Delta Lake

Ressources associées

• Qu’est-ce que Delta Lake dans Azure Databricks ?