Parcourir les aide-mémoire · PySpark
GroupBy et agrégations avec PySpark
Agrégez des DataFrames PySpark en toute sécurité en définissant la granularité de sortie, en traitant les clés de regroupement nulles, en choisissant les bonnes fonctions d’agrégation, en validant les totaux et en maîtrisant les charges de travail groupBy gourmandes en shuffle.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Regrouper sur une colonne
- 2. Regrouper sur plusieurs colonnes
- 3. Compter les lignes avec count("*")
- 4. Compter les valeurs non nulles d’une colonne
- 5. Compter les clés métier distinctes
- 6. Additionner des valeurs numériques
- 7. Calculer une moyenne
- 8. Calculer plusieurs agrégats en une seule passe
- 9. Obtenir les horodatages minimum et maximum
- 10. Conserver les clés de regroupement nulles
- 11. Filtrer les clés de regroupement non valides avant l’agrégation
- 12. Mesurer séparément les clés de regroupement nulles
- 13. Regrouper sur une colonne de date
- 14. Dériver le jour à partir d’un horodatage
- 15. Agréger par mois
- 16. Agrégation conditionnelle
- 17. Somme conditionnelle
- 18. Calculer un ratio à partir de composantes agrégées
- 19. Calculer une moyenne pondérée
- 20. Agréger des booléens ou des indicateurs
- 21. Collecter des valeurs dans un tableau
- 22. N’utiliser collect_list() que lorsque les doublons comptent
- 23. Ne pas supposer que collect_list() préserve l’ordre
- 24. Agréger dans un struct
- 25. Utiliser first() et last() avec prudence
- 26. Obtenir la valeur la plus récente avec max_by lorsqu’il est disponible
- 27. Obtenir la ligne associée à l’horodatage le plus récent
- 28. Utiliser rollup() pour des totaux hiérarchiques
- 29. Utiliser cube() pour toutes les combinaisons de regroupement
- 30. Utiliser grouping_id() avec les rollups et les cubes
- 31. N’utiliser pivot() qu’avec des catégories bornées
- 32. Éviter de faire un pivot sur des identifiants de client ou de transaction
- 33. Rapprocher les totaux agrégés de la source
- 34. Valider l’unicité du résultat à la granularité prévue
- 35. Vérifier la duplication des données d’entrée avant de sommer
- 36. Filtrer et projeter avant l’agrégation
- 37. Inspecter le plan physique
- 38. Vérifier le skew des clés de regroupement
- 39. Ne pas remplacer toutes les clés nulles par une seule valeur sentinelle avant le regroupement
- 40. Éviter l’agrégation par UDF Python lorsque les fonctions intégrées suffisent
- Interpréter le résultat
- Points à vérifier
- Le chiffre d’affaires est trop élevé
- Le nombre de lignes baisse plus que prévu
- Le comptage distinct diffère fortement du nombre de lignes
- Une étape prend beaucoup plus de temps que prévu
- collect_list() provoque une pression mémoire
- La moyenne semble fausse
- Notes de production
- GroupBy est généralement une opération gourmande en shuffle
- Les agrégats intégrés peuvent utiliser l’agrégation partielle
- La cardinalité des clés de regroupement influe sur la taille du résultat
- Le skew compte davantage que la taille moyenne des groupes
- Les types décimaux sont préférables pour des totaux financiers exacts
- L’agrégation distincte peut être coûteuse
- N’utilisez pas l’agrégation pour masquer une mauvaise granularité
- Erreurs fréquentes
- 1. Regrouper avant de définir la granularité de sortie
- 2. Utiliser count(col) alors que le nombre de lignes est requis
- 3. Utiliser une moyenne simple alors qu’une moyenne pondérée est requise
- 4. Supposer que first() signifie le plus ancien
- 5. Utiliser max() sur plusieurs colonnes pour reconstituer la ligne la plus récente
- 6. Faire un pivot sur des champs à forte cardinalité
- 7. Utiliser collect_list() sur des groupes non bornés
- 8. Ignorer les clés de regroupement nulles
- 9. Incriminer les performances du groupBy avant de vérifier le skew
- 10. Exécuter de nombreuses agrégations distinctes sur les mêmes données d’entrée
- Étape suivante
- Pour aller plus loin
Problème
Vous devez résumer un DataFrame PySpark par client, commerçant, date, région ou selon une autre granularité métier.
La syntaxe est simple, mais les erreurs en production proviennent souvent :
- d’une agrégation à la mauvaise granularité
- d’un double comptage après une jointure
- de la perte des clés de regroupement nulles
- d’une confusion entre nombre de lignes et nombre de valeurs non nulles
- d’une moyenne simple sur des valeurs qui devraient être pondérées
- de l’utilisation de
collect_list()sur des groupes non bornés - d’une agrégation personnalisée coûteuse en Python
- d’un shuffle ou d’un skew extrême
- d’un regroupement sur des clés à forte cardinalité sans en mesurer le coût
L’objectif est de rendre la logique d’agrégation explicite, correcte et capable de monter en charge.
Réponse rapide
Définissez d’abord la granularité de sortie.
Exemple :
Granularité de sortie :
une ligne par merchant_id + sale_date
Puis agrégez :
from pyspark.sql import functions as F
summary = (
sales
.groupBy(
"merchant_id",
"sale_date",
)
.agg(
F.count("*").alias("row_count"),
F.countDistinct("sale_id").alias("sale_count"),
F.sum("amount").alias("revenue"),
F.avg("amount").alias("avg_sale_amount"),
)
)
Avant de vous fier au résultat, vérifiez :
Le nombre de lignes a-t-il changé comme prévu ?
Les totaux concordent-ils ?
Des lignes source en double gonflent-elles les indicateurs ?
Les clés de regroupement nulles sont-elles conservées ou supprimées de façon délibérée ?
La justesse de l’agrégation passe avant l’optimisation de Spark.
Code / commandes
1. Regrouper sur une colonne
summary = (
df
.groupBy("merchant_id")
.count()
)
Cela renvoie une ligne par valeur distincte de merchant_id.
Utilisez count() lorsque vous avez besoin du nombre de lignes par groupe.
2. Regrouper sur plusieurs colonnes
summary = (
df
.groupBy(
"merchant_id",
"sale_date",
)
.agg(
F.sum("amount").alias("revenue")
)
)
Les colonnes de regroupement définissent la granularité de sortie.
Documentez-les.
3. Compter les lignes avec count("*")
summary = (
df
.groupBy("merchant_id")
.agg(
F.count("*").alias("row_count")
)
)
Cela compte les lignes, que les colonnes individuelles contiennent des valeurs nulles ou non.
Utilisez-le lorsque la question est :
Combien d’enregistrements chaque groupe contient-il ?
4. Compter les valeurs non nulles d’une colonne
summary = (
df
.groupBy("merchant_id")
.agg(
F.count("sale_id").alias("non_null_sale_id_count")
)
)
Cela ne compte que les valeurs non nulles de sale_id.
Ne le confondez pas avec le nombre de lignes.
5. Compter les clés métier distinctes
summary = (
df
.groupBy("merchant_id")
.agg(
F.countDistinct("sale_id").alias("distinct_sales")
)
)
Utilisez-le lorsque les lignes source peuvent contenir plusieurs enregistrements par vente.
Cela permet de distinguer :
le nombre de lignes physiques
de :
le nombre d’événements métier
6. Additionner des valeurs numériques
summary = (
df
.groupBy("merchant_id")
.agg(
F.sum("amount").alias("revenue")
)
)
Les valeurs nulles sont ignorées par sum().
Si toutes les valeurs d’un groupe sont nulles, le résultat de la somme peut être null.
Ne remplacez pas automatiquement null par zéro, sauf si cela correspond à la règle métier.
7. Calculer une moyenne
summary = (
df
.groupBy("merchant_id")
.agg(
F.avg("amount").alias("avg_amount")
)
)
Les valeurs nulles sont ignorées.
Demandez-vous si une moyenne simple est le bon indicateur métier.
8. Calculer plusieurs agrégats en une seule passe
summary = (
df
.groupBy("merchant_id")
.agg(
F.count("*").alias("row_count"),
F.countDistinct("sale_id").alias("sale_count"),
F.sum("amount").alias("revenue"),
F.avg("amount").alias("avg_amount"),
F.min("amount").alias("min_amount"),
F.max("amount").alias("max_amount"),
)
)
C’est généralement préférable à l’exécution de plusieurs jobs groupBy distincts sur les mêmes données d’entrée.
9. Obtenir les horodatages minimum et maximum
summary = (
df
.groupBy("merchant_id")
.agg(
F.min("event_time").alias("first_event_time"),
F.max("event_time").alias("last_event_time"),
)
)
Vous obtenez ainsi les valeurs d’horodatage la plus ancienne et la plus récente.
Cela ne renvoie pas la ligne complète associée à ces horodatages.
Utilisez une fenêtre lorsque vous avez besoin de la ligne la plus récente elle-même.
10. Conserver les clés de regroupement nulles
Spark regroupe les valeurs nulles ensemble.
Exemple :
summary = (
df
.groupBy("country")
.count()
)
Les lignes dont country est null forment leur propre groupe.
Ce comportement diffère de certains comportements par défaut de pandas.
Si les clés de regroupement nulles ne sont pas valides, filtrez-les ou mettez-les en quarantaine explicitement.
11. Filtrer les clés de regroupement non valides avant l’agrégation
valid = df.filter(
F.col("merchant_id").isNotNull()
)
summary = (
valid
.groupBy("merchant_id")
.agg(
F.sum("amount").alias("revenue")
)
)
N’utilisez cette approche que lorsque les clés nulles sont réellement non valides.
Ne les supprimez pas silencieusement sans en mesurer l’impact.
12. Mesurer séparément les clés de regroupement nulles
null_key_count = (
df
.filter(
F.col("merchant_id").isNull()
)
.count()
)
print(
"Rows with null merchant_id:",
null_key_count,
)
Pour les charges de travail de production volumineuses, combinez si possible cette mesure avec d’autres indicateurs dans une seule agrégation.
13. Regrouper sur une colonne de date
daily = (
df
.groupBy("sale_date")
.agg(
F.sum("amount").alias("revenue")
)
)
Assurez-vous que sale_date est bien une date et non un texte arbitraire.
14. Dériver le jour à partir d’un horodatage
daily = (
df
.withColumn(
"sale_date",
F.to_date("sale_time"),
)
.groupBy("sale_date")
.agg(
F.sum("amount").alias("revenue")
)
)
Faites attention à la sémantique des fuseaux horaires.
Si sale_time est en UTC mais que le reporting repose sur l’heure locale, convertissez-le dans le fuseau horaire métier avant de dériver la date.
15. Agréger par mois
monthly = (
df
.withColumn(
"sale_month",
F.date_trunc(
"month",
F.col("sale_time"),
),
)
.groupBy("sale_month")
.agg(
F.sum("amount").alias("revenue")
)
)
Cela conserve une limite de mois de type timestamp.
Utilisez une clé de date dédiée si votre modèle exige une sémantique de date seule.
16. Agrégation conditionnelle
Compter les lignes en succès :
summary = (
df
.groupBy("merchant_id")
.agg(
F.sum(
F.when(
F.col("status") == "success",
1,
).otherwise(0)
).alias("success_count")
)
)
C’est souvent plus clair et plus efficace que de créer de nombreux DataFrames filtrés et de les agréger chacun séparément.
17. Somme conditionnelle
summary = (
df
.groupBy("merchant_id")
.agg(
F.sum(
F.when(
F.col("status") == "approved",
F.col("amount"),
).otherwise(F.lit(0))
).alias("approved_amount")
)
)
N’utilisez zéro que si les lignes exclues doivent contribuer pour zéro à l’indicateur.
Si la sémantique des valeurs nulles compte, encodez-la délibérément.
18. Calculer un ratio à partir de composantes agrégées
summary = (
df
.groupBy("merchant_id")
.agg(
F.count("*").alias("total_rows"),
F.sum(
F.when(
F.col("status") == "success",
1,
).otherwise(0)
).alias("success_rows"),
)
.withColumn(
"success_rate",
F.when(
F.col("total_rows") > 0,
F.col("success_rows")
/ F.col("total_rows"),
),
)
)
Construisez le ratio à partir d’un numérateur et d’un dénominateur explicites.
Ne faites pas la moyenne de pourcentages calculés ligne par ligne, sauf si c’est mathématiquement correct.
19. Calculer une moyenne pondérée
Supposons que :
price × quantity
doive être pondéré par la quantité.
summary = (
df
.groupBy("product_id")
.agg(
F.sum(
F.col("price")
* F.col("quantity")
).alias("weighted_value"),
F.sum("quantity").alias("total_quantity"),
)
.withColumn(
"weighted_avg_price",
F.when(
F.col("total_quantity") != 0,
F.col("weighted_value")
/ F.col("total_quantity"),
),
)
)
N’utilisez pas avg(price) lorsque chaque ligne représente un poids différent.
20. Agréger des booléens ou des indicateurs
Exemple :
summary = (
df
.groupBy("customer_id")
.agg(
F.max(
F.col("is_high_risk").cast("int")
).alias("has_high_risk")
)
)
Si une ligne au moins est vraie, le résultat devient 1.
Explicitez ensuite le type de sortie et sa signification métier si nécessaire.
21. Collecter des valeurs dans un tableau
summary = (
df
.groupBy("merchant_id")
.agg(
F.collect_set("country").alias("countries")
)
)
Utilisez collect_set() lorsque les valeurs uniques par groupe sont utiles.
Faites attention aux groupes non bornés.
Un seul groupe volumineux peut créer un très grand tableau en mémoire.
22. N’utiliser collect_list() que lorsque les doublons comptent
summary = (
df
.groupBy("customer_id")
.agg(
F.collect_list("event_type").alias("events")
)
)
Cela conserve les doublons, mais ne garantit pas un ordre d’événements significatif, sauf si vous modélisez explicitement l’ordre.
N’utilisez pas collect_list() pour construire d’énormes tableaux pour des groupes à fort volume.
23. Ne pas supposer que collect_list() préserve l’ordre
Si l’ordre compte, utilisez un modèle structuré.
Exemple :
events = (
df
.groupBy("customer_id")
.agg(
F.sort_array(
F.collect_list(
F.struct(
"event_time",
"event_type",
)
)
).alias("events")
)
)
Cela trie les structs collectés selon leurs champs.
Explicitez la sémantique croissante ou décroissante exigée par la règle métier.
24. Agréger dans un struct
summary = (
df
.groupBy("merchant_id")
.agg(
F.struct(
F.sum("amount").alias("revenue"),
F.countDistinct("sale_id").alias("sales"),
).alias("metrics")
)
)
N’utilisez des sorties imbriquées que lorsque le consommateur en aval tire profit d’un struct.
Les tables analytiques plates sont souvent plus faciles à interroger.
25. Utiliser first() et last() avec prudence
summary = (
df
.groupBy("customer_id")
.agg(
F.first(
"status",
ignorenulls=True,
).alias("some_status")
)
)
Sans stratégie d’ordonnancement explicite, first() ne signifie pas :
le plus ancien par horodatage
et last() ne signifie pas :
le plus récent par horodatage
Utilisez une fenêtre ou un modèle d’agrégat ordonné lorsque l’ordre temporel compte.
26. Obtenir la valeur la plus récente avec max_by lorsqu’il est disponible
Dans les versions de Spark qui le prennent en charge :
summary = (
df
.groupBy("customer_id")
.agg(
F.max_by(
F.col("status"),
F.col("event_time"),
).alias("latest_status")
)
)
Cela renvoie la valeur associée au maximum de l’expression d’ordonnancement.
Utilisez une fenêtre lorsque vous avez besoin de plusieurs colonnes de la même ligne la plus récente ou d’un départage complexe des ex æquo.
27. Obtenir la ligne associée à l’horodatage le plus récent
Utilisez une fenêtre :
from pyspark.sql import Window
w = (
Window
.partitionBy("customer_id")
.orderBy(
F.col("event_time").desc(),
F.col("event_id").desc(),
)
)
latest = (
df
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(F.col("_rn") == 1)
.drop("_rn")
)
N’utilisez pas des appels max() indépendants sur plusieurs colonnes pour reconstituer une ligne.
28. Utiliser rollup() pour des totaux hiérarchiques
summary = (
df
.rollup(
"region",
"merchant_id",
)
.agg(
F.sum("amount").alias("revenue")
)
)
Cela peut produire :
total par région + commerçant
sous-total par région
total général
Les valeurs nulles dans les colonnes de regroupement peuvent représenter des lignes de sous-total.
Utilisez grouping() / grouping_id() lorsque vous devez distinguer les véritables valeurs nulles des marqueurs de sous-total.
29. Utiliser cube() pour toutes les combinaisons de regroupement
summary = (
df
.cube(
"region",
"channel",
)
.agg(
F.sum("amount").alias("revenue")
)
)
cube() peut produire de nombreuses combinaisons d’agrégation.
Utilisez-le avec prudence, car la taille du résultat augmente avec le nombre de dimensions de regroupement.
30. Utiliser grouping_id() avec les rollups et les cubes
summary = (
df
.rollup(
"region",
"merchant_id",
)
.agg(
F.sum("amount").alias("revenue"),
F.grouping_id().alias("grouping_id"),
)
)
Cela aide à distinguer :
une véritable valeur de dimension nulle
de :
une ligne de sous-total ou de total général
31. N’utiliser pivot() qu’avec des catégories bornées
pivoted = (
df
.groupBy("merchant_id")
.pivot(
"status",
[
"approved",
"declined",
"pending",
],
)
.agg(
F.count("*")
)
)
Fournir les valeurs de pivot attendues évite à Spark de devoir d’abord découvrir chaque catégorie distincte.
Ne faites pas de pivot sur des champs non bornés ou à forte cardinalité.
32. Éviter de faire un pivot sur des identifiants de client ou de transaction
À éviter :
df.groupBy("merchant_id").pivot("customer_id")
Cela peut créer un nombre énorme de colonnes.
Ne faites de pivot que sur de petits ensembles de catégories maîtrisés.
33. Rapprocher les totaux agrégés de la source
Avant :
source_total = (
df
.agg(
F.sum("amount").alias("amount")
)
.first()["amount"]
)
Après :
summary_total = (
summary
.agg(
F.sum("revenue").alias("amount")
)
.first()["amount"]
)
Comparez ensuite.
Si la transformation ne fait que changer la granularité, les totaux doivent concorder, sauf si la logique métier exclut ou modifie intentionnellement des lignes.
34. Valider l’unicité du résultat à la granularité prévue
Pour :
merchant_id + sale_date
vérifiez :
duplicates = (
summary
.groupBy(
"merchant_id",
"sale_date",
)
.count()
.filter(F.col("count") > 1)
)
if duplicates.limit(1).count() > 0:
raise RuntimeError(
"Aggregation output grain is not unique"
)
Un groupBy() correct devrait naturellement produire des combinaisons de regroupement uniques.
Si des doublons apparaissent plus tard, une jointure en aval a peut-être modifié la granularité.
35. Vérifier la duplication des données d’entrée avant de sommer
(
df
.groupBy("sale_id")
.count()
.filter(F.col("count") > 1)
.show(50, truncate=False)
)
Si une vente qui devrait apparaître une seule fois apparaît plusieurs fois, l’agrégation peut masquer la duplication sous-jacente tout en gonflant les totaux.
Corrigez la granularité en amont lorsque c’est pertinent.
36. Filtrer et projeter avant l’agrégation
Préférez :
small = (
df
.filter(
F.col("sale_date") >= "2026-10-01"
)
.select(
"merchant_id",
"sale_date",
"sale_id",
"amount",
)
)
summary = (
small
.groupBy(
"merchant_id",
"sale_date",
)
.agg(
F.sum("amount").alias("revenue")
)
)
N’emportez pas dans le shuffle de grandes colonnes de données inutilisées.
37. Inspecter le plan physique
summary.explain("formatted")
Recherchez :
Exchange- l’agrégation par hachage (hash aggregation)
- l’agrégation par tri (sort aggregation)
- l’agrégation partielle
- le repartitionnement
Le regroupement nécessite normalement un shuffle, sauf si les données sont déjà partitionnées de manière utile.
38. Vérifier le skew des clés de regroupement
(
df
.groupBy("merchant_id")
.count()
.orderBy(
F.desc("count")
)
.show(
50,
truncate=False,
)
)
Un petit nombre de groupes énormes peut créer des tâches retardataires.
Causes fréquentes :
- un tenant ou client dominant
- une clé nulle ou sentinelle
- des données malformées
- une distribution métier très inégale
39. Ne pas remplacer toutes les clés nulles par une seule valeur sentinelle avant le regroupement
Risqué :
df = df.fillna(
{
"merchant_id": 0
}
)
Cela peut fusionner de nombreuses lignes sans rapport en un seul groupe gigantesque.
N’utilisez une valeur sentinelle que lorsqu’elle a une véritable signification métier.
40. Éviter l’agrégation par UDF Python lorsque les fonctions intégrées suffisent
Préférez :
F.sum("amount")
F.avg("amount")
F.max("event_time")
F.countDistinct("sale_id")
à une logique d’agrégation Python personnalisée.
Les fonctions Spark intégrées restent dans le moteur d’exécution optimisé de Spark.
N’utilisez des pandas UDF ou une agrégation personnalisée que lorsque la logique métier ne peut pas être exprimée avec les fonctions intégrées.
Interpréter le résultat
| Fonction | Signification |
|---|---|
count("*") |
Nombre de lignes du groupe |
count("col") |
Nombre de valeurs non nulles dans col |
countDistinct() |
Valeurs distinctes non nulles |
sum() |
Somme des valeurs non nulles |
avg() |
Moyenne des valeurs non nulles |
min() / max() |
Valeur minimale/maximale |
collect_set() |
Valeurs uniques collectées dans un tableau |
collect_list() |
Valeurs collectées dans un tableau, doublons conservés |
rollup() |
Sous-totaux hiérarchiques + total général |
cube() |
Toutes les combinaisons des dimensions de regroupement |
pivot() |
Convertit des valeurs de catégorie en colonnes |
grouping_id() |
Identifie le niveau de regroupement sous-total/total général |
Le concept le plus important est le suivant :
colonnes du groupBy = granularité de sortie
Si la granularité est mauvaise, chaque indicateur construit dessus peut être faux.
Points à vérifier
Le chiffre d’affaires est trop élevé
Vérifiez :
- les clés source en double
- la multiplication des lignes due à des jointures antérieures
- une mauvaise granularité de regroupement
- des fichiers d’entrée en double
- des lots rejoués
L’agrégation peut masquer des lignes en double tout en gonflant les totaux.
Le nombre de lignes baisse plus que prévu
C’est normal lorsqu’on regroupe de nombreuses lignes en moins de groupes, mais vérifiez :
- la granularité prévue
- le traitement des clés nulles
- les filtres appliqués avant l’agrégation
Le comptage distinct diffère fortement du nombre de lignes
Cela peut indiquer :
- plusieurs lignes physiques par événement métier
- des doublons
- une granularité légitime au niveau des lignes de détail
- des enregistrements de statut ou d’historique répétés
Comprenez la granularité de la source avant de conclure qu’elle est erronée.
Une étape prend beaucoup plus de temps que prévu
Vérifiez le skew des clés de regroupement et le volume du shuffle.
Une clé chaude peut dominer le temps d’agrégation.
collect_list() provoque une pression mémoire
Un ou plusieurs groupes accumulent peut-être de très grands tableaux.
Utilisez un autre modèle de données si la cardinalité des groupes n’est pas bornée.
La moyenne semble fausse
Vérifiez si :
- les valeurs nulles sont exclues
- une pondération est nécessaire
- les données d’entrée ont été dupliquées
- l’unité ou la granularité est correcte
Notes de production
GroupBy est généralement une opération gourmande en shuffle
Spark doit souvent redistribuer les lignes selon la clé de regroupement.
Réduisez les lignes et les colonnes avant l’agrégation lorsque la logique métier le permet.
Les agrégats intégrés peuvent utiliser l’agrégation partielle
Spark peut souvent agréger localement avant le shuffle, puis combiner les résultats.
C’est l’une des raisons pour lesquelles les fonctions d’agrégation intégrées sont préférables à une logique Python personnalisée.
La cardinalité des clés de regroupement influe sur la taille du résultat
Regrouper par :
merchant_id + date
peut produire des millions de groupes.
Regrouper par :
country
peut n’en produire que quelques dizaines.
Une forte cardinalité n’est pas fautive en soi, mais elle modifie le comportement du shuffle et de la mémoire.
Le skew compte davantage que la taille moyenne des groupes
Une charge de travail peut sembler équilibrée en moyenne alors qu’un seul groupe contient un pourcentage énorme des lignes.
Inspectez les plus gros groupes lorsque des étapes présentent des tâches retardataires.
Les types décimaux sont préférables pour des totaux financiers exacts
Utilisez une précision/échelle DecimalType adaptée pour les valeurs de type monétaire lorsque l’arithmétique exacte compte.
Évitez d’introduire inutilement des erreurs de virgule flottante dans les rapprochements financiers.
L’agrégation distincte peut être coûteuse
countDistinct() et les opérations distinctes similaires peuvent nécessiter un shuffle ou un état importants.
Ne les utilisez que lorsque l’indicateur métier exige réellement une sémantique distincte.
N’utilisez pas l’agrégation pour masquer une mauvaise granularité
Si une jointure a doublé chaque vente et que vous regroupez ensuite pour revenir à une ligne par vente, le résultat peut rester faux.
Corrigez la relation en amont.
Erreurs fréquentes
1. Regrouper avant de définir la granularité de sortie
Les colonnes de regroupement constituent le contrat métier du résultat.
Définissez-les en premier.
2. Utiliser count(col) alors que le nombre de lignes est requis
count(col) ignore les valeurs nulles.
Utilisez count("*") pour compter les lignes.
3. Utiliser une moyenne simple alors qu’une moyenne pondérée est requise
Cela produit des indicateurs métier mathématiquement faux.
4. Supposer que first() signifie le plus ancien
Sans ordonnancement, ce n’est pas le cas.
Utilisez une fenêtre ou un agrégat ordonné.
5. Utiliser max() sur plusieurs colonnes pour reconstituer la ligne la plus récente
Chaque maximum peut provenir d’une ligne source différente.
Sélectionnez la ligne réelle.
6. Faire un pivot sur des champs à forte cardinalité
Cela peut créer un nombre de colonnes ingérable.
7. Utiliser collect_list() sur des groupes non bornés
Un seul groupe peut devenir trop volumineux pour la mémoire.
8. Ignorer les clés de regroupement nulles
Spark regroupe les valeurs nulles ensemble.
Décidez si ce groupe est valide.
9. Incriminer les performances du groupBy avant de vérifier le skew
Une seule clé chaude peut dicter toute l’étape.
10. Exécuter de nombreuses agrégations distinctes sur les mêmes données d’entrée
Combinez les agrégats liés dans un seul agg() lorsque c’est possible.
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.