Parcourir les aide-mémoire · PySpark

Technologie: PySparkCatégorie: Transformation de donnéesNiveau: IntermédiaireMis à jour

Joindre des DataFrames avec PySpark

Joignez des DataFrames PySpark en toute sécurité en validant la cardinalité des clés, en choisissant le bon type et la bonne stratégie de jointure, en évitant la multiplication des lignes et en gérant le skew, les valeurs nulles et les colonnes ambiguës.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Jointure interne
  5. 2. Jointure gauche
  6. 3. Jointure droite
  7. 4. Jointure externe complète
  8. 5. Semi-jointure gauche
  9. 6. Anti-jointure gauche
  10. 7. Joindre sur plusieurs clés
  11. 8. Joindre lorsque les noms de clés diffèrent
  12. 9. Sélectionner explicitement les colonnes de sortie après une jointure
  13. 10. Valider l’unicité attendue du côté droit
  14. 11. Vérifier les deux côtés avant une jointure un-à-un
  15. 12. Mesurer le nombre de lignes avant et après une jointure d’enrichissement
  16. 13. Vérifier la fréquence des clés en double
  17. 14. Afficher le nombre de correspondances reçues par chaque clé de gauche
  18. 15. Comprendre l’expansion plusieurs-à-plusieurs
  19. 16. Dédoublonner délibérément avant une jointure
  20. 17. N’utiliser dropDuplicates() que lorsque toutes les lignes en double sont équivalentes
  21. 18. Traiter délibérément les clés de jointure nulles
  22. 19. Utiliser l’égalité null-safe lorsque c’est nécessaire
  23. 20. Normaliser les types des clés de jointure avant la jointure
  24. 21. Normaliser les clés textuelles avec prudence
  25. 22. Filtrer et projeter avant la jointure
  26. 23. Inspecter le plan physique de la jointure
  27. 24. Diffuser (broadcast) une petite table de référence
  28. 25. Vérifier que le broadcast a bien eu lieu
  29. 26. Éviter de collecter les clés de référence sur le driver
  30. 27. Rechercher du skew dans les clés de jointure
  31. 28. Rechercher du skew des deux côtés
  32. 29. Éviter de remplacer toutes les clés nulles par une seule valeur sentinelle avant une jointure
  33. 30. Repartitionner délibérément avant un travail répété basé sur les clés
  34. 31. Comprendre la différence entre bucketing et repartitionnement
  35. 32. N’utiliser une jointure croisée qu’intentionnellement
  36. 33. Se méfier des jointures croisées accidentelles
  37. 34. Utiliser avec prudence les jointures par plage ou de non-égalité
  38. 35. Valider les lignes de gauche sans correspondance
  39. 36. Calculer un taux de correspondance
  40. 37. Rapprocher les totaux après une jointure d’enrichissement
  41. 38. Préserver la granularité après la jointure
  42. 39. Mettre en cache une petite dimension réutilisée uniquement lorsque c’est justifié
  43. 40. Comparer les plans avant et après une modification d’optimisation
  44. Interpréter le résultat
  45. Points à vérifier
  46. La jointure gauche augmente le nombre de lignes
  47. Les totaux augmentent après l’enrichissement
  48. De nombreuses lignes restent sans correspondance
  49. Une tâche Spark dure bien plus longtemps que les autres
  50. Le plan utilise une jointure sort-merge pour une très petite table de référence
  51. La jointure broadcast provoque des problèmes de mémoire
  52. La jointure génère un shuffle énorme malgré un petit résultat
  53. Notes de production
  54. La granularité du résultat doit être documentée
  55. Le nombre de lignes ne suffit pas
  56. Les décisions de broadcast doivent tenir compte des octets, pas seulement des lignes
  57. Adaptive Query Execution peut modifier le comportement des jointures
  58. Les clés nulles méritent un traitement explicite
  59. Une relation plusieurs-à-plusieurs n’est pas fautive en soi
  60. L’optimisation des jointures dépend de la distribution des données
  61. Erreurs fréquentes
  62. 1. Joindre avant de vérifier l’unicité des clés
  63. 2. Utiliser dropDuplicates() après une mauvaise jointure
  64. 3. Faire un broadcast sans vérifier la taille
  65. 4. Collecter les clés de référence vers Python
  66. 5. Joindre des DataFrames larges
  67. 6. Ignorer la sémantique des nulls dans les jointures
  68. 7. Remplacer les clés nulles par une seule valeur sentinelle
  69. 8. Valider la justesse uniquement par le nombre de lignes
  70. 9. Supposer que l’optimiseur a choisi le meilleur plan dans tous les cas
  71. 10. Repartitionner aveuglément avant chaque jointure
  72. Étape suivante
  73. Pour aller plus loin

