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

# WHERE no MySQL

> Como a cláusula WHERE do MySQL mantém apenas as linhas que você quer, quais colunas uma condição pode testar, e por que ela não consegue ver um alias de coluna da mesma consulta.

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

`WHERE` mantém as linhas que satisfazem uma condição e descarta o resto. Todas as
lições até aqui retornaram tabelas inteiras. Esta é a cláusula que transforma uma tabela em
uma resposta.

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

## Como WHERE funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME
WHERE SEARCH_CONDITION;
```

Substitua `COLUMN_LIST` pelas colunas que você quer, `TABLE_NAME` pela tabela,
e `SEARCH_CONDITION` por um teste que o servidor consegue aplicar a uma linha de cada vez. O servidor lê cada linha, avalia a condição contra os valores
dessa linha, e mantém a linha quando o resultado é verdadeiro. Uma linha que dá falso, ou
dá NULL, é descartada.

`WHERE` vem depois de `FROM` e antes de `ORDER BY`, e essa é a ordem em que o
resultado é definido: filtrar, depois ordenar o que sobrou, depois aplicar `LIMIT`. Então um
`LIMIT 5` depois de um `WHERE` dá a você 5 das linhas correspondentes, e não 5 linhas das quais
algumas correspondem. O servidor é livre para chegar a essa resposta do jeito que quiser, e
`EXPLAIN` mostra qual caminho ele escolheu.

## Exemplos

### Filtre por um valor

O Sakila classifica todos os filmes. Isto mantém os filmes classificados como `G`.

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

```text theme={null}
+---------+-------------------+--------+
| film_id | title             | rating |
+---------+-------------------+--------+
|       2 | ACE GOLDFINGER    | G      |
|       4 | AFFAIR PREJUDICE  | G      |
|       5 | AFRICAN EGG       | G      |
|      11 | ALAMO VIDEOTAPE   | G      |
|      22 | AMISTAD MIDSUMMER | G      |
+---------+-------------------+--------+
5 rows in set (0.00 sec)
```

Uma string vai entre aspas simples. Um número não.

### Compare um número

```sql theme={null}
SELECT title, length
FROM film
WHERE length > 180
ORDER BY length DESC, title
LIMIT 5;
```

```text theme={null}
+----------------+--------+
| title          | length |
+----------------+--------+
| CHICAGO NORTH  |    185 |
| CONTROL ANTHEM |    185 |
| DARN FORRESTER |    185 |
| GANGS PRIDE    |    185 |
| HOME PITY      |    185 |
+----------------+--------+
5 rows in set (0.00 sec)
```

185 minutos é o filme mais longo do catálogo e 10 filmes duram isso, então
as primeiras 5 linhas são todas empates. Ordenar também por `title` desempata, e é
isso que faz os mesmos 5 voltarem todas as vezes.

### Filtre por uma coluna que você não selecionou

A condição testa a linha, não o resultado. `rental_rate` nunca aparece na
saída aqui, e o filtro funciona mesmo assim.

```sql theme={null}
SELECT title
FROM film
WHERE rental_rate = 4.99
ORDER BY title
LIMIT 5;
```

```text theme={null}
+------------------+
| title            |
+------------------+
| ACE GOLDFINGER   |
| AIRPLANE SIERRA  |
| AIRPORT POLLOCK  |
| ALADDIN CALENDAR |
| ALI FOREVER      |
+------------------+
5 rows in set (0.00 sec)
```

### Tudo exceto um valor

```sql theme={null}
SELECT title, rating
FROM film
WHERE 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)
```

`<>` é "diferente de". `!=` significa a mesma coisa e qualquer um dos dois serve.

## WHERE não consegue ver um alias de coluna

Um alias nomeia uma coluna do resultado. `WHERE` é executado antes de o resultado existir,
então nomear um alias ali falha.

```sql theme={null}
SELECT title, rental_rate * 2 AS double_rate
FROM film
WHERE double_rate > 8
ORDER BY title;
```

```text theme={null}
ERROR 1054 (42S22): Unknown column 'double_rate' in 'where clause'
```

Em vez disso, escreva a expressão de novo na condição.

```sql theme={null}
SELECT title, rental_rate * 2 AS double_rate
FROM film
WHERE rental_rate * 2 > 8
ORDER BY title
LIMIT 5;
```

```text theme={null}
+------------------+-------------+
| title            | double_rate |
+------------------+-------------+
| ACE GOLDFINGER   |        9.98 |
| AIRPLANE SIERRA  |        9.98 |
| AIRPORT POLLOCK  |        9.98 |
| ALADDIN CALENDAR |        9.98 |
| ALI FOREVER      |        9.98 |
+------------------+-------------+
5 rows in set (0.00 sec)
```

`ORDER BY` é a cláusula que consegue usar um alias, porque ela é executada depois que o
resultado foi construído. A lição sobre [ORDER BY](https://villagesql.com/docs/pt-BR/tutorial/order-by.md) mostra isso.

## Nenhuma correspondência não é um erro

```sql theme={null}
SELECT title FROM film WHERE rating = 'X';
```

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

`Empty set` significa que a consulta foi executada e nenhuma linha satisfez a condição. O servidor
o imprime no lugar de uma tabela, então também não há cabeçalhos de coluna. É uma
resposta.

## Resumo

* Use `WHERE` para manter apenas as linhas que satisfazem uma condição.
* Coloque uma string entre aspas simples e deixe um número sem aspas.
* Espere que o servidor filtre primeiro, depois ordene, depois aplique `LIMIT`.
* Teste qualquer coluna da tabela, quer você a tenha selecionado ou não.
* Repita a expressão no `WHERE` em vez de nomear um alias, o que dá `ERROR 1054`.

## Veja também

* [SELECT](https://villagesql.com/docs/pt-BR/tutorial/select.md) — a instrução à qual WHERE se liga
* [Operadores](https://villagesql.com/docs/pt-BR/tutorial/operators.md) — as comparações com que uma condição é construída
* [AND, OR e NOT](https://villagesql.com/docs/pt-BR/tutorial/and-or-not.md) — combinando várias condições
* [ORDER BY](https://villagesql.com/docs/pt-BR/tutorial/order-by.md) — ordenando o que sobrevive ao filtro


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