SQL · Lección 08 de 15

LEFT, RIGHT y FULL JOIN

INNER JOIN solo muestra coincidencias. Pero a veces necesitás ver TODOS los clientes, incluso los que no tienen cuentas. O encontrar "los que NO tienen" — clientes sin transacciones, productos sin ventas. Para eso existen los OUTER JOINs.

80–100 min Prerrequisitos: SQL 07

Concepto teórico

Tipos de JOIN

JOIN	Qué incluye	Uso típico
`INNER JOIN`	Solo coincidencias de AMBAS tablas	Combinar datos relacionados
`LEFT JOIN`	TODAS las filas de la izquierda + coincidencias de la derecha	Todos los clientes, con o sin cuenta
`RIGHT JOIN`	TODAS las filas de la derecha + coincidencias de la izquierda	Menos usado (invertí el LEFT)
`FULL JOIN`	TODAS las filas de AMBAS tablas	Reconciliación de datos
`CROSS JOIN`	Producto cartesiano (cada fila × cada fila)	Generar combinaciones

LEFT JOIN — la estrella de los OUTER JOINs

LEFT JOIN devuelve TODAS las filas de la tabla izquierda (la del FROM). Si hay coincidencia en la tabla derecha, trae los datos. Si NO hay coincidencia, llena con NULL:

SELECT c.nombre, cu.tipo, cu.saldo
FROM clientes c                              -- tabla IZQUIERDA: todos aparecen
LEFT JOIN cuentas cu ON c.id = cu.cliente_id; -- tabla DERECHA: NULL si no hay match

-- Resultado:
-- García  | CA$  | 150000   ← tiene cuenta
-- López   | CA$  | 320000   ← tiene cuenta
-- Sosa    | NULL | NULL     ← NO tiene cuenta (LEFT JOIN lo incluye igual)

LEFT JOIN es el más usado de los OUTER JOINs. En la práctica, casi siempre usás INNER o LEFT. RIGHT es poco frecuente (podés invertir el orden de las tablas y usar LEFT). FULL es raro en análisis diario. Focalizate en dominar LEFT JOIN.

El patrón "Anti-JOIN" — encontrar los que NO tienen

Uno de los patrones más poderosos: LEFT JOIN + WHERE ... IS NULL para encontrar filas SIN coincidencia:

-- Clientes SIN cuentas
SELECT c.nombre
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id
WHERE cu.id IS NULL;  -- las que NO tuvieron match

En el trabajo: "¿Qué clientes no tienen tarjeta de crédito?" (oportunidad de cross-sell), "¿Qué productos no se vendieron este mes?" (stock muerto), "¿Qué sucursales no registraron transacciones?" (posible problema operativo). Todos se resuelven con LEFT JOIN + IS NULL.

COALESCE con LEFT JOIN

Cuando un LEFT JOIN produce NULLs, usás COALESCE para reemplazarlos con valores por defecto:

SELECT c.nombre,
       COALESCE(SUM(cu.saldo), 0) AS saldo_total
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id
GROUP BY c.id, c.nombre;

Ejemplos explicados paso a paso

Ejemplo 1: INNER vs LEFT — la diferencia

ejemplo_01_inner_vs_left.sqlSQL

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, tipo TEXT, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires'),(2,'López','Córdoba'),
(3,'Pérez','Buenos Aires'),(4,'Sosa','Rosario');
INSERT INTO cuentas VALUES (101,1,'CA$',150000),(102,2,'CA$',320000),(103,3,'CA$',890000);
-- Sosa (id=4) NO tiene cuenta

-- INNER JOIN: solo 3 filas (Sosa no aparece)
-- SELECT c.nombre, cu.saldo FROM clientes c
-- INNER JOIN cuentas cu ON c.id = cu.cliente_id;

-- LEFT JOIN: 4 filas (Sosa aparece con NULL)
SELECT c.nombre, cu.tipo, cu.saldo
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id;

Hacé clic en ▶ Ejecutar

Ejemplo 2: Anti-JOIN — encontrar los que NO tienen

ejemplo_02_anti_join.sqlSQL

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT, score INTEGER);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, tipo TEXT);
INSERT INTO clientes VALUES (1,'García','Buenos Aires',720),(2,'López','Córdoba',680),
(3,'Pérez','Buenos Aires',810),(4,'Sosa','Rosario',590),(5,'Luna','Mendoza',700);
INSERT INTO cuentas VALUES (101,1,'CA$'),(102,2,'CA$'),(103,3,'CA$');
-- Sosa y Luna NO tienen cuenta

-- Clientes SIN cuenta (oportunidad de apertura)
SELECT c.nombre, c.ciudad, c.score
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id
WHERE cu.id IS NULL;

Hacé clic en ▶ Ejecutar

Ejemplo 3: LEFT JOIN + COALESCE + GROUP BY

