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

# MySQL LIKE

> Como o operador LIKE do MySQL corresponde a um padrão com % e _, como corresponder a esses caracteres literalmente, e por que o LIKE ignora maiúsculas e minúsculas por padrão.

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

`=` corresponde a um valor completo. `LIKE` corresponde a um padrão, então você pode pedir os
títulos que começam com uma palavra, terminam com uma, ou têm uma certa forma.

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

## Como o LIKE funciona

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

Substitua `PATTERN_TEXT` pelo padrão a corresponder. Um padrão é texto comum
mais 2 caracteres especiais:

| Caractere | Corresponde a |
| - | - |
| `%` | qualquer sequência de caracteres, inclusive nenhum |
| `_` | exatamente 1 caractere |

Todo o resto do padrão corresponde a si mesmo. Um padrão sem `%` nem
`_` se comporta quase como `=`. Os 2 se separam nos espaços finais: sob uma
collation `PAD SPACE` como `utf8mb4_general_ci`, `'a ' = 'a'` é verdadeiro e
`'a ' LIKE 'a'` é falso. Sob uma collation `NO PAD`, que é o caso de toda collation
`utf8mb4_0900`, os dois são falsos.

## Exemplos

### Começa com

```sql theme={null}
SELECT title FROM film WHERE title LIKE 'ACADEMY%' ORDER BY title;
```

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

### Termina com

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

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

### Um número fixo de caracteres

3 sublinhados depois do `J` pedem um nome de exatamente 4 caracteres.

```sql theme={null}
SELECT first_name, last_name
FROM actor
WHERE first_name LIKE 'J___'
ORDER BY first_name, last_name;
```

```text theme={null}
+------------+-------------+
| first_name | last_name   |
+------------+-------------+
| JADA       | RYDER       |
| JANE       | JACKMAN     |
| JEFF       | SILVERSTONE |
| JOHN       | SUVARI      |
| JUDE       | CRUISE      |
| JUDY       | DEAN        |
+------------+-------------+
6 rows in set (0.00 sec)
```

`JOHNNY` não está na lista, porque `J___` corresponde a 4 caracteres e nada mais.

### Não corresponde

```sql theme={null}
SELECT title FROM film WHERE title NOT LIKE 'A%' ORDER BY title LIMIT 5;
```

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

## O LIKE ignora maiúsculas e minúsculas aqui

O mesmo padrão em minúsculas retorna a mesma linha.

```sql theme={null}
SELECT title FROM film WHERE title LIKE 'academy%' ORDER BY title;
```

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

Isso não é uma regra sobre o `LIKE`. É uma regra sobre a coluna, cuja collation
decide se 2 strings contam como iguais. A do Sakila não diferencia maiúsculas de minúsculas, e o
padrão do MySQL também não. A lição sobre [Diferenciação de maiúsculas e minúsculas](https://villagesql.com/docs/pt-BR/tutorial/case-sensitivity.md)
mostra como verificar uma coluna e como pedir uma correspondência que diferencie maiúsculas de minúsculas.

## Correspondendo a um % ou \_ literal

Um `%` no seu texto de busca é um curinga, a menos que você diga o contrário. `ESCAPE`
nomeia um caractere que desliga o caractere seguinte, então um padrão pode pedir um
sinal de porcentagem de verdade.

```sql theme={null}
SELECT 'axxb' LIKE 'a%b' AS wildcard, 'axxb' LIKE 'a!%b' ESCAPE '!' AS literal_percent;
```

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

`a%b` correspondeu a `axxb` porque `%` ficou no lugar de `xx`. `a!%b` pediu um
sinal de porcentagem literal entre `a` e `b`, que `axxb` não tem.

```sql theme={null}
SELECT '50%' LIKE '50!%' ESCAPE '!' AS literal_percent;
```

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

O sublinhado funciona do mesmo jeito.

```sql theme={null}
SELECT 'a_b' LIKE 'a!_b' ESCAPE '!' AS underscore, 'axb' LIKE 'a!_b' ESCAPE '!' AS any_char;
```

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

Qualquer caractere que você tenha certeza de que seus dados não contêm serve. Sem
`ESCAPE`, uma barra invertida escapa o caractere seguinte, então `'a\%b'` significa a mesma
coisa. Esse atalho para de funcionar quando o servidor roda com
`NO_BACKSLASH_ESCAPES` no seu `sql_mode`, e `ESCAPE` funciona de qualquer jeito.

## Um % no início é o caro

`LIKE 'ACADEMY%'` pode usar um índice na coluna, porque toda correspondência começa
com o mesmo texto conhecido e um índice é mantido em ordem, então o servidor
pula direto para aquela parte dele. `LIKE '%GOLDFINGER'` não dá a ele um ponto de partida,
porque uma correspondência pode começar em qualquer lugar, então ele lê todos os valores da coluna e
testa cada um. `EXPLAIN` nas 2 consultas mostra a diferença: 1 linha estimada
contra 1.000.

Em 1.000 filmes ninguém nota. Em uma tabela grande é a diferença entre uma
busca e uma varredura completa. Quando você precisa pesquisar dentro de texto em escala, uma
ferramenta diferente se encaixa: consulte
[Busca de texto completo no MySQL](https://villagesql.com/docs/pt-BR/guides/full-text-search.md).

## Resumo

* Use `LIKE` para corresponder a um padrão em vez de a um valor completo.
* Leia `%` como qualquer sequência de caracteres e `_` como exatamente 1 caractere.
* Nomeie um caractere de escape com `ESCAPE` para corresponder a um `%` ou `_` literal.
* Espere que a collation da coluna, não o `LIKE`, decida se maiúsculas e minúsculas importam.
* Evite um `%` no início em uma tabela grande, porque nenhum índice consegue estreitar a busca.

## Veja também

* [REGEXP](https://villagesql.com/docs/pt-BR/tutorial/regexp.md) — padrões que `%` e `_` não conseguem descrever
* [Diferenciação de maiúsculas e minúsculas](https://villagesql.com/docs/pt-BR/tutorial/case-sensitivity.md) — por que o padrão em minúsculas correspondeu
* [Funções de string do MySQL](https://villagesql.com/docs/pt-BR/guides/string-functions.md) — remodelando texto antes de compará-lo
* [Busca de texto completo no MySQL](https://villagesql.com/docs/pt-BR/guides/full-text-search.md) — pesquisando dentro de texto em escala


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