Explorar guías rápidas · PySpark

Tecnología: PySparkCategoría: Transformación de datosNivel: IntermedioActualizado

GroupBy y agregaciones en PySpark

Agrega DataFrames de PySpark de forma segura definiendo la granularidad de salida, gestionando las claves de agrupación nulas, eligiendo las funciones de agregación correctas, validando los totales y controlando las cargas de trabajo de groupBy con mucho shuffle.

En esta página
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Agrupar por una columna
  5. 2. Agrupar por varias columnas
  6. 3. Contar filas con count("*")
  7. 4. Contar los valores no nulos de una columna
  8. 5. Contar claves de negocio distintas
  9. 6. Sumar valores numéricos
  10. 7. Calcular promedios
  11. 8. Calcular varios agregados en una sola pasada
  12. 9. Obtener las marcas de tiempo mínima y máxima
  13. 10. Conservar las claves de agrupación nulas
  14. 11. Filtrar las claves de agrupación no válidas antes de agregar
  15. 12. Medir por separado las claves de agrupación nulas
  16. 13. Agrupar por una columna de fecha
  17. 14. Derivar el día a partir de una marca de tiempo
  18. 15. Agregar por mes
  19. 16. Agregación condicional
  20. 17. Suma condicional
  21. 18. Calcular una proporción a partir de componentes agregados
  22. 19. Calcular un promedio ponderado
  23. 20. Agregar booleanos o indicadores
  24. 21. Recopilar valores en un array
  25. 22. Usar collect_list() solo cuando importen los duplicados
  26. 23. No suponer que collect_list() conserva el orden
  27. 24. Agregar en un struct
  28. 25. Usar first() y last() con cuidado
  29. 26. Obtener el valor más reciente con max_by cuando esté disponible
  30. 27. Obtener la fila asociada a la marca de tiempo más reciente
  31. 28. Usar rollup() para totales jerárquicos
  32. 29. Usar cube() para todas las combinaciones de agrupación
  33. 30. Usar grouping_id() con rollups y cubes
  34. 31. Usar pivot() solo con categorías acotadas
  35. 32. Evitar hacer pivot sobre IDs de cliente o de transacción
  36. 33. Conciliar los totales agregados con el origen
  37. 34. Validar la unicidad de la salida con la granularidad prevista
  38. 35. Comprobar la duplicación de la entrada antes de sumar
  39. 36. Filtrar y proyectar antes de agregar
  40. 37. Inspeccionar el plan físico
  41. 38. Comprobar el skew de las claves de agrupación
  42. 39. No reemplazar todas las claves nulas por un único valor centinela antes de agrupar
  43. 40. Evitar agregar con UDF de Python cuando bastan las funciones integradas
  44. Qué significa el resultado
  45. Qué revisar
  46. Los ingresos son demasiado altos
  47. El número de filas baja más de lo esperado
  48. El recuento distinto difiere mucho del número de filas
  49. Una etapa tarda mucho más de lo esperado
  50. collect_list() provoca presión de memoria
  51. El promedio parece incorrecto
  52. Notas de producción
  53. GroupBy suele ser una operación con mucho shuffle
  54. Los agregados integrados pueden usar agregación parcial
  55. La cardinalidad de las claves de agrupación afecta al tamaño de la salida
  56. El skew importa más que el tamaño medio de los grupos
  57. Los tipos decimales son preferibles para totales financieros exactos
  58. La agregación distinct puede ser costosa
  59. No uses la agregación para ocultar una granularidad incorrecta
  60. Errores comunes
  61. 1. Agrupar antes de definir la granularidad de salida
  62. 2. Usar count(col) cuando se necesita el número de filas
  63. 3. Usar un promedio simple cuando se necesita un promedio ponderado
  64. 4. Suponer que first() significa el más antiguo
  65. 5. Usar max() en varias columnas para reconstruir la fila más reciente
  66. 6. Hacer pivot sobre campos de alta cardinalidad
  67. 7. Usar collect_list() en grupos no acotados
  68. 8. Ignorar las claves de agrupación nulas
  69. 9. Culpar al rendimiento del groupBy antes de comprobar el skew
  70. 10. Ejecutar muchas agregaciones separadas sobre la misma entrada
  71. Siguiente paso
  72. Para profundizar

