Explorar guías rápidas · PySpark
Joins de DataFrames en PySpark
Haz joins de DataFrames de PySpark de forma segura validando la cardinalidad de las claves, eligiendo el tipo y la estrategia de join adecuados, evitando la multiplicación de filas y gestionando el skew, los nulos y las columnas ambiguas.
En esta página
- Problema
- Respuesta rápida
- Código / comandos
- 1. Inner join
- 2. Left join
- 3. Right join
- 4. Full outer join
- 5. Left semi join
- 6. Left anti join
- 7. Join sobre varias claves
- 8. Join cuando los nombres de las claves son distintos
- 9. Selecciona explícitamente las columnas de salida después de un join
- 10. Valida la unicidad esperada del lado derecho
- 11. Comprueba ambos lados antes de un join de uno a uno
- 12. Mide el número de filas antes y después de un join de enriquecimiento
- 13. Comprueba la frecuencia de las claves duplicadas
- 14. Muestra cuántas correspondencias recibe cada clave del lado izquierdo
- 15. Entiende la expansión de muchos a muchos
- 16. Elimina duplicados de forma deliberada antes de un join
- 17. Usa dropDuplicates() solo cuando cualquier fila duplicada sea equivalente
- 18. Gestiona de forma deliberada las claves de join nulas
- 19. Usa la igualdad null-safe cuando sea necesario
- 20. Normaliza los tipos de las claves del join antes de hacerlo
- 21. Normaliza las claves de texto con cuidado
- 22. Filtra y proyecta antes del join
- 23. Inspecciona el plan físico del join
- 24. Haz broadcast de una tabla de búsqueda pequeña
- 25. Verifica que el broadcast se haya producido
- 26. Evita recopilar claves de búsqueda en el driver
- 27. Comprueba el skew de las claves del join
- 28. Comprueba el skew en ambos lados
- 29. Evita reemplazar todas las claves nulas por un único valor centinela antes de un join
- 30. Reparticiona de forma deliberada antes de trabajo repetido basado en claves
- 31. Entiende la diferencia entre bucketing y reparticionamiento
- 32. Usa un cross join solo de forma intencional
- 33. Cuidado con los cross joins accidentales
- 34. Usa con cuidado los joins por rango o de no igualdad
- 35. Valida las filas izquierdas sin correspondencia
- 36. Calcula una tasa de correspondencia
- 37. Concilia los totales después de un join de enriquecimiento
- 38. Preserva la granularidad después del join
- 39. Guarda en caché una dimensión pequeña reutilizada solo cuando esté justificado
- 40. Compara los planes antes y después de un cambio de ajuste
- Qué significa el resultado
- Qué revisar
- El left join aumenta el número de filas
- Los totales aumentan después del enriquecimiento
- Muchas filas siguen sin correspondencia
- Una tarea de Spark tarda mucho más que las demás
- El plan usa un sort-merge join para una tabla de búsqueda muy pequeña
- El broadcast join causa problemas de memoria
- El join genera un shuffle enorme a pesar de un resultado pequeño
- Notas de producción
- La granularidad del resultado debe documentarse
- El número de filas no es suficiente
- Las decisiones de broadcast deben considerar los bytes, no solo las filas
- Adaptive Query Execution puede cambiar el comportamiento de los joins
- Las claves nulas merecen un tratamiento explícito
- Una relación de muchos a muchos no es incorrecta en sí misma
- La optimización de joins depende de la distribución de los datos
- Errores comunes
- 1. Hacer el join antes de comprobar la unicidad de las claves
- 2. Usar dropDuplicates() después de un join incorrecto
- 3. Hacer broadcast sin comprobar el tamaño
- 4. Recopilar claves de búsqueda en Python
- 5. Hacer joins de DataFrames anchos
- 6. Ignorar la semántica de los nulos en los joins
- 7. Reemplazar las claves nulas por un único valor centinela
- 8. Validar la corrección solo con el número de filas
- 9. Suponer que el optimizador eligió el mejor plan en todos los casos
- 10. Reparticionar a ciegas antes de cada join
- Siguiente paso
- Para profundizar
Problema
Hacer joins de DataFrames es una de las operaciones más comunes y más costosas en Spark.
Los problemas en producción suelen deberse a:
- un tipo de join incorrecto
- claves duplicadas en uno o ambos lados
- una expansión de muchos a muchos accidental
- claves de join nulas
- nombres de columna duplicados ambiguos
- hacer el join antes de filtrar o proyectar
- hacer broadcast de una tabla que en realidad no es pequeña
- claves de join con skew
- recopilar claves de búsqueda en Python
- suposiciones incorrectas sobre la granularidad del resultado
El objetivo es hacer explícita la relación del join antes de optimizar el rendimiento.
Respuesta rápida
Empieza validando la relación esperada.
Ejemplo de enriquecimiento de muchos a uno:
from pyspark.sql import functions as F
duplicate_keys = (
merchants
.groupBy("merchant_id")
.count()
.filter(F.col("count") > 1)
)
if duplicate_keys.limit(1).count() > 0:
raise RuntimeError(
"merchant_id is not unique in merchants"
)
Después, haz el join:
result = (
sales.alias("s")
.join(
merchants.alias("m"),
on="merchant_id",
how="left",
)
.select(
"sale_id",
"merchant_id",
"amount",
"merchant_name",
)
)
Usa este modelo de decisión:
Necesitas solo las filas con correspondencia
→ inner
Necesitas todas las filas del lado izquierdo
→ left
Necesitas todas las filas del lado derecho
→ right
Necesitas todas las filas de ambos lados
→ full
Necesitas solo las filas izquierdas con correspondencia
→ left_semi
Necesitas solo las filas izquierdas sin correspondencia
→ left_anti
Antes de optimizar el join, verifica que el número de filas y la granularidad del resultado sean correctos.
Código / comandos
1. Inner join
result = sales.join(
merchants,
on="merchant_id",
how="inner",
)
Úsalo cuando solo deban conservarse las claves con correspondencia.
Ten en cuenta que las filas sin correspondencia de cualquiera de los dos lados desaparecen.
2. Left join
result = sales.join(
merchants,
on="merchant_id",
how="left",
)
Úsalo cuando deba conservarse cada fila del lado izquierdo.
Es habitual para enriquecer datos.
Un left join puede aumentar igualmente el número de filas si el lado derecho tiene claves duplicadas.
3. Right join
result = sales.join(
merchants,
on="merchant_id",
how="right",
)
Úsalo cuando deba conservarse cada fila del lado derecho.
Si la lógica resulta poco natural, considera intercambiar las entradas izquierda/derecha y usar un left join para mayor claridad.
4. Full outer join
result = left.join(
right,
on="customer_id",
how="full",
)
Úsalo cuando importen las filas sin correspondencia de ambos lados.
Es útil para conciliar.
Decide de forma deliberada cómo se interpretarán más adelante los nulos procedentes de los lados sin correspondencia.
5. Left semi join
Conserva solo las filas izquierdas que tienen correspondencia:
matched_sales = sales.join(
merchants.select("merchant_id"),
on="merchant_id",
how="left_semi",
)
Es un filtro de existencia.
No añade al resultado columnas del lado derecho.
6. Left anti join
Conserva solo las filas izquierdas sin correspondencia:
orphan_sales = sales.join(
merchants.select("merchant_id"),
on="merchant_id",
how="left_anti",
)
Úsalo para:
- claves foráneas sin correspondencia
- excepciones de calidad de datos
- detección incremental de claves nuevas
- conciliación
7. Join sobre varias claves
result = left.join(
right,
on=[
"member_id",
"merchant_id",
"site_id",
],
how="left",
)
Usa todas las columnas que definen la relación de negocio real.
No reduzcas una clave compuesta a una sola columna por comodidad.
8. Join cuando los nombres de las claves son distintos
l = left.alias("l")
r = right.alias("r")
result = (
l.join(
r,
F.col("l.customer_id")
== F.col("r.client_id"),
"left",
)
)
Al usar una condición explícita, pueden quedar columnas de clave del join duplicadas.
Selecciona explícitamente las columnas de salida que necesitas.
9. Selecciona explícitamente las columnas de salida después de un join
result = (
sales.alias("s")
.join(
merchants.alias("m"),
F.col("s.merchant_id")
== F.col("m.merchant_id"),
"left",
)
.select(
F.col("s.sale_id"),
F.col("s.merchant_id"),
F.col("s.amount"),
F.col("m.merchant_name"),
)
)
Así evitas:
- columnas ambiguas
- columnas de clave duplicadas
- arrastrar datos innecesarios
10. Valida la unicidad esperada del lado derecho
Para un join de muchos a uno:
duplicate_right = (
right
.groupBy("customer_id")
.count()
.filter(F.col("count") > 1)
)
Falla si no se permiten duplicados:
if duplicate_right.limit(1).count() > 0:
raise RuntimeError(
"Expected unique customer_id on right side"
)
Es el equivalente en Spark de hacer explícitas las suposiciones de cardinalidad del join.
11. Comprueba ambos lados antes de un join de uno a uno
def has_duplicate_keys(df, keys):
return (
df.groupBy(*keys)
.count()
.filter(F.col("count") > 1)
.limit(1)
.count()
> 0
)
Después:
keys = ["customer_id"]
if has_duplicate_keys(left, keys):
raise RuntimeError(
"Left side is not unique"
)
if has_duplicate_keys(right, keys):
raise RuntimeError(
"Right side is not unique"
)
Úsalo para suposiciones de uno a uno críticas para el negocio.
Para DataFrames muy grandes, crea un patrón de validación reutilizable que evite lecturas completas repetidas innecesarias.
12. Mide el número de filas antes y después de un join de enriquecimiento
before = sales.count()
result = sales.join(
merchants,
"merchant_id",
"left",
)
after = result.count()
print("Before:", before)
print("After:", after)
print("Difference:", after - before)
Si un left join de enriquecimiento crece de forma inesperada, revisa primero los duplicados del lado derecho.
En pipelines a escala de producción, evita los recuentos completos repetidos salvo que la validación compense el costo de la lectura.
13. Comprueba la frecuencia de las claves duplicadas
(
merchants
.groupBy("merchant_id")
.count()
.filter(F.col("count") > 1)
.orderBy(F.desc("count"))
.show(50, truncate=False)
)
Esto te indica si la duplicación está:
- aislada
- generalizada
- dominada por unas pocas claves
14. Muestra cuántas correspondencias recibe cada clave del lado izquierdo
match_counts = (
sales.alias("s")
.join(
merchants.alias("m"),
F.col("s.merchant_id")
== F.col("m.merchant_id"),
"left",
)
.groupBy(
F.col("s.merchant_id").alias("merchant_id")
)
.agg(
F.count("*").alias("joined_rows")
)
)
Úsalo con cuidado: si sales ya tiene IDs de comercio repetidos, esto no es un recuento directo de correspondencias del lado derecho.
Para analizar la relación, revisa primero cada lado de forma independiente.
15. Entiende la expansión de muchos a muchos
Supón que el lado izquierdo tiene:
customer_id = 1
2 filas
y el lado derecho tiene:
customer_id = 1
3 filas
El join produce:
2 × 3 = 6 filas
No es un error de Spark.
Es la semántica de un join relacional.
Si no es lo que pretendías, corrige la granularidad antes del join.
16. Elimina duplicados de forma deliberada antes de un join
Si debe sobrevivir una sola fila:
from pyspark.sql import Window
w = (
Window
.partitionBy("merchant_id")
.orderBy(
F.col("updated_at").desc(),
F.col("source_sequence").desc(),
)
)
merchants_one_row = (
merchants
.withColumn(
"_rn",
F.row_number().over(w),
)
.filter(F.col("_rn") == 1)
.drop("_rn")
)
Después, haz el join.
No uses un dropDuplicates() arbitrario cuando importa qué fila sobrevive.
17. Usa dropDuplicates() solo cuando cualquier fila duplicada sea equivalente
unique_merchants = (
merchants
.dropDuplicates(
["merchant_id"]
)
)
Esto solo es seguro si todas las filas duplicadas son equivalentes para el uso posterior.
Si los valores difieren, define un ganador determinista.
18. Gestiona de forma deliberada las claves de join nulas
Los joins de igualdad estándar no hacen coincidir null con null.
Ejemplo:
left.join(
right,
"customer_id",
"inner",
)
Las filas con customer_id null no coinciden entre sí mediante la igualdad normal.
Si la igualdad null-safe es realmente la regla de negocio, usa la igualdad null-safe de Spark.
19. Usa la igualdad null-safe cuando sea necesario
result = (
left.alias("l")
.join(
right.alias("r"),
F.col("l.customer_id").eqNullSafe(
F.col("r.customer_id")
),
"inner",
)
)
Úsala solo cuando:
null en el lado izquierdo
deba coincidir deliberadamente con:
null en el lado derecho
Es poco habitual en claves de negocio reales.
20. Normaliza los tipos de las claves del join antes de hacerlo
Inspecciona:
left.printSchema()
right.printSchema()
Normaliza de forma explícita:
left = left.withColumn(
"customer_id",
F.col("customer_id").cast("string"),
)
right = right.withColumn(
"customer_id",
F.col("customer_id").cast("string"),
)
Una clave de join debe tener tipos semánticos y físicos coherentes.
No dependas de conversiones implícitas accidentales.
21. Normaliza las claves de texto con cuidado
left = left.withColumn(
"customer_id_normalized",
F.trim(
F.col("customer_id")
),
)
Si una semántica que no distingue mayúsculas de minúsculas es válida:
left = left.withColumn(
"customer_id_normalized",
F.lower(
F.trim(F.col("customer_id"))
),
)
Aplica la misma regla en ambos lados.
No conviertas a minúsculas ni elimines espacios de los identificadores salvo que la semántica de negocio lo permita.
22. Filtra y proyecta antes del join
Prefiere:
sales_small = (
sales
.filter(
F.col("sale_date") >= "2026-10-01"
)
.select(
"merchant_id",
"sale_id",
"amount",
)
)
merchants_small = (
merchants
.select(
"merchant_id",
"merchant_name",
)
)
result = sales_small.join(
merchants_small,
"merchant_id",
"left",
)
Reduce los datos antes del shuffle siempre que la lógica lo permita.
23. Inspecciona el plan físico del join
result.explain("formatted")
Busca operadores de join como:
BroadcastHashJoinSortMergeJoinShuffledHashJoin
La estrategia elegida te indica cómo planea Spark mover y comparar los datos.
No fuerces una estrategia sin entender por qué la actual es lenta.
24. Haz broadcast de una tabla de búsqueda pequeña
result = sales.join(
F.broadcast(merchants),
on="merchant_id",
how="left",
)
El broadcast puede evitar el shuffle del lado grande.
Úsalo cuando la tabla de búsqueda sea realmente lo bastante pequeña para la memoria de los executors.
No hagas broadcast de una tabla solo porque tenga menos filas que la tabla de hechos.
El ancho de las filas también importa.
25. Verifica que el broadcast se haya producido
result.explain("formatted")
Busca:
BroadcastHashJoin
No supongas que la sugerencia (hint) o el umbral de broadcast automático produjeron el plan que esperabas.
26. Evita recopilar claves de búsqueda en el driver
Incorrecto:
merchant_ids = [
row["merchant_id"]
for row in merchants.collect()
]
filtered = sales.filter(
F.col("merchant_id").isin(
merchant_ids
)
)
Usa un semi join:
filtered = sales.join(
merchants.select("merchant_id"),
"merchant_id",
"left_semi",
)
Así la operación sigue siendo distribuida.
27. Comprueba el skew de las claves del join
(
sales
.groupBy("merchant_id")
.count()
.orderBy(F.desc("count"))
.show(50, truncate=False)
)
Busca claves que dominen la distribución de las filas.
Una clave caliente puede hacer que una o unas pocas tareas duren mucho más que el resto.
28. Comprueba el skew en ambos lados
(
merchants
.groupBy("merchant_id")
.count()
.orderBy(F.desc("count"))
.show(50, truncate=False)
)
El skew en cualquiera de los dos lados puede afectar al join.
Claves calientes habituales:
- valores de reemplazo de nulos
"UNKNOWN"0- un tenant o cliente muy grande
- registros mal formados que se agrupan en una sola clave
29. Evita reemplazar todas las claves nulas por un único valor centinela antes de un join
Arriesgado:
df = df.fillna(
{
"merchant_id": 0
}
)
Después, hacer el join sobre merchant_id puede crear un enorme grupo de clave caliente en 0.
Usa el reemplazo por un valor centinela solo cuando la regla de negocio lo exija y se entienda el impacto en el skew.
30. Reparticiona de forma deliberada antes de trabajo repetido basado en claves
sales_by_merchant = sales.repartition(
"merchant_id"
)
Esto crea un shuffle.
Úsalo solo cuando el particionamiento resultante pueda reutilizarse lo suficiente para justificar el costo.
No reparticiones antes de cada join por costumbre.
31. Entiende la diferencia entre bucketing y reparticionamiento
repartition() afecta a la ejecución actual del DataFrame.
Las estrategias persistentes de bucketing o de diseño de tablas son distintas y dependen de la ruta de almacenamiento de Spark/Fabric y de las características de tabla admitidas.
No supongas que una llamada a repartition() organiza de forma permanente la tabla Delta en disco.
32. Usa un cross join solo de forma intencional
result = left.crossJoin(
right
)
Un cross join produce:
left_rows × right_rows
Úsalo solo cuando la multiplicación cartesiana sea el requisito real.
Con entradas grandes, el resultado puede dispararse rápidamente.
33. Cuidado con los cross joins accidentales
Una condición de join incorrecta puede producir un comportamiento cartesiano inesperado o un crecimiento masivo del número de filas.
Valida siempre:
las claves del join
la condición del join
el número de filas de salida
la granularidad de negocio
después de añadir o cambiar la lógica del join.
34. Usa con cuidado los joins por rango o de no igualdad
Ejemplo:
result = (
events.alias("e")
.join(
rates.alias("r"),
(
F.col("e.event_time")
>= F.col("r.valid_from")
)
& (
F.col("e.event_time")
< F.col("r.valid_to")
),
"left",
)
)
Los joins por rango pueden ser costosos, porque los hash joins basados en igualdad pueden no aplicarse directamente.
Reduce al máximo ambos lados y valida la multiplicación de filas.
35. Valida las filas izquierdas sin correspondencia
unmatched = sales.join(
merchants.select("merchant_id"),
"merchant_id",
"left_anti",
)
Inspecciona:
unmatched.show(
100,
truncate=False,
)
Suele ser la forma más rápida de diagnosticar datos de referencia faltantes.
36. Calcula una tasa de correspondencia
total = sales.count()
matched = (
sales.join(
merchants.select("merchant_id"),
"merchant_id",
"left_semi",
)
.count()
)
match_rate = (
matched / total
if total
else None
)
print(match_rate)
No existe una tasa de correspondencia aceptable universal.
Compárala con el contrato de la fuente y con el comportamiento histórico.
37. Concilia los totales después de un join de enriquecimiento
Supón que el join no debería cambiar los totales de los importes de ventas.
Antes:
before = (
sales
.agg(
F.sum("amount").alias("amount")
)
.first()["amount"]
)
Después:
after = (
result
.agg(
F.sum("amount").alias("amount")
)
.first()["amount"]
)
Si el total aumenta de forma inesperada, investiga la multiplicación de filas.
38. Preserva la granularidad después del join
Documenta:
Granularidad de ventas de entrada:
una fila por sale_id
Granularidad de salida esperada:
una fila por sale_id
Después, valida:
duplicates = (
result
.groupBy("sale_id")
.count()
.filter(F.col("count") > 1)
)
if duplicates.limit(1).count() > 0:
raise RuntimeError(
"Join changed sale_id grain"
)
Esto es más significativo que el número de filas por sí solo.
39. Guarda en caché una dimensión pequeña reutilizada solo cuando esté justificado
merchants_small = (
merchants
.select(
"merchant_id",
"merchant_name",
)
.cache()
)
merchants_small.count()
Si muchos joins reutilizan la misma dimensión costosa de construir, la caché puede ayudar.
Si se lee una sola vez, la caché añade trabajo y uso de memoria innecesarios.
40. Compara los planes antes y después de un cambio de ajuste
Antes:
result.explain("formatted")
Después de añadir un broadcast o cambiar las proyecciones:
optimized_result.explain("formatted")
Después, mide una acción real de Spark.
No des por bueno un cambio porque el código parezca más limpio.
Valida:
- el plan físico
- el tiempo de ejecución
- el shuffle
- la corrección del resultado
Qué significa el resultado
| Tipo de join | Conserva |
|---|---|
inner |
solo las filas con correspondencia |
left |
todas las filas izquierdas + correspondencias |
right |
todas las filas derechas + correspondencias |
full |
todas las filas de ambos lados |
left_semi |
las filas izquierdas que tienen correspondencia |
left_anti |
las filas izquierdas que no tienen correspondencia |
| cross join | cada fila izquierda emparejada con cada fila derecha |
Estrategias físicas comunes:
| Estrategia | Significado habitual |
|---|---|
BroadcastHashJoin |
un lado se envía a los executors; se puede evitar el shuffle del lado grande |
SortMergeJoin |
ambos lados se redistribuyen/ordenan por las claves del join |
ShuffledHashJoin |
hash join después del shuffle |
La distinción más importante es:
la corrección lógica del join
va antes de
la optimización física del join
Qué revisar
El left join aumenta el número de filas
Causas probables:
- claves duplicadas en el lado derecho
- una relación real de uno a muchos
- una clave de join incorrecta
No añadas dropDuplicates() después del join hasta entender la relación.
Los totales aumentan después del enriquecimiento
Es una señal clara de multiplicación de filas.
Revisa la unicidad de las claves y la granularidad.
Muchas filas siguen sin correspondencia
Revisa:
- el dtype
- los espacios en blanco
- las mayúsculas y minúsculas
- los ceros a la izquierda
- las filas de referencia faltantes
- la completitud de las claves compuestas
Una tarea de Spark tarda mucho más que las demás
Revisa el skew de las claves.
Una sola clave dominante puede determinar la duración total del join.
El plan usa un sort-merge join para una tabla de búsqueda muy pequeña
Comprueba si el broadcast es adecuado y si Spark reconoce el lado pequeño.
No fuerces el broadcast antes de comprobar el tamaño real.
El broadcast join causa problemas de memoria
Es posible que el lado del broadcast no sea lo bastante pequeño en bytes.
Quita la sugerencia o reduce más la dimensión.
El join genera un shuffle enorme a pesar de un resultado pequeño
Filtra y proyecta antes.
El tamaño del resultado no refleja cuántos datos tuvo que mover Spark.
Notas de producción
La granularidad del resultado debe documentarse
Para cada join importante, anota:
granularidad del lado izquierdo
granularidad del lado derecho
granularidad de salida esperada
Esto detecta más errores que los ajustes de configuración.
El número de filas no es suficiente
Un join puede mantener el mismo número de filas y aun así asociar la fila de referencia equivocada.
Valida también:
- las claves de negocio
- los recuentos sin correspondencia
- los totales importantes
- una muestra de claves
- la lógica de fechas de vigencia
Las decisiones de broadcast deben considerar los bytes, no solo las filas
Una tabla de búsqueda con pocas filas pero con datos muy anchos puede seguir siendo costosa de distribuir mediante broadcast.
Proyecta solo las columnas necesarias antes del broadcast.
Adaptive Query Execution puede cambiar el comportamiento de los joins
Spark puede ajustar los planes en tiempo de ejecución según las estadísticas recopiladas y la configuración.
Inspecciona el comportamiento físico realmente ejecutado en lugar de suponer que la forma lógica inicial lo explica todo.
Las claves nulas merecen un tratamiento explícito
En los joins de igualdad normales, null no es igual a null.
No reemplaces los nulos a la ligera por un único valor centinela, porque eso puede provocar tanto errores semánticos como skew.
Una relación de muchos a muchos no es incorrecta en sí misma
Algunas cargas de trabajo requieren legítimamente joins de muchos a muchos.
El problema aparece cuando se esperaba que la relación fuera de uno a uno o de muchos a uno.
La optimización de joins depende de la distribución de los datos
No existe una estrategia de join universalmente mejor.
Mide con datos representativos.
Errores comunes
1. Hacer el join antes de comprobar la unicidad de las claves
Es el camino más rápido hacia una multiplicación de filas accidental.
2. Usar dropDuplicates() después de un join incorrecto
Esto oculta el problema de cardinalidad y puede descartar filas válidas.
3. Hacer broadcast sin comprobar el tamaño
El broadcast no es automáticamente mejor.
4. Recopilar claves de búsqueda en Python
Usa semi/anti joins en su lugar.
5. Hacer joins de DataFrames anchos
Proyecta solo las columnas necesarias antes del shuffle.
6. Ignorar la semántica de los nulos en los joins
Los nulos no coinciden con la igualdad normal.
7. Reemplazar las claves nulas por un único valor centinela
Esto puede crear una clave caliente enorme.
8. Validar la corrección solo con el número de filas
Valida también la granularidad y los totales de negocio.
9. Suponer que el optimizador eligió el mejor plan en todos los casos
Normalmente lo hace bien, pero el skew, unas estadísticas desactualizadas, una forma de datos inusual o las sugerencias pueden cambiar el resultado.
Inspecciona el plan cuando el rendimiento importe.
10. Reparticionar a ciegas antes de cada join
Un reparticionamiento es en sí mismo un shuffle.
Paga ese costo solo cuando haya un beneficio claro.
¿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.