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

# EXISTS no MySQL

> Como o operador EXISTS do MySQL testa se uma subconsulta encontra alguma linha, como NOT EXISTS lista as linhas sem correspondência, e por que ele é seguro onde NOT IN não é.

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

`EXISTS` faz uma pergunta de sim ou não: esta subconsulta encontrou alguma coisa? Ele não
se importa com o que a subconsulta retornou, só se houve uma linha, o que o torna
a ferramenta certa quando você quer testar se há uma linha relacionada e não quer nenhuma de suas
colunas.

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

## Como EXISTS funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME AS OUTER_ALIAS
WHERE EXISTS (
  SELECT 1 FROM OTHER_TABLE AS INNER_ALIAS
  WHERE INNER_ALIAS.COLUMN_NAME = OUTER_ALIAS.COLUMN_NAME
);
```

Substitua `COLUMN_LIST` pelas colunas que você quer, `TABLE_NAME` e `OTHER_TABLE`
pelas 2 tabelas, `OUTER_ALIAS` e `INNER_ALIAS` por nomes para elas,
`COLUMN_NAME` pelas colunas que as ligam, e o `WHERE` interno por
o que quer que torne uma linha relacionada.

`SELECT 1` é a convenção. A lista do select é ignorada, então `SELECT 1`,
`SELECT *` e `SELECT column` se comportam de forma idêntica, e `1` diz claramente que
nada está sendo lido.

A subconsulta é correlacionada: ela nomeia a linha externa. O servidor pode parar na
primeira linha correspondente, porque 1 basta para responder sim.

## Exemplos

### Linhas que têm correspondência

```sql theme={null}
SELECT l.name
FROM language AS l
WHERE EXISTS (SELECT 1 FROM film AS f WHERE f.language_id = l.language_id)
ORDER BY l.name;
```

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

1 dos 6 idiomas tem filmes.

### Linhas que não têm nenhuma

`NOT EXISTS` é a outra parte, e é assim que você escreve um anti-join.

```sql theme={null}
SELECT l.name
FROM language AS l
WHERE NOT EXISTS (SELECT 1 FROM film AS f WHERE f.language_id = l.language_id)
ORDER BY l.name;
```

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

Os outros 5. A lição [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) responde à mesma
pergunta com `WHERE f.film_id IS NULL`, e as 2 formas retornam as mesmas linhas.

## NOT EXISTS é seguro onde NOT IN não é

A lição [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) mostra `NOT IN` não retornando linha nenhuma quando a
lista contém um NULL. `NOT EXISTS` não tem essa armadilha, porque ele nunca compara
valores: ele conta linhas.

Então, quando a subconsulta lê uma coluna que pode ser NULL, prefira `NOT EXISTS`.
`NOT IN` funciona bem sobre uma coluna declarada `NOT NULL`, e vira um risco no momento
em que isso deixa de ser verdade.

## EXISTS nunca multiplica linhas

Um join com uma tabela que tem várias linhas correspondentes repete a linha externa uma vez por
correspondência, o que a lição [INNER JOIN](https://villagesql.com/docs/pt-BR/tutorial/inner-join.md) mostra. `EXISTS`
não consegue fazer isso: ele responde sim ou não, então cada linha externa aparece uma vez, não importa
quantas correspondências existam.

`EXISTS`, `IN` e um join podem todos expressar "tem uma linha relacionada", e qual é o
mais rápido depende dos dados.
[Subconsultas vs JOINs no MySQL](https://villagesql.com/docs/pt-BR/guides/subqueries-vs-joins.md) os compara com
planos.

## Resumo

* Use `EXISTS` para testar se uma subconsulta encontra alguma linha.
* Escreva `SELECT 1` dentro, porque a lista do select é ignorada.
* Use `NOT EXISTS` para as linhas sem correspondência.
* Prefira `NOT EXISTS` a `NOT IN` quando a coluna da subconsulta pode ser NULL.
* Não espere nenhuma multiplicação de linhas, que um join daria a você.

## Veja também

* [Subconsultas correlacionadas](https://villagesql.com/docs/pt-BR/tutorial/correlated-subqueries.md) — a forma de subconsulta que EXISTS usa
* [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) — o operador com a armadilha de NULL
* [LEFT JOIN](https://villagesql.com/docs/pt-BR/tutorial/left-join.md) — a mesma pergunta feita com um join
* [Subconsultas vs JOINs no MySQL](https://villagesql.com/docs/pt-BR/guides/subqueries-vs-joins.md) — qual forma o otimizador prefere


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