ejemplo_03_coalesce.sqlSQL

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, tipo TEXT, saldo REAL);
INSERT INTO clientes VALUES (1,'García','Buenos Aires'),(2,'López','Córdoba'),
(3,'Pérez','Buenos Aires'),(4,'Sosa','Rosario');
INSERT INTO cuentas VALUES (101,1,'CA$',150000),(102,1,'PF',500000),
(103,2,'CA$',320000),(104,3,'CA$',890000);

-- Saldo total por cliente (incluyendo los que no tienen cuentas = $0)
SELECT c.nombre,
       COUNT(cu.id) AS num_cuentas,
       COALESCE(SUM(cu.saldo), 0) AS saldo_total,
       CASE WHEN COUNT(cu.id) = 0 THEN 'Sin productos' ELSE 'Activo' END AS estado
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id
GROUP BY c.id, c.nombre
ORDER BY saldo_total DESC;

Hacé clic en ▶ Ejecutar

Ejemplo 4: CROSS JOIN — generar combinaciones

ejemplo_04_cross.sqlSQL

CREATE TABLE ciudades (nombre TEXT);
CREATE TABLE productos (nombre TEXT);
INSERT INTO ciudades VALUES ('Buenos Aires'),('Córdoba'),('Rosario');
INSERT INTO productos VALUES ('Cuenta'),('Tarjeta'),('Préstamo');

-- CROSS JOIN: todas las combinaciones posibles (3×3 = 9 filas)
SELECT c.nombre AS ciudad, p.nombre AS producto
FROM ciudades c
CROSS JOIN productos p
ORDER BY c.nombre, p.nombre;

Hacé clic en ▶ Ejecutar

Ejemplo 5: Reporte completo — todos los clientes con detalle

ejemplo_05_reporte.sqlSQL

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT, score INTEGER);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, tipo TEXT, saldo REAL);
CREATE TABLE transacciones (id INTEGER, cuenta_id INTEGER, monto REAL);

INSERT INTO clientes VALUES (1,'García','Buenos Aires',720),(2,'López','Córdoba',680),
(3,'Pérez','Buenos Aires',810),(4,'Sosa','Rosario',590);
INSERT INTO cuentas VALUES (101,1,'CA$',150000),(102,2,'CA$',320000),(103,3,'CA$',890000);
INSERT INTO transacciones VALUES (1,101,50000),(2,101,20000),(3,102,80000),(4,103,120000);

-- Reporte: TODOS los clientes, con saldo y transacciones si las tienen
SELECT c.nombre, c.ciudad, c.score,
       COALESCE(SUM(DISTINCT cu.saldo), 0) AS saldo,
       COUNT(t.id) AS num_transacc,
       COALESCE(SUM(t.monto), 0) AS monto_transacc,
       CASE WHEN cu.id IS NULL THEN 'Sin productos' ELSE 'Con productos' END AS estado
FROM clientes c
LEFT JOIN cuentas cu ON c.id = cu.cliente_id
LEFT JOIN transacciones t ON cu.id = t.cuenta_id
GROUP BY c.id, c.nombre, c.ciudad, c.score
ORDER BY saldo DESC;

Hacé clic en ▶ Ejecutar

Referencia rápida

JOIN	Tabla izquierda	Tabla derecha	Sin coincidencia
INNER	Solo coincidencias	Solo coincidencias	Se excluye
LEFT	TODAS	Solo coincidencias	NULL en cols de derecha
RIGHT	Solo coincidencias	TODAS	NULL en cols de izquierda
FULL	TODAS	TODAS	NULL donde no hay match
CROSS	TODAS × TODAS	TODAS × TODAS	Producto cartesiano

Patrón	Código
Todos con o sin	`LEFT JOIN ... (todos los clientes)`
Los que NO tienen	`LEFT JOIN ... WHERE t2.id IS NULL`
Reemplazar NULL	`COALESCE(SUM(col), 0)`

Ejercicios

Nivel 1 · Básico

Ejercicio 1: LEFT JOIN básico

Mostrá TODOS los clientes con sus cuentas (incluso sin cuenta). Debe incluir Sosa.

ejercicio_01.sqlDebe incluir "Sosa"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García'),(2,'López'),(3,'Sosa');
INSERT INTO cuentas VALUES (101,1,150000),(102,2,320000);

-- LEFT JOIN (Sosa debe aparecer con NULL):

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Anti-JOIN — clientes sin cuenta

Encontrá clientes que NO tienen cuenta. Debe incluir Sosa.

ejercicio_02.sqlDebe incluir "Sosa"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, score INTEGER);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER);
INSERT INTO clientes VALUES (1,'García',720),(2,'López',680),(3,'Sosa',590),(4,'Luna',700);
INSERT INTO cuentas VALUES (101,1),(102,2);

-- Clientes SIN cuenta:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: COALESCE con LEFT JOIN

Mostrá saldo de cada cliente, usando 0 cuando no tiene cuenta. Debe incluir 0.

ejercicio_03.sqlDebe incluir "0"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García'),(2,'López'),(3,'Sosa');
INSERT INTO cuentas VALUES (101,1,150000),(102,2,320000);