Problema

Necesitas resumir un DataFrame de PySpark por cliente, comercio, fecha, región u otra granularidad de negocio.

La sintaxis es sencilla, pero los errores en producción suelen deberse a:

  • agregar con la granularidad incorrecta
  • contar dos veces después de un join
  • perder las claves de agrupación nulas
  • confundir el número de filas con el número de valores no nulos
  • promediar valores que deberían ponderarse
  • usar collect_list() en grupos no acotados
  • ejecutar agregaciones personalizadas costosas en Python
  • generar un shuffle o un skew extremos
  • agrupar por claves de alta cardinalidad sin entender el costo

El objetivo es que la lógica de agregación sea explícita, correcta y escalable.

Respuesta rápida

Define primero la granularidad de salida.

Ejemplo:

Granularidad de salida:
una fila por merchant_id + sale_date

Después, agrega:

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"),
    )
)

Antes de confiar en el resultado, valida:

¿El número de filas cambió como se esperaba?
¿Cuadran los totales?
¿Hay filas de origen duplicadas que inflan las métricas?
¿Las claves de agrupación nulas se conservan o se descartan de forma intencional?

La corrección de la agregación va antes que el ajuste de Spark.

Código / comandos

1. Agrupar por una columna

summary = (
    df
    .groupBy("merchant_id")
    .count()
)

Esto devuelve una fila por cada valor distinto de merchant_id.

Usa count() cuando necesites el número de filas por grupo.


2. Agrupar por varias columnas

summary = (
    df
    .groupBy(
        "merchant_id",
        "sale_date",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Las columnas de agrupación definen la granularidad de salida.

Documéntalas.


3. Contar filas con count("*")

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("*").alias("row_count")
    )
)

Esto cuenta las filas independientemente de que las columnas individuales contengan nulos.

Úsalo cuando la pregunta sea:

¿Cuántos registros hay en cada grupo?

4. Contar los valores no nulos de una columna

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.count("sale_id").alias("non_null_sale_id_count")
    )
)

Esto cuenta solo los valores no nulos de sale_id.

No lo confundas con el número de filas.


5. Contar claves de negocio distintas

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.countDistinct("sale_id").alias("distinct_sales")
    )
)

Úsalo cuando las filas de origen puedan contener varios registros por venta.

Esto ayuda a distinguir:

el número de filas físicas

de:

el número de eventos de negocio

6. Sumar valores numéricos

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

sum() ignora los valores nulos.

Si todos los valores de un grupo son nulos, el resultado de la suma puede ser null.

No reemplaces automáticamente null por cero salvo que eso coincida con la regla de negocio.


7. Calcular promedios

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.avg("amount").alias("avg_amount")
    )
)

Los valores nulos se ignoran.

Pregúntate si un promedio simple es la métrica de negocio correcta.


8. Calcular varios agregados en una sola pasada

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"),
    )
)

Normalmente es mejor que ejecutar varios jobs de groupBy separados sobre la misma entrada.


9. Obtener las marcas de tiempo mínima y máxima

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.min("event_time").alias("first_event_time"),
        F.max("event_time").alias("last_event_time"),
    )
)

Esto devuelve los valores de marca de tiempo más antiguo y más reciente.

No devuelve la fila completa asociada a esas marcas de tiempo.

Usa una ventana cuando necesites la fila más reciente real.


10. Conservar las claves de agrupación nulas

Spark agrupa los valores nulos juntos.

Ejemplo:

summary = (
    df
    .groupBy("country")
    .count()
)

Las filas en las que country es null forman su propio grupo.

Esto difiere de algunos comportamientos predeterminados de pandas.

Si las claves de agrupación nulas no son válidas, fíltralas o ponlas en cuarentena de forma explícita.


11. Filtrar las claves de agrupación no válidas antes de agregar

