Parcourir les aide-mémoire · PySpark

Technologie: PySparkCatégorie: Ingénierie des donnéesNiveau: IntermédiaireMis à jour

Lire et écrire des tables Delta

Lire 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.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Lire une table Delta enregistrée
  5. 2. Lire une table Delta par son chemin
  6. 3. Ne lire que les colonnes nécessaires
  7. 4. Filtrer le plus tôt possible
  8. 5. Ajouter des lignes immuables
  9. 6. Ajouter des métadonnées de lot avant l’ajout
  10. 7. Écraser volontairement une table entière
  11. 8. N’écraser avec remplacement du schéma que de façon délibérée
  12. 9. Ajouter des colonnes compatibles grâce à l’évolution du schéma
  13. 10. Faire un upsert avec MERGE
  14. 11. Préférer des correspondances explicites de mise à jour/insertion pour des contrats stables
  15. 12. Dédupliquer les lignes source avant le merge
  16. 13. Valider l’unicité de la source
  17. 14. Faire un merge sur des clés métier composées
  18. 15. Ne mettre à jour que si la source est plus récente
  19. 16. N’insérer que les clés manquantes
  20. 17. Gérer explicitement les suppressions issues de la source
  21. 18. Utiliser MERGE en SQL lorsque c’est plus clair
  22. 19. Lire l’historique de la table
  23. 20. Lire une version antérieure d’une table Delta
  24. 21. Lire la table à un horodatage donné
  25. 22. Valider la granularité de la cible après les écritures
  26. 23. Rapprocher le nombre de lignes
  27. 24. Rapprocher les totaux métier
  28. 25. Partitionner une table lorsque le modèle d’accès le justifie
  29. 26. Éviter le surpartitionnement
  30. 27. Éviter repartition(1) avant les écritures Delta
  31. 28. Réduire le nombre de partitions de sortie avec prudence
  32. 29. Compacter les petits fichiers avec OPTIMIZE
  33. 30. Utiliser le Z-Order pour des modèles d’accès sélectifs répétés
  34. 31. Utiliser VACUUM pour nettoyer le stockage
  35. 32. Ne pas réduire la rétention à la légère
  36. 33. Utiliser le staging pour les producteurs concurrents
  37. 34. Ne relancer que les conflits de concurrence compris
  38. 35. Examiner la configuration du low shuffle merge lorsque c’est pertinent
  39. 36. Éviter de réécrire toute la table pour une petite modification incrémentale
  40. 37. Garder Bronze en ajout seul lorsque c’est possible
  41. 38. Sécuriser les relances
  42. 39. Journaliser les métadonnées d’écriture
  43. 40. Examiner le plan avant les écritures coûteuses
  44. Interpréter le résultat
  45. Points à vérifier
  46. La cible grossit à chaque relance
  47. Le merge est plus lent que prévu
  48. Le merge échoue par intermittence en situation de concurrence
  49. Les lectures ralentissent après de nombreuses mises à jour
  50. Les anciennes versions ne fonctionnent plus
  51. Le schéma de la table change de façon inattendue
  52. Notes de production
  53. Delta fournit des transactions ACID au niveau de la table
  54. L’idempotence relève de l’application
  55. Les performances du merge dépendent du volume de données de la cible touché
  56. Les opérations de maintenance consomment des ressources
  57. Le partitionnement est facultatif
  58. L’évolution du schéma doit être encadrée
  59. Erreurs fréquentes
  60. 1. Faire un ajout aveugle sur des données rejouables
  61. 2. Utiliser l’écrasement à chaque relance
  62. 3. Faire un merge avec des clés source en double
  63. 4. Utiliser updateAll() / insertAll() sans examiner le couplage des schémas
  64. 5. Partitionner par des clés à forte cardinalité
  65. 6. Utiliser repartition(1) pour une sortie Delta de production
  66. 7. Exécuter VACUUM pour accélérer les requêtes
  67. 8. Réduire la rétention sans planifier la reprise
  68. 9. Considérer une écriture réussie comme la preuve d’une granularité correcte
  69. 10. Relancer chaque échec d’écriture
  70. Étape suivante
  71. Pour aller plus loin

Problème

Vous devez lire des tables Delta depuis PySpark, y ajouter des données, les écraser ou y faire un upsert, sans introduire de lignes en double, de dérive de schéma, de réécritures complètes accidentelles ni de comportement dangereux lors des relances.