Problème

La jointure de DataFrames est l’une des opérations les plus courantes et les plus coûteuses dans Spark.

En production, les problèmes proviennent généralement :

  • d’un mauvais type de jointure
  • de clés en double d’un côté ou des deux
  • d’une expansion plusieurs-à-plusieurs accidentelle
  • de clés de jointure nulles
  • de noms de colonnes en double ambigus
  • d’une jointure effectuée avant le filtrage ou la projection
  • du broadcast d’une table qui n’est pas réellement petite
  • de clés de jointure présentant du skew
  • de la collecte des clés de référence vers Python
  • d’hypothèses erronées sur la granularité du résultat

L’objectif est de rendre explicite la relation de jointure avant d’en optimiser les performances.

Réponse rapide

Commencez par valider la relation attendue.

Exemple d’enrichissement plusieurs-à-un :

from pyspark.sql import functions as F

duplicate_keys = (
    merchants
    .groupBy("merchant_id")
    .count()
    .filter(F.col("count") > 1)
)

if duplicate_keys.limit(1).count() > 0:
    raise RuntimeError(
        "merchant_id is not unique in merchants"
    )

Puis effectuez la jointure :

result = (
    sales.alias("s")
    .join(
        merchants.alias("m"),
        on="merchant_id",
        how="left",
    )
    .select(
        "sale_id",
        "merchant_id",
        "amount",
        "merchant_name",
    )
)

Utilisez ce modèle de décision :

Seules les lignes avec correspondance sont nécessaires
→ inner

Chaque ligne de gauche est nécessaire
→ left

Chaque ligne de droite est nécessaire
→ right

Chaque ligne des deux côtés est nécessaire
→ full

Seules les lignes de gauche avec correspondance sont nécessaires
→ left_semi

Seules les lignes de gauche sans correspondance sont nécessaires
→ left_anti

Avant d’optimiser la jointure, vérifiez que le nombre de lignes et la granularité du résultat sont corrects.

Code / commandes

1. Jointure interne

result = sales.join(
    merchants,
    on="merchant_id",
    how="inner",
)

Utilisez-la lorsque seules les clés avec correspondance doivent subsister.

Gardez à l’esprit que les lignes sans correspondance disparaissent, d’un côté comme de l’autre.


2. Jointure gauche

result = sales.join(
    merchants,
    on="merchant_id",
    how="left",
)

Utilisez-la lorsque chaque ligne du côté gauche doit être conservée.

C’est le cas courant pour l’enrichissement.

Une jointure gauche peut tout de même augmenter le nombre de lignes si le côté droit contient des clés en double.


3. Jointure droite

result = sales.join(
    merchants,
    on="merchant_id",
    how="right",
)

Utilisez-la lorsque chaque ligne du côté droit doit être conservée.

Si la logique devient peu lisible, envisagez d’inverser les entrées gauche/droite et d’utiliser une jointure gauche pour plus de clarté.


4. Jointure externe complète

result = left.join(
    right,
    on="customer_id",
    how="full",
)

Utilisez-la lorsque les lignes sans correspondance des deux côtés comptent.

C’est utile pour le rapprochement.

Décidez délibérément de la façon dont les valeurs nulles provenant des côtés sans correspondance seront interprétées en aval.


5. Semi-jointure gauche

Conservez uniquement les lignes de gauche qui ont une correspondance :

matched_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_semi",
)

Il s’agit d’un filtre d’existence.

Elle n’ajoute au résultat aucune colonne du côté droit.


6. Anti-jointure gauche

