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

# AND, OR e NOT no MySQL

> Como combinar condições em uma cláusula WHERE do MySQL com AND, OR e NOT, qual deles tem precedência, e os 2 erros que retornam silenciosamente as linhas erradas.

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

Uma condição responde a uma pergunta. `AND`, `OR` e `NOT` juntam condições
para que um único `WHERE` possa fazer uma pergunta composta.

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

## Como AND, OR e NOT funcionam

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME
WHERE FIRST_CONDITION AND SECOND_CONDITION;
```

Substitua `COLUMN_LIST` pelas colunas que você quer, `TABLE_NAME` pela tabela,
e cada um de `FIRST_CONDITION` e `SECOND_CONDITION` por um teste próprio.

`AND` mantém uma linha somente quando as duas condições são verdadeiras. `OR` mantém uma linha quando pelo
menos uma é verdadeira. `NOT` inverte a condição que vem depois dele.

Eles não têm todos a mesma precedência. Dos 3, `NOT` tem a precedência mais alta, depois `AND`, depois
`OR`. O servidor portanto lê `a OR b AND c` como `a OR (b AND c)`, o que
raramente é o que quem escreveu quis dizer. Os parênteses sobrepõem isso, e não custam
nada.

Os 3 têm precedência mais baixa do que uma comparação, e é por isso que `NOT rating = 'G'`
abaixo inverte a comparação inteira, e não só a coluna.

## Exemplos

### As duas condições

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

```text theme={null}
+-----------------+--------+--------+
| title           | rating | length |
+-----------------+--------+--------+
| BAKED CLEOPATRA | G      |    182 |
| CATCH AMISTAD   | G      |    183 |
| CONTROL ANTHEM  | G      |    185 |
| DARN FORRESTER  | G      |    185 |
| INTRIGUE WORST  | G      |    181 |
| LAWLESS VISION  | G      |    181 |
| MOONWALKER FOOL | G      |    184 |
| MUSCLE BRIGHT   | G      |    185 |
| YOUNG LANGUAGE  | G      |    183 |
+-----------------+--------+--------+
9 rows in set (0.00 sec)
```

9 filmes têm classificação `G` e duram mais de 180 minutos.

### Qualquer uma das condições

```sql theme={null}
SELECT title, rating
FROM film
WHERE rating = 'G' OR rating = 'PG'
ORDER BY title
LIMIT 5;
```

```text theme={null}
+------------------+--------+
| title            | rating |
+------------------+--------+
| ACADEMY DINOSAUR | PG     |
| ACE GOLDFINGER   | G      |
| AFFAIR PREJUDICE | G      |
| AFRICAN EGG      | G      |
| AGENT TRUMAN     | PG     |
+------------------+--------+
5 rows in set (0.00 sec)
```

Testar uma coluna contra uma lista de valores é comum o bastante para ter seu próprio
operador. [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) escreve o mesmo filtro em uma cláusula.

### Inverter uma condição

```sql theme={null}
SELECT title, rating
FROM film
WHERE NOT rating = 'G'
ORDER BY title
LIMIT 5;
```

```text theme={null}
+------------------+--------+
| title            | rating |
+------------------+--------+
| ACADEMY DINOSAUR | PG     |
| ADAPTATION HOLES | NC-17  |
| AGENT TRUMAN     | PG     |
| AIRPLANE SIERRA  | PG-13  |
| AIRPORT POLLOCK  | R      |
+------------------+--------+
5 rows in set (0.00 sec)
```

`NOT rating = 'G'` e `rating <> 'G'` selecionam as mesmas linhas. Prefira `<>` para uma
comparação única e reserve `NOT` para inverter algo maior.

## AND tem precedência sobre OR

Isto parece "classificação G ou PG, e mais de 180 minutos".

```sql theme={null}
SELECT title, rating, length
FROM film
WHERE rating = 'G' OR rating = 'PG' AND length > 180
ORDER BY title;
```

```text theme={null}
+---------------------------+--------+--------+
| title                     | rating | length |
+---------------------------+--------+--------+
| ACE GOLDFINGER            | G      |     48 |
| AFFAIR PREJUDICE          | G      |    117 |
| AFRICAN EGG               | G      |    130 |
...
+---------------------------+--------+--------+
182 rows in set (0.00 sec)
```

182 linhas, e a primeira dura 48 minutos. `AND` se ligou ao par ao lado
dele, então o servidor respondeu "classificação G, ou então classificação PG e mais de 180 minutos".
Todo filme `G` se qualificou só pelo primeiro ramo, qualquer que fosse sua duração.

Os parênteses dizem o que se queria dizer.

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

```text theme={null}
+-----------------+--------+--------+
| title           | rating | length |
+-----------------+--------+--------+
| BAKED CLEOPATRA | G      |    182 |
| CATCH AMISTAD   | G      |    183 |
| CONTROL ANTHEM  | G      |    185 |
| DARN FORRESTER  | G      |    185 |
| INTRIGUE WORST  | G      |    181 |
| LAWLESS VISION  | G      |    181 |
| MONSOON CAUSE   | PG     |    182 |
| MOONWALKER FOOL | G      |    184 |
| MUSCLE BRIGHT   | G      |    185 |
| RECORDS ZORRO   | PG     |    182 |
| STAR OPERATION  | PG     |    181 |
| WORST BANGER    | PG     |    185 |
| YOUNG LANGUAGE  | G      |    183 |
+-----------------+--------+--------+
13 rows in set (0.01 sec)
```

13 linhas. Nenhuma das consultas é inválida, e nada avisa você, então a única defesa
é colocar parênteses em toda mistura de `AND` e `OR` no momento em que a escreve.

## OR não aceita um segundo valor solto

`rating = 'G' OR 'PG'` se lê em português como "classificação G ou PG". Para o servidor são
2 condições separadas, e a segunda é a string `'PG'` sozinha.

```sql theme={null}
SELECT title, rating
FROM film
WHERE rating = 'G' OR 'PG'
ORDER BY title
LIMIT 5;
```

```text theme={null}
+-------------------+--------+
| title             | rating |
+-------------------+--------+
| ACE GOLDFINGER    | G      |
| AFFAIR PREJUDICE  | G      |
| AFRICAN EGG       | G      |
| ALAMO VIDEOTAPE   | G      |
| AMISTAD MIDSUMMER | G      |
+-------------------+--------+
5 rows in set, 1 warning (0.00 sec)
```

Só filmes `G` voltaram, e o rodapé informa um aviso. Execute `SHOW WARNINGS`
na mesma sessão e o servidor se explica:
`Warning 1292 Truncated incorrect DOUBLE value: 'PG'`.

Uma condição tem de ser verdadeira ou falsa, então o servidor converteu `'PG'` em um
número. `'PG'` não começa com dígito, o que converte para 0, que é falso. O
segundo ramo inteiro estava, portanto, morto. Nomeie a coluna dos dois lados, ou use
[IN](https://villagesql.com/docs/pt-BR/tutorial/in.md).

## NOT inverte só o que vem em seguida

```sql theme={null}
SELECT title, rating, length
FROM film
WHERE NOT rating = 'G' AND length > 180
ORDER BY title;
```

```text theme={null}
+--------------------+--------+--------+
| title              | rating | length |
+--------------------+--------+--------+
| ANALYZE HOOSIERS   | R      |    181 |
| CHICAGO NORTH      | PG-13  |    185 |
| CONSPIRACY SPIRIT  | PG-13  |    184 |
...
+--------------------+--------+--------+
30 rows in set (0.00 sec)
```

`NOT` pegou a comparação ao lado dele, então isto é "não classificado como G, e mais de 180
minutos". Para inverter o par inteiro, coloque-o entre parênteses.

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

```text theme={null}
+------------------+--------+--------+
| title            | rating | length |
+------------------+--------+--------+
| ACADEMY DINOSAUR | PG     |     86 |
| ACE GOLDFINGER   | G      |     48 |
| ADAPTATION HOLES | NC-17  |     50 |
| AFFAIR PREJUDICE | G      |    117 |
| AFRICAN EGG      | G      |    130 |
+------------------+--------+--------+
5 rows in set (0.00 sec)
```

`ACE GOLDFINGER` tem classificação `G` e dura 48 minutos. Ele falha no par entre parênteses,
então inverter o par o mantém.

## Resumo

* Use `AND` quando todas as condições precisam valer, e `OR` quando qualquer uma basta.
* Coloque parênteses em qualquer `WHERE` que misture `AND` e `OR`, porque `AND` tem precedência.
* Espere que `NOT` inverta só a condição ao lado dele.
* Repita a coluna dos dois lados do `OR`, porque um valor solto é convertido em número.
* Observe a contagem de avisos no rodapé, e então execute `SHOW WARNINGS`.

## Veja também

* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula que esses operadores constroem
* [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) — uma forma mais limpa de testar uma coluna contra vários valores
* [Operadores](https://villagesql.com/docs/pt-BR/tutorial/operators.md) — as comparações que estão sendo combinadas


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