> ## 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 LEFT JOIN

> Como um LEFT JOIN do MySQL mantém linhas que não correspondem a nada, como listar essas linhas com IS NULL, e por que um filtro no WHERE o transforma de volta em um inner 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 →

Um inner join relata o que correspondeu. Um `LEFT JOIN` mantém todas as linhas da tabela
da esquerda, com correspondência ou não, que é como você responde à outra pergunta:
o que não correspondeu.

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

## Como o LEFT JOIN funciona

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

Substitua `COLUMN_LIST` pelas colunas que você quer, `LEFT_TABLE` pela tabela
da qual você quer manter todas as linhas, `RIGHT_TABLE` pela tabela de onde você está puxando
colunas extras, e cada `COLUMN_NAME` pela coluna daquele lado que
as liga.

O servidor se comporta como um inner join para as linhas que correspondem. Para uma linha da esquerda
que não corresponde a nada, ele mantém a linha mesmo assim e preenche todas as colunas da
tabela da direita com NULL. `LEFT OUTER JOIN` é a mesma cláusula por extenso, e
a palavra `OUTER` não acrescenta nada.

## Exemplos

### Manter as linhas sem correspondência

O Sakila tem 6 idiomas e todo filme é em inglês, então 5 idiomas não correspondem a nenhum filme.
Um inner join os descarta. Este não.

```sql theme={null}
SELECT l.name, f.title
FROM language AS l
LEFT JOIN film AS f ON l.language_id = f.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: as 1.000 correspondências, mais 1 linha para cada um dos 5 idiomas que
não corresponderam a nada.

### Listar só as linhas que não corresponderam a nada

Adicione um `WHERE` em uma coluna da tabela da direita que nunca pode ser NULL em uma
correspondência real, e você manteve exatamente as linhas sem correspondência.

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

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

`f.film_id` é a chave primária de `film`, então uma linha com correspondência sempre tem uma. Um
NULL ali só pode ter vindo do join preenchendo uma linha que não correspondeu a
nada. Teste qualquer coluna `NOT NULL` da tabela da direita e o mesmo raciocínio
vale. A chave primária é a escolha mais segura, porque ela é `NOT NULL` em toda
tabela.

### A pergunta que isso responde na prática

Nem todo filme do catálogo está em uma prateleira. `inventory` guarda as cópias, então
um filme sem linha em `inventory` é um que ninguém pode alugar.

```sql theme={null}
SELECT f.title
FROM film AS f
LEFT JOIN inventory AS i ON f.film_id = i.film_id
WHERE i.film_id IS NULL
ORDER BY f.title;
```

```text theme={null}
+------------------------+
| title                  |
+------------------------+
| ALICE FANTASIA         |
| APOLLO TEEN            |
| ARGONAUTS TOWN         |
...
+------------------------+
42 rows in set (0.00 sec)
```

42 dos 1.000 filmes não têm cópias. Esse padrão, um `LEFT JOIN` mais
`WHERE <chave da direita> IS NULL`, é como você encontra linhas em uma tabela sem nada
correspondente em outra.

## Um filtro no WHERE desfaz o outer join

Este é o erro que custa mais tempo às pessoas com `LEFT JOIN`. Adicionar uma
condição comum na tabela da direita parece inofensivo.

```sql theme={null}
SELECT l.name, f.title
FROM language AS l
LEFT JOIN film AS f ON l.language_id = f.language_id
WHERE f.title LIKE 'ACADEMY%'
ORDER BY l.name, f.title;
```

```text theme={null}
+---------+------------------+
| name    | title            |
+---------+------------------+
| English | ACADEMY DINOSAUR |
+---------+------------------+
1 row in set (0.00 sec)
```

1 linha. Os 5 idiomas sem correspondência sumiram, então a consulta agora é um inner join,
diga ela o que disser. A razão é a ordem: o join roda primeiro e produz as 5
linhas com NULL em `f.title`, depois o `WHERE` testa cada linha, e `NULL LIKE
'ACADEMY%'` é NULL em vez de verdadeiro, então o `WHERE` as descarta.

Mova a mesma condição para o `ON` e ela passa a fazer parte do que conta como
correspondência.

```sql theme={null}
SELECT l.name, f.title
FROM language AS l
LEFT JOIN film AS f ON l.language_id = f.language_id AND f.title LIKE 'ACADEMY%'
ORDER BY l.name, f.title;
```

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

Todos os 6 idiomas, e só 1 deles encontrou um filme correspondente. A regra vale a pena
memorizar: em um `LEFT JOIN`, uma condição sobre a tabela da direita pertence ao `ON`,
e uma condição sobre a tabela da esquerda pertence ao `WHERE`. A única exceção
deliberada é o `IS NULL` do exemplo 2, em que descartar as linhas com correspondência é o
objetivo.

## Resumo

* Use `LEFT JOIN` para manter todas as linhas da tabela da esquerda, com correspondência ou não.
* Espere NULL em todas as colunas do lado direito de uma linha que não correspondeu a nada.
* Teste uma coluna `NOT NULL` da tabela da direita com `IS NULL` para listar só as linhas sem correspondência.
* Coloque uma condição sobre a tabela da direita no `ON`, porque no `WHERE` ela descarta as linhas sem correspondência.
* Leia `LEFT OUTER JOIN` como outra grafia da mesma cláusula.

## Veja também

* [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) — o join que mantém só as correspondências
* [RIGHT JOIN](https://villagesql.com/docs/pt-BR/tutorial/right-join.md) — a mesma ideia do outro lado
* [IS NULL](https://villagesql.com/docs/pt-BR/tutorial/is-null.md) — o teste que torna visíveis as linhas sem correspondência
* [EXISTS](https://villagesql.com/docs/pt-BR/tutorial/exists.md) — a mesma pergunta feita sem um join
* [Desempenho de JOIN no MySQL e erros comuns](https://villagesql.com/docs/pt-BR/guides/joins.md) — a mesma armadilha, vista como um relatório de bug


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