Conservez uniquement les lignes de gauche sans correspondance :

orphan_sales = sales.join(
    merchants.select("merchant_id"),
    on="merchant_id",
    how="left_anti",
)

Utilisez-la pour :

  • les clés étrangères sans correspondance
  • les exceptions de qualité des données
  • la détection incrémentale de nouvelles clés
  • le rapprochement

7. Joindre sur plusieurs clés

result = left.join(
    right,
    on=[
        "member_id",
        "merchant_id",
        "site_id",
    ],
    how="left",
)

Utilisez toutes les colonnes qui définissent la véritable relation métier.

Ne réduisez pas une clé composite à une seule colonne par commodité.


8. Joindre lorsque les noms de clés diffèrent

l = left.alias("l")
r = right.alias("r")

result = (
    l.join(
        r,
        F.col("l.customer_id")
        == F.col("r.client_id"),
        "left",
    )
)

Avec une condition explicite, des colonnes de clé de jointure en double peuvent subsister.

Sélectionnez explicitement les colonnes souhaitées en sortie.


9. Sélectionner explicitement les colonnes de sortie après une jointure

result = (
    sales.alias("s")
    .join(
        merchants.alias("m"),
        F.col("s.merchant_id")
        == F.col("m.merchant_id"),
        "left",
    )
    .select(
        F.col("s.sale_id"),
        F.col("s.merchant_id"),
        F.col("s.amount"),
        F.col("m.merchant_name"),
    )
)

Cela évite :

  • les colonnes ambiguës
  • les colonnes de clé en double
  • le transport de données inutiles

10. Valider l’unicité attendue du côté droit

Pour une jointure plusieurs-à-un :

duplicate_right = (
    right
    .groupBy("customer_id")
    .count()
    .filter(F.col("count") > 1)
)

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

if duplicate_right.limit(1).count() > 0:
    raise RuntimeError(
        "Expected unique customer_id on right side"
    )

C’est l’équivalent Spark de l’explicitation des hypothèses de cardinalité d’une jointure.


11. Vérifier les deux côtés avant une jointure un-à-un

def has_duplicate_keys(df, keys):
    return (
        df.groupBy(*keys)
        .count()
        .filter(F.col("count") > 1)
        .limit(1)
        .count()
        > 0
    )

Puis :

keys = ["customer_id"]

if has_duplicate_keys(left, keys):
    raise RuntimeError(
        "Left side is not unique"
    )

if has_duplicate_keys(right, keys):
    raise RuntimeError(
        "Right side is not unique"
    )

Utilisez ce modèle pour les hypothèses un-à-un critiques pour le métier.

Pour les DataFrames très volumineux, construisez un modèle de validation réutilisable qui évite les scans répétés inutiles.


12. Mesurer le nombre de lignes avant et après une jointure d’enrichissement

before = sales.count()

result = sales.join(
    merchants,
    "merchant_id",
    "left",
)

after = result.count()

print("Before:", before)
print("After:", after)
print("Difference:", after - before)

Si une jointure gauche d’enrichissement grossit de manière inattendue, vérifiez d’abord les doublons du côté droit.

Pour les pipelines à l’échelle de la production, évitez les comptages complets répétés, sauf si la validation justifie le coût du scan.


13. Vérifier la fréquence des clés en double

(
    merchants
    .groupBy("merchant_id")
    .count()
    .filter(F.col("count") > 1)
    .orderBy(F.desc("count"))
    .show(50, truncate=False)
)

Cela vous indique si la duplication est :

  • isolée
  • généralisée
  • dominée par quelques clés

14. Afficher le nombre de correspondances reçues par chaque clé de gauche

match_counts = (
    sales.alias("s")
    .join(
        merchants.alias("m"),
        F.col("s.merchant_id")
        == F.col("m.merchant_id"),
        "left",
    )
    .groupBy(
        F.col("s.merchant_id").alias("merchant_id")
    )
    .agg(
        F.count("*").alias("joined_rows")
    )
)

Utilisez cette requête avec prudence : si sales contient déjà des identifiants de commerçant répétés, il ne s’agit pas d’un comptage direct des correspondances du côté droit.

