> ## Documentation Index
> Fetch the complete documentation index at: https://villagesql.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Como os joins do MySQL funcionam

> Por que os dados são divididos entre tabelas no MySQL, o que um join faz para juntá-los de novo, e o que separa um inner join de um outer join e de um cross join.

> [card] [VillageSQL is a drop-in replacement for MySQL with extensions.](https://villagesql.com/docs/en/8.4/stable/install-server.md)
>
> All examples on this page work on VillageSQL. Install Now →

Toda consulta até aqui leu 1 tabela. Bancos de dados reais espalham suas informações por
muitas, e um join é como você as lê em conjunto. Esta lição explica o que um join
faz e para que servem os diferentes tipos. As lições seguintes tratam de cada tipo
por vez.

Abra o cliente com `mysql -u root -p sakila` antes de começar.

## Por que os dados são divididos

O Sakila registra o idioma de cada filme como um número.

```sql theme={null}
SELECT film_id, title, language_id FROM film ORDER BY film_id LIMIT 3;
```

```text theme={null}
+---------+------------------+-------------+
| film_id | title            | language_id |
+---------+------------------+-------------+
|       1 | ACADEMY DINOSAUR |           1 |
|       2 | ACE GOLDFINGER   |           1 |
|       3 | ADAPTATION HOLES |           1 |
+---------+------------------+-------------+
3 rows in set (0.00 sec)
```

O nome que acompanha o número mora em uma tabela própria.

```sql theme={null}
SELECT language_id, name FROM language ORDER BY language_id;
```

```text theme={null}
+-------------+----------+
| language_id | name     |
+-------------+----------+
|           1 | English  |
|           2 | Italian  |
|           3 | Japanese |
|           4 | Mandarin |
|           5 | French   |
|           6 | German   |
+-------------+----------+
6 rows in set (0.00 sec)
```

Armazenar a palavra `English` uma vez e apontar para ela 1.000 vezes ocupa menos espaço
do que armazená-la 1.000 vezes, e corrigir uma grafia significa mudar 1 linha
em vez de 1.000. O custo é que uma consulta que quer o título e o nome do
idioma tem de ler as duas tabelas.

## Como um join funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM LEFT_TABLE
JOIN RIGHT_TABLE ON LEFT_TABLE.COLUMN_NAME = RIGHT_TABLE.COLUMN_NAME;
```

Substitua `COLUMN_LIST` pelas colunas que você quer, `LEFT_TABLE` pela tabela de onde você
parte, `RIGHT_TABLE` pela tabela de onde você está puxando colunas extras, e
cada `COLUMN_NAME` pela coluna daquele lado que liga as 2 tabelas.

O servidor pega cada linha da tabela da esquerda, encontra as linhas da tabela da direita
em que a condição `ON` é verdadeira, e retorna 1 linha combinada por correspondência.

## Exemplos

### Ler o nome em vez do número

```sql theme={null}
SELECT f.title, l.name
FROM film AS f
JOIN language AS l ON f.language_id = l.language_id
ORDER BY f.title
LIMIT 3;
```

```text theme={null}
+------------------+---------+
| title            | name    |
+------------------+---------+
| ACADEMY DINOSAUR | English |
| ACE GOLDFINGER   | English |
| ADAPTATION HOLES | English |
+------------------+---------+
3 rows in set (0.00 sec)
```

`AS f` e `AS l` são aliases de tabela, que a [próxima
lição](https://villagesql.com/docs/pt-BR/tutorial/table-aliases.md) cobre.

## Para que servem os tipos de join

Eles diferem em 1 coisa: o que acontece com uma linha que não encontra correspondência.

| Join | Mantém |
| - | - |
| `INNER JOIN` | só as linhas que encontraram correspondência nos dois lados |
| `LEFT JOIN` | todas as linhas da tabela da esquerda, com correspondência ou não |
| `RIGHT JOIN` | todas as linhas da tabela da direita, com correspondência ou não |
| `CROSS JOIN` | cada linha da esquerda emparelhada com cada linha da direita |

Uma linha sem correspondência mantida por um outer join ainda tem de preencher as colunas para as quais não
tem valores, e ela as preenche com NULL. É por isso que
[IS NULL](https://villagesql.com/docs/pt-BR/tutorial/is-null.md) aparece tanto ao lado de um `LEFT JOIN`: é como
você pede as linhas que não corresponderam a nada.

`CROSS JOIN` é o diferente, porque ele não faz nenhuma correspondência. É o que você
pede de propósito quando quer todas as combinações, e o que você obtém por
acidente quando deixa uma cláusula `ON` de fora.

## A condição importa mais do que a palavra-chave

`JOIN`, `INNER JOIN` e `CROSS JOIN` são 1 coisa só no MySQL, e a gramática
aceita uma cláusula `ON` em qualquer um deles ou em nenhum. Então a palavra-chave que você digita não
decide o seu resultado. A presença de uma condição `ON` decide: com uma você obtém
correspondências, sem uma você obtém todas as combinações, seja qual for das 3 palavras que você
escreveu.

Como o servidor não vai distingui-los por você, escreva `INNER JOIN ... ON`
quando quiser dizer uma correspondência e `CROSS JOIN` sem `ON` quando quiser dizer todas as
combinações. A palavra-chave é então uma nota para o próximo leitor em vez de uma
instrução para o servidor.

## Resumo

* Espere que a informação esteja dividida entre tabelas, com 1 tabela apontando para outra por id.
* Use um join para ler essas tabelas em conjunto em 1 consulta.
* Leia a condição `ON` como a regra de quais linhas pertencem uma à outra.
* Escolha o tipo de join pelo que deve acontecer com uma linha que não corresponde a nada.
* Espere NULL nas colunas de uma linha que um outer join manteve sem correspondência.

## Veja também

* [Aliases de tabela](https://villagesql.com/docs/pt-BR/tutorial/table-aliases.md) e [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) — os nomes curtos, e o join que mantém só as correspondências
* [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) e [RIGHT JOIN](https://villagesql.com/docs/pt-BR/tutorial/right-join.md) — os joins que mantêm as linhas sem correspondência
* [CROSS JOIN](https://villagesql.com/docs/pt-BR/tutorial/cross-join.md) e [self join](https://villagesql.com/docs/pt-BR/tutorial/self-join.md) — todas as combinações, e uma tabela juntada a si mesma
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — o que dá errado quando as tabelas ficam grandes


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.