> ## 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.

# MySQL INNER JOIN

> Como a cláusula INNER JOIN do MySQL faz a correspondência de linhas entre 2 ou mais tabelas, com ON e USING, e por que a contagem de linhas cresce quando uma linha corresponde a muitas.

> [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 →

`INNER JOIN` mantém uma linha somente quando a correspondência dá certo. É o join que você quer
sempre que uma linha de uma tabela aponta para uma linha de outra e você quer as duas.

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

## Como o INNER JOIN funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM LEFT_TABLE
INNER 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 as liga.

A cláusula `ON` diz quais linhas pertencem uma à outra. O MySQL pega cada linha da
tabela da esquerda, encontra as linhas da tabela da direita em que essa condição vale, e
retorna 1 linha combinada para cada correspondência. Uma linha que não encontra nada é descartada, de
qualquer um dos lados. [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) é a cláusula que a mantém
em vez disso.

## Exemplos

### Juntar 2 tabelas

`film.language_id` aponta para `language.language_id`. Faça a correspondência desse par e você
pode imprimir o nome do idioma ao lado do título.

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

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

1.000 linhas, a mesma contagem de `film` sozinha. Cada filme correspondeu a exatamente 1
idioma, que é o que você obtém quando a coluna de junção aponta para uma única linha.

### Juntar por uma chave estrangeira

Os clientes guardam o endereço em uma tabela separada.

```sql theme={null}
SELECT c.first_name, c.last_name, a.address
FROM customer AS c
INNER JOIN address AS a ON c.address_id = a.address_id
ORDER BY c.last_name, c.first_name;
```

```text theme={null}
+-------------+--------------+----------------------------------------+
| first_name  | last_name    | address                                |
+-------------+--------------+----------------------------------------+
| RAFAEL      | ABNEY        | 48 Maracaíbo Place                     |
| NATHANIEL   | ADAM         | 786 Matsue Way                         |
| KATHLEEN    | ADAMS        | 334 Munger (Monghyr) Lane              |
...
+-------------+--------------+----------------------------------------+
599 rows in set (0.00 sec)
```

599 linhas, 1 por cliente.

### Juntar 3 tabelas

Adicione outra cláusula `INNER JOIN` para cada tabela a mais. O Sakila divide a localização
entre `address`, `city` e `country`, então chegar ao nome da cidade leva 2 saltos.

```sql theme={null}
SELECT c.first_name, c.last_name, ci.city
FROM customer AS c
INNER JOIN address AS a ON c.address_id = a.address_id
INNER JOIN city AS ci ON a.city_id = ci.city_id
ORDER BY c.last_name, c.first_name;
```

```text theme={null}
+-------------+--------------+----------------------------+
| first_name  | last_name    | city                       |
+-------------+--------------+----------------------------+
| RAFAEL      | ABNEY        | Talavera                   |
| NATHANIEL   | ADAM         | Joliet                     |
| KATHLEEN    | ADAMS        | Arak                       |
...
+-------------+--------------+----------------------------+
599 rows in set (0.00 sec)
```

Ainda 599 linhas. Cada join correspondeu a uma única linha, então a contagem não mudou.

### Encurtar com USING

Quando as 2 colunas têm o mesmo nome, `USING` substitui `ON` e diz o nome
uma vez.

```sql theme={null}
SELECT f.title, l.name
FROM film AS f
INNER JOIN language AS l USING (language_id)
ORDER BY f.title;
```

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

As mesmas 1.000 linhas do exemplo 1. `USING` só funciona quando os nomes coincidem nos
dois lados, então `ON` é a forma que sempre se aplica.

## Corresponder a várias linhas as multiplica

Um join retorna 1 linha por correspondência, então uma linha que corresponde a muitas linhas volta muitas
vezes. Cada filme tem vários atores.

```sql theme={null}
SELECT f.title, fa.actor_id
FROM film AS f
INNER JOIN film_actor AS fa ON f.film_id = fa.film_id
ORDER BY f.title, fa.actor_id;
```

```text theme={null}
+-----------------------------+----------+
| title                       | actor_id |
+-----------------------------+----------+
| ACADEMY DINOSAUR            |        1 |
| ACADEMY DINOSAUR            |       10 |
| ACADEMY DINOSAUR            |       20 |
...
+-----------------------------+----------+
5462 rows in set (0.00 sec)
```

5.462 linhas de 1.000 filmes, com cada título repetido uma vez por ator. Essa é
a razão habitual de um join retornar mais linhas do que você esperava, e é a
razão de um total calculado sobre um join poder sair alto demais.

## 2 coisas que pegam as pessoas de surpresa

**Uma linha sem correspondência some, em vez de ficar em branco.** Parta de `language` em vez de
`film` e você ainda obtém 1.000 linhas, não 1.005: os outros 5 idiomas do Sakila
não correspondem a nenhum filme e caem fora. Um inner join relata o que correspondeu, nunca o que está
faltando. [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) é como você faz a outra pergunta.

**Um `ON` ausente não é um erro.** O MySQL lê `INNER JOIN` sem `ON` como
todas as combinações das duas tabelas, então um erro de digitação retorna 1.000 vezes 6 linhas em vez
de uma reclamação. [CROSS JOIN](https://villagesql.com/docs/pt-BR/tutorial/cross-join.md) cobre isso, de propósito
e por acidente.

## Resumo

* Use `INNER JOIN` com `ON` para combinar linhas de tabelas que correspondem.
* Adicione 1 cláusula `INNER JOIN` por tabela a mais.
* Espere que as linhas sem correspondência desapareçam, porque um inner join relata só as correspondências.
* Espere que a contagem de linhas cresça quando 1 linha corresponde a muitas.
* Use `USING` somente quando a coluna tiver o mesmo nome nos dois lados.

## Veja também

* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — o que separa este dos outros tipos
* [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) — mantendo as linhas que este descarta
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — indexando um join, e as contagens de linhas que saem erradas
* [Chaves estrangeiras no MySQL](https://villagesql.com/docs/pt-BR/guides/foreign-keys.md) — as relações que esses joins seguem


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