Pour analyser la relation, vérifiez d’abord chaque côté indépendamment.


15. Comprendre l’expansion plusieurs-à-plusieurs

Supposons que le côté gauche contienne :

customer_id = 1
2 lignes

et le côté droit :

customer_id = 1
3 lignes

La jointure produit :

2 × 3 = 6 lignes

Ce n’est pas un bogue de Spark.

C’est la sémantique d’une jointure relationnelle.

Si ce n’est pas voulu, corrigez la granularité avant la jointure.


16. Dédoublonner délibérément avant une jointure

Si une seule ligne doit subsister :

from pyspark.sql import Window

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

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

Effectuez ensuite la jointure.

N’utilisez pas un dropDuplicates() arbitraire lorsque le choix de la ligne conservée compte.


17. N’utiliser dropDuplicates() que lorsque toutes les lignes en double sont équivalentes

unique_merchants = (
    merchants
    .dropDuplicates(
        ["merchant_id"]
    )
)

Ce n’est sûr que si toutes les lignes en double sont équivalentes pour l’usage en aval.

Si les valeurs diffèrent, définissez une ligne gagnante déterministe.


18. Traiter délibérément les clés de jointure nulles

Les jointures d’égalité standard ne font pas correspondre null avec null.

Exemple :

left.join(
    right,
    "customer_id",
    "inner",
)

Les lignes dont customer_id est null ne se correspondent pas entre elles avec l’égalité normale.

Si l’égalité null-safe est réellement la règle métier, utilisez l’égalité null-safe de Spark.


19. Utiliser l’égalité null-safe lorsque c’est nécessaire

result = (
    left.alias("l")
    .join(
        right.alias("r"),
        F.col("l.customer_id").eqNullSafe(
            F.col("r.customer_id")
        ),
        "inner",
    )
)

Utilisez-la uniquement lorsque :

null à gauche

doit délibérément correspondre à :

null à droite

C’est rare pour de véritables clés métier.


20. Normaliser les types des clés de jointure avant la jointure

Inspectez :

left.printSchema()
right.printSchema()

Normalisez explicitement :

left = left.withColumn(
    "customer_id",
    F.col("customer_id").cast("string"),
)

right = right.withColumn(
    "customer_id",
    F.col("customer_id").cast("string"),
)

Une clé de jointure doit avoir des types sémantique et physique cohérents.

Ne comptez pas sur un cast implicite accidentel.


21. Normaliser les clés textuelles avec prudence

left = left.withColumn(
    "customer_id_normalized",
    F.trim(
        F.col("customer_id")
    ),
)

Si une sémantique insensible à la casse est valable :

left = left.withColumn(
    "customer_id_normalized",
    F.lower(
        F.trim(F.col("customer_id"))
    ),
)

Appliquez la même règle des deux côtés.

Ne mettez pas les identifiants en minuscules et ne supprimez pas leurs espaces, sauf si la sémantique métier le permet.


22. Filtrer et projeter avant la jointure

Préférez :

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

merchants_small = (
    merchants
    .select(
        "merchant_id",
        "merchant_name",
    )
)

result = sales_small.join(
    merchants_small,
    "merchant_id",
    "left",
)

Réduisez les données avant le shuffle chaque fois que la logique le permet.


23. Inspecter le plan physique de la jointure

result.explain("formatted")

Recherchez des opérateurs de jointure tels que :

  • BroadcastHashJoin
  • SortMergeJoin
  • ShuffledHashJoin

La stratégie choisie vous indique comment Spark prévoit de déplacer et de comparer les données.

Ne forcez pas une stratégie sans comprendre pourquoi la stratégie actuelle est lente.


24. Diffuser (broadcast) une petite table de référence

result = sales.join(
    F.broadcast(merchants),
    on="merchant_id",
    how="left",
)

Le broadcast peut éviter de redistribuer par shuffle le côté volumineux.

Utilisez-le lorsque la table de référence est réellement assez petite pour la mémoire des executors.

Ne diffusez pas une table simplement parce qu’elle a moins de lignes que la table de faits.

La largeur des lignes compte aussi.


25. Vérifier que le broadcast a bien eu lieu

