Explorar guías rápidas · PySpark

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

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
  1. Problema
  2. Respuesta rápida
  3. Código / comandos
  4. 1. Inner join
  5. 2. Left join
  6. 3. Right join
  7. 4. Full outer join
  8. 5. Left semi join
  9. 6. Left anti join
  10. 7. Join sobre varias claves
  11. 8. Join cuando los nombres de las claves son distintos
  12. 9. Selecciona explícitamente las columnas de salida después de un join
  13. 10. Valida la unicidad esperada del lado derecho
  14. 11. Comprueba ambos lados antes de un join de uno a uno
  15. 12. Mide el número de filas antes y después de un join de enriquecimiento
  16. 13. Comprueba la frecuencia de las claves duplicadas
  17. 14. Muestra cuántas correspondencias recibe cada clave del lado izquierdo
  18. 15. Entiende la expansión de muchos a muchos
  19. 16. Elimina duplicados de forma deliberada antes de un join
  20. 17. Usa dropDuplicates() solo cuando cualquier fila duplicada sea equivalente
  21. 18. Gestiona de forma deliberada las claves de join nulas
  22. 19. Usa la igualdad null-safe cuando sea necesario
  23. 20. Normaliza los tipos de las claves del join antes de hacerlo
  24. 21. Normaliza las claves de texto con cuidado
  25. 22. Filtra y proyecta antes del join
  26. 23. Inspecciona el plan físico del join
  27. 24. Haz broadcast de una tabla de búsqueda pequeña
  28. 25. Verifica que el broadcast se haya producido
  29. 26. Evita recopilar claves de búsqueda en el driver
  30. 27. Comprueba el skew de las claves del join
  31. 28. Comprueba el skew en ambos lados
  32. 29. Evita reemplazar todas las claves nulas por un único valor centinela antes de un join
  33. 30. Reparticiona de forma deliberada antes de trabajo repetido basado en claves
  34. 31. Entiende la diferencia entre bucketing y reparticionamiento
  35. 32. Usa un cross join solo de forma intencional
  36. 33. Cuidado con los cross joins accidentales
  37. 34. Usa con cuidado los joins por rango o de no igualdad
  38. 35. Valida las filas izquierdas sin correspondencia
  39. 36. Calcula una tasa de correspondencia
  40. 37. Concilia los totales después de un join de enriquecimiento
  41. 38. Preserva la granularidad después del join
  42. 39. Guarda en caché una dimensión pequeña reutilizada solo cuando esté justificado
  43. 40. Compara los planes antes y después de un cambio de ajuste
  44. Qué significa el resultado
  45. Qué revisar
  46. El left join aumenta el número de filas
  47. Los totales aumentan después del enriquecimiento
  48. Muchas filas siguen sin correspondencia
  49. Una tarea de Spark tarda mucho más que las demás
  50. El plan usa un sort-merge join para una tabla de búsqueda muy pequeña
  51. El broadcast join causa problemas de memoria
  52. El join genera un shuffle enorme a pesar de un resultado pequeño
  53. Notas de producción
  54. La granularidad del resultado debe documentarse
  55. El número de filas no es suficiente
  56. Las decisiones de broadcast deben considerar los bytes, no solo las filas
  57. Adaptive Query Execution puede cambiar el comportamiento de los joins
  58. Las claves nulas merecen un tratamiento explícito
  59. Una relación de muchos a muchos no es incorrecta en sí misma
  60. La optimización de joins depende de la distribución de los datos
  61. Errores comunes
  62. 1. Hacer el join antes de comprobar la unicidad de las claves
  63. 2. Usar dropDuplicates() después de un join incorrecto
  64. 3. Hacer broadcast sin comprobar el tamaño
  65. 4. Recopilar claves de búsqueda en Python
  66. 5. Hacer joins de DataFrames anchos
  67. 6. Ignorar la semántica de los nulos en los joins
  68. 7. Reemplazar las claves nulas por un único valor centinela
  69. 8. Validar la corrección solo con el número de filas
  70. 9. Suponer que el optimizador eligió el mejor plan en todos los casos
  71. 10. Reparticionar a ciegas antes de cada join
  72. Siguiente paso
  73. 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:

  • BroadcastHashJoin
  • SortMergeJoin
  • ShuffledHashJoin

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.

Siguiente paso

Usa el síntoma para elegir la siguiente acción.

  • El número de filas del left join aumentó → revisa las claves duplicadas del lado derecho.
  • Muchas filas sin correspondencia → compara los tipos de las claves, el formato y la completitud de las claves compuestas.
  • Totales inflados → inspecciona la expansión de muchos a muchos.
  • Una tarea domina el tiempo de ejecución → investiga el skew de las claves del join.
  • La tabla de búsqueda es pequeña → prueba el broadcast y verifica el plan.
  • El shuffle es grande → filtra/proyecta ambos lados antes.
  • Las claves nulas se comportan de forma inesperada → define explícitamente la semántica de los nulos.
  • La granularidad del resultado cambió → corrige la lógica de la relación antes de ajustar el rendimiento.
  • El join sigue siendo lento después de demostrar su corrección → pasa a Referencia rápida de rendimiento de PySpark e inspecciona las etapas de Spark y el shuffle.

← Todas las guías rápidas