-- LEFT JOIN + COALESCE para saldo 0:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: LEFT JOIN + GROUP BY

Saldo total por cliente (incluyendo $0 para los sin cuenta). Debe incluir 650000.

ejercicio_04.sqlDebe incluir "650000"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, saldo REAL);
INSERT INTO clientes VALUES (1,'García'),(2,'López'),(3,'Sosa');
INSERT INTO cuentas VALUES (101,1,150000),(102,1,500000),(103,2,320000);

-- Saldo total (García: 650K, López: 320K, Sosa: 0):

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Contar productos por cliente

¿Cuántas cuentas tiene cada cliente? (0 si no tiene). Debe incluir 0.

ejercicio_05.sqlDebe incluir "0"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER, tipo TEXT);
INSERT INTO clientes VALUES (1,'García'),(2,'López'),(3,'Sosa');
INSERT INTO cuentas VALUES (101,1,'CA$'),(102,1,'PF'),(103,2,'CA$');

-- Conteo de cuentas por cliente:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: CROSS JOIN

Generá todas las combinaciones de 3 sucursales × 2 productos. Debe incluir 9 (si son 3×3) o la cantidad correcta.

ejercicio_06.sqlDebe incluir "Centro"

CREATE TABLE sucursales (nombre TEXT);
CREATE TABLE productos (nombre TEXT);
INSERT INTO sucursales VALUES ('Centro'),('Norte'),('Sur');
INSERT INTO productos VALUES ('Cuenta'),('Tarjeta'),('Préstamo');

-- Todas las combinaciones:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Productos no vendidos (anti-JOIN)

Encontrá productos que NO tuvieron ventas. Debe incluir Auriculares.

ejercicio_07.sqlDebe incluir "Auriculares"

CREATE TABLE productos (id INTEGER PRIMARY KEY, nombre TEXT, precio REAL);
CREATE TABLE ventas (id INTEGER, producto_id INTEGER, cantidad INTEGER);
INSERT INTO productos VALUES (1,'Notebook',920000),(2,'Mouse',23000),(3,'Auriculares',35000);
INSERT INTO ventas VALUES (1,1,5),(2,2,20),(3,1,3);

-- Productos sin ventas:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: LEFT JOIN + CASE para estado

Mostrá cada cliente con estado "Con cuenta" o "Sin cuenta" usando LEFT JOIN + CASE. Debe incluir Sin cuenta.

ejercicio_08.sqlDebe incluir "Sin cuenta"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, score INTEGER);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER);
INSERT INTO clientes VALUES (1,'García',720),(2,'López',680),(3,'Sosa',590);
INSERT INTO cuentas VALUES (101,1),(102,2);

-- Estado de cada cliente:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Doble LEFT JOIN — 3 tablas

TODOS los clientes con sus cuentas y transacciones (NULL donde no haya). Debe incluir Sosa.

ejercicio_09.sqlDebe incluir "Sosa"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT);
CREATE TABLE cuentas (id INTEGER PRIMARY KEY, cliente_id INTEGER, saldo REAL);
CREATE TABLE transacciones (id INTEGER, cuenta_id INTEGER, monto REAL);
INSERT INTO clientes VALUES (1,'García'),(2,'López'),(3,'Sosa');
INSERT INTO cuentas VALUES (101,1,150000),(102,2,320000);
INSERT INTO transacciones VALUES (1,101,50000),(2,102,80000);

-- Doble LEFT JOIN:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Reporte de penetración de productos

Para cada ciudad, mostrá: total clientes, clientes CON cuenta, clientes SIN cuenta, y % de penetración. Debe incluir penetracion.

ejercicio_10.sqlDebe incluir "penetracion"

CREATE TABLE clientes (id INTEGER PRIMARY KEY, nombre TEXT, ciudad TEXT);
CREATE TABLE cuentas (id INTEGER, cliente_id INTEGER);
INSERT INTO clientes VALUES (1,'García','Buenos Aires'),(2,'López','Córdoba'),
(3,'Pérez','Buenos Aires'),(4,'Sosa','Buenos Aires'),(5,'Luna','Córdoba');
INSERT INTO cuentas VALUES (101,1),(102,2),(103,3);

-- Penetración por ciudad:

Hacé clic en ▶ Ejecutar

Resumen y conexión

LEFT JOIN incluye TODAS las filas de la tabla izquierda, con NULL donde no hay match.
Anti-JOIN: LEFT JOIN ... WHERE t2.id IS NULL encuentra los que NO tienen coincidencia.
COALESCE(SUM(col), 0) reemplaza NULLs por 0 en agregaciones con LEFT JOIN.
CROSS JOIN genera el producto cartesiano (todas las combinaciones).
En la práctica, usás INNER y LEFT en el 95% de los casos.

En la siguiente lección (09 · Subconsultas) vas a aprender a usar SELECTs dentro de otros SELECTs — la herramienta para consultas complejas que no se resuelven con un solo SELECT.

Hecho con ❤️ por Rodri Gonzalez