Delta Lake
Performance de MERGE dans Delta Lake : modèles pour les grandes tables
Pourquoi la performance de MERGE se dégrade sur les grandes tables Delta, et comment la préserver : sources propres, élagage, moins de fichiers touchés, concurrence sûre et alternatives.
Dans cet article
MERGE est l’outil d’upsert par défaut pour les tables Delta, et c’est aussi l’une des raisons les plus fréquentes pour lesquelles un pipeline qui prenait quatre minutes le trimestre dernier en prend désormais quarante. L’instruction ressemble à une opération au niveau des lignes. Physiquement, c’est une opération au niveau des fichiers : Delta trouve les fichiers qui contiennent des lignes correspondantes et en écrit de nouvelles versions. L’essentiel du travail sur la performance de MERGE consiste à réduire cet ensemble de fichiers et à faire en sorte que le travail restant porte sur des lignes qui ont réellement changé.
Les exemples utilisent PySpark et Spark SQL et s’exécutent dans des notebooks Microsoft Fabric ou dans n’importe quel environnement Spark avec Delta Lake.
Ce que fait réellement MERGE
Un MERGE comporte une source (les lignes nouvelles ou modifiées), une cible (la table Delta), une condition de correspondance et un ensemble de clauses WHEN. Conceptuellement, Delta l’exécute en deux passes :
- Trouver les fichiers touchés. Delta joint la source à la cible selon la condition de correspondance pour déterminer quels fichiers de la cible contiennent au moins une ligne correspondante. Cette passe n’a besoin que des colonnes utilisées dans la condition, elle est donc relativement légère — sauf si la condition l’oblige à lire toute la table.
- Réécrire. Pour chaque fichier touché, Delta produit le nouveau contenu : lignes mises à jour, lignes supprimées retirées, lignes inchangées recopiées. Les insertions sont écrites dans de nouveaux fichiers. La validation (commit) marque ensuite les anciens fichiers comme supprimés et les nouveaux comme ajoutés dans le journal des transactions.
La partie coûteuse, ce sont les lignes « recopiées ». Avec le copy-on-write classique, un fichier de 512 Mo contenant une seule ligne mise à jour est réécrit en entier ; 2 000 mises à jour dispersées sur 2 000 fichiers signifient 2 000 fichiers réécrits. Deux fonctionnalités changent ce calcul :
- Low shuffle merge, activé par défaut dans tous les runtimes Spark de Fabric, exclut les lignes non modifiées du shuffle coûteux de la seconde passe. Elles sont tout de même écrites, séparément et dans leur ordre d’origine, ce qui peut produire jusqu’à deux fois plus de fichiers en sortie.
- Les vecteurs de suppression (deletion vectors) permettent à une mise à jour ou à une suppression de marquer d’anciennes lignes comme supprimées dans un petit fichier annexe au lieu de réécrire le fichier de données. Fabric les active par défaut pour les nouvelles tables à partir de Spark Runtime 2.0 (Delta 4.1). Le coût se reporte sur les lecteurs jusqu’à ce qu’un compactage réécrive les fichiers.
Aucune de ces fonctionnalités ne dispense d’un bon élagage (pruning). Les deux rendent un fichier touché moins coûteux ; aucune ne fait disparaître un scan complet de la table.
Mesurer avant d’optimiser
Chaque commit MERGE enregistre des métriques d’opération dans l’historique Delta. Lisez-les avant de modifier quoi que ce soit :
from delta.tables import DeltaTable
target = DeltaTable.forName(spark, "silver_orders")
history = (
target.history(20)
.filter("operation = 'MERGE'")
.select("version", "timestamp", "operationParameters.predicate", "operationMetrics")
)
for row in history.collect():
m = row["operationMetrics"]
changed = int(m["numTargetRowsUpdated"]) + int(m["numTargetRowsInserted"]) + int(m["numTargetRowsDeleted"])
copied = int(m["numTargetRowsCopied"])
print({
"version": row["version"],
"source_rows": m["numSourceRows"],
"changed_rows": changed,
"copied_rows": copied,
"copy_ratio": round(copied / changed, 1) if changed else None,
"files_added": m["numTargetFilesAdded"],
"files_removed": m["numTargetFilesRemoved"],
})Les signaux utiles :
numTargetRowsCopiedpar rapport aux lignes modifiées. C’est l’amplification d’écriture. Un ratio de 500 signifie que MERGE a écrit 500 lignes inchangées pour chaque ligne modifiée. C’est le chiffre à faire baisser.numTargetFilesRemoved. Le nombre de fichiers touchés par le MERGE. S’il est proche du nombre total de fichiers de la table, la condition de correspondance n’élague rien.numSourceRowspar rapport aux lignes modifiées. Si la source compte 10 millions de lignes et que 30 000 ont changé, l’essentiel de la source a été du travail inutile. Filtrer la source coûte moins cher que de laisser MERGE découvrir que rien n’a changé.numTargetFilesAddedpar rapport aux fichiers supprimés. Un MERGE qui supprime 40 fichiers et en ajoute 4 000 fragmente la table et ralentit l’exécution suivante.
Journalisez ces valeurs avec la durée de chaque exécution. Une tendance sur plusieurs semaines vous en apprend plus qu’une exécution isolée, et l’interface Spark montre où une exécution passe son temps : scan de la cible, jointure ou écriture.
Modèle 1 : corriger d’abord la source
Beaucoup de problèmes de MERGE sont des problèmes de source.
Clés en double dans la source. Si deux lignes de la source correspondent à la même ligne de la cible, Delta ne peut pas décider quelle mise à jour l’emporte et échoue avec une erreur indiquant que plusieurs lignes de la source ont correspondu et tenté de modifier la même ligne de la cible. Même lorsque les doublons n’atteignent que la branche d’insertion, ils insèrent silencieusement des doublons. Dédupliquez de manière déterministe avant le MERGE, en conservant la version la plus récente par clé :
from pyspark.sql import Window
from pyspark.sql import functions as F
latest_per_key = Window.partitionBy("order_id").orderBy(
F.col("source_updated_at").desc(),
F.col("ingestion_id").desc(),
)
source = (
raw_changes
.withColumn("rn", F.row_number().over(latest_per_key))
.filter("rn = 1")
.drop("rn", "ingestion_id")
)La seconde colonne de tri sert à départager les égalités. Sans elle, deux lignes ayant le même horodatage produisent un gagnant non déterministe, et des réexécutions peuvent donner des résultats différents. La supprimer ensuite maintient le schéma de la source identique à celui de la cible, ce qui compte pour INSERT * et pour l’évolution du schéma par la suite.
Lignes sans changement. Les extractions complètes renvoient souvent des lignes qui n’ont pas changé. Les mettre à jour réécrit des fichiers pour rien. Un hachage de ligne rend la détection des changements peu coûteuse et évite de longues chaînes de OR :
tracked = ["status", "amount", "currency", "customer_id"]
source = source.withColumn(
"row_hash",
F.sha2(F.concat_ws("||", *[F.coalesce(F.col(c).cast("string"), F.lit("<null>")) for c in tracked]), 256),
)Stockez aussi row_hash dans la cible, puis utilisez WHEN MATCHED AND t.row_hash IS DISTINCT FROM s.row_hash THEN UPDATE. Utilisez la comparaison sûre vis-à-vis de NULL : avec un simple <>, une ligne de la cible dont le hachage est encore NULL (par exemple, des lignes chargées avant l’ajout de la colonne) donne une comparaison inconnue et n’est jamais mise à jour. Soyez lucide sur ce que cette condition vous apporte : elle empêche la mise à jour des lignes inchangées, mais une ligne correspondante entraîne quand même son fichier dans l’ensemble à réécrire. Lors d’un test local avec Delta 3.2, le re-MERGE d’un lot inchangé a indiqué zéro ligne mise à jour tout en supprimant et en ré-ajoutant chaque fichier touché. Pour éviter de toucher ces fichiers, retirez les lignes inchangées de la source avant le MERGE, par exemple avec une anti-jointure sur une projection étroite (order_id, row_hash) de la cible dans la même fenêtre incrémentale, et conservez la condition de la clause comme filet de sécurité.
Cardinalité du merge. Une ligne de la source doit correspondre à au plus une ligne de la cible, sur la clé métier. Si une clé est unique par convention plutôt que par validation, vérifiez la cible périodiquement : une correspondance plusieurs-à-un silencieuse est un bogue de justesse avant d’être un problème de performance.
Modèle 2 : restreindre la cible avec la condition de correspondance
Par défaut, MERGE recherche des correspondances dans toute la cible. La première recommandation d’optimisation de la documentation Delta consiste à réduire cet espace de recherche en ajoutant des contraintes connues à la condition de correspondance. Ces contraintes n’élaguent des fichiers que si Delta peut les évaluer à partir des métadonnées des fichiers — valeurs de partition ou statistiques min/max par fichier — avant de lire les données.
La méthode la plus fiable consiste à calculer les bornes à partir de la source et à les injecter sous forme de littéraux :
bounds = source.agg(
F.min("order_date").alias("min_d"),
F.max("order_date").alias("max_d"),
).first()
if bounds["min_d"] is None:
print("Empty source, nothing to merge")
else:
condition = (
"t.order_id = s.order_id "
f"AND t.order_date >= DATE'{bounds['min_d']}' "
f"AND t.order_date <= DATE'{bounds['max_d']}'"
)
(
target.alias("t")
.merge(source.alias("s"), condition)
.whenMatchedUpdate(
condition="t.row_hash IS DISTINCT FROM s.row_hash",
set={c: f"s.{c}" for c in tracked + ["row_hash", "order_date", "source_updated_at"]},
)
.whenNotMatchedInsertAll()
.execute()
)Cela n’a de sens que si order_date est immuable pour un order_id donné. Si une ligne peut passer d’une date à une autre, une condition bornée par date manquera l’ancienne version et insérera un doublon. Choisissez une colonne d’élagage stable pendant toute la vie de la clé.
Le même modèle en Spark SQL, avec des bornes fournies en paramètres par le pipeline :
MERGE INTO silver_orders AS t
USING staged_orders AS s
ON t.order_id = s.order_id
AND t.order_date >= DATE'2026-10-01'
AND t.order_date <= DATE'2026-10-07'
WHEN MATCHED AND t.row_hash IS DISTINCT FROM s.row_hash THEN
UPDATE SET *
WHEN NOT MATCHED THEN
INSERT *UPDATE SET * et INSERT * exigent que la source contienne toutes les colonnes de la cible. C’est pratique pour une table de staging ayant le même schéma, et risqué dans les autres cas ; voir la section sur le schéma plus bas.
Quand le partitionnement aide réellement MERGE
« Partitionnez la table et MERGE ira plus vite » n’est vrai que dans des conditions précises :
- La colonne de partition apparaît dans la condition de correspondance avec des valeurs que Delta peut résoudre avant de lire les données — des littéraux ou des expressions qui se réduisent à un ensemble fixe de partitions. Une égalité de jointure comme
t.order_date = s.order_dateseule peut ne pas élaguer la cible, car les valeurs correspondantes ne sont connues qu’après la lecture de la source. - Les changements sont concentrés dans quelques partitions. Si chaque lot quotidien met à jour des lignes sur trois ans de dates, le MERGE touche de toute façon la plupart des partitions, et le partitionnement ajoute une surcharge de répertoires et de fichiers sans réduire le travail.
- Chaque partition est suffisamment volumineuse. Les recommandations de Fabric sont de viser au moins 1 Go par partition et de garder une cardinalité faible à modérée. Partitionner par date une table de taille modeste crée des milliers de petites partitions, ce qui ralentit chaque scan, y compris la passe de correspondance.
Fabric présente désormais le partitionnement principalement comme un moyen d’isoler les écrivains concurrents, et recommande le clustering liquide (liquid clustering) pour l’organisation en lecture à partir de Runtime 2.0. Pour MERGE : partitionnez sur une colonne stable, de faible cardinalité, que chaque MERGE cible explicitement et qui sépare les travaux concurrents ; sinon, appuyez-vous sur le clustering et les statistiques.
Quand les statistiques de fichiers aident
Sans partitions, Delta peut ignorer des fichiers grâce aux statistiques min/max par fichier sur les colonnes de la condition, mais seulement si une plage de clés se trouve dans peu de fichiers. Si les valeurs de order_id sont des UUID aléatoires répartis dans tous les fichiers, le min/max de chaque fichier couvre presque tout l’espace de clés et rien n’est ignoré. Le clustering sur les colonnes de merge (clustering liquide ou OPTIMIZE ... ZORDER BY) et des clés qui suivent l’ordre d’arrivée (dates, identifiants croissants) rendent efficace l’élagage fondé sur les statistiques.
Modèle 3 : concevoir le prédicat pour l’élagage, pas pour la commodité
De petits détails de la clause ON décident si l’élagage a lieu :
- N’enveloppez pas les colonnes de la cible dans des fonctions.
CAST(t.order_id AS STRING) = s.order_idouto_date(t.created_at) = ...peuvent empêcher le saut de fichiers sur cette colonne. Convertissez plutôt le côté source, et corrigez les incompatibilités de types dans le schéma. - Évitez les
ORportant sur des colonnes différentes dans la condition de correspondance ; cela transforme une recherche sélective en scan étendu. Deux instructions MERGE ciblées ou une clé normalisée sont généralement préférables. - Réservez la clause
ONà l’identité et à l’élagage. La détection des changements et les règles métier ont leur place dans les conditionsWHEN. - Rendez les bornes déterministes. Des expressions comme
current_date()dans la condition font dépendre les réexécutions de l’horloge. Passez la fenêtre en paramètre depuis le pipeline afin qu’une réexécution du chargement d’hier élague les données d’hier ; Paramètres des notebooks Microsoft Fabric couvre ce modèle. - Faites attention à
WHEN NOT MATCHED BY SOURCE. Cette clause met à jour ou supprime les lignes de la cible qui n’ont pas de correspondance dans la source, ce qui l’oblige à considérer toute la cible, sauf si vous la bornez. Ajoutez toujours une condition, comme la même fenêtre de dates, à la clauseWHEN NOT MATCHED BY SOURCE.
Modèle 4 : réduire les fichiers touchés
Une fois que la condition de correspondance élague correctement, le coût restant est proportionnel au nombre de fichiers touchés et à leur taille.
- Alignez l’organisation des données sur la clé de merge. Si les mises à jour concernent des commandes récentes, une organisation par date de commande maintient ces lignes dans un petit nombre de fichiers récents. Une organisation par client disperse les changements d’une journée dans toute la table.
- Utilisez les vecteurs de suppression lorsque le compromis en lecture est acceptable. Pour des petites mises à jour fréquentes, ils coûtent beaucoup moins cher que la réécriture de gros fichiers ; planifiez un compactage pour que les lecteurs ne paient pas pour une pile de vecteurs qui ne cesse de grossir.
- N’exécutez pas MERGE dans une boucle. Un MERGE par entité ou par micro-lot multiplie les lectures de snapshot, les jointures, les commits et les petits fichiers en sortie. Fusionnez chaque table une seule fois par exécution.
Modèle 5 : maîtriser la taille des fichiers et les petits fichiers
MERGE écrit via un shuffle, donc le nombre de fichiers en sortie dépend du parallélisme du shuffle. La documentation Delta indique que spark.sql.shuffle.partitions contrôle à la fois le parallélisme et le nombre de fichiers en sortie, et qu’une valeur plus élevée produit davantage de fichiers, plus petits. Pour les tables partitionnées, un MERGE peut écrire beaucoup plus de fichiers qu’il n’y a de partitions de shuffle, car chaque tâche peut écrire dans plusieurs partitions ; la parade documentée est spark.databricks.delta.merge, qui repartitionne la sortie selon les colonnes de partition avant l’écriture.
# Size shuffle parallelism to the data actually being rewritten, not to the cluster
spark.conf.set("spark.sql.shuffle.partitions", "64")
# For partitioned targets: repartition MERGE output by partition columns before writing
spark.conf.set("spark.databricks.delta.merge.repartitionBeforeWrite.enabled", "true")Considérez ces valeurs comme des points de départ à tester. L’exécution adaptative des requêtes (adaptive query execution) et les optimisations d’écriture de Fabric influent aussi sur le nombre de fichiers ; mesurez donc les fichiers ajoutés par MERGE avant et après un changement. Les opérations MERGE fréquentes finissent quand même par fragmenter une table, ce qui ralentit la passe de correspondance suivante ; le compactage fait donc partie de la performance de MERGE :
-- Compact recent data and co-locate rows by the merge key
OPTIMIZE silver_orders
WHERE order_date >= DATE'2026-09-01'
ZORDER BY (order_id);La clause WHERE de OPTIMIZE doit référencer des colonnes de partition ; cette forme convient donc à une table partitionnée par order_date. Sur une table en clustering liquide, exécutez un simple OPTIMIZE sans ZORDER BY et laissez le clustering décider de l’organisation. Le compactage peut entrer en conflit avec un MERGE concurrent sur les mêmes fichiers ; planifiez-le donc en dehors de la fenêtre du MERGE.
Modèle 6 : une évolution du schéma sans surprises
MERGE vérifie que la source est compatible avec le schéma de la cible. Avec UPDATE SET * et INSERT *, la source doit contenir toutes les colonnes de la cible, et les colonnes supplémentaires de la source sont ignorées, sauf si l’évolution du schéma est activée.
Il existe deux façons de l’activer. Le paramètre de session spark.databricks.delta.schema s’applique à chaque écriture de la session, ce qui est plus large que ce que souhaitent la plupart des pipelines. Delta Lake 3.2 et versions ultérieures propose aussi withSchemaEvolution() sur le builder de merge, ce qui limite l’évolution à une seule instruction :
(
target.alias("t")
.merge(source.alias("s"), condition)
.withSchemaEvolution()
.whenMatchedUpdateAll(condition="t.row_hash IS DISTINCT FROM s.row_hash")
.whenNotMatchedInsertAll()
.execute()
)Vérifiez la version de Delta fournie par votre runtime avant de compter sur cette méthode du builder. Les risques apparaissent dans les mêmes travaux : une faute de frappe dans une colonne de la source devient une nouvelle colonne permanente, un changement de type en amont fait échouer le travail ou est converti silencieusement, et les lecteurs voient des colonnes que personne n’a relues. Faites évoluer le schéma par des changements relus, et réservez l’évolution automatique aux cas où les nouvelles colonnes sont attendues et sans danger.
Modèle 7 : concurrence et commits optimistes
Delta utilise un contrôle de concurrence optimiste. Un écrivain lit un snapshot, écrit de nouveaux fichiers, puis vérifie au moment du commit que rien de ce qu’il a lu n’a été modifié par un autre commit. Deux opérations MERGE peuvent entrer en conflit si elles lisent ou modifient les mêmes fichiers ; un INSERT ne peut pas entrer en conflit avec un autre INSERT, mais un MERGE peut entrer en conflit avec presque tout ce qui ajoute des fichiers aux données qu’il a lues.
La surprise la plus fréquente est ConcurrentAppendException lorsque deux travaux fusionnent des régions ou des dates différentes dans la même table. Ils semblent indépendants, mais si la condition de correspondance ne restreint pas explicitement chaque travail à sa tranche, chaque travail lit toute la table et entre en conflit avec les nouveaux fichiers de l’autre. Les documentations Delta et Fabric décrivent la même solution : partitionner selon la colonne qui sépare les travaux, et placer des valeurs littérales de cette colonne dans la condition de correspondance de chaque travail :
MERGE INTO sales_orders AS t
USING staged_orders_emea AS s
ON t.order_id = s.order_id
AND t.region = 'EMEA'
WHEN MATCHED THEN UPDATE SET *
WHEN NOT MATCHED THEN INSERT *Sans partitionnement, ou sans le littéral dans la condition, les travaux peuvent entrer en conflit même s’ils modifient des lignes différentes. Lorsque les travaux ne peuvent pas être séparés proprement, sérialisez-les dans l’orchestrateur. Avant d’ajouter des nouvelles tentatives en cas de conflit, rendez le MERGE idempotent : une déduplication et une détection des changements déterministes garantissent qu’une nouvelle tentative produit le même état de la table.
Mesurer correctement un changement
Chaque exécution voit une source différente ; comparez donc les variantes sur la même entrée : capturez un lot représentatif, exécutez la référence et le changement sur une copie de la cible à la même version, et comparez la durée ainsi que les fichiers supprimés, les fichiers ajoutés et les lignes recopiées. Exécutez ensuite le lot du lendemain après chaque variante, car un changement qui accélère le MERGE d’aujourd’hui en écrivant des milliers de petits fichiers ralentit souvent celui de demain. Un changement est réel lorsqu’il réduit les lignes recopiées ou les fichiers touchés pour les mêmes lignes modifiées ; une exécution plus rapide avec le même ratio de copie signifie généralement que le cluster était moins chargé.
Quand MERGE n’est pas le bon outil
MERGE est le bon outil lorsqu’une minorité des lignes de la cible change à chaque exécution et que vous avez besoin d’une sémantique d’upsert au niveau des lignes. C’est le mauvais outil dans plusieurs situations courantes :
- Événements en ajout seul. Les journaux et les faits immuables nécessitent des ajouts, pas des upserts. Si la source renvoie des doublons, utilisez un MERGE en insertion seule borné à une fenêtre récente, ou dédupliquez en aval.
- La majeure partie de la tranche change de toute façon. Si une exécution modifie 60 % des lignes d’une plage de dates, MERGE paie la correspondance puis réécrit presque tout. Reconstruisez la tranche.
- Les snapshots complets de dimensions petites ou moyennes sont plus clairs sous forme d’écrasement que d’un MERGE qui compare chaque ligne.
- Les agrégats recalculés. Les tables Gold entièrement dérivées de Silver sont plus simples à reconstruire pour la fenêtre concernée qu’à mettre à jour par upsert.
Pour reconstruire une fenêtre, l’écrasement sélectif de Delta remplace de manière atomique les lignes qui correspondent à un prédicat et laisse le reste de la table intact. En SQL (Delta Lake 2.4 et versions ultérieures), c’est INSERT ... REPLACE WHERE ; les writers DataFrame exposent la même fonctionnalité via l’option replaceWhere :
INSERT INTO gold_daily_sales
REPLACE WHERE order_date >= DATE'2026-10-01' AND order_date <= DATE'2026-10-07'
SELECT * FROM rebuilt_windowPar défaut, Delta vérifie que chaque ligne écrite correspond au prédicat et fait échouer l’écriture dans le cas contraire, ce qui vous protège contre une écriture accidentelle hors de la fenêtre. Les lecteurs voient soit l’ancienne fenêtre, soit la nouvelle, jamais un état à moitié écrit.
Fenêtres incrémentales et données tardives
Les travaux incrémentaux doivent borner les deux côtés : filtrer la source sur la fenêtre de changement et borner la condition sur la cible à la plage que ces changements peuvent affecter. Borner uniquement la source laisse MERGE scanner toute la cible. Pour les données tardives, ajoutez une période de rattrapage (lookback) : si des enregistrements arrivent jusqu’à trois jours en retard, chaque exécution traite [watermark - 3 days, now] et la borne sur la cible y correspond. Avec la détection des changements, ce chevauchement coûte peu. Conservez le watermark dans une table de contrôle, et passez la fenêtre en paramètre afin que les réexécutions et les rechargements historiques (backfills) utilisent la même logique que les exécutions planifiées.
Liste de contrôle pour la production
- Source dédupliquée par clé métier avec un critère de départage déterministe ; lignes sans changement retirées.
- Bornes d’élagage littérales dans la condition de correspondance, sur des colonnes qui ne changent jamais pour une clé ; aucune fonction sur les colonnes de la cible.
WHEN NOT MATCHED BY SOURCEborné, s’il est utilisé.- Organisation des données alignée sur la clé de merge ou sur le schéma d’arrivée ; partitionnement uniquement pour des colonnes de faible cardinalité qui séparent les écrivains.
- Nombre de fichiers en sortie mesuré et compactage planifié.
- Évolution du schéma limitée à l’instruction, et non activée pour toute la session.
- Travaux concurrents séparés par des littéraux de partition explicites, ou sérialisés.
operationMetricset durée journalisés et suivis dans le temps.- Ajout ou reconstruction de fenêtre lorsque la majeure partie de la tranche change.
Recommandation
Commencez chaque investigation sur un MERGE par les métriques de l’historique, pas par les paramètres Spark. Si les lignes recopiées écrasent les lignes modifiées, travaillez sur l’élagage et l’organisation des données. Si les fichiers ajoutés augmentent à chaque exécution, travaillez sur le dimensionnement de la sortie et le compactage. Si les exécutions échouent en situation de concurrence, rendez la séparation explicite dans la condition de correspondance. Et si la plupart des données de la fenêtre changent à chaque exécution, arrêtez de faire des MERGE et reconstruisez la fenêtre.
Pour situer MERGE dans une conception plus large, Architecture Medallion expliquée montre quelles couches ont généralement besoin d’upserts, Fabric Lakehouse ou Warehouse explique quand un MERGE T-SQL dans un Warehouse est plus adapté, et Comment accélérer les notebooks Microsoft Fabric traite du côté Spark des travaux lents. La liste de contrôle du partitionnement Delta Lake est une référence rapide pour décider si une colonne de partition en vaut la peine.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Continuer à apprendre
- Aide-mémoireLire et écrire des tables DeltaLire et écrire des tables Delta avec PySpark à l’aide de modèles sûrs d’ajout (append), d’écrasement (overwrite), de merge, d’évolution du schéma, de partitionnement et de maintenance pour les pipelines de données en production.Ouvrir l’aide-mémoire
- Feuille de routeFabric Performance at ScalePourquoi la performance de MERGE se dégrade sur les grandes tables Delta, et comment la préserver : sources propres, élagage, moins de fichiers touchés, concurrence sûre et alternatives.Voir la feuille de route
Que devrais-je créer ensuite ?
Je développe Javi Builds autour des problèmes concrets rencontrés par les data engineers. Dites-moi quel sujet vous aimeriez voir ensuite.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.