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