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

# ANY e ALL no MySQL

> Como os operadores ANY e ALL do MySQL comparam um valor com todas as linhas que uma subconsulta retorna, o que cada um significa, e o que os dois fazem quando a subconsulta está vazia.

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

`=` compara um valor com 1 valor. `ANY` e `ALL` colocam uma comparação na frente de
um resultado inteiro de subconsulta: maior do que qualquer um deles, maior do que todos eles. Você vai encontrá-los com mais frequência nas consultas de outras pessoas do que escrevê-los
você mesmo, então o que levar desta lição é a capacidade de ler um deles.

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

## Como ANY e ALL funcionam

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME
WHERE COLUMN_NAME > ALL (SELECT COLUMN_NAME FROM OTHER_TABLE);
```

Substitua `COLUMN_LIST` pelas colunas que você quer, `TABLE_NAME` pela tabela,
`COLUMN_NAME` pela coluna a testar, e `OTHER_TABLE` pela tabela que a
subconsulta lê. Substitua `>` por qualquer operador de comparação.

`ANY` é verdadeiro quando a comparação vale para pelo menos 1 linha retornada. `ALL`
é verdadeiro quando ela vale para todas. `SOME` é outra grafia de `ANY`
e significa exatamente a mesma coisa.

Os dois dão NULL em vez de verdadeiro ou falso quando um NULL na subconsulta deixa a
resposta indefinida, da mesma forma que qualquer outra comparação com NULL faz, e
o `WHERE` então descarta a linha.

Leia-os em português simples: `> ANY` é "maior do que pelo menos um deles",
que é o mesmo que maior do que o menor. `> ALL` é "maior do que cada
um deles", o mesmo que maior do que o maior.

## Exemplos

### Maior do que pelo menos um

```sql theme={null}
SELECT title, length
FROM film
WHERE length > ANY (SELECT length FROM film WHERE rating = 'G')
ORDER BY length, title
LIMIT 3;
```

```text theme={null}
+---------------------+--------+
| title               | length |
+---------------------+--------+
| ACE GOLDFINGER      |     48 |
| HEAVEN FREEDOM      |     48 |
| MIDSUMMER GROUNDHOG |     48 |
+---------------------+--------+
3 rows in set (0.00 sec)
```

O filme `G` mais curto dura 47 minutos, então todo filme de 48 ou mais se qualifica.

### Maior do que todos

```sql theme={null}
SELECT title, length
FROM film
WHERE length > ALL (SELECT length FROM film WHERE rating = 'G')
ORDER BY title;
```

```text theme={null}
Empty set (0.01 sec)
```

Nenhuma linha, e essa é a resposta certa. O filme `G` mais longo tem 185 minutos,
que é também o filme mais longo do catálogo, então nada é mais longo do que todos
eles.

### = ANY é IN

```sql theme={null}
SELECT title FROM film WHERE rating = ANY (SELECT rating FROM film WHERE title = 'ACADEMY DINOSAUR') ORDER BY title LIMIT 3;
```

```text theme={null}
+------------------+
| title            |
+------------------+
| ACADEMY DINOSAUR |
| AGENT TRUMAN     |
| ALASKA PHANTOM   |
+------------------+
3 rows in set (0.00 sec)
```

`= ANY` e [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) são o mesmo operador escrito de 2 formas, e `IN`
é o que as pessoas leem mais rápido. `<> ALL` é, da mesma forma, `NOT IN`, com a mesma
armadilha de NULL que aquela lição descreve.

## Uma subconsulta vazia os inverte

Esta é a parte que vale a pena saber, porque parece errada.

```sql theme={null}
SELECT title, length
FROM film
WHERE length > ALL (SELECT length FROM film WHERE rating = 'X')
ORDER BY title
LIMIT 3;
```

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

Nenhum filme tem classificação `X`, então a subconsulta não retorna nada, e todos os filmes
voltam. `ALL` sobre um conjunto vazio é verdadeiro: não há linha que falhe no teste.
`ANY` sobre um conjunto vazio é falso pela razão inversa, então a mesma consulta com
`ANY` não retorna nada.

Um erro de digitação na subconsulta, portanto, dá a você a tabela inteira com `ALL` e um
resultado vazio com `ANY`, nos dois casos sem erro.

## Resumo

* Leia `> ANY` como maior do que o menor, e `> ALL` como maior do que o maior.
* Leia `SOME` como outra grafia de `ANY`.
* Prefira `IN` a `= ANY` e `NOT IN` a `<> ALL`, porque são mais rápidos de ler.
* Espere que `ALL` seja verdadeiro e `ANY` seja falso quando a subconsulta não retorna nada.
* Espere NULL em vez de verdadeiro ou falso quando um NULL na subconsulta deixa a resposta indefinida.

## Veja também

* [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) — o mesmo teste, escrito do jeito que a maioria das pessoas escreve
* [Subconsultas](https://villagesql.com/docs/pt-BR/tutorial/subqueries.md) — as consultas contra as quais esses operadores comparam
* [EXISTS](https://villagesql.com/docs/pt-BR/tutorial/exists.md) — testando a existência de uma linha em vez de comparar valores


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