valid = df.filter(
    F.col("merchant_id").isNotNull()
)

summary = (
    valid
    .groupBy("merchant_id")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Hazlo solo cuando las claves nulas sean realmente no válidas.

No las descartes en silencio sin medir el impacto.


12. Medir por separado las claves de agrupación nulas

null_key_count = (
    df
    .filter(
        F.col("merchant_id").isNull()
    )
    .count()
)

print(
    "Rows with null merchant_id:",
    null_key_count,
)

En cargas de trabajo de producción grandes, combina esta medición con otras métricas en una sola agregación cuando sea posible.


13. Agrupar por una columna de fecha

daily = (
    df
    .groupBy("sale_date")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Asegúrate de que sale_date sea realmente una fecha y no un texto arbitrario.


14. Derivar el día a partir de una marca de tiempo

daily = (
    df
    .withColumn(
        "sale_date",
        F.to_date("sale_time"),
    )
    .groupBy("sale_date")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Ten cuidado con la semántica de las zonas horarias.

Si sale_time está en UTC pero los informes se basan en la hora local, conviértelo a la zona horaria del negocio antes de derivar la fecha.


15. Agregar por mes

monthly = (
    df
    .withColumn(
        "sale_month",
        F.date_trunc(
            "month",
            F.col("sale_time"),
        ),
    )
    .groupBy("sale_month")
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Esto conserva un límite de mes de tipo timestamp.

Usa una clave de fecha dedicada si tu modelo requiere una semántica de solo fecha.


16. Agregación condicional

Contar las filas correctas:

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum(
            F.when(
                F.col("status") == "success",
                1,
            ).otherwise(0)
        ).alias("success_count")
    )
)

Esto suele ser más claro y eficiente que crear muchos DataFrames filtrados y agregar cada uno por separado.


17. Suma condicional

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.sum(
            F.when(
                F.col("status") == "approved",
                F.col("amount"),
            ).otherwise(F.lit(0))
        ).alias("approved_amount")
    )
)

Usa cero solo si las filas excluidas deben aportar cero a la métrica.

Si la semántica de los nulos importa, codifícala de forma deliberada.


18. Calcular una proporción a partir de componentes agregados

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"),
        ),
    )
)

Construye la proporción a partir de un numerador y un denominador explícitos.

No promedies porcentajes a nivel de fila salvo que sea matemáticamente correcto.


19. Calcular un promedio ponderado

Supón que:

price × quantity

debe ponderarse por la cantidad.

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"),
        ),
    )
)

No uses avg(price) cuando cada fila representa un peso distinto.


20. Agregar booleanos o indicadores

Ejemplo:

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.max(
            F.col("is_high_risk").cast("int")
        ).alias("has_high_risk")
    )
)

Si alguna fila es verdadera, el resultado pasa a ser 1.

Si hace falta, deja explícitos después el tipo de salida y su significado de negocio.


21. Recopilar valores en un array

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.collect_set("country").alias("countries")
    )
)

Usa collect_set() cuando te resulten útiles los valores únicos por grupo.

Ten cuidado con los grupos no acotados.

Un solo grupo grande puede crear un array muy grande en memoria.


22. Usar collect_list() solo cuando importen los duplicados

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.collect_list("event_type").alias("events")
    )
)

Esto conserva los duplicados, pero no garantiza un orden de eventos significativo salvo que modeles el orden de forma explícita.

No uses collect_list() para construir arrays enormes en grupos de gran volumen.


23. No suponer que collect_list() conserva el orden

Si el orden importa, usa un patrón estructurado.

Ejemplo:

events = (
    df
    .groupBy("customer_id")
    .agg(
        F.sort_array(
            F.collect_list(
                F.struct(
                    "event_time",
                    "event_type",
                )
            )
        ).alias("events")
    )
)

Esto ordena los structs recopilados según sus campos.

Deja explícita la semántica ascendente o descendente que exige la regla de negocio.


24. Agregar en un struct

