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

# REGEXP no MySQL

> Como fazer a correspondência de uma expressão regular no MySQL com REGEXP, RLIKE e REGEXP_LIKE, as âncoras e classes que vale a pena conhecer, e como forçar uma correspondência que diferencia maiúsculas de minúsculas.

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

`LIKE` descreve uma forma com 2 caracteres. `REGEXP` descreve uma forma com uma
linguagem de padrões inteira, então consegue pedir coisas que `LIKE` não consegue expressar: uma escolha
entre alternativas, um grupo repetido, um intervalo de caracteres.

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

## Como REGEXP funciona

```sql theme={null}
SELECT COLUMN_LIST
FROM TABLE_NAME
WHERE COLUMN_NAME REGEXP 'PATTERN_TEXT';
```

Substitua `PATTERN_TEXT` pela expressão regular a procurar.

A condição é verdadeira quando o padrão corresponde a qualquer parte do valor. Essa
é a primeira diferença em relação a `LIKE`, que precisa descrever o valor inteiro.

As peças usadas abaixo:

| Peça | Significa |
| - | - |
| `^` | o início do valor |
| `$` | o fim do valor |
| `.` | 1 caractere qualquer |
| `*` | o que vem antes dele, repetido qualquer número de vezes |
| `[AB]` | qualquer 1 dos caracteres entre os colchetes |
| `(AL\|BE)` | qualquer uma das alternativas |

## Exemplos

### Começa com

```sql theme={null}
SELECT title FROM film WHERE title REGEXP '^ACA' ORDER BY title;
```

```text theme={null}
+------------------+
| title            |
+------------------+
| ACADEMY DINOSAUR |
+------------------+
1 row in set (0.01 sec)
```

Sem `^`, o padrão corresponderia a `ACA` em qualquer parte do título.

### Termina com

```sql theme={null}
SELECT title FROM film WHERE title REGEXP 'GOLDFINGER$' ORDER BY title;
```

```text theme={null}
+----------------------+
| title                |
+----------------------+
| ACE GOLDFINGER       |
| BREAKFAST GOLDFINGER |
| SILVERADO GOLDFINGER |
+----------------------+
3 rows in set (0.00 sec)
```

### Qualquer um de 2 inícios

```sql theme={null}
SELECT first_name FROM actor WHERE first_name REGEXP '^(AL|BE)' ORDER BY first_name LIMIT 5;
```

```text theme={null}
+------------+
| first_name |
+------------+
| AL         |
| ALAN       |
| ALBERT     |
| ALBERT     |
| ALEC       |
+------------+
5 rows in set (0.00 sec)
```

`ALBERT` aparece duas vezes porque 2 atores têm o mesmo nome. `SELECT` retorna linhas,
não valores distintos.

### Uma forma que LIKE não consegue descrever

Isto pede os títulos que começam com `A` ou `B` e terminam com `S`.

```sql theme={null}
SELECT title FROM film WHERE title REGEXP '^[AB].*S$' ORDER BY title LIMIT 5;
```

```text theme={null}
+----------------------+
| title                |
+----------------------+
| ADAPTATION HOLES     |
| AMELIE HELLFIGHTERS  |
| AMERICAN CIRCUS      |
| ANACONDA CONFESSIONS |
| ANALYZE HOOSIERS     |
+----------------------+
5 rows in set (0.00 sec)
```

### Tudo o que não corresponde

`NOT REGEXP` inverte o teste, da mesma forma que `NOT LIKE` faz.

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

```text theme={null}
+---------------------+--------+
| title               | rating |
+---------------------+--------+
| BABY HALL           | NC-17  |
| BACKLASH UNDEFEATED | PG-13  |
| BADMAN DAWN         | R      |
| BAKED CLEOPATRA     | G      |
| BALLOON HOMEWARD    | NC-17  |
+---------------------+--------+
5 rows in set (0.00 sec)
```

Um valor NULL não corresponde nem a `REGEXP` nem a `NOT REGEXP`, porque ambos retornam
NULL para ele. [IS NULL](https://villagesql.com/docs/pt-BR/tutorial/is-null.md) cobre isso.

## RLIKE é o mesmo operador

```sql theme={null}
SELECT title FROM film WHERE title RLIKE '^ACA' ORDER BY title;
```

```text theme={null}
+------------------+
| title            |
+------------------+
| ACADEMY DINOSAUR |
+------------------+
1 row in set (0.00 sec)
```

`RLIKE` e `REGEXP` são 2 grafias de um único operador. Escolha uma e mantenha-a.

## Diferenciação de maiúsculas e minúsculas, e como exigi-la

Um padrão segue a collation daquilo com que está sendo comparado, da mesma forma que `LIKE`. Então
um padrão em minúsculas corresponde a texto em maiúsculas por padrão. `REGEXP_LIKE()` é a
forma de função do operador, e seu terceiro argumento substitui esse comportamento: `'c'`
significa que a correspondência diferencia maiúsculas de minúsculas.

```sql theme={null}
SELECT REGEXP_LIKE('ACADEMY DINOSAUR', '^aca') AS default_mode,
       REGEXP_LIKE('ACADEMY DINOSAUR', '^aca', 'c') AS case_sensitive;
```

```text theme={null}
+--------------+----------------+
| default_mode | case_sensitive |
+--------------+----------------+
|            1 |              0 |
+--------------+----------------+
1 row in set (0.00 sec)
```

## Prefira LIKE quando LIKE consegue expressar

Nenhum índice consegue restringir uma busca com `REGEXP`, porque uma correspondência pode começar em qualquer lugar, então
o servidor testa todos os valores. `LIKE` com um padrão que começa com texto fixo
consegue pular direto para a parte correspondente de um índice. Quando ambos conseguem expressar o
filtro, `LIKE` é o mais barato dos 2. A lição sobre [LIKE](https://villagesql.com/docs/pt-BR/tutorial/like.md)
explica quais padrões conseguem usar um índice e quais não conseguem.

## Resumo

* Use `REGEXP` para fazer a correspondência de um padrão em qualquer parte de um valor.
* Ancore com `^` e `$` quando a correspondência precisa estar no início ou no fim.
* Leia `RLIKE` como outro nome para `REGEXP`.
* Use `REGEXP_LIKE(value, pattern, 'c')` para forçar uma correspondência que diferencia maiúsculas de minúsculas.
* Recorra a `LIKE` primeiro, porque nenhum índice consegue restringir uma busca com `REGEXP`.

## Veja também

* [LIKE](https://villagesql.com/docs/pt-BR/tutorial/like.md) — o operador de padrões mais simples
* [Diferenciação de maiúsculas e minúsculas](https://villagesql.com/docs/pt-BR/tutorial/case-sensitivity.md) — o que decide o comportamento padrão
* [WHERE](https://villagesql.com/docs/pt-BR/tutorial/where.md) — a cláusula em que o padrão vai
* [Busca de texto completo no MySQL](https://villagesql.com/docs/pt-BR/guides/full-text-search.md) — buscando palavras em texto em grande escala
* [Correspondência aproximada de strings no MySQL](https://villagesql.com/docs/pt-BR/guides/fuzzy-string-matching.md) — correspondência de texto que é parecido, mas não igual


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