La syntaxe est simple.

Les décisions de production ne le sont pas.

Vous devez répondre aux questions suivantes :

  • Ce chargement est-il en ajout seul ou modifiable ?
  • Le même lot peut-il être rejoué ?
  • Quelle est la clé métier ?
  • La table doit-elle être reconstruite ou mise à jour de façon incrémentale ?
  • Des changements de schéma peuvent-ils apparaître automatiquement ?
  • Des traitements concurrents vont-ils écrire dans la même cible ?
  • La table est-elle partitionnée de manière appropriée ?
  • Comment allez-vous valider l’écriture ?

L’objectif est d’aligner le modèle d’écriture sur le contrat de données.

Réponse rapide

Utilisez ce modèle de décision :

Lire une table Delta existante
→ spark.read.table(...) ou format("delta").load(...)

Nouvelles lignes immuables
→ append

Reconstruction complète et déterministe
→ overwrite

Insérer + mettre à jour des clés existantes
→ MERGE

Source rejouable
→ MERGE idempotent ou logique de lot résistante au rejeu

Producteurs concurrents
→ ajout en staging, puis réconciliation dans la cible

Lire une table enregistrée :

df = spark.read.table("sales")

Ajout (append) :

(
    df.write
    .format("delta")
    .mode("append")
    .saveAsTable("sales")
)

Upsert :

from delta.tables import DeltaTable

target = DeltaTable.forName(
    spark,
    "sales",
)

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

N’utilisez pas l’écrasement comme stratégie de relance par défaut pour des données de production modifiables.

Code / commandes

1. Lire une table Delta enregistrée

df = spark.read.table(
    "sales"
)

Équivalent :

df = spark.sql(
    "SELECT * FROM sales"
)

Utilisez les noms de tables enregistrées lorsque le contexte du catalogue/Lakehouse est stable et clair.


2. Lire une table Delta par son chemin

df = (
    spark.read
    .format("delta")
    .load("Tables/sales")
)

Utilisez les lectures par chemin lorsque le chemin fait lui-même partie du contrat.

Évitez de mélanger à la légère l’accès par nom et l’accès par chemin pour une même table.


3. Ne lire que les colonnes nécessaires

df = (
    spark.read.table("sales")
    .select(
        "sale_id",
        "merchant_id",
        "sale_date",
        "amount",
    )
)

L’élagage des colonnes réduit la mémoire utilisée en aval et la largeur du shuffle.


4. Filtrer le plus tôt possible

from pyspark.sql import functions as F

df = (
    spark.read.table("sales")
    .filter(
        F.col("sale_date") >= "2026-10-01"
    )
    .select(
        "sale_id",
        "merchant_id",
        "sale_date",
        "amount",
    )
)

Filtrez tôt lorsque cela ne modifie pas la sémantique métier attendue.


5. Ajouter des lignes immuables

(
    new_rows.write
    .format("delta")
    .mode("append")
    .saveAsTable("sales")
)

Utilisez l’ajout lorsque :

  • les lignes sont nouvelles
  • les lignes existantes ne doivent pas changer
  • la gestion du rejeu est déjà conçue

L’ajout n’est pas automatiquement idempotent.


6. Ajouter des métadonnées de lot avant l’ajout

output = (
    new_rows
    .withColumn(
        "_batch_id",
        F.lit(batch_id),
    )
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
)

Cela facilite :

  • la détection des rejeux
  • la traçabilité (lineage)
  • l’investigation des incidents

Cela n’empêche pas les doublons à lui seul.


7. Écraser volontairement une table entière

(
    rebuilt.write
    .format("delta")
    .mode("overwrite")
    .saveAsTable("sales_summary")
)

À n’utiliser que lorsque le remplacement complet constitue réellement le contrat de la table.

Exemples :

  • petites dimensions déterministes
  • agrégats reconstructibles
  • rechargements historiques (backfills) contrôlés

8. N’écraser avec remplacement du schéma que de façon délibérée

(
    rebuilt.write
    .format("delta")
    .mode("overwrite")
    .option(
        "overwriteSchema",
        "true",
    )
    .saveAsTable("sales_summary")
)

Cela peut modifier le schéma de la cible.

Ne l’activez pas globalement.


9. Ajouter des colonnes compatibles grâce à l’évolution du schéma