result.explain("formatted")

Recherchez :

BroadcastHashJoin

Ne supposez pas que l’indication (hint) ou le seuil d’auto-broadcast a produit le plan attendu.


26. Éviter de collecter les clés de référence sur le driver

À éviter :

merchant_ids = [
    row["merchant_id"]
    for row in merchants.collect()
]

filtered = sales.filter(
    F.col("merchant_id").isin(
        merchant_ids
    )
)

Utilisez une semi-jointure :

filtered = sales.join(
    merchants.select("merchant_id"),
    "merchant_id",
    "left_semi",
)

L’opération reste ainsi distribuée.


27. Rechercher du skew dans les clés de jointure

(
    sales
    .groupBy("merchant_id")
    .count()
    .orderBy(F.desc("count"))
    .show(50, truncate=False)
)

Recherchez les clés qui dominent la distribution des lignes.

Une clé chaude peut faire durer une ou quelques tâches bien plus longtemps que les autres.


28. Rechercher du skew des deux côtés

(
    merchants
    .groupBy("merchant_id")
    .count()
    .orderBy(F.desc("count"))
    .show(50, truncate=False)
)

Un skew de l’un ou l’autre côté peut affecter la jointure.

Clés chaudes fréquentes :

  • valeurs de remplacement des nulls
  • "UNKNOWN"
  • 0
  • un client (tenant) très volumineux
  • des enregistrements malformés regroupés sous une même clé

29. Éviter de remplacer toutes les clés nulles par une seule valeur sentinelle avant une jointure

Risqué :

df = df.fillna(
    {
        "merchant_id": 0
    }
)

Joindre ensuite sur merchant_id peut créer un énorme groupe de clé chaude sur 0.

N’utilisez le remplacement par une valeur sentinelle que lorsque la règle métier l’exige et que l’impact sur le skew est compris.


30. Repartitionner délibérément avant un travail répété basé sur les clés

sales_by_merchant = sales.repartition(
    "merchant_id"
)

Cette opération crée un shuffle.

Utilisez-la uniquement lorsque le partitionnement obtenu peut être suffisamment réutilisé pour justifier le coût.

Ne repartitionnez pas avant chaque jointure par habitude.


31. Comprendre la différence entre bucketing et repartitionnement

repartition() affecte l’exécution actuelle du DataFrame.

Les stratégies persistantes de bucketing ou d’organisation des tables sont différentes et dépendent du chemin de stockage Spark/Fabric et des fonctionnalités de table prises en charge.

Ne supposez pas qu’un seul appel à repartition() organise durablement la table Delta sur le disque.


32. N’utiliser une jointure croisée qu’intentionnellement

result = left.crossJoin(
    right
)

Une jointure croisée produit :

left_rows × right_rows

Ne l’utilisez que lorsque la multiplication cartésienne est le besoin réel.

Avec des entrées volumineuses, le résultat peut exploser rapidement.


33. Se méfier des jointures croisées accidentelles

Une condition de jointure incorrecte peut produire un comportement cartésien inattendu ou une croissance massive du nombre de lignes.

Validez toujours :

les clés de jointure
la condition de jointure
le nombre de lignes en sortie
la granularité métier

après avoir ajouté ou modifié une logique de jointure.


34. Utiliser avec prudence les jointures par plage ou de non-égalité

Exemple :

result = (
    events.alias("e")
    .join(
        rates.alias("r"),
        (
            F.col("e.event_time")
            >= F.col("r.valid_from")
        )
        & (
            F.col("e.event_time")
            < F.col("r.valid_to")
        ),
        "left",
    )
)

Les jointures par plage peuvent être coûteuses, car les jointures par hachage fondées sur l’égalité ne s’appliquent pas forcément directement.

Réduisez fortement les deux côtés et validez la multiplication des lignes.


35. Valider les lignes de gauche sans correspondance

unmatched = sales.join(
    merchants.select("merchant_id"),
    "merchant_id",
    "left_anti",
)

Inspectez :

unmatched.show(
    100,
    truncate=False,
)

C’est souvent le moyen le plus rapide de diagnostiquer des données de référence manquantes.


36. Calculer un taux de correspondance

