Parcourir les aide-mémoire · PySpark
Fonctions de fenêtre dans PySpark
Utilisez les fonctions de fenêtre PySpark en toute sécurité pour le classement, la sélection de la ligne la plus récente, les totaux cumulés, l’analyse lag/lead et les calculs partitionnés, sans réduire la granularité du DataFrame.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. Importer Window et les fonctions Spark
- 2. Attribuer un numéro de ligne au sein de chaque groupe
- 3. Reproduire ROW_NUMBER() de SQL
- 4. Conserver la ligne la plus récente par clé métier
- 5. Conserver les N premières lignes par groupe
- 6. Utiliser rank() lorsque les ex aequo partagent le même rang
- 7. Utiliser dense_rank() lorsque les ex aequo ne doivent pas créer de trous
- 8. Comparer row_number, rank et dense_rank
- 9. Obtenir la valeur de la ligne précédente avec lag()
- 10. Obtenir la valeur de la ligne suivante avec lead()
- 11. Calculer le temps écoulé depuis l’événement précédent
- 12. Détecter les changements de valeur
- 13. Construire un total cumulé
- 14. Construire un comptage cumulé
- 15. Construire un maximum cumulé
- 16. Utiliser une fenêtre glissante basée sur un nombre de lignes
- 17. Utiliser rangeBetween() pour des cadres basés sur les valeurs
- 18. Comprendre rowsBetween() et rangeBetween()
- 19. Calculer le total de la partition sans réduire les lignes
- 20. Calculer le pourcentage du total du groupe
- 21. Calculer la moyenne de la partition
- 22. Comparer la valeur d’une ligne à la moyenne du groupe
- 23. Utiliser first_value() avec une fenêtre triée
- 24. Utiliser last_value() avec un cadre explicite couvrant toute la partition
- 25. Obtenir la première valeur non nulle
- 26. Utiliser nth_value() lorsque c’est pris en charge et approprié
- 27. Utiliser cume_dist() pour la distribution cumulée
- 28. Utiliser percent_rank() pour un classement relatif
- 29. Utiliser ntile() pour répartir les lignes en groupes
- 30. Construire des plages de dates d’effet avec lead()
- 31. Créer des limites de session à partir des écarts entre événements
- 32. Attribuer des identifiants de session avec une somme cumulée
- 33. Dédoublonner avec row_number() avant un MERGE
- 34. Éviter les fenêtres globales sauf si elles sont réellement nécessaires
- 35. Aligner les partitions sur l’entité métier
- 36. Vérifier le skew des partitions avant de grandes fenêtres
- 37. Ne pas remplacer à la légère les clés de partition nulles par une seule valeur sentinelle globale
- 38. Réutiliser la même spécification de fenêtre
- 39. Inspecter le plan physique
- 40. Filtrer avant une grande fenêtre lorsque c’est sûr
- Interpréter le résultat
- Points à vérifier
- La ligne la plus récente change d’une exécution à l’autre
- last_value() est égal à la ligne courante de manière inattendue
- Le total cumulé fait des sauts inattendus
- L’étape de fenêtre comporte une tâche très lente
- La fenêtre provoque un tri/shuffle massif
- La métrique glissante « sur 7 jours » est fausse
- Notes de production
- Les fonctions de fenêtre impliquent généralement des tris coûteux
- Un tri déterministe est important
- Les partitions de fenêtre peuvent devenir gourmandes en mémoire
- Filtrer avant une fenêtre peut changer la sémantique
- rangeBetween() exige une sémantique de tri rigoureuse
- Utiliser les fonctions de fenêtre intégrées avant une logique Python personnalisée
- Erreurs fréquentes
- 1. Utiliser row_number() sans tri complet
- 2. Utiliser rank() lorsqu’il faut exactement N lignes
- 3. Utiliser row_number() lorsque tous les ex aequo doivent être conservés
- 4. Considérer que first() / last() tiennent automatiquement compte du temps
- 5. Confondre rowsBetween() avec des plages de temps
- 6. Utiliser inutilement une fenêtre triée globale
- 7. Ignorer le skew des partitions
- 8. Éliminer l’historique par filtrage avant de calculer une fenêtre sur toute la durée de vie
- 9. Remplacer toutes les clés nulles par une seule valeur sentinelle
- 10. Utiliser des fenêtres lorsque groupBy() suffit
- Étape suivante
- Pour aller plus loin
Problème
Vous devez calculer des valeurs sur des lignes liées entre elles sans réduire le DataFrame à une ligne par groupe.
Les cas d’usage courants en production sont notamment :
- conserver la ligne la plus récente par clé métier
- classer les produits au sein de chaque catégorie
- calculer des totaux cumulés
- comparer chaque ligne à l’événement précédent ou suivant
- calculer l’écart de temps entre des événements
- détecter les changements de statut
- calculer des métriques glissantes
- attribuer des numéros de ligne déterministes
- sélectionner les N premières lignes par groupe
Les principaux risques sont :
- un tri incomplet
- des ex aequo ambigus
- des partitions de fenêtre énormes
- des tris globaux inutiles
- une mauvaise sémantique de cadre (frame)
- le recours à
first()/last()sans comprendre le tri - un mélange incorrect de cadres basés sur les lignes et sur les plages de valeurs
L’objectif est de rendre explicites la partition, le tri et le cadre.
Réponse rapide
Pour la ligne la plus récente par client :
from pyspark.sql import Window
from pyspark.sql import functions as F
w = (
Window
.partitionBy("customer_id")
.orderBy(
F.col("event_time").desc(),
F.col("event_id").desc(),
)
)
latest = (
df
.withColumn(
"_row_number",
F.row_number().over(w),
)
.filter(
F.col("_row_number") == 1
)
.drop("_row_number")
)
Pour un total cumulé :
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.currentRow,
)
)
df = df.withColumn(
"running_amount",
F.sum("amount").over(w),
)
La règle clé est la suivante :
PARTITION BY
→ quelles lignes vont ensemble
ORDER BY
→ quelle ligne vient en premier
FRAME
→ quelles lignes triées participent au calcul
Code / commandes
1. Importer Window et les fonctions Spark
from pyspark.sql import Window
from pyspark.sql import functions as F
Utilisez Window pour définir le partitionnement, le tri et les cadres.
2. Attribuer un numéro de ligne au sein de chaque groupe
w = (
Window
.partitionBy("customer_id")
.orderBy(
F.col("event_time").asc()
)
)
df = df.withColumn(
"row_number",
F.row_number().over(w),
)
Chaque ligne reçoit ainsi un numéro de séquence unique au sein de sa partition.
Utilisez-le lorsque des ex aequo doivent tout de même recevoir des numéros de ligne différents.
3. Reproduire ROW_NUMBER() de SQL
w = (
Window
.partitionBy("merchant_id")
.orderBy(
F.col("revenue").desc(),
F.col("product_id").asc(),
)
)
ranked = df.withColumn(
"row_number",
F.row_number().over(w),
)
La deuxième colonne de tri permet de départager les ex aequo de manière déterministe.
Ne vous fiez pas à un ordre physique arbitraire des lignes.
4. Conserver la ligne la plus récente par clé métier
w = (
Window
.partitionBy("customer_id")
.orderBy(
F.col("updated_at").desc(),
F.col("source_sequence").desc(),
)
)
latest = (
df
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(F.col("_rn") == 1)
.drop("_rn")
)
C’est le modèle à privilégier lorsque le choix de la ligne conservée compte.
5. Conserver les N premières lignes par groupe
w = (
Window
.partitionBy("category")
.orderBy(
F.col("revenue").desc(),
F.col("product_id").asc(),
)
)
top_3 = (
df
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(
F.col("_rn") <= 3
)
.drop("_rn")
)
Cela conserve exactement N lignes au maximum par partition.
Si tous les ex aequo doivent être conservés, utilisez plutôt rank() ou dense_rank().
6. Utiliser rank() lorsque les ex aequo partagent le même rang
w = (
Window
.partitionBy("category")
.orderBy(
F.col("revenue").desc()
)
)
df = df.withColumn(
"rank",
F.rank().over(w),
)
Valeurs d’exemple :
100
100
90
80
produisent les rangs :
1
1
3
4
7. Utiliser dense_rank() lorsque les ex aequo ne doivent pas créer de trous
df = df.withColumn(
"dense_rank",
F.dense_rank().over(w),
)
Pour les mêmes valeurs :
100
100
90
80
les rangs denses sont :
1
1
2
3
Utilisez la méthode de classement qui correspond à la définition métier.
8. Comparer row_number, rank et dense_rank
Utilisez :
row_number
→ chaque ligne reçoit un numéro de séquence unique
rank
→ les ex aequo partagent le rang ; des trous subsistent
dense_rank
→ les ex aequo partagent le rang ; aucun trou
Ne remplacez pas l’une par l’autre sans vérifier la sémantique des ex aequo.
9. Obtenir la valeur de la ligne précédente avec lag()
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
df = df.withColumn(
"previous_status",
F.lag(
"status",
1,
).over(w),
)
Utilisez-la pour :
- les transitions de statut
- le montant précédent
- l’horodatage précédent
- la détection de changements
10. Obtenir la valeur de la ligne suivante avec lead()
df = df.withColumn(
"next_status",
F.lead(
"status",
1,
).over(w),
)
Utilisez-la pour :
- l’analyse de l’événement suivant
- les plages de dates d’effet
- les comparaisons avec l’état futur
11. Calculer le temps écoulé depuis l’événement précédent
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
df = (
df
.withColumn(
"previous_event_time",
F.lag("event_time").over(w),
)
.withColumn(
"seconds_since_previous",
F.col("event_time").cast("long")
- F.col("previous_event_time").cast("long"),
)
)
C’est utile pour :
- la sessionisation
- l’analyse des requêtes répétées
- la latence
- la détection d’écarts entre événements
Assurez-vous que le tri par horodatage est correct sur le plan sémantique.
12. Détecter les changements de valeur
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
df = (
df
.withColumn(
"previous_status",
F.lag("status").over(w),
)
.withColumn(
"status_changed",
F.when(
F.col("previous_status").isNull(),
F.lit(False),
).otherwise(
~F.col("status").eqNullSafe(
F.col("previous_status")
)
),
)
)
Utilisez eqNullSafe() lorsque la sémantique d’égalité des nulls compte.
13. Construire un total cumulé
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.currentRow,
)
)
df = df.withColumn(
"running_amount",
F.sum("amount").over(w),
)
Cela inclut toutes les lignes précédentes de la partition jusqu’à la ligne courante.
14. Construire un comptage cumulé
df = df.withColumn(
"running_count",
F.count("*").over(w),
)
Utile pour :
- la séquence d’événements
- l’activité cumulée
- les compteurs progressifs
15. Construire un maximum cumulé
df = df.withColumn(
"running_max_amount",
F.max("amount").over(w),
)
Cela donne la plus grande valeur observée jusqu’ici dans la partition triée.
16. Utiliser une fenêtre glissante basée sur un nombre de lignes
Ligne courante plus les six lignes précédentes :
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
-6,
0,
)
)
df = df.withColumn(
"rolling_7_row_avg",
F.avg("amount").over(w),
)
Cela signifie :
7 lignes
et non :
7 jours
Ne confondez pas les fenêtres basées sur les lignes avec les fenêtres basées sur le temps.
17. Utiliser rangeBetween() pour des cadres basés sur les valeurs
Supposons que la colonne de tri soit en secondes epoch :
df = df.withColumn(
"event_epoch",
F.col("event_time").cast("long"),
)
Une fenêtre glissante sur les 7 derniers jours :
seconds_7_days = 7 * 24 * 60 * 60
w = (
Window
.partitionBy("customer_id")
.orderBy("event_epoch")
.rangeBetween(
-seconds_7_days,
0,
)
)
df = df.withColumn(
"rolling_7_day_amount",
F.sum("amount").over(w),
)
Ce cadre est basé sur la valeur numérique de la colonne de tri, et non sur un nombre de lignes.
Utilisez-le avec prudence et documentez l’unité.
18. Comprendre rowsBetween() et rangeBetween()
Utilisez :
rowsBetween()
→ positions physiques relatives des lignes
rangeBetween()
→ valeurs relatives de l’expression ORDER BY
Exemple :
rowsBetween(-6, 0)
signifie sept lignes.
Exemple :
rangeBetween(-604800, 0)
sur des secondes epoch signifie les sept jours précédents.
Ils ne sont pas interchangeables.
19. Calculer le total de la partition sans réduire les lignes
w = (
Window
.partitionBy("merchant_id")
)
df = df.withColumn(
"merchant_total",
F.sum("amount").over(w),
)
Contrairement à groupBy(), cela conserve la granularité d’origine des lignes.
Utilisez-le lorsque chaque ligne a besoin à la fois :
- du détail au niveau de la ligne
- d’une métrique au niveau du groupe
20. Calculer le pourcentage du total du groupe
w = (
Window
.partitionBy("merchant_id")
)
df = (
df
.withColumn(
"merchant_total",
F.sum("amount").over(w),
)
.withColumn(
"pct_of_merchant",
F.when(
F.col("merchant_total") != 0,
F.col("amount")
/ F.col("merchant_total"),
),
)
)
Cela conserve chaque ligne source et ajoute sa part du total de la partition.
21. Calculer la moyenne de la partition
w = (
Window
.partitionBy("merchant_id")
)
df = df.withColumn(
"merchant_avg_amount",
F.avg("amount").over(w),
)
Là encore, la granularité d’origine des lignes reste intacte.
22. Comparer la valeur d’une ligne à la moyenne du groupe
df = (
df
.withColumn(
"merchant_avg_amount",
F.avg("amount").over(w),
)
.withColumn(
"above_merchant_avg",
F.col("amount")
> F.col("merchant_avg_amount"),
)
)
C’est utile pour des comparaisons au sein d’un groupe sans agrégation ni jointure séparées.
23. Utiliser first_value() avec une fenêtre triée
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.unboundedFollowing,
)
)
df = df.withColumn(
"first_status",
F.first_value("status").over(w),
)
Utilisez un cadre explicite lorsque vous voulez la valeur sur l’ensemble de la partition.
24. Utiliser last_value() avec un cadre explicite couvrant toute la partition
df = df.withColumn(
"last_status",
F.last_value("status").over(w),
)
Sans cadre approprié, last_value() peut renvoyer la valeur de la ligne courante au lieu de la dernière valeur de la partition.
C’est l’une des erreurs les plus courantes avec les fonctions de fenêtre.
25. Obtenir la première valeur non nulle
df = df.withColumn(
"first_non_null_status",
F.first(
"status",
ignorenulls=True,
).over(w),
)
Indiquez explicitement si les nulls doivent être ignorés.
26. Utiliser nth_value() lorsque c’est pris en charge et approprié
Exemple :
df = df.withColumn(
"second_status",
F.nth_value(
"status",
2,
).over(w),
)
Utilisez-la lorsqu’une position fixe dans l’ordre a une signification métier.
Si vous avez besoin d’une sélection au niveau des lignes, row_number() est souvent plus clair.
27. Utiliser cume_dist() pour la distribution cumulée
w = (
Window
.partitionBy("category")
.orderBy(
F.col("revenue").asc()
)
)
df = df.withColumn(
"cume_dist",
F.cume_dist().over(w),
)
Cela montre la position relative de chaque ligne au sein de la partition triée.
Utile pour l’analyse de distribution.
28. Utiliser percent_rank() pour un classement relatif
df = df.withColumn(
"percent_rank",
F.percent_rank().over(w),
)
Cela renvoie une valeur de 0 à 1 basée sur la position dans le classement.
Ne la confondez pas avec une valeur de percentile statistique.
29. Utiliser ntile() pour répartir les lignes en groupes
w = (
Window
.partitionBy("region")
.orderBy(
F.col("revenue").desc()
)
)
df = df.withColumn(
"quartile",
F.ntile(4).over(w),
)
Cela divise les lignes triées en groupes de taille approximativement égale.
Ne l’utilisez pas en remplacement de bornes de percentile exactes lorsque des seuils basés sur les valeurs comptent.
30. Construire des plages de dates d’effet avec lead()
w = (
Window
.partitionBy("customer_id")
.orderBy("effective_from")
)
history = df.withColumn(
"effective_to",
F.lead(
"effective_from"
).over(w),
)
C’est utile pour les enregistrements versionnés.
Décidez si effective_to est :
exclusive
ou :
inclusive
et appliquez cette convention de manière cohérente.
31. Créer des limites de session à partir des écarts entre événements
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
events = (
df
.withColumn(
"previous_event_time",
F.lag("event_time").over(w),
)
.withColumn(
"gap_seconds",
F.col("event_time").cast("long")
- F.col("previous_event_time").cast("long"),
)
)
Marquer une nouvelle session :
events = events.withColumn(
"new_session",
F.when(
F.col("previous_event_time").isNull()
| (F.col("gap_seconds") > 1800),
1,
).otherwise(0),
)
Le seuil de 1 800 secondes est un exemple.
Utilisez un seuil défini par la véritable règle métier ou de session.
32. Attribuer des identifiants de session avec une somme cumulée
session_window = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.currentRow,
)
)
events = events.withColumn(
"session_number",
F.sum("new_session").over(
session_window
),
)
Cela transforme les limites détectées en groupes de sessions séquentiels.
33. Dédoublonner avec row_number() avant un MERGE
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")
)
C’est un modèle solide pour préparer des entrées déterministes pour un MERGE Delta.
34. Éviter les fenêtres globales sauf si elles sont réellement nécessaires
Ceci :
w = Window.orderBy("event_time")
n’a pas de clé de partition.
Toutes les lignes appartiennent à une seule fenêtre logique.
Pour de grands DataFrames, cela peut imposer un tri global très coûteux.
N’utilisez des fenêtres globales que lorsque la question métier est réellement globale.
35. Aligner les partitions sur l’entité métier
Bon :
Window.partitionBy("customer_id")
pour l’historique des événements par client.
Potentiellement coûteux :
Window.partitionBy("country")
si un pays contient des centaines de millions de lignes et que la logique pourrait utiliser une clé d’entité plus spécifique.
Choisissez une partition qui correspond à la fois à la signification métier et à la distribution réelle des données.
36. Vérifier le skew des partitions avant de grandes fenêtres
(
df
.groupBy("customer_id")
.count()
.orderBy(
F.desc("count")
)
.show(
50,
truncate=False,
)
)
Quelques partitions énormes peuvent provoquer des tâches de fenêtre de longue durée.
Recherchez :
- un client/locataire dominant
- des clés nulles ou sentinelles
- des clés mal formées
- des utilisateurs intensifs légitimes
37. Ne pas remplacer à la légère les clés de partition nulles par une seule valeur sentinelle globale
Risqué :
df = df.fillna(
{
"customer_id": "UNKNOWN"
}
)
Toutes les lignes à clé nulle peuvent alors se retrouver dans une seule partition de fenêtre énorme.
Traitez séparément les clés invalides ou manquantes lorsque c’est possible.
38. Réutiliser la même spécification de fenêtre
Au lieu de reconstruire des fenêtres identiques :
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
puis :
df = (
df
.withColumn(
"previous_amount",
F.lag("amount").over(w),
)
.withColumn(
"next_amount",
F.lead("amount").over(w),
)
)
Le code reste ainsi plus facile à relire.
Spark peut aussi combiner des opérations de fenêtre compatibles dans le plan physique.
39. Inspecter le plan physique
result.explain("formatted")
Recherchez :
WindowExchangeSort
Les opérations de fenêtre nécessitent généralement un repartitionnement selon les clés de partition et un tri selon les clés de tri.
Ne supposez pas qu’une fenêtre est peu coûteuse simplement parce qu’elle ajoute une seule colonne.
40. Filtrer avant une grande fenêtre lorsque c’est sûr
Préférez :
recent = (
df
.filter(
F.col("event_date") >= "2026-10-01"
)
.select(
"customer_id",
"event_time",
"event_id",
"amount",
)
)
puis appliquez la fenêtre.
Cela peut réduire le volume de shuffle et de tri.
Mais ne filtrez pas les lignes antérieures si la logique de la fenêtre a besoin du contexte historique.
Par exemple, un total cumulé sur toute la durée de vie nécessite l’historique antérieur.
Interpréter le résultat
| Fonction | Signification |
|---|---|
row_number() |
Numéro séquentiel unique au sein de chaque partition triée |
rank() |
Les ex aequo partagent le rang ; des trous subsistent |
dense_rank() |
Les ex aequo partagent le rang ; aucun trou |
lag() |
Valeur d’une ligne précédente |
lead() |
Valeur d’une ligne suivante |
sum().over() |
Somme cumulée/partitionnée sans réduire la granularité |
avg().over() |
Moyenne de partition/fenêtre sans réduire la granularité |
first_value() |
Première valeur du cadre trié défini |
last_value() |
Dernière valeur du cadre trié défini |
ntile(n) |
Groupes de lignes de taille approximativement égale |
cume_dist() |
Position dans la distribution cumulée |
percent_rank() |
Rang relatif de 0 à 1 |
rowsBetween() |
Cadre basé sur les positions des lignes |
rangeBetween() |
Cadre basé sur une plage de valeurs de l’ORDER BY |
La distinction essentielle est la suivante :
groupBy()
→ réduit les lignes
fonction de fenêtre
→ conserve les lignes et ajoute des calculs relatifs au groupe
Points à vérifier
La ligne la plus récente change d’une exécution à l’autre
Votre tri est probablement incomplet.
Ajoutez des colonnes déterministes pour départager les ex aequo, par exemple :
- l’identifiant de l’événement
- la séquence source
- l’horodatage d’ingestion
last_value() est égal à la ligne courante de manière inattendue
Votre cadre de fenêtre se termine probablement à la ligne courante.
Utilisez un cadre explicite couvrant toute la partition lorsque vous avez besoin de la dernière valeur de la partition.
Le total cumulé fait des sauts inattendus
Vérifiez :
- les lignes sources en double
- le tri
- les nulls
- si des ex aequo créent un séquencement ambigu
L’étape de fenêtre comporte une tâche très lente
Inspectez le skew des clés de partition.
Un seul client/locataire énorme peut dominer l’exécution.
La fenêtre provoque un tri/shuffle massif
Vérifiez :
- la cardinalité de la clé de partition
- si le filtrage peut intervenir plus tôt
- si toutes les colonnes sont nécessaires
- si la fenêtre peut être restreinte
La métrique glissante « sur 7 jours » est fausse
Vérifiez si vous avez utilisé :
7 lignes
au lieu de :
7 jours
Utilisez le bon type de cadre.
Notes de production
Les fonctions de fenêtre impliquent généralement des tris coûteux
La plupart des fenêtres triées obligent Spark à :
partitionner
→ effectuer un shuffle
→ trier
→ évaluer la fenêtre
Elles peuvent être coûteuses sur de grands jeux de données.
Un tri déterministe est important
Si les valeurs de orderBy() sont à égalité et qu’aucune clé secondaire n’existe, les fonctions au niveau des lignes telles que row_number(), lag() et lead() peuvent ne pas avoir de signification métier stable.
Ajoutez une véritable règle pour départager les ex aequo.
Les partitions de fenêtre peuvent devenir gourmandes en mémoire
Les grandes partitions exigent une gestion importante du tri et de l’état.
Évitez de partitionner des millions de lignes sans rapport sous une seule clé nulle ou sentinelle.
Filtrer avant une fenêtre peut changer la sémantique
Par exemple :
total cumulé sur toute la durée de vie
nécessite l’historique complet.
Si vous filtrez d’abord sur le dernier mois, vous calculez :
total cumulé depuis le début du mois
et non le total sur toute la durée de vie.
Ne réduisez les données d’entrée que lorsque la définition métier le permet.
rangeBetween() exige une sémantique de tri rigoureuse
Le cadre est basé sur la valeur de l’expression de tri.
Lorsque vous utilisez des valeurs epoch numériques, documentez explicitement l’unité.
Utiliser les fonctions de fenêtre intégrées avant une logique Python personnalisée
Les fonctions intégrées restent dans le moteur d’exécution optimisé de Spark.
Ne collectez pas des groupes triés vers Python pour calculer un rang, un lag ou des totaux cumulés.
Erreurs fréquentes
1. Utiliser row_number() sans tri complet
Des lignes ex aequo peuvent produire des gagnants ambigus.
2. Utiliser rank() lorsqu’il faut exactement N lignes
Les ex aequo peuvent faire qualifier plus de N lignes.
Utilisez row_number() pour obtenir exactement N lignes.
3. Utiliser row_number() lorsque tous les ex aequo doivent être conservés
Utilisez plutôt rank() ou dense_rank().
4. Considérer que first() / last() tiennent automatiquement compte du temps
La sémantique du tri et du cadre doit être explicite.
5. Confondre rowsBetween() avec des plages de temps
Un cadre de lignes compte des lignes, pas du temps écoulé.
6. Utiliser inutilement une fenêtre triée globale
Cela peut imposer un tri global très coûteux.
7. Ignorer le skew des partitions
Une seule clé chaude peut dominer toute l’étape de fenêtre.
8. Éliminer l’historique par filtrage avant de calculer une fenêtre sur toute la durée de vie
Cela modifie silencieusement la définition de la métrique.
9. Remplacer toutes les clés nulles par une seule valeur sentinelle
Cela peut créer une partition de fenêtre énorme.
10. Utiliser des fenêtres lorsque groupBy() suffit
Si vous n’avez besoin que d’une ligne par groupe, une agrégation peut être plus simple et moins coûteuse.
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.