(
    new_rows.write
    .format("delta")
    .mode("append")
    .option(
        "mergeSchema",
        "true",
    )
    .saveAsTable("sales")
)

À n’utiliser que lorsque l’évolution du schéma est une politique opérationnelle acceptée.

Ne vous en servez pas pour masquer une dérive de schéma non maîtrisée en amont.


10. Faire un upsert avec MERGE

from delta.tables import DeltaTable

target = DeltaTable.forName(
    spark,
    "sales",
)

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

À utiliser lorsque les lignes entrantes peuvent mettre à jour des clés métier existantes.


11. Préférer des correspondances explicites de mise à jour/insertion pour des contrats stables

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdate(
        set={
            "merchant_id": "s.merchant_id",
            "sale_date": "s.sale_date",
            "amount": "s.amount",
            "updated_at": "s.updated_at",
        }
    )
    .whenNotMatchedInsert(
        values={
            "sale_id": "s.sale_id",
            "merchant_id": "s.merchant_id",
            "sale_date": "s.sale_date",
            "amount": "s.amount",
            "updated_at": "s.updated_at",
        }
    )
    .execute()
)

Cela réduit le couplage accidentel entre les schémas source et cible.


12. Dédupliquer les lignes source avant le merge

from pyspark.sql import Window

w = (
    Window
    .partitionBy("sale_id")
    .orderBy(
        F.col("updated_at").desc(),
        F.col("source_sequence").desc(),
    )
)

source_deduped = (
    source
    .withColumn(
        "_rn",
        F.row_number().over(w),
    )
    .filter(F.col("_rn") == 1)
    .drop("_rn")
)

Utilisez un ordre déterministe lorsque plusieurs lignes source peuvent viser la même clé.


13. Valider l’unicité de la source

duplicates = (
    source
    .groupBy("sale_id")
    .count()
    .filter(
        F.col("count") > 1
    )
)

Échouez si les doublons ne sont pas autorisés :

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Duplicate sale_id values in merge source"
    )

14. Faire un merge sur des clés métier composées

condition = """
    t.member_id = s.member_id
    AND t.merchant_id = s.merchant_id
    AND t.site_id = s.site_id
"""

Puis :

(
    target.alias("t")
    .merge(
        source.alias("s"),
        condition,
    )
    .whenMatchedUpdateAll()
    .whenNotMatchedInsertAll()
    .execute()
)

Utilisez la clé métier complète.


15. Ne mettre à jour que si la source est plus récente

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedUpdateAll(
        condition="s.updated_at > t.updated_at"
    )
    .whenNotMatchedInsertAll()
    .execute()
)

À n’utiliser que lorsque updated_at est suffisamment fiable pour définir la priorité entre versions.


16. N’insérer que les clés manquantes

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenNotMatchedInsertAll()
    .execute()
)

Cela peut rendre les lots répétés idempotents par clé métier.


17. Gérer explicitement les suppressions issues de la source

(
    target.alias("t")
    .merge(
        source.alias("s"),
        "t.sale_id = s.sale_id",
    )
    .whenMatchedDelete(
        condition="s.is_deleted = true"
    )
    .whenMatchedUpdateAll(
        condition="s.is_deleted = false"
    )
    .whenNotMatchedInsertAll(
        condition="s.is_deleted = false"
    )
    .execute()
)

Ne supprimez que lorsque le contrat source indique explicitement que la ligne est supprimée.

L’absence d’une ligne dans un lot incrémental ne prouve pas sa suppression.


18. Utiliser MERGE en SQL lorsque c’est plus clair

MERGE INTO sales AS t
USING sales_stage AS s
ON t.sale_id = s.sale_id

WHEN MATCHED
    AND s.updated_at > t.updated_at
THEN UPDATE SET
    t.merchant_id = s.merchant_id,
    t.sale_date = s.sale_date,
    t.amount = s.amount,
    t.updated_at = s.updated_at

WHEN NOT MATCHED
THEN INSERT
(
    sale_id,
    merchant_id,
    sale_date,
    amount,
    updated_at
)
VALUES
(
    s.sale_id,
    s.merchant_id,
    s.sale_date,
    s.amount,
    s.updated_at
);

Choisissez la forme API ou SQL la plus facile à relire.


19. Lire l’historique de la table

history = spark.sql(
    "DESCRIBE HISTORY sales"
)

history.show(
    truncate=False
)

