Unión completa de datos con FULL OUTER JOIN

Hoy vamos a ver la forma más democrática de unir datos — FULL OUTER JOIN. Es una unión donde todo el que quiera entra en el resultado, aunque no tenga pareja.

FULL OUTER JOIN es un tipo de unión de datos donde se devuelven todas las filas de ambas tablas. Si una fila de una tabla no tiene su correspondiente en la otra, en el resultado esos valores faltantes serán NULL. Es como llevar la cuenta de todas las personas que vinieron a dos fiestas diferentes: aunque alguien solo haya ido a una, igual aparece en la lista.

Visualmente se puede imaginar así:

Tabla A                     Tabla B
+----+----------+             +----+----------+
| id | nombre   |             | id | curso    |
+----+----------+             +----+----------+
| 1  | Alice    |             | 2  | Matemáticas |
| 2  | Bob      |             | 3  | Física      |
| 4  | Charlie  |             | 5  | Historia    |
+----+----------+             +----+----------+

FULL OUTER JOIN RESULTADO:
+----+----------+----------+
| id | nombre   | curso    |
+----+----------+----------+
| 1  | Alice    | NULL     |
| 2  | Bob      | Matemáticas |
| 3  | NULL     | Física      |
| 4  | Charlie  | NULL     |
| 5  | NULL     | Historia   |
+----+----------+----------+

Las filas sin correspondencia se quedan, pero los datos de las columnas que faltan se rellenan con NULL.

Sintaxis de FULL OUTER JOIN

La sintaxis es sencilla, pero su poder es grande:

SELECT
    columnas
FROM 
    tabla1
FULL OUTER JOIN 
    tabla2
ON tabla1.columna_comun = tabla2.columna_comun;

La parte clave aquí es FULL OUTER JOIN, que hace que PostgreSQL coja todas las filas de ambas tablas. Si a alguna fila le falta pareja según la condición ON, los valores se ponen como NULL.

Ejemplos de uso

Vamos a ver ejemplos reales usando la base de datos university con las tablas students y enrollments.

Ejemplo 1: lista de todos los estudiantes y cursos

Imagina que tenemos dos tablas:

Tabla students:

Tabla enrollments:

Nuestra tarea es hacer una lista completa de estudiantes y cursos, incluyendo los estudiantes que no están inscritos en ningún curso y los cursos sin estudiantes.

Aquí va la consulta:

SELECT
    s.student_id, 
    s.nombre, 
    e.curso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Resultado:

Como ves, en el resultado están todos los estudiantes y todos los cursos. El estudiante Charlie no está inscrito en ningún curso, así que su campo curso es NULL. Y el curso Historia no tiene estudiante, así que su student_id y nombre son NULL.

Ejemplo 2: Análisis de ventas y productos

Ahora pensemos en una tienda. Tenemos dos tablas:

Tabla products:

Tabla sales:

Queremos obtener la lista completa de todos los productos y ventas, incluyendo los productos que no se han vendido y ventas con identificadores product_id incorrectos.

Consulta:

SELECT
    p.product_id,
    p.nombre AS nombre_producto,
    s.cantidad
FROM 
    products p
FULL OUTER JOIN 
    sales s
ON 
    p.product_id = s.product_id;

Resultado:

Aquí vemos que Smartphone no tuvo ventas (cantidad = NULL), y la venta con product_id = 4 no corresponde a ningún producto.

Ejercicio práctico

Intenta escribir una consulta para las tablas departments y employees:

Tabla departments:

Tabla employees:

Escribe un FULL OUTER JOIN para obtener la lista completa de departamentos y empleados. Rellena los datos que faltan con NULL.

Cómo manejar valores NULL

El tema de los valores NULL es una consecuencia inevitable de usar FULL OUTER JOIN. Por ejemplo, en tareas reales puede que quieras reemplazar NULL por valores más comprensibles. En PostgreSQL puedes hacerlo con la función COALESCE().

Ejemplo:

SELECT
    COALESCE(s.nombre, 'Sin Estudiante') AS nombre_estudiante,
    COALESCE(e.curso, 'Sin Curso') AS nombre_curso
FROM 
    students s
FULL OUTER JOIN 
    enrollments e
ON 
    s.student_id = e.student_id;

Resultado:

Ahora en vez de NULL vemos valores claros, lo que hace los informes más legibles.

Cuándo usar FULL OUTER JOIN

FULL OUTER JOIN es útil cuando necesitas ver todos los datos de ambas tablas, aunque no estén completamente relacionados. Ejemplos:

• Informes de ventas y productos — para ver tanto los productos vendidos como los no vendidos.
• Análisis de estudiantes y cursos — para comprobar si hay datos no registrados.
• Comparación de listas — por ejemplo, para detectar diferencias entre dos conjuntos de datos.

Espero que esta lección te haya dado una buena idea de FULL OUTER JOIN. ¡Ahora te espera el mundo divertido de uniones más complejas y manejo de datos!