total = sales.count()

matched = (
    sales.join(
        merchants.select("merchant_id"),
        "merchant_id",
        "left_semi",
    )
    .count()
)

match_rate = (
    matched / total
    if total
    else None
)

print(match_rate)

Il n’existe pas de taux de correspondance acceptable universel.

Comparez-le au contrat de la source et au comportement historique.


37. Rapprocher les totaux après une jointure d’enrichissement

Supposons que la jointure ne doive pas modifier les totaux des montants de ventes.

Avant :

before = (
    sales
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Après :

after = (
    result
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Si le total augmente de manière inattendue, recherchez une multiplication des lignes.


38. Préserver la granularité après la jointure

Documentez :

Granularité des ventes en entrée :
une ligne par sale_id

Granularité attendue en sortie :
une ligne par sale_id

Puis validez :

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

if duplicates.limit(1).count() > 0:
    raise RuntimeError(
        "Join changed sale_id grain"
    )

C’est plus significatif que le seul nombre de lignes.


39. Mettre en cache une petite dimension réutilisée uniquement lorsque c’est justifié

merchants_small = (
    merchants
    .select(
        "merchant_id",
        "merchant_name",
    )
    .cache()
)

merchants_small.count()

Si de nombreuses jointures réutilisent la même dimension coûteuse à construire, le cache peut aider.

Si elle n’est lue qu’une fois, le cache ajoute du travail et une consommation de mémoire inutiles.


40. Comparer les plans avant et après une modification d’optimisation

Avant :

result.explain("formatted")

Après l’ajout d’un broadcast ou la modification des projections :

optimized_result.explain("formatted")

Mesurez ensuite une véritable action Spark.

Ne considérez pas une modification comme réussie parce que le code paraît plus propre.

Validez :

  • le plan physique
  • le temps d’exécution
  • le shuffle
  • la justesse du résultat

Interpréter le résultat

Type de jointure Conserve
inner uniquement les lignes avec correspondance
left toutes les lignes de gauche + les correspondances
right toutes les lignes de droite + les correspondances
full toutes les lignes des deux côtés
left_semi les lignes de gauche qui ont une correspondance
left_anti les lignes de gauche qui n’ont pas de correspondance
jointure croisée chaque ligne de gauche associée à chaque ligne de droite

Stratégies physiques courantes :

Stratégie Signification habituelle
BroadcastHashJoin un côté est envoyé aux executors ; le shuffle du côté volumineux peut être évité
SortMergeJoin les deux côtés sont redistribués/triés selon les clés de jointure
ShuffledHashJoin jointure par hachage après shuffle

La distinction la plus importante est la suivante :

la justesse logique de la jointure
passe avant
l’optimisation physique de la jointure

Points à vérifier

La jointure gauche augmente le nombre de lignes

Causes probables :

  • des clés en double à droite
  • une véritable relation un-à-plusieurs
  • une mauvaise clé de jointure

N’ajoutez pas dropDuplicates() après la jointure tant que la relation n’est pas comprise.

Les totaux augmentent après l’enrichissement

C’est un signe fort de multiplication des lignes.

Vérifiez l’unicité des clés et la granularité.

De nombreuses lignes restent sans correspondance

Vérifiez :

  • le dtype
  • les espaces
  • la casse
  • les zéros non significatifs
  • les lignes de référence manquantes
  • l’exhaustivité des clés composites

Une tâche Spark dure bien plus longtemps que les autres

Vérifiez le skew des clés.

Une seule clé dominante peut déterminer la durée totale de la jointure.

Le plan utilise une jointure sort-merge pour une très petite table de référence

Vérifiez si le broadcast est approprié et si Spark reconnaît le petit côté.

Ne forcez pas le broadcast avant d’avoir vérifié la taille réelle.

La jointure broadcast provoque des problèmes de mémoire

Le côté diffusé n’est peut-être pas assez petit en octets.

Supprimez l’indication ou réduisez davantage la dimension.

La jointure génère un shuffle énorme malgré un petit résultat

Filtrez et projetez plus tôt.

La taille du résultat ne reflète pas la quantité de données que Spark a dû déplacer.

Notes de production

La granularité du résultat doit être documentée

Pour chaque jointure importante, notez :

granularité de gauche
granularité de droite
granularité attendue en sortie

Cela permet de détecter plus de bogues que les paramètres d’optimisation.

Le nombre de lignes ne suffit pas

Une jointure peut conserver le même nombre de lignes et pourtant rattacher la mauvaise ligne de référence.

Validez également :

  • les clés métier
  • le nombre de lignes sans correspondance
  • les totaux importants
  • un échantillon de clés
  • la logique de dates d’effet

Les décisions de broadcast doivent tenir compte des octets, pas seulement des lignes

Une table de référence avec peu de lignes mais des données très larges peut tout de même être coûteuse à diffuser.

Ne projetez que les colonnes nécessaires avant le broadcast.

Adaptive Query Execution peut modifier le comportement des jointures

Spark peut ajuster les plans à l’exécution en fonction des statistiques collectées et de la configuration.

Inspectez le comportement physique réellement exécuté plutôt que de supposer que la forme logique initiale raconte toute l’histoire.

Les clés nulles méritent un traitement explicite

Pour les jointures d’égalité normales, null n’est pas égal à null.

Ne remplacez pas les nulls à la légère par une seule valeur sentinelle, car cela peut créer à la fois des erreurs sémantiques et du skew.

Une relation plusieurs-à-plusieurs n’est pas fautive en soi

Certaines charges de travail exigent légitimement des jointures plusieurs-à-plusieurs.

Le problème survient lorsque la relation était censée être un-à-un ou plusieurs-à-un.

L’optimisation des jointures dépend de la distribution des données

Il n’existe pas de meilleure stratégie de jointure universelle.

Mesurez avec des données représentatives.

Erreurs fréquentes

1. Joindre avant de vérifier l’unicité des clés

C’est le chemin le plus rapide vers une multiplication accidentelle des lignes.

2. Utiliser dropDuplicates() après une mauvaise jointure

Cela masque le problème de cardinalité et peut supprimer des lignes valides.

3. Faire un broadcast sans vérifier la taille

Le broadcast n’est pas automatiquement meilleur.

4. Collecter les clés de référence vers Python

Utilisez plutôt des semi-jointures ou des anti-jointures.

5. Joindre des DataFrames larges

Ne projetez que les colonnes nécessaires avant le shuffle.

6. Ignorer la sémantique des nulls dans les jointures

Les nulls ne se correspondent pas avec l’égalité normale.

7. Remplacer les clés nulles par une seule valeur sentinelle

Cela peut créer une énorme clé chaude.

8. Valider la justesse uniquement par le nombre de lignes

Validez aussi la granularité et les totaux métier.

9. Supposer que l’optimiseur a choisi le meilleur plan dans tous les cas

Il s’en sort généralement bien, mais le skew, des statistiques obsolètes, une forme de données inhabituelle ou des indications peuvent changer le résultat.

Inspectez le plan lorsque les performances comptent.

10. Repartitionner aveuglément avant chaque jointure

Un repartitionnement est lui-même un shuffle.

Ne payez ce coût que lorsque le bénéfice est clair.

Étape suivante

Utilisez le symptôme pour choisir l’action suivante.

  • Le nombre de lignes de la jointure gauche a augmenté → vérifiez les clés en double du côté droit.
  • Beaucoup de lignes sans correspondance → comparez les types des clés, leur formatage et l’exhaustivité des clés composites.
  • Totaux gonflés → inspectez l’expansion plusieurs-à-plusieurs.
  • Une tâche domine le temps d’exécution → analysez le skew des clés de jointure.
  • La table de référence est petite → testez le broadcast et vérifiez le plan.
  • Le shuffle est volumineux → filtrez/projetez les deux côtés plus tôt.
  • Les clés nulles se comportent de manière inattendue → définissez explicitement la sémantique des nulls.
  • La granularité du résultat a changé → corrigez la logique de la relation avant d’optimiser les performances.
  • La jointure reste lente une fois sa justesse prouvée → passez à PySpark : référence rapide des performances et inspectez les étapes Spark et le shuffle.

← Tous les aide-mémoire