Utilisez l’historique pour investiguer :

  • les ajouts
  • les écrasements
  • les merges
  • les optimisations
  • les changements opérationnels liés à VACUUM
  • les modifications inattendues

20. Lire une version antérieure d’une table Delta

older = (
    spark.read
    .format("delta")
    .option(
        "versionAsOf",
        42,
    )
    .table("sales")
)

Utilisez-la pour :

  • le débogage
  • la comparaison
  • l’analyse de reprise

La disponibilité dépend de l’historique et des fichiers conservés.


21. Lire la table à un horodatage donné

older = (
    spark.read
    .format("delta")
    .option(
        "timestampAsOf",
        "2026-10-03T12:00:00Z",
    )
    .table("sales")
)

Soyez explicite sur la sémantique des fuseaux horaires lorsque vous comparez des versions historiques.


22. Valider la granularité de la cible après les écritures

Si sale_id doit être unique :

duplicates = (
    spark.table("sales")
    .groupBy("sale_id")
    .count()
    .filter(
        F.col("count") > 1
    )
)

Puis :

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Target grain validation failed"
    )

Une transaction Delta réussie ne garantit pas l’unicité des clés métier.


23. Rapprocher le nombre de lignes

source_count = source.count()
target_count = (
    spark.table("sales")
    .count()
)

print(
    "Source:",
    source_count,
)

print(
    "Target:",
    target_count,
)

Le nombre de lignes seul ne prouve pas l’exactitude.

Utilisez-le avec :

  • les clés métier distinctes
  • les identifiants de lot
  • le nombre de valeurs nulles
  • les totaux métier

24. Rapprocher les totaux métier

