SQL LIKE: filtros por prefixo, sufixo e trecho

SQL LIKE filtra linhas ao comparar uma coluna de texto com um padrão que usa curingas SQL. O curinga % corresponde a zero ou mais caracteres, e _ corresponde a exatamente um caractere. Use SQL LIKE para filtros de “começa com” ('prefixo%'), “termina com” ('%sufixo') e “contém” ('%termo%').

Exemplo de SQL LIKE para correspondência de prefixo

Saída:

+-------+----------------+
| nome  | email          |
+-------+----------------+
| Alice | [email protected] |
| Alina | [email protected] |
+-------+----------------+
2 row(s)

Como LIKE ‘Al%’ filtra linhas

1. CREATE TABLE e INSERT preenchem clientes com quatro linhas.
2. nome LIKE 'Al%' mantém nomes que começam com Al; % corresponde aos caracteres restantes.
3. Com um índice B-tree normal em nome, um padrão de prefixo como 'Al%' pode usar varredura por intervalo no índice.

O que é o operador SQL LIKE?

SQL LIKE compara uma coluna de texto com um padrão. LIKE corresponde à string inteira (não a um trecho) a menos que você adicione % em um ou nos dois lados. Sem curingas, LIKE 'texto' se comporta como = 'texto'. Se a coluna for NULL, LIKE e NOT LIKE são avaliados como desconhecido e a linha é filtrada no WHERE.

Padrões curinga: %, _, e ESCAPE

% e _ cobrem a maioria das necessidades de filtragem. Em um padrão curinga no SQL WHERE, combine texto fixo com % e _ para expressar correspondências por prefixo/sufixo/substring:

Para buscar um % ou _ literal, defina um caractere de escape com a cláusula ESCAPE:

SELECT rotulo FROM metricas
WHERE rotulo LIKE '%100\%%' ESCAPE '\';

O \ é declarado como caractere de escape, então \% corresponde a um % real em vez de agir como curinga.

SQL NOT LIKE: excluir linhas correspondentes

NOT LIKE inverte a correspondência. Uma consulta SQL com NOT LIKE retorna toda linha em que o padrão não corresponde:

SELECT nome FROM clientes
WHERE email NOT LIKE '%corp%';

Isso retorna Bob e Carol, qualquer pessoa cujo email não contém corp. Linhas em que a coluna é NULL são excluídas tanto de LIKE quanto de NOT LIKE. Para incluir NULLs, adicione OR coluna IS NULL.

Erros comuns com SQL LIKE

Erro: assumir que LIKE 'termo' corresponde a trechos da string.

Errado:

WHERE nome LIKE 'li'

Certo:

WHERE nome LIKE '%li%'

Por quê: LIKE compara a string inteira. Sem % nos dois lados, o padrão exige correspondência exata com li.

Erro: buscar um % literal sem ESCAPE.

Errado:

WHERE desconto LIKE '100%'

Certo:

WHERE desconto LIKE '100\%' ESCAPE '\'

Por quê: sem ESCAPE, % atua como curinga e corresponde a 100, 1000, 100USD e qualquer outro valor que comece com 100.

Desempenho do LIKE: prefixo vs curinga inicial

Com um índice B-tree normal, LIKE 'abc%' pode usar varredura por intervalo no índice. Padrões que começam com % (como '%abc' ou '%abc%') impedem uma busca por índice, então o mecanismo normalmente varre muito mais linhas.

Para busca de substring em grande escala, use full-text search (FTS) em vez de LIKE '%termo%'.

Sensibilidade a maiúsculas por dialeto

O comportamento de maiúsculas/minúsculas do LIKE varia por mecanismo de banco de dados:

No SQLite, LIKE 'al%' e LIKE 'Al%' têm o mesmo resultado para ASCII. PRAGMA case_sensitive_like = ON muda para correspondência com caixa exata. O ILIKE do PostgreSQL é uma extensão fora do padrão SQL.

Envolver colunas em LOWER() funciona entre dialetos, mas impede uso de índice. Prefira collation case-insensitive ou operadores específicos do dialeto quando desempenho importa.