summary = (
    df
    .groupBy("merchant_id")
    .agg(
        F.struct(
            F.sum("amount").alias("revenue"),
            F.countDistinct("sale_id").alias("sales"),
        ).alias("metrics")
    )
)

Usa salidas anidadas solo cuando el consumidor posterior se beneficie de un struct.

Las tablas analíticas planas suelen ser más fáciles de consultar.


25. Usar first() y last() con cuidado

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.first(
            "status",
            ignorenulls=True,
        ).alias("some_status")
    )
)

Sin una estrategia de ordenación explícita, first() no significa:

el más antiguo por marca de tiempo

y last() no significa:

el más reciente por marca de tiempo

Usa una ventana o un patrón de agregado ordenado cuando importe el orden temporal.


26. Obtener el valor más reciente con max_by cuando esté disponible

En las versiones de Spark que lo admiten:

summary = (
    df
    .groupBy("customer_id")
    .agg(
        F.max_by(
            F.col("status"),
            F.col("event_time"),
        ).alias("latest_status")
    )
)

Esto devuelve el valor asociado al máximo de la expresión de ordenación.

Usa una ventana cuando necesites varias columnas de la misma fila más reciente o un desempate complejo.


27. Obtener la fila asociada a la marca de tiempo más reciente

Usa una ventana:

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")
)

No uses llamadas independientes a max() sobre varias columnas para reconstruir una fila.


28. Usar rollup() para totales jerárquicos

summary = (
    df
    .rollup(
        "region",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

Esto puede producir:

total por región + comercio
subtotal por región
total general

Los nulos en las columnas de agrupación pueden representar filas de subtotal.

Usa grouping() / grouping_id() cuando necesites distinguir los valores nulos reales de los marcadores de subtotal.


29. Usar cube() para todas las combinaciones de agrupación

summary = (
    df
    .cube(
        "region",
        "channel",
    )
    .agg(
        F.sum("amount").alias("revenue")
    )
)

cube() puede producir muchas combinaciones de agregación.

Úsalo con cuidado, porque el tamaño de la salida crece con el número de dimensiones de agrupación.


30. Usar grouping_id() con rollups y cubes

summary = (
    df
    .rollup(
        "region",
        "merchant_id",
    )
    .agg(
        F.sum("amount").alias("revenue"),
        F.grouping_id().alias("grouping_id"),
    )
)

Esto ayuda a distinguir:

un valor de dimensión nulo real

de:

una fila de subtotal o de total general

31. Usar pivot() solo con categorías acotadas

pivoted = (
    df
    .groupBy("merchant_id")
    .pivot(
        "status",
        [
            "approved",
            "declined",
            "pending",
        ],
    )
    .agg(
        F.count("*")
    )
)

Proporcionar los valores de pivot esperados evita que Spark tenga que descubrir primero cada categoría distinta.

No hagas pivot sobre campos no acotados o de alta cardinalidad.


32. Evitar hacer pivot sobre IDs de cliente o de transacción

Incorrecto:

df.groupBy("merchant_id").pivot("customer_id")

Esto puede crear una cantidad enorme de columnas.

Haz pivot solo sobre conjuntos de categorías pequeños y controlados.


33. Conciliar los totales agregados con el origen

Antes:

source_total = (
    df
    .agg(
        F.sum("amount").alias("amount")
    )
    .first()["amount"]
)

Después:

summary_total = (
    summary
    .agg(
        F.sum("revenue").alias("amount")
    )
    .first()["amount"]
)

Luego compáralos.

Si la transformación solo cambia la granularidad, los totales deberían cuadrar, salvo que la lógica de negocio excluya o modifique filas de forma intencional.


34. Validar la unicidad de la salida con la granularidad prevista

Para:

merchant_id + sale_date

comprueba:

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() correcto debería producir de forma natural combinaciones de agrupación únicas.

Si aparecen duplicados más adelante, puede que un join posterior haya cambiado la granularidad.


35. Comprobar la duplicación de la entrada antes de sumar

(
    df
    .groupBy("sale_id")
    .count()
    .filter(F.col("count") > 1)
    .show(50, truncate=False)
)

Si una venta que debería aparecer una vez aparece varias veces, la agregación puede ocultar la duplicación subyacente mientras infla los totales.

Corrige la granularidad en origen cuando corresponda.


36. Filtrar y proyectar antes de agregar

Prefiere:

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")
    )
)

No arrastres al shuffle columnas grandes de datos que no usas.


37. Inspeccionar el plan físico

summary.explain("formatted")

Busca:

  • Exchange
  • agregación por hash (hash aggregation)
  • agregación por ordenación (sort aggregation)
  • agregación parcial
  • reparticionamiento

Agrupar suele requerir un shuffle, salvo que los datos ya estén particionados de una forma útil.


38. Comprobar el skew de las claves de agrupación

(
    df
    .groupBy("merchant_id")
    .count()
    .orderBy(
        F.desc("count")
    )
    .show(
        50,
        truncate=False,
    )
)

Un número pequeño de grupos enormes puede crear tareas rezagadas.

Causas comunes:

  • un tenant o cliente dominante
  • una clave nula o centinela
  • datos mal formados
  • una distribución de negocio muy desigual

39. No reemplazar todas las claves nulas por un único valor centinela antes de agrupar

Arriesgado:

df = df.fillna(
    {
        "merchant_id": 0
    }
)

Esto puede juntar muchas filas no relacionadas en un único grupo gigantesco.

Usa un valor centinela solo cuando tenga un significado de negocio real.


40. Evitar agregar con UDF de Python cuando bastan las funciones integradas

Prefiere:

F.sum("amount")
F.avg("amount")
F.max("event_time")
F.countDistinct("sale_id")

frente a una lógica de agregación personalizada en Python.

Las funciones integradas de Spark se mantienen dentro del motor de ejecución optimizado de Spark.

Usa pandas UDF o agregaciones personalizadas solo cuando la lógica de negocio no pueda expresarse con funciones integradas.

Qué significa el resultado

Función Significado
count("*") Número de filas del grupo
count("col") Número de valores no nulos en col
countDistinct() Valores distintos no nulos
sum() Suma de los valores no nulos
avg() Media de los valores no nulos
min() / max() Valor mínimo/máximo
collect_set() Valores únicos recopilados en un array
collect_list() Valores recopilados en un array, conservando los duplicados
rollup() Subtotales jerárquicos + total general
cube() Todas las combinaciones de las dimensiones de agrupación
pivot() Convierte valores de categoría en columnas
grouping_id() Identifica el nivel de agrupación de subtotal/total general

El concepto más importante es:

columnas del groupBy = granularidad de salida

Si la granularidad es incorrecta, todas las métricas construidas sobre ella pueden ser incorrectas.

Qué revisar

Los ingresos son demasiado altos

Revisa:

  • claves de origen duplicadas
  • multiplicación de filas por joins anteriores
  • granularidad de agrupación incorrecta
  • archivos de entrada duplicados
  • lotes reprocesados

La agregación puede ocultar filas duplicadas y aun así inflar los totales.

El número de filas baja más de lo esperado

Es normal al agrupar muchas filas en menos grupos, pero verifica:

  • la granularidad prevista
  • el tratamiento de las claves nulas
  • los filtros aplicados antes de agregar

El recuento distinto difiere mucho del número de filas

Esto puede indicar:

  • varias filas físicas por evento de negocio
  • duplicados
  • una granularidad válida de línea de detalle
  • registros de estado o de historial repetidos

Entiende la granularidad del origen antes de decidir que es incorrecta.

Una etapa tarda mucho más de lo esperado

Comprueba el skew de las claves de agrupación y el volumen del shuffle.

Una clave caliente puede dominar el tiempo de agregación.

collect_list() provoca presión de memoria

Puede que uno o varios grupos estén acumulando arrays muy grandes.

Usa otro modelo de datos si la cardinalidad de los grupos no está acotada.

El promedio parece incorrecto

Comprueba si:

  • se excluyen los nulos
  • se requiere ponderación
  • la entrada estaba duplicada
  • la unidad o la granularidad son correctas

Notas de producción

GroupBy suele ser una operación con mucho shuffle

Spark a menudo tiene que redistribuir las filas por clave de agrupación.

Reduce filas y columnas antes de agregar cuando la lógica de negocio lo permita.

Los agregados integrados pueden usar agregación parcial

Spark a menudo puede agregar localmente antes del shuffle y después combinar los resultados.

Esta es una de las razones por las que las funciones de agregación integradas son preferibles a la lógica personalizada en Python.

La cardinalidad de las claves de agrupación afecta al tamaño de la salida

Agrupar por:

merchant_id + fecha

puede producir millones de grupos.

Agrupar por:

country

puede producir solo unas decenas.

La alta cardinalidad no es incorrecta en sí misma, pero cambia el comportamiento del shuffle y de la memoria.

El skew importa más que el tamaño medio de los grupos

Una carga de trabajo puede parecer equilibrada en promedio mientras un solo grupo contiene un porcentaje enorme de las filas.

Inspecciona los grupos más grandes cuando las etapas tengan tareas rezagadas.

Los tipos decimales son preferibles para totales financieros exactos

Usa una precisión/escala de DecimalType adecuada para valores de tipo monetario cuando importe la aritmética exacta.

Evita introducir innecesariamente errores de coma flotante en la conciliación financiera.

La agregación distinct puede ser costosa

countDistinct() y otras operaciones distinct similares pueden requerir un shuffle o un estado considerables.

Úsalas solo cuando la métrica de negocio requiera realmente una semántica distinct.

No uses la agregación para ocultar una granularidad incorrecta

Si un join duplicó cada venta y después vuelves a agrupar a una fila por venta, el resultado puede seguir siendo incorrecto.

Corrige la relación en origen.

Errores comunes

1. Agrupar antes de definir la granularidad de salida

Las columnas de agrupación son el contrato de negocio del resultado.

Defínelas primero.

2. Usar count(col) cuando se necesita el número de filas

count(col) ignora los nulos.

Usa count("*") para contar filas.

3. Usar un promedio simple cuando se necesita un promedio ponderado

Esto produce métricas de negocio matemáticamente incorrectas.

4. Suponer que first() significa el más antiguo

Sin una ordenación, no lo significa.

Usa una ventana o un agregado ordenado.

5. Usar max() en varias columnas para reconstruir la fila más reciente

Cada máximo puede proceder de una fila de origen distinta.

Selecciona la fila real.

6. Hacer pivot sobre campos de alta cardinalidad

Esto puede crear una cantidad de columnas poco práctica.

7. Usar collect_list() en grupos no acotados

Un solo grupo puede llegar a ser demasiado grande para la memoria.

8. Ignorar las claves de agrupación nulas

Spark agrupa los nulos juntos.

Decide si ese grupo es válido.

9. Culpar al rendimiento del groupBy antes de comprobar el skew

Una sola clave caliente puede controlar toda la etapa.

10. Ejecutar muchas agregaciones separadas sobre la misma entrada

Combina los agregados relacionados en un solo agg() cuando sea práctico.

Siguiente paso

Usa el resultado para elegir la siguiente acción.

  • Los totales son demasiado altos → revisa los duplicados en origen y la cardinalidad de los joins.
  • El recuento distinto difiere del número de filas → confirma la granularidad del origen y la semántica de los eventos repetidos.
  • El promedio es engañoso → determina si se requiere ponderación.
  • El valor más reciente es incorrecto → usa lógica de ventana o un agregado ordenado.
  • Un grupo domina → investiga el skew y las claves centinela o nulas.
  • La agregación es lenta → filtra/proyecta antes e inspecciona el shuffle en el plan de Spark.
  • La salida necesita las N primeras filas o las más recientes en lugar de un valor escalar por grupo → pasa a Funciones de ventana en PySpark.
  • El resultado debe persistirse → elige un patrón de escritura Delta adecuado y valida la granularidad de destino.

← Todas las guías rápidas