source_total = (
    source
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Comparez avec la tranche appropriée de la cible.

Utilisez des types décimaux exacts pour les données financières lorsque c’est possible.


25. Partitionner une table lorsque le modèle d’accès le justifie

(
    df.write
    .format("delta")
    .mode("append")
    .partitionBy(
        "sale_year",
        "sale_month",
    )
    .saveAsTable("sales")
)

Le partitionnement peut faciliter :

  • l’élagage
  • l’isolation des écrivains
  • la gestion du cycle de vie

Ne partitionnez pas par des identifiants à forte cardinalité.


26. Éviter le surpartitionnement

Mauvais candidats :

transaction_id
customer_id avec des millions de valeurs
horodatage exact

Un trop grand nombre de partitions peut créer :

  • de nombreux petits fichiers
  • une surcharge de métadonnées
  • des lectures inefficaces

Ne partitionnez qu’en fonction de vrais modèles d’accès/d’écriture.


27. Éviter repartition(1) avant les écritures Delta

Risqué :

(
    df.repartition(1)
    .write
    .format("delta")
    .mode("append")
    .saveAsTable("sales")
)

Cela crée un goulot d’étranglement d’écriture unique.

Une table Delta est censée contenir plusieurs fichiers.


28. Réduire le nombre de partitions de sortie avec prudence

Si la sortie est petite :

small = df.coalesce(20)

Puis :

(
    small.write
    .format("delta")
    .mode("append")
    .saveAsTable("sales_summary")
)

Mesurez d’abord.

Un nombre trop faible de partitions peut aussi créer des tâches surdimensionnées et lentes.


29. Compacter les petits fichiers avec OPTIMIZE

spark.sql(
    "OPTIMIZE sales"
)

À utiliser lorsque des écritures répétées créent de nombreux petits fichiers et dégradent les performances de lecture.

Ne l’exécutez pas par défaut après chaque petite écriture.


30. Utiliser le Z-Order pour des modèles d’accès sélectifs répétés

spark.sql(
    """
    OPTIMIZE sales
    ZORDER BY (merchant_id, sale_date)
    """
)

À utiliser lorsque les requêtes filtrent fréquemment sur ces colonnes et que la table est assez volumineuse pour en tirer profit.

N’appliquez pas le Z-Order à toutes les colonnes.


31. Utiliser VACUUM pour nettoyer le stockage

spark.sql(
    "VACUUM sales"
)

Ou avec une rétention explicite :

spark.sql(
    "VACUUM sales RETAIN 168 HOURS"
)

VACUUM supprime les anciens fichiers non référencés une fois le seuil de rétention dépassé.

Il ne remplace pas OPTIMIZE pour les performances des requêtes.


32. Ne pas réduire la rétention à la légère

Les anciens fichiers peuvent encore être nécessaires pour :

  • le voyage dans le temps (time travel)
  • les lecteurs de longue durée
  • la reprise après incident
  • l’analyse d’un retour arrière

Une fois supprimés, ils sont perdus.

Traitez la rétention comme une décision opérationnelle de reprise.


33. Utiliser le staging pour les producteurs concurrents

Un modèle plus sûr :

    • Producteur A
    • Producteur B
    • Producteur C
  1. Delta de staging
  2. Merge contrôlé
  3. Delta cible
Staging pour les producteurs concurrents

Cela réduit le chevauchement entre écrivains indépendants.


34. Ne relancer que les conflits de concurrence compris

Modèle conceptuel :

import time

for attempt in range(3):
    try:
        run_merge()
        break
    except Exception as exc:
        if not is_expected_delta_conflict(exc):
            raise

        if attempt == 2:
            raise

        time.sleep(2 ** attempt)

Ne relancez pas :

  • les bogues de schéma
  • les données incorrectes
  • une logique de merge invalide
  • les échecs d’autorisation

35. Examiner la configuration du low shuffle merge lorsque c’est pertinent

Sur les plateformes/runtimes qui le prennent en charge :

print(
    spark.conf.get(
        "spark.microsoft.delta.merge.lowShuffle.enabled"
    )
)

Ne considérez pas les paramètres d’optimisation du runtime comme un substitut à des clés de merge correctes et à une bonne organisation des données.


36. Éviter de réécrire toute la table pour une petite modification incrémentale

Mauvais modèle :

target = spark.table("sales")

combined = (
    target
    .unionByName(source)
)

# global dedupe
# full overwrite

Mieux :

source incrémentale
→ dédoublonnage déterministe
→ MERGE ciblé

Ne faites des reconstructions complètes que lorsqu’elles sont réellement appropriées.


37. Garder Bronze en ajout seul lorsque c’est possible

Un modèle courant :

Bronze
→ ajout de l’historique source brut

Silver
→ MERGE de l’état courant

Gold
→ couche de consommation organisée

Cela préserve la capacité de rejeu et simplifie la reprise après incident.


38. Sécuriser les relances

Avant d’autoriser les relances, décidez :

Que se passe-t-il si le même lot s’exécute deux fois ?

Les bons modèles incluent :

MERGE par clé métier
garde-fou contre le rejeu de lot
remplacement de partition
staging + promotion

Mauvais choix par défaut :

ajout aveugle

pour les flux modifiables et rejouables.


39. Journaliser les métadonnées d’écriture

Champs utiles :

pipeline_run_id
batch_id
source_system
ingested_at_utc
source_modified_at

Exemple :

output = (
    output
    .withColumn(
        "_pipeline_run_id",
        F.lit(pipeline_run_id),
    )
    .withColumn(
        "_batch_id",
        F.lit(batch_id),
    )
    .withColumn(
        "_ingested_at_utc",
        F.current_timestamp(),
    )
)

Veillez à ce que les métadonnées opérationnelles restent sûres et non sensibles.


40. Examiner le plan avant les écritures coûteuses

output.explain("formatted")

Avant une écriture volumineuse, vérifiez que la transformation ne fait pas accidentellement :

  • un shuffle inutile
  • une jointure croisée (cross join)
  • des scans répétés
  • un énorme tri global
  • une UDF Python coûteuse

Le réglage de l’écriture ne peut pas corriger un mauvais plan en amont.

Interpréter le résultat

Modèle À utiliser pour
read.table() Table Delta enregistrée
format("delta").load() Chemin Delta explicite
append Nouvelles lignes immuables
overwrite Reconstruction complète voulue
MERGE Upsert / réconciliation incrémentale
mergeSchema Évolution additive et contrôlée du schéma
overwriteSchema Remplacement volontaire du schéma
OPTIMIZE Compacter/réorganiser les fichiers de données actifs
Z-Order Améliorer le saut de fichiers pour des filtres répétés
VACUUM Supprimer les anciens fichiers non référencés
time travel Lire l’état historique de la table
staging + merge Modèle plus sûr pour les producteurs concurrents

La distinction essentielle est la suivante :

transaction Delta réussie
!=
exactitude métier

Validez le contrat de données obtenu.

Points à vérifier

La cible grossit à chaque relance

Cause probable :

  • ajout aveugle
  • absence de protection contre le rejeu
  • clé métier incorrecte

Le merge est plus lent que prévu

Vérifiez :

  • la taille de la source
  • la sélectivité de la condition de merge
  • l’organisation de la cible
  • l’élagage des partitions
  • le nombre de fichiers
  • le déséquilibre (skew)

Le merge échoue par intermittence en situation de concurrence

Vérifiez les écrivains qui se chevauchent et le chevauchement des fichiers de la cible.

Envisagez le staging + un merge contrôlé.

Les lectures ralentissent après de nombreuses mises à jour

Vérifiez :

  • l’accumulation de petits fichiers
  • l’organisation
  • le besoin d’un OPTIMIZE

Les anciennes versions ne fonctionnent plus

Vérifiez si d’anciens fichiers ont été supprimés par la rétention/VACUUM.

Le schéma de la table change de façon inattendue

Vérifiez :

  • mergeSchema
  • la dérive de la source
  • le comportement d’écrasement du schéma
  • les changements de déploiement

Notes de production

Delta fournit des transactions ACID au niveau de la table

Cela protège l’intégrité des commits.

Cela n’impose pas automatiquement :

  • l’unicité
  • les clés étrangères
  • les règles d’une ligne par clé métier

Validez-les vous-même.

L’idempotence relève de l’application

Une écriture Delta peut être valide sur le plan transactionnel tout en dupliquant des données lors d’une relance.

Concevez délibérément le comportement de rejeu.

Les performances du merge dépendent du volume de données de la cible touché

Une très petite source peut quand même entraîner un travail coûteux sur la cible si la condition de merge ou l’organisation des données est trop large.

Les opérations de maintenance consomment des ressources

OPTIMIZE et VACUUM doivent être planifiés volontairement.

Ne les exécutez pas aveuglément après chaque écriture.

Le partitionnement est facultatif

Ne partez pas du principe que chaque table Delta a besoin d’un partitionnement physique.

Ne l’utilisez que lorsqu’il favorise :

  • l’élagage
  • le cycle de vie
  • l’isolation des écrivains

L’évolution du schéma doit être encadrée

La croissance automatique du schéma peut être pratique, mais elle peut aussi casser les consommateurs.

Traitez le schéma comme un contrat.

Erreurs fréquentes

1. Faire un ajout aveugle sur des données rejouables

Cela crée des doublons.

2. Utiliser l’écrasement à chaque relance

Cela transforme de petites mises à jour incrémentales en réécritures complètes coûteuses.

3. Faire un merge avec des clés source en double

Dédupliquez d’abord de façon déterministe.

4. Utiliser updateAll() / insertAll() sans examiner le couplage des schémas

Ce qui est pratique aujourd’hui peut devenir fragile demain.

5. Partitionner par des clés à forte cardinalité

Cela produit de nombreux petits fichiers/partitions.

6. Utiliser repartition(1) pour une sortie Delta de production

Cela crée un goulot d’étranglement à tâche unique.

7. Exécuter VACUUM pour accélérer les requêtes

Utilisez OPTIMIZE et le réglage de l’organisation des données pour les performances de lecture.

8. Réduire la rétention sans planifier la reprise

Vous pouvez perdre la possibilité d’utiliser le time travel.

9. Considérer une écriture réussie comme la preuve d’une granularité correcte

Validez les clés métier et les totaux.

10. Relancer chaque échec d’écriture

Ne relancez que les échecs transitoires ou de concurrence que vous comprenez.

Étape suivante

Partez du comportement du chargement pour choisir l’action suivante.

  • Uniquement de nouvelles lignes immuables → faites un ajout.
  • Le même lot peut être rejoué → ajoutez un merge idempotent ou un garde-fou contre le rejeu.
  • Des clés existantes peuvent changer → utilisez MERGE.
  • La source contient des clés métier en double → dédupliquez d’abord avec un ordre déterministe.
  • Des producteurs concurrents entrent en conflit → utilisez le staging + une réconciliation contrôlée.
  • La cible accumule de petits fichiers → revoyez le partitionnement et envisagez OPTIMIZE.
  • Le schéma change de façon inattendue → resserrez la politique d’évolution du schéma.
  • Les anciennes versions comptent → protégez la rétention avant VACUUM.
  • L’écriture reste lente → examinez le plan physique et passez à PySpark : référence rapide des performances.

← Tous les aide-mémoire