Explorar guías rápidas · PySpark
Funciones de ventana en PySpark
Usa las funciones de ventana de PySpark de forma segura para clasificar, seleccionar la fila más reciente, calcular totales acumulados, analizar con lag/lead y hacer cálculos por partición sin reducir la granularidad del DataFrame.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Importar Window y las funciones de Spark
- 2. Asignar un número de fila dentro de cada grupo
- 3. Reproducir ROW_NUMBER() de SQL
- 4. Conservar la fila más reciente por clave de negocio
- 5. Conservar las N primeras filas por grupo
- 6. Usar rank() cuando los empates comparten el mismo rango
- 7. Usar dense_rank() cuando los empates no deben crear huecos
- 8. Comparar row_number, rank y dense_rank
- 9. Obtener el valor de la fila anterior con lag()
- 10. Obtener el valor de la fila siguiente con lead()
- 11. Calcular el tiempo transcurrido desde el evento anterior
- 12. Detectar cambios de valor
- 13. Construir un total acumulado
- 14. Construir un recuento acumulado
- 15. Construir un máximo acumulado
- 16. Usar una ventana móvil basada en número de filas
- 17. Usar rangeBetween() para marcos basados en valores
- 18. Entender rowsBetween() frente a rangeBetween()
- 19. Calcular el total de la partición sin reducir filas
- 20. Calcular el porcentaje del total del grupo
- 21. Calcular la media de la partición
- 22. Comparar el valor de la fila con la media del grupo
- 23. Usar first_value() con una ventana ordenada
- 24. Usar last_value() con un marco explícito de toda la partición
- 25. Obtener el primer valor no nulo
- 26. Usar nth_value() cuando esté disponible y sea adecuado
- 27. Usar cume_dist() para la distribución acumulada
- 28. Usar percent_rank() para una clasificación relativa
- 29. Usar ntile() para asignar grupos
- 30. Construir rangos de fechas de vigencia con lead()
- 31. Crear límites de sesión a partir de los intervalos entre eventos
- 32. Asignar IDs de sesión con una suma acumulada
- 33. Deduplicar con row_number() antes de un MERGE
- 34. Evitar las ventanas globales salvo que sean realmente necesarias
- 35. Alinear las particiones con la entidad de negocio
- 36. Comprobar el skew de las particiones antes de ventanas grandes
- 37. No reemplazar a la ligera las claves de partición nulas por un único valor centinela global
- 38. Reutilizar la misma especificación de ventana
- 39. Inspeccionar el plan físico
- 40. Filtrar antes de una ventana grande cuando sea seguro
- Qué significa el resultado
- Qué revisar
- La fila más reciente cambia entre ejecuciones
- last_value() coincide inesperadamente con la fila actual
- El total acumulado da saltos inesperados
- La etapa de ventana tiene una tarea muy lenta
- La ventana provoca un ordenamiento/shuffle masivo
- La métrica móvil «de 7 días» es incorrecta
- Notas de producción
- Las funciones de ventana suelen requerir ordenamientos costosos
- El ordenamiento determinista importa
- Las particiones de ventana pueden consumir mucha memoria
- Filtrar antes de una ventana puede cambiar la semántica
- rangeBetween() requiere una semántica de ordenamiento cuidadosa
- Usa las funciones de ventana integradas antes que lógica personalizada en Python
- Errores comunes
- 1. Usar row_number() sin un ordenamiento completo
- 2. Usar rank() cuando se requieren exactamente N filas
- 3. Usar row_number() cuando deben conservarse todos los empates
- 4. Suponer que first() / last() tienen en cuenta el tiempo automáticamente
- 5. Confundir rowsBetween() con rangos de tiempo
- 6. Usar innecesariamente una ventana ordenada global
- 7. Ignorar el skew de las particiones
- 8. Eliminar historial por filtrado antes de calcular una ventana de toda la vida
- 9. Reemplazar todas las claves nulas por un único valor centinela
- 10. Usar ventanas cuando basta con groupBy()
- Siguiente paso
- Para profundizar
Problema
Necesitas calcular valores sobre filas relacionadas sin reducir el DataFrame a una fila por grupo.
Entre los casos de uso habituales en producción están:
- conservar la fila más reciente por clave de negocio
- clasificar productos dentro de cada categoría
- calcular totales acumulados
- comparar cada fila con el evento anterior o siguiente
- calcular el tiempo transcurrido entre eventos
- detectar cambios de estado
- calcular métricas móviles
- asignar números de fila deterministas
- seleccionar las N primeras filas por grupo
Los principales riesgos son:
- un ordenamiento incompleto
- empates ambiguos
- particiones de ventana enormes
- ordenamientos globales innecesarios
- usar una semántica de marco (frame) incorrecta
- depender de
first()/last()sin entender el ordenamiento - mezclar de forma incorrecta marcos basados en filas y en rangos de valores
El objetivo es hacer explícitos la partición, el ordenamiento y el marco.
Respuesta rápida
Para la fila más reciente por cliente:
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")
)
Para un total acumulado:
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.currentRow,
)
)
df = df.withColumn(
"running_amount",
F.sum("amount").over(w),
)
La regla clave es:
PARTITION BY
→ qué filas van juntas
ORDER BY
→ qué fila va primero
FRAME
→ qué filas ordenadas participan en el cálculo
Código / comandos
1. Importar Window y las funciones de Spark
from pyspark.sql import Window
from pyspark.sql import functions as F
Usa Window para definir la partición, el ordenamiento y los marcos.
2. Asignar un número de fila dentro de cada grupo
w = (
Window
.partitionBy("customer_id")
.orderBy(
F.col("event_time").asc()
)
)
df = df.withColumn(
"row_number",
F.row_number().over(w),
)
Esto asigna a cada fila un número de secuencia único dentro de su partición.
Úsalo cuando los empates deban recibir igualmente números de fila distintos.
3. Reproducir 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 segunda columna de ordenamiento permite desempatar de forma determinista.
No dependas de un orden físico arbitrario de las filas.
4. Conservar la fila más reciente por clave de negocio
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")
)
Este es el patrón preferido cuando importa qué fila se conserva.
5. Conservar las N primeras filas por grupo
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")
)
Esto conserva exactamente hasta N filas por partición.
Si todos los empates deben conservarse, usa rank() o dense_rank() en su lugar.
6. Usar rank() cuando los empates comparten el mismo rango
w = (
Window
.partitionBy("category")
.orderBy(
F.col("revenue").desc()
)
)
df = df.withColumn(
"rank",
F.rank().over(w),
)
Valores de ejemplo:
100
100
90
80
producen los rangos:
1
1
3
4
7. Usar dense_rank() cuando los empates no deben crear huecos
df = df.withColumn(
"dense_rank",
F.dense_rank().over(w),
)
Para los mismos valores:
100
100
90
80
los rangos densos son:
1
1
2
3
Usa el método de clasificación que coincida con la definición de negocio.
8. Comparar row_number, rank y dense_rank
Usa:
row_number
→ cada fila recibe un número de secuencia único
rank
→ los empates comparten rango; quedan huecos
dense_rank
→ los empates comparten rango; sin huecos
No sustituyas una por otra sin comprobar la semántica de los empates.
9. Obtener el valor de la fila anterior con lag()
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
df = df.withColumn(
"previous_status",
F.lag(
"status",
1,
).over(w),
)
Úsala para:
- transiciones de estado
- el importe anterior
- la marca de tiempo anterior
- la detección de cambios
10. Obtener el valor de la fila siguiente con lead()
df = df.withColumn(
"next_status",
F.lead(
"status",
1,
).over(w),
)
Úsala para:
- el análisis del evento siguiente
- rangos de fechas de vigencia
- comparaciones con el estado futuro
11. Calcular el tiempo transcurrido desde el evento anterior
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"),
)
)
Esto es útil para:
- la sesionización
- el análisis de solicitudes repetidas
- la latencia
- la detección de intervalos entre eventos
Asegúrate de que el ordenamiento por marca de tiempo sea semánticamente correcto.
12. Detectar cambios de valor
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")
)
),
)
)
Usa eqNullSafe() cuando importe la semántica de igualdad de los nulos.
13. Construir un total acumulado
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.currentRow,
)
)
df = df.withColumn(
"running_amount",
F.sum("amount").over(w),
)
Esto incluye todas las filas anteriores de la partición hasta la fila actual.
14. Construir un recuento acumulado
df = df.withColumn(
"running_count",
F.count("*").over(w),
)
Útil para:
- la secuencia de eventos
- la actividad acumulada
- contadores progresivos
15. Construir un máximo acumulado
df = df.withColumn(
"running_max_amount",
F.max("amount").over(w),
)
Esto da el mayor valor observado hasta el momento dentro de la partición ordenada.
16. Usar una ventana móvil basada en número de filas
La fila actual más las seis filas anteriores:
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
-6,
0,
)
)
df = df.withColumn(
"rolling_7_row_avg",
F.avg("amount").over(w),
)
Esto significa:
7 filas
no:
7 días
No confundas las ventanas basadas en filas con las ventanas basadas en tiempo.
17. Usar rangeBetween() para marcos basados en valores
Supón que la columna de ordenamiento está en segundos epoch:
df = df.withColumn(
"event_epoch",
F.col("event_time").cast("long"),
)
Una ventana móvil de los últimos 7 días:
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),
)
Este marco se basa en el valor numérico de la columna de ordenamiento, no en el número de filas.
Úsalo con cuidado y documenta la unidad.
18. Entender rowsBetween() frente a rangeBetween()
Usa:
rowsBetween()
→ posiciones físicas relativas de las filas
rangeBetween()
→ valores relativos de la expresión ORDER BY
Ejemplo:
rowsBetween(-6, 0)
significa siete filas.
Ejemplo:
rangeBetween(-604800, 0)
sobre segundos epoch significa los siete días anteriores.
No son intercambiables.
19. Calcular el total de la partición sin reducir filas
w = (
Window
.partitionBy("merchant_id")
)
df = df.withColumn(
"merchant_total",
F.sum("amount").over(w),
)
A diferencia de groupBy(), esto mantiene la granularidad original de las filas.
Úsalo cuando cada fila necesite tanto:
- el detalle a nivel de fila
- una métrica a nivel de grupo
20. Calcular el porcentaje del total del grupo
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"),
),
)
)
Esto conserva cada fila de origen y añade su proporción del total de la partición.
21. Calcular la media de la partición
w = (
Window
.partitionBy("merchant_id")
)
df = df.withColumn(
"merchant_avg_amount",
F.avg("amount").over(w),
)
De nuevo, la granularidad original de las filas se mantiene intacta.
22. Comparar el valor de la fila con la media del grupo
df = (
df
.withColumn(
"merchant_avg_amount",
F.avg("amount").over(w),
)
.withColumn(
"above_merchant_avg",
F.col("amount")
> F.col("merchant_avg_amount"),
)
)
Esto es útil para comparaciones dentro del grupo sin una agregación y un join por separado.
23. Usar first_value() con una ventana ordenada
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
.rowsBetween(
Window.unboundedPreceding,
Window.unboundedFollowing,
)
)
df = df.withColumn(
"first_status",
F.first_value("status").over(w),
)
Usa un marco explícito cuando quieras el valor de toda la partición.
24. Usar last_value() con un marco explícito de toda la partición
df = df.withColumn(
"last_status",
F.last_value("status").over(w),
)
Sin un marco adecuado, last_value() puede devolver el valor de la fila actual en lugar del último valor de la partición.
Este es uno de los errores más comunes con las funciones de ventana.
25. Obtener el primer valor no nulo
df = df.withColumn(
"first_non_null_status",
F.first(
"status",
ignorenulls=True,
).over(w),
)
Indica explícitamente si deben ignorarse los nulos.
26. Usar nth_value() cuando esté disponible y sea adecuado
Ejemplo:
df = df.withColumn(
"second_status",
F.nth_value(
"status",
2,
).over(w),
)
Úsala cuando una posición fija en el orden tenga significado de negocio.
Si necesitas seleccionar filas, row_number() suele ser más claro.
27. Usar cume_dist() para la distribución acumulada
w = (
Window
.partitionBy("category")
.orderBy(
F.col("revenue").asc()
)
)
df = df.withColumn(
"cume_dist",
F.cume_dist().over(w),
)
Esto muestra la posición relativa de cada fila dentro de la partición ordenada.
Útil para el análisis de distribución.
28. Usar percent_rank() para una clasificación relativa
df = df.withColumn(
"percent_rank",
F.percent_rank().over(w),
)
Esto devuelve un valor de 0 a 1 basado en la posición en la clasificación.
No lo confundas con un valor de percentil estadístico.
29. Usar ntile() para asignar grupos
w = (
Window
.partitionBy("region")
.orderBy(
F.col("revenue").desc()
)
)
df = df.withColumn(
"quartile",
F.ntile(4).over(w),
)
Esto divide las filas ordenadas en grupos de tamaño aproximadamente igual.
No lo uses como sustituto de límites de percentil exactos cuando importen los umbrales basados en valores.
30. Construir rangos de fechas de vigencia con lead()
w = (
Window
.partitionBy("customer_id")
.orderBy("effective_from")
)
history = df.withColumn(
"effective_to",
F.lead(
"effective_from"
).over(w),
)
Esto es útil para registros versionados.
Decide si effective_to es:
exclusiva
o:
inclusiva
y mantén esa convención de forma coherente.
31. Crear límites de sesión a partir de los intervalos entre eventos
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"),
)
)
Marca una nueva sesión:
events = events.withColumn(
"new_session",
F.when(
F.col("previous_event_time").isNull()
| (F.col("gap_seconds") > 1800),
1,
).otherwise(0),
)
El umbral de 1.800 segundos es un ejemplo.
Usa un umbral definido por la regla real de negocio o de sesión.
32. Asignar IDs de sesión con una suma acumulada
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
),
)
Esto convierte los límites detectados en grupos de sesión secuenciales.
33. Deduplicar con row_number() antes de 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")
)
Este es un patrón sólido para preparar entradas deterministas para un MERGE de Delta.
34. Evitar las ventanas globales salvo que sean realmente necesarias
Esto:
w = Window.orderBy("event_time")
no tiene clave de partición.
Todas las filas pertenecen a una única ventana lógica.
En DataFrames grandes, esto puede forzar un ordenamiento global muy costoso.
Usa ventanas globales solo cuando la pregunta de negocio sea realmente global.
35. Alinear las particiones con la entidad de negocio
Bien:
Window.partitionBy("customer_id")
para el historial de eventos por cliente.
Potencialmente costoso:
Window.partitionBy("country")
si un país contiene cientos de millones de filas y la lógica podría usar una clave de entidad más específica.
Elige una partición que coincida tanto con el significado de negocio como con la distribución real de los datos.
36. Comprobar el skew de las particiones antes de ventanas grandes
(
df
.groupBy("customer_id")
.count()
.orderBy(
F.desc("count")
)
.show(
50,
truncate=False,
)
)
Unas pocas particiones enormes pueden provocar tareas de ventana de larga duración.
Busca:
- un cliente/tenant dominante
- claves nulas o centinela
- claves mal formadas
- usuarios intensivos legítimos
37. No reemplazar a la ligera las claves de partición nulas por un único valor centinela global
Arriesgado:
df = df.fillna(
{
"customer_id": "UNKNOWN"
}
)
Así, todas las filas con clave nula pueden acabar en una única partición de ventana enorme.
Trata por separado las claves no válidas o faltantes cuando sea posible.
38. Reutilizar la misma especificación de ventana
En lugar de reconstruir ventanas idénticas:
w = (
Window
.partitionBy("customer_id")
.orderBy("event_time")
)
después:
df = (
df
.withColumn(
"previous_amount",
F.lag("amount").over(w),
)
.withColumn(
"next_amount",
F.lead("amount").over(w),
)
)
Esto hace que el código sea más fácil de revisar.
Spark también puede combinar operaciones de ventana compatibles en el plan físico.
39. Inspeccionar el plan físico
result.explain("formatted")
Busca:
WindowExchangeSort
Las operaciones de ventana suelen requerir reparticionar por las claves de partición y ordenar por las claves de ordenamiento.
No supongas que una ventana es barata solo porque añade una columna.
40. Filtrar antes de una ventana grande cuando sea seguro
Prefiere:
recent = (
df
.filter(
F.col("event_date") >= "2026-10-01"
)
.select(
"customer_id",
"event_time",
"event_id",
"amount",
)
)
y después aplica la ventana.
Esto puede reducir el volumen de shuffle y de ordenamiento.
Pero no elimines por filtrado filas anteriores si la lógica de la ventana necesita el contexto histórico.
Por ejemplo, un total acumulado de toda la vida requiere el historial anterior.
Qué significa el resultado
| Función | Significado |
|---|---|
row_number() |
Número secuencial único dentro de cada partición ordenada |
rank() |
Los empates comparten rango; quedan huecos |
dense_rank() |
Los empates comparten rango; sin huecos |
lag() |
Valor de una fila anterior |
lead() |
Valor de una fila siguiente |
sum().over() |
Suma acumulada/por partición sin reducir la granularidad |
avg().over() |
Media por partición/ventana sin reducir la granularidad |
first_value() |
Primer valor del marco ordenado definido |
last_value() |
Último valor del marco ordenado definido |
ntile(n) |
Grupos de filas de tamaño aproximadamente igual |
cume_dist() |
Posición en la distribución acumulada |
percent_rank() |
Rango relativo de 0 a 1 |
rowsBetween() |
Marco basado en posiciones de fila |
rangeBetween() |
Marco basado en un rango de valores del ORDER BY |
La distinción fundamental es:
groupBy()
→ reduce las filas
función de ventana
→ conserva las filas y añade cálculos relativos al grupo
Qué revisar
La fila más reciente cambia entre ejecuciones
Probablemente tu ordenamiento está incompleto.
Añade columnas deterministas para desempatar, como:
- el ID del evento
- la secuencia de origen
- la marca de tiempo de ingesta
last_value() coincide inesperadamente con la fila actual
Probablemente tu marco de ventana termina en la fila actual.
Usa un marco explícito de toda la partición cuando necesites el último valor de la partición.
El total acumulado da saltos inesperados
Comprueba:
- filas de origen duplicadas
- el ordenamiento
- los nulos
- si los empates crean una secuencia ambigua
La etapa de ventana tiene una tarea muy lenta
Inspecciona el skew de las claves de partición.
Un único cliente/tenant enorme puede dominar la ejecución.
La ventana provoca un ordenamiento/shuffle masivo
Comprueba:
- la cardinalidad de la clave de partición
- si el filtrado puede hacerse antes
- si todas las columnas son necesarias
- si la ventana puede acotarse
La métrica móvil «de 7 días» es incorrecta
Comprueba si usaste:
7 filas
en lugar de:
7 días
Usa el tipo de marco correcto.
Notas de producción
Las funciones de ventana suelen requerir ordenamientos costosos
La mayoría de las ventanas ordenadas obligan a Spark a:
particionar
→ hacer shuffle
→ ordenar
→ evaluar la ventana
Pueden ser costosas en conjuntos de datos grandes.
El ordenamiento determinista importa
Si los valores de orderBy() empatan y no existe una clave secundaria, las funciones a nivel de fila como row_number(), lag() y lead() pueden no tener un significado de negocio estable.
Añade una regla de desempate real.
Las particiones de ventana pueden consumir mucha memoria
Las particiones grandes requieren un manejo considerable de ordenamiento y estado.
Evita particionar millones de filas no relacionadas bajo una única clave nula o centinela.
Filtrar antes de una ventana puede cambiar la semántica
Por ejemplo:
total acumulado de toda la vida
requiere el historial completo.
Si primero filtras al último mes, calculas:
total acumulado del mes en curso
no el total de toda la vida.
Reduce la entrada solo cuando la definición de negocio lo permita.
rangeBetween() requiere una semántica de ordenamiento cuidadosa
El marco se basa en el valor de la expresión de ordenamiento.
Cuando uses valores epoch numéricos, documenta la unidad de forma explícita.
Usa las funciones de ventana integradas antes que lógica personalizada en Python
Las funciones integradas se ejecutan en el motor de ejecución optimizado de Spark.
No recopiles grupos ordenados en Python para calcular rangos, lag o totales acumulados.
Errores comunes
1. Usar row_number() sin un ordenamiento completo
Las filas empatadas pueden producir ganadores ambiguos.
2. Usar rank() cuando se requieren exactamente N filas
Los empates pueden hacer que califiquen más de N filas.
Usa row_number() para obtener exactamente N filas.
3. Usar row_number() cuando deben conservarse todos los empates
Usa rank() o dense_rank() en su lugar.
4. Suponer que first() / last() tienen en cuenta el tiempo automáticamente
La semántica del ordenamiento y del marco debe ser explícita.
5. Confundir rowsBetween() con rangos de tiempo
Un marco de filas cuenta filas, no tiempo transcurrido.
6. Usar innecesariamente una ventana ordenada global
Esto puede forzar un ordenamiento global muy costoso.
7. Ignorar el skew de las particiones
Una sola clave caliente puede dominar toda la etapa de ventana.
8. Eliminar historial por filtrado antes de calcular una ventana de toda la vida
Esto cambia silenciosamente la definición de la métrica.
9. Reemplazar todas las claves nulas por un único valor centinela
Esto puede crear una partición de ventana enorme.
10. Usar ventanas cuando basta con groupBy()
Si solo necesitas una fila por grupo, la agregación puede ser más sencilla y barata.
¿Te resultó útil este contenido?
¿Qué podríamos mejorar?
Gracias — esto me ayuda a mejorar Javi Builds.
Mantente al día
Recibe solo las novedades de Javi Builds que realmente te interesan.
Revisa tu bandeja de entrada
Te he enviado un enlace de confirmación. Tu suscripción se activará cuando la confirmes.