Guia de joins no MySQL: domine os joins com exemplos

Se você já tentou buscar dados de várias tabelas do MySQL e se sentiu perdido, saiba que não está sozinho. Joins são um daqueles conceitos que parecem intimidadores no início, mas se tornam incrivelmente poderosos quando você pega o jeito.

Pense nos joins como uma forma de dizer ao MySQL: “ei, quero pegar dados desta tabela E daquela tabela, mas só onde certas condições baterem.” Depois que você entender os padrões básicos, vai combinar dados como um profissional.

🔖 Referência rápida: Precisa de uma consulta rápida? Confira nosso SQL JOIN Cheat Sheet, com todos os tipos de JOIN, diagramas visuais e exemplos de código em um só lugar.

A árvore genealógica dos joins

Em essência, um join permite combinar linhas de tabelas diferentes quando elas têm algo em comum. É como apresentar dois grupos de amigos que têm conhecidos em comum.

Estes são os tipos de join que vamos abordar:

• INNER JOIN - Mostre apenas os registros que existem nas duas tabelas
• LEFT JOIN - Mostre tudo da tabela da esquerda, mais as correspondências da direita
• RIGHT JOIN - O oposto do LEFT JOIN (embora, sinceramente, a maioria das pessoas simplesmente inverta as tabelas)
• FULL JOIN - Tudo das duas tabelas (o MySQL nos faz suar um pouco para este)
• CROSS JOIN - Todas as combinações possíveis (use com cuidado!)
• SELF JOIN - Quando uma tabela precisa conversar consigo mesma

INNER JOIN - O perfeccionista

O INNER JOIN é exigente. Ele só retorna linhas em que as duas tabelas têm dados correspondentes. Pense nele como a interseção de um diagrama de Venn.

Exemplo:

Vamos trabalhar com duas tabelas simples - employees e 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 com 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 - O inclusivo

O LEFT JOIN é mais generoso que o INNER JOIN. Ele diz: “quero tudo da tabela da esquerda e, se houver algo correspondente na tabela da direita, ótimo! Se não houver, coloco NULL ali.”

Repare que o Charlie aparece desta vez, mesmo sem ter um departamento:

Consulta com 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 - O outro lado

O RIGHT JOIN é só um LEFT JOIN com as tabelas invertidas. A maioria dos desenvolvedores o evita e simplesmente reorganiza a cláusula FROM - fica menos confuso assim.

Consulta com 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 - A abordagem “leva tudo”

É aqui que o MySQL fica um pouco irritante - ele não tem um FULL JOIN nativo. Mas dá para simular com um truque usando UNION:

Simulação 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 - O criador do caos

O CROSS JOIN é como aquele amigo que, numa festa, apresenta todo mundo para todo mundo. Ele combina cada linha da primeira tabela com cada linha da segunda. Com 3 funcionários e 2 departamentos, temos 6 combinações:

Consulta com 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 - O introspectivo

Self joins acontecem quando uma tabela referencia a si mesma. O exemplo clássico é uma tabela de funcionários em que alguns funcionários gerenciam outros.

Exemplo:

Aqui está uma tabela managers em que o mgr_id aponta para outra linha da mesma tabela:

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

Consulta com 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     |
+---------+----------+

Concluindo

Joins podem parecer complicados no início, mas na verdade são apenas formas diferentes de dizer “mostre dados de várias tabelas com estas regras.” Comece com INNER e LEFT joins - eles resolvem 90% do que você precisa fazer.

A melhor forma de se familiarizar com joins é praticar com seus próprios dados. Crie algumas tabelas de teste, insira dados de exemplo e comece a experimentar. Em pouco tempo você estará fazendo joins à esquerda e à direita (trocadilho intencional).

E lembre-se: se o seu join estiver retornando muito mais linhas do que o esperado, você provavelmente fez um CROSS JOIN sem querer. Todo mundo já passou por isso!