Guía de joins en MySQL: domina los joins con ejemplos

Si alguna vez intentaste sacar datos de varias tablas de MySQL y te sentiste perdido, no eres el único. Los joins son de esos conceptos que al principio intimidan, pero que se vuelven increíblemente poderosos en cuanto les agarras la onda.

Piensa en los joins como una forma de decirle a MySQL: “oye, quiero traer datos de esta tabla Y de esa otra, pero solo donde ciertas condiciones coincidan”. Una vez que entiendas los patrones básicos, vas a combinar datos como todo un pro.

🔖 Referencia rápida: ¿Necesitas una consulta rápida? Revisa nuestra hoja de referencia de SQL JOIN con todos los tipos de JOIN, diagramas visuales y ejemplos de código en un solo lugar.

El árbol genealógico de los joins

En esencia, un join te permite combinar filas de distintas tablas cuando comparten algo en común. Es como presentar a dos grupos de amigos que tienen conocidos en común.

Estos son los tipos de join que vamos a ver:

• INNER JOIN - Muéstrame solo los registros que existen en ambas tablas
• LEFT JOIN - Muéstrame todo lo de la tabla izquierda, más las coincidencias de la derecha
• RIGHT JOIN - Lo opuesto a LEFT JOIN (aunque, la verdad, la mayoría simplemente invierte el orden de sus tablas)
• FULL JOIN - Todo de ambas tablas (MySQL nos hace trabajar un poco para este)
• CROSS JOIN - Todas las combinaciones posibles (¡úsalo con cuidado!)
• SELF JOIN - Cuando una tabla necesita hablar consigo misma

INNER JOIN - El perfeccionista

INNER JOIN es exigente. Solo te da las filas donde ambas tablas tienen datos que coinciden. Piénsalo como la intersección en un diagrama de Venn.

Ejemplo:

Trabajemos con dos tablas sencillas: employees y departments:

-- Employees Table
+----+----------+-------------+
| id | name     | department_id|
+----+----------+-------------+
| 1  | Alice    | 1           |
| 2  | Bob      | 2           |
| 3  | Charlie  | NULL        |
+----+----------+-------------+

-- Departments Table
+----+-------------+
| id | department  |
+----+-------------+
| 1  | HR          |
| 2  | IT          |
+----+-------------+

Consulta INNER JOIN:

SELECT employees.name, departments.department
FROM employees
INNER JOIN departments ON employees.department_id = departments.id;

Resultado:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

LEFT JOIN - El incluyente

LEFT JOIN es más generoso que INNER JOIN. Dice: “Quiero todo de la tabla izquierda, y si hay algo que coincida en la tabla derecha, ¡genial! Si no, ahí pongo NULL”.

Fíjate cómo esta vez aparece Charlie, aunque no tiene departamento:

Consulta LEFT JOIN:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id;

Resultado:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

RIGHT JOIN - La otra cara

RIGHT JOIN es simplemente un LEFT JOIN con las tablas invertidas. La mayoría de los desarrolladores lo evita y prefiere reordenar su cláusula FROM: así es menos confuso.

Consulta RIGHT JOIN:

SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Resultado:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Bob   | IT         |
+-------+------------+

FULL JOIN - El enfoque de todo incluido

Aquí es donde MySQL se pone un poco molesto: no tiene un FULL JOIN integrado. Pero podemos simularlo con un truco de UNION:

Simulación de FULL JOIN:

SELECT employees.name, departments.department
FROM employees
LEFT JOIN departments ON employees.department_id = departments.id
UNION
SELECT employees.name, departments.department
FROM employees
RIGHT JOIN departments ON employees.department_id = departments.id;

Resultado:

+---------+------------+
| name    | department |
+---------+------------+
| Alice   | HR         |
| Bob     | IT         |
| Charlie | NULL       |
+---------+------------+

CROSS JOIN - El creador del caos

CROSS JOIN es como ese amigo que en una fiesta quiere que todos conozcan a todos. Empareja cada fila de la primera tabla con cada fila de la segunda. Con 3 empleados y 2 departamentos, obtenemos 6 combinaciones:

Consulta CROSS JOIN:

SELECT employees.name, departments.department
FROM employees
CROSS JOIN departments;

Resultado:

+-------+------------+
| name  | department |
+-------+------------+
| Alice | HR         |
| Alice | IT         |
| Bob   | HR         |
| Bob   | IT         |
| Charlie | HR       |
| Charlie | IT       |
+-------+------------+

SELF JOIN - El introspectivo

Los self joins ocurren cuando una tabla se referencia a sí misma. El ejemplo clásico es una tabla de empleados donde algunos empleados son jefes de otros.

Ejemplo:

Aquí tienes una tabla managers donde mgr_id apunta a otra fila de la misma tabla:

-- Managers Table
+----+----------+--------+
| id | name     | mgr_id |
+----+----------+--------+
| 1  | Tom      | NULL   |
| 2  | Jerry    | 1      |
| 3  | Spike    | 1      |
+----+----------+--------+

Consulta SELF JOIN:

SELECT m1.name AS manager, m2.name AS employee
FROM managers m1
LEFT JOIN managers m2 ON m1.id = m2.mgr_id;

Resultado:

+---------+----------+
| manager | employee |
+---------+----------+
| Tom     | Jerry    |
| Tom     | Spike    |
| Jerry   | NULL     |
| Spike   | NULL     |
+---------+----------+

Para cerrar

Los joins pueden parecer abrumadores al principio, pero en realidad solo son distintas formas de decir “muéstrame datos de varias tablas con estas reglas”. Empieza con INNER y LEFT JOIN: con ellos resolverás el 90% de lo que necesitas.

La mejor forma de sentirte cómodo con los joins es practicar con tus propios datos. Crea algunas tablas de prueba, agrégales datos de ejemplo y ponte a experimentar. Muy pronto estarás uniendo tablas a diestra y siniestra (y sí, el juego de palabras es intencional).

Y recuerda: si tu join devuelve muchísimas más filas de las que esperabas, seguro hiciste un CROSS JOIN por accidente. ¡A todos nos ha pasado!