Cómo hacer un join de DataFrames en PySpark: paso a paso

Combinar información de varias tablas es una de las tareas más habituales en la ingeniería de datos. En PySpark, el método join permite cruzar dos DataFrames por una columna en común — por ejemplo, asociar cada venta con el nombre de su cliente. Un join es, en la práctica, el equivalente al JOIN de SQL, pero aplicado a DataFrames distribuidos. En esta guía aprenderá, paso a paso, cómo hacer un join de DataFrames en PySpark, elegir el tipo correcto y evitar los errores más frecuentes.

Requisitos previos

• Un entorno con PySpark disponible (Databricks, Microsoft Fabric o una instalación local de Spark).
• Una SparkSession activa — en los notebooks de Databricks y de Fabric ya existe con el nombre spark.
• Nociones básicas de DataFrames: cómo crearlos y cómo ver los datos con show().

Paso 1: Crear dos DataFrames de ejemplo

Vamos a usar dos DataFrames pequeños: uno con clientes y otro con ventas. Cada venta tiene un cliente_id que corresponde al id de un cliente. Esa columna en común es la que enlaza las dos tablas — sin una clave compartida no hay join posible.

from pyspark.sql import SparkSession

spark = SparkSession.builder.getOrCreate()

clientes = spark.createDataFrame(
    [(1, "Ana"), (2, "Bruno"), (3, "Carla")],
    ["id", "nome"],
)

vendas = spark.createDataFrame(
    [(101, 1, 250.0), (102, 1, 90.0), (103, 2, 400.0)],
    ["venda_id", "cliente_id", "valor"],
)

Paso 2: Hacer el join de los DataFrames

El método join recibe tres argumentos: el segundo DataFrame, la condición de unión y el tipo de join. Para asociar cada venta con su cliente, comparamos vendas.cliente_id con clientes.id. El tipo inner — el valor por defecto — mantiene solo las filas que tienen correspondencia en las dos tablas.

resultado = vendas.join(
    clientes,
    vendas.cliente_id == clientes.id,
    "inner",
)

resultado.show()

El resultado combina las columnas de las dos tablas: cada fila de venta pasa a incluir también el nome del cliente. Con los datos del ejemplo se obtienen tres filas — las dos compras de Ana y la compra de Bruno — cada una ya con el nombre correspondiente. Carla no aparece porque no tiene ventas.

Paso 3: Elegir el tipo de join correcto

No siempre queremos solo las correspondencias. Un left join mantiene todas las filas de la tabla de la izquierda, incluso cuando no hay pareja a la derecha — en esos casos, las columnas que faltan se rellenan con null. Basta con cambiar el tercer argumento:

vendas.join(clientes, vendas.cliente_id == clientes.id, "left").show()

Los tipos más comunes son inner, left, right y outer. La elección depende de la pregunta que quiera responder: "solo lo que tiene pareja" (inner) o "todo de un lado, con o sin pareja" (left o right).

Paso 4: Evitar nombres de columnas duplicados

Un error clásico ocurre cuando las columnas de unión tienen el mismo nombre en las dos tablas: el resultado queda con dos columnas con el mismo nombre y cualquier intento de seleccionarlas da un error de ambigüedad. La forma más limpia de evitarlo es dar el mismo nombre a la clave en las dos tablas y pasar solo ese nombre como texto — así PySpark las fusiona en una única columna:

clientes2 = clientes.withColumnRenamed("id", "cliente_id")

vendas.join(clientes2, "cliente_id", "inner").show()

Ahora la condición es solo "cliente_id" y el resultado tiene una sola columna con ese nombre, sin duplicados.

Consejo: cuando una de las tablas es mucho más pequeña (como una tabla de referencia), envuélvala en broadcast para acelerar el join y reducir el intercambio de datos entre nodos — from pyspark.sql.functions import broadcast y después vendas.join(broadcast(clientes2), "cliente_id").

Verificar el resultado

Para confirmar que el join salió bien, compare el número de filas antes y después. Un inner join nunca devuelve más correspondencias de las que existen; si el total se dispara de forma inesperada, es señal de que la clave tiene valores repetidos y ha creado una relación muchos-a-muchos.

print("Vendas:", vendas.count())
print("Resultado:", resultado.count())
resultado.printSchema()

El printSchema() muestra todas las columnas finales — debería ver las columnas de las ventas más las columnas de los clientes (id y nome). Si las columnas y el recuento cuadran, el join es correcto.

Conclusión

Ya sabe cruzar dos DataFrames en PySpark, elegir el tipo de join adecuado y evitar el problema de las columnas duplicadas — la base de casi todos los pipelines de datos. El siguiente paso natural es combinar el join con groupBy para agregar los datos cruzados, como calcular el total de ventas por cliente. ¿Cuál será la primera tabla que va a unir en su proyecto?