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