Parcourir les aide-mémoire · PySpark

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

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
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Importer Window et les fonctions Spark
  5. 2. Attribuer un numéro de ligne au sein de chaque groupe
  6. 3. Reproduire ROW_NUMBER() de SQL
  7. 4. Conserver la ligne la plus récente par clé métier
  8. 5. Conserver les N premières lignes par groupe
  9. 6. Utiliser rank() lorsque les ex aequo partagent le même rang
  10. 7. Utiliser dense_rank() lorsque les ex aequo ne doivent pas créer de trous
  11. 8. Comparer row_number, rank et dense_rank
  12. 9. Obtenir la valeur de la ligne précédente avec lag()
  13. 10. Obtenir la valeur de la ligne suivante avec lead()
  14. 11. Calculer le temps écoulé depuis l’événement précédent
  15. 12. Détecter les changements de valeur
  16. 13. Construire un total cumulé
  17. 14. Construire un comptage cumulé
  18. 15. Construire un maximum cumulé
  19. 16. Utiliser une fenêtre glissante basée sur un nombre de lignes
  20. 17. Utiliser rangeBetween() pour des cadres basés sur les valeurs
  21. 18. Comprendre rowsBetween() et rangeBetween()
  22. 19. Calculer le total de la partition sans réduire les lignes
  23. 20. Calculer le pourcentage du total du groupe
  24. 21. Calculer la moyenne de la partition
  25. 22. Comparer la valeur d’une ligne à la moyenne du groupe
  26. 23. Utiliser first_value() avec une fenêtre triée
  27. 24. Utiliser last_value() avec un cadre explicite couvrant toute la partition
  28. 25. Obtenir la première valeur non nulle
  29. 26. Utiliser nth_value() lorsque c’est pris en charge et approprié
  30. 27. Utiliser cume_dist() pour la distribution cumulée
  31. 28. Utiliser percent_rank() pour un classement relatif
  32. 29. Utiliser ntile() pour répartir les lignes en groupes
  33. 30. Construire des plages de dates d’effet avec lead()
  34. 31. Créer des limites de session à partir des écarts entre événements
  35. 32. Attribuer des identifiants de session avec une somme cumulée
  36. 33. Dédoublonner avec row_number() avant un MERGE
  37. 34. Éviter les fenêtres globales sauf si elles sont réellement nécessaires
  38. 35. Aligner les partitions sur l’entité métier
  39. 36. Vérifier le skew des partitions avant de grandes fenêtres
  40. 37. Ne pas remplacer à la légère les clés de partition nulles par une seule valeur sentinelle globale
  41. 38. Réutiliser la même spécification de fenêtre
  42. 39. Inspecter le plan physique
  43. 40. Filtrer avant une grande fenêtre lorsque c’est sûr
  44. Interpréter le résultat
  45. Points à vérifier
  46. La ligne la plus récente change d’une exécution à l’autre
  47. last_value() est égal à la ligne courante de manière inattendue
  48. Le total cumulé fait des sauts inattendus
  49. L’étape de fenêtre comporte une tâche très lente
  50. La fenêtre provoque un tri/shuffle massif
  51. La métrique glissante « sur 7 jours » est fausse
  52. Notes de production
  53. Les fonctions de fenêtre impliquent généralement des tris coûteux
  54. Un tri déterministe est important
  55. Les partitions de fenêtre peuvent devenir gourmandes en mémoire
  56. Filtrer avant une fenêtre peut changer la sémantique
  57. rangeBetween() exige une sémantique de tri rigoureuse
  58. Utiliser les fonctions de fenêtre intégrées avant une logique Python personnalisée
  59. Erreurs fréquentes
  60. 1. Utiliser row_number() sans tri complet
  61. 2. Utiliser rank() lorsqu’il faut exactement N lignes
  62. 3. Utiliser row_number() lorsque tous les ex aequo doivent être conservés
  63. 4. Considérer que first() / last() tiennent automatiquement compte du temps
  64. 5. Confondre rowsBetween() avec des plages de temps
  65. 6. Utiliser inutilement une fenêtre triée globale
  66. 7. Ignorer le skew des partitions
  67. 8. Éliminer l’historique par filtrage avant de calculer une fenêtre sur toute la durée de vie
  68. 9. Remplacer toutes les clés nulles par une seule valeur sentinelle
  69. 10. Utiliser des fenêtres lorsque groupBy() suffit
  70. Étape suivante
  71. 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 :

  • Window
  • Exchange
  • Sort

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.

Étape suivante

Utilisez le besoin pour choisir l’action suivante.

  • Besoin de la ligne la plus récente par clé → utilisez row_number() avec un tri décroissant déterministe.
  • Besoin d’exactement N premières lignes → utilisez row_number().
  • Besoin de tous les ex aequo → utilisez rank() ou dense_rank().
  • Besoin de l’événement précédent/suivant → utilisez lag() / lead().
  • Besoin d’un total cumulé → utilisez un cadre cumulatif trié.
  • Besoin d’une fenêtre temporelle glissante → utilisez un cadre basé sur une plage de valeurs avec des unités de temps explicites.
  • Besoin d’une seule ligne scalaire par groupe → utilisez groupBy() plutôt qu’une fenêtre.
  • La fenêtre est lente → inspectez le skew des partitions, le tri/shuffle et la taille des données d’entrée.
  • La logique de ligne la plus récente alimente un MERGE Delta → dédoublonnez de manière déterministe avant l’écriture.
  • La fenêtre reste coûteuse après réduction des données → passez à PySpark : référence rapide des performances et inspectez le plan et les étapes Spark.

← Tous les aide-mémoire