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

# RIGHT JOIN no MySQL

> Como um RIGHT JOIN do MySQL mantém todas as linhas da segunda tabela, por que ele é um LEFT JOIN com as tabelas trocadas, e por que a maior parte do SQL é escrita com LEFT 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 →

`RIGHT JOIN` mantém todas as linhas da tabela da direita, com correspondência ou não. Ele é
a imagem espelhada do [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) e não faz nada que um
`LEFT JOIN` não consiga fazer, então esta lição é curta. Ela existe porque você vai encontrá-lo
no SQL de outras pessoas.

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

## Como RIGHT JOIN funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM LEFT_TABLE
RIGHT 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 que você
parte, `RIGHT_TABLE` pela tabela da qual você quer manter todas as linhas,
e cada `COLUMN_NAME` pela coluna daquele lado que as liga. Uma
linha da direita que não corresponde a nada volta com todas as colunas da tabela da esquerda
definidas como NULL. `RIGHT OUTER JOIN` é a mesma cláusula escrita por extenso.

## Exemplos

### Mantenha todas as linhas da segunda tabela

`film` está à esquerda e `language` à direita, então isto mantém todos os 6
idiomas.

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

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

1.005 linhas, a mesma contagem que a lição sobre `LEFT JOIN` obteve das mesmas 2 tabelas na
ordem inversa.

### Liste as linhas que não corresponderam a nada

O mesmo padrão de um left join, com o teste de NULL agora na tabela da esquerda.

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

```text theme={null}
+-------+----------+
| title | name     |
+-------+----------+
| NULL  | French   |
| NULL  | German   |
| NULL  | Italian  |
| NULL  | Japanese |
| NULL  | Mandarin |
+-------+----------+
5 rows in set (0.00 sec)
```

Os 5 idiomas em que nenhum filme está.

## Todo RIGHT JOIN pode ser escrito como um LEFT JOIN

`a RIGHT JOIN b` retorna as mesmas linhas que `b LEFT JOIN a`. Troque os 2 nomes de
tabela, troque a palavra-chave, e a resposta não muda. Com `SELECT *`, as
colunas voltam em uma ordem diferente, porque `*` se expande na ordem em que as
tabelas aparecem no `FROM`, então nomeie suas colunas se a ordem importa.

A maior parte do SQL que você lê é escrita com `LEFT JOIN` por essa razão: uma consulta é
mais fácil de acompanhar quando todos os joins dela pendem para o mesmo lado.

Todo o resto sobre ele, incluindo a armadilha do `WHERE`, funciona exatamente como a
lição sobre [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) descreve, com a esquerda e a direita
trocadas.

## Resumo

* Use `RIGHT JOIN` para manter todas as linhas da tabela nomeada em segundo lugar.
* Espere NULL em todas as colunas do lado esquerdo de uma linha que não correspondeu a nada.
* Leia `a RIGHT JOIN b` como `b LEFT JOIN a`, e nomeie suas colunas em vez de usar `*`.
* Prefira `LEFT JOIN` no SQL que você escreve, para que todos os joins de uma consulta pendam para o mesmo lado.

## Veja também

* [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) — o mesmo comportamento, e as armadilhas que vêm com ele
* [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) — o join que mantém apenas as correspondências
* [Como os joins funcionam](https://villagesql.com/docs/pt-BR/tutorial/joins.md) — o que separa os tipos de join
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — por que um revisor pede para você reescrevê-lo


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