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

# BETWEEN no MySQL

> Como o operador BETWEEN do MySQL testa um intervalo, por que os dois limites são incluídos, por que o limite inferior deve vir primeiro, e o intervalo de datas que ele silenciosamente erra.

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

`BETWEEN` testa se um valor cai dentro de um intervalo. É uma abreviação de um par de
comparações, e é a cláusula que as pessoas mais erram de forma sutil com datas.

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

## Como BETWEEN funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME
WHERE COLUMN_NAME BETWEEN LOW_BOUND AND HIGH_BOUND;
```

Substitua `LOW_BOUND` e `HIGH_BOUND` pelas 2 extremidades do intervalo.

`x BETWEEN a AND b` significa `x >= a AND x <= b`. O intervalo inclui os dois limites,
e você escreve o limite inferior primeiro.

## Exemplos

### Um intervalo de números

```sql theme={null}
SELECT title, length
FROM film
WHERE length BETWEEN 60 AND 70
ORDER BY length, title
LIMIT 5;
```

```text theme={null}
+-----------------------+--------+
| title                 | length |
+-----------------------+--------+
| BUBBLE GROSSE         |     60 |
| JERSEY SASSY          |     60 |
| MOCKINGBIRD HOLLYWOOD |     60 |
| PHANTOM GLORY         |     60 |
| PITY BOUND            |     60 |
+-----------------------+--------+
5 rows in set (0.00 sec)
```

Filmes de exatamente 60 minutos estão no resultado, o que mostra que o limite inferior
conta como correspondência.

### A mesma coisa escrita por extenso

```sql theme={null}
SELECT title, length
FROM film
WHERE length >= 60 AND length <= 70
ORDER BY length, title
LIMIT 5;
```

```text theme={null}
+-----------------------+--------+
| title                 | length |
+-----------------------+--------+
| BUBBLE GROSSE         |     60 |
| JERSEY SASSY          |     60 |
| MOCKINGBIRD HOLLYWOOD |     60 |
| PHANTOM GLORY         |     60 |
| PITY BOUND            |     60 |
+-----------------------+--------+
5 rows in set (0.00 sec)
```

Linhas idênticas. `BETWEEN` poupa você de nomear a coluna duas vezes e nada mais.

### Fora do intervalo

```sql theme={null}
SELECT title, length
FROM film
WHERE length NOT BETWEEN 60 AND 70
ORDER BY length, title
LIMIT 5;
```

```text theme={null}
+---------------------+--------+
| title               | length |
+---------------------+--------+
| ALIEN CENTER        |     46 |
| IRON MOON           |     46 |
| KWAI HOMEWARD       |     46 |
| LABYRINTH LEAGUE    |     46 |
| RIDGEMONT SUBMARINE |     46 |
+---------------------+--------+
5 rows in set (0.01 sec)
```

`NOT BETWEEN` mantém as linhas abaixo do limite inferior e acima do limite superior. 46
minutos é o filme mais curto do catálogo.

## O limite inferior tem de vir primeiro

`BETWEEN` não ordena os limites para você. Dê a ele um valor alto primeiro e ele
pede números que sejam ao mesmo tempo pelo menos 70 e no máximo 60, o que nenhum número é.

```sql theme={null}
SELECT title, length
FROM film
WHERE length BETWEEN 70 AND 60
ORDER BY length, title;
```

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

Nenhum erro e nenhum aviso. Um resultado vazio de um intervalo que você esperava que correspondesse
merece primeiro uma verificação de limites trocados.

## BETWEEN com datas termina à meia-noite

Este é o que custa tempo de verdade às pessoas, e começa com o tipo da
coluna.

```sql theme={null}
SHOW COLUMNS FROM payment LIKE 'payment_date';
```

```text theme={null}
+--------------+----------+------+-----+---------+-------+
| Field        | Type     | Null | Key | Default | Extra |
+--------------+----------+------+-----+---------+-------+
| payment_date | datetime | NO   |     | NULL    |       |
+--------------+----------+------+-----+---------+-------+
1 row in set (0.00 sec)
```

`payment_date` é um `datetime`, então todo valor carrega uma hora do dia. Uma data
escrita sem hora significa meia-noite no início daquele dia.

```sql theme={null}
SELECT payment_id
FROM payment
WHERE payment_date BETWEEN '2005-05-25' AND '2005-05-26'
ORDER BY payment_id;
```

```text theme={null}
+------------+
| payment_id |
+------------+
|          1 |
|        146 |
|        174 |
...
+------------+
137 rows in set (0.01 sec)
```

Isso se lê como "o dia 25 e o dia 26" e retorna 137 linhas. Pedir os mesmos
2 dias como um intervalo semiaberto retorna 311.

```sql theme={null}
SELECT payment_id
FROM payment
WHERE payment_date >= '2005-05-25' AND payment_date < '2005-05-27'
ORDER BY payment_id;
```

```text theme={null}
+------------+
| payment_id |
+------------+
|          1 |
|        146 |
|        174 |
...
+------------+
311 rows in set (0.00 sec)
```

O limite superior `'2005-05-26'` virou `2005-05-26 00:00:00`. Todo pagamento recebido
durante o dia 26 é posterior a esse instante, então `BETWEEN` excluiu todos eles.
As 137 linhas são o dia 25 sozinho, e elas teriam incluído um pagamento
que caísse exatamente na batida da meia-noite se houvesse um.

Escreva um intervalo de datas como `>= início AND < o dia seguinte ao fim`. Essa forma não exige
pensar se a coluna carrega uma hora, e continua correta se a
coluna ganhar uma mais tarde.

## Resumo

* Use `BETWEEN` para um intervalo, e espere que ele inclua os dois limites.
* Escreva o limite inferior primeiro, porque um intervalo invertido não corresponde a nada e não diz nada.
* Leia `x BETWEEN a AND b` como `x >= a AND x <= b`.
* Use `>= start AND < day_after_end` para datas em vez de `BETWEEN`.

## Veja também

* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula em que BETWEEN entra
* [Operadores](https://villagesql.com/docs/pt-BR/tutorial/operators.md) — as comparações das quais BETWEEN é abreviação
* [IN](https://villagesql.com/docs/pt-BR/tutorial/in.md) — testando uma lista de valores em vez de um intervalo
* [Funções de data e hora no MySQL](https://villagesql.com/docs/pt-BR/guides/date-time-functions.md) — construindo os limites de um intervalo


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