SQL LIKE

Uma cliente liga para a Loja Aurora: "é a Ana, já comprei aí". Ana de quê? A atendente não sabe o nome completo, então o = não serve: nome = 'Ana' só acharia alguém chamado exatamente "Ana", e ninguém se chama assim. Ela precisa procurar por um pedaço do texto: "nomes que começam com Ana". É para isso que serve o LIKE ("parecido com", em inglês): ele compara o texto com um padrão, em vez de exigir que seja igualzinho.

Os exemplos usam o banco da Loja Aurora, e cada quadro "Resultado" vem do SQLite de verdade, rodando no seu navegador. Os dois "curingas" do LIKE, o % e o _, aparecem aqui só no básico; todas as combinações estão na próxima aula, Curingas (% e _).

A ideia: o "qualquer coisa"

No LIKE, o padrão é um texto comum com um símbolo especial: o % (sinal de porcentagem), que quer dizer "qualquer coisa aqui" (qualquer sequência de letras, de qualquer tamanho, até nenhuma). É como dizer à atendente: "procure 'Ana', seguido de um espaço, seguido de qualquer coisa".

Há um segundo curinga, o _ (sublinhado), que quer dizer "exatamente uma letra qualquer". Ele é o assunto da próxima aula.

1. O primeiro LIKE

SELECT nome, cidade
FROM clientes
WHERE nome LIKE 'Ana %';

nome

A coluna de texto que vai ser comparada.

LIKE

"Parecido com": compara com um padrão, não com um valor exato.

'Ana %'

O padrão, entre aspas simples (é um texto). "Ana", um espaço e depois qualquer coisa.

Duas clientes: Ana Beatriz Sousa, de São Paulo, e Ana Carvalho Lima, de Teresina. Agora a atendente pode perguntar "a senhora é de São Paulo ou de Teresina?".

Por que o espaço depois de "Ana"? Sem ele, 'Ana%' também acharia uma "Anabela" ou uma "Anastácia". Com o espaço, só quem tem "Ana" como primeiro nome inteiro.

Compare com o =, que não conhece curingas:

SELECT nome
FROM clientes
WHERE nome = 'Ana %';

Nenhuma linha. Para o =, o % é só um caractere comum: ele procurou alguém chamado literalmente "Ana %".

2. Começa com, termina com, contém

A posição do % decide o tipo de busca. Os produtos que começam com "Garrafa":

SELECT nome
FROM produtos
WHERE nome LIKE 'Garrafa%';

Os que terminam com "azul" (repare: escrevi em minúsculas, e veio "Azul"; a seção 3 explica):

SELECT nome
FROM produtos
WHERE nome LIKE '%azul';

E os que contêm o número de telefone de Teresina, o DDD 86, entre parênteses, no começo:

SELECT nome, telefone
FROM fornecedores
WHERE telefone LIKE '(86)%';

SELECT nome, preco
FROM produtos
WHERE nome = 'Jogo';

SELECT nome, preco
FROM produtos
WHERE nome LIKE 'Jogo%';

3. Maiúsculas, minúsculas e acentos

No SQLite, o LIKE não diferencia maiúsculas de minúsculas. Por isso 'ana %', 'Ana %' e 'ANA %' acham as mesmas duas clientes:

SELECT nome, cidade
FROM clientes
WHERE nome LIKE 'ana %';

Mas há uma pegadinha, e ela é grande para quem escreve em português. A documentação do SQLite avisa: por padrão, ele só entende maiúsculas e minúsculas das letras ASCII, ou seja, de A a Z, sem acento. Para as letras acentuadas (á, ã, ç, é, ô…), o LIKE diferencia maiúscula de minúscula. Veja letra por letra:

SELECT 'a' LIKE 'A', 'á' LIKE 'Á', 'ç' LIKE 'Ç', 'Água' LIKE 'água', 'Água' LIKE 'ÁGUA';

Na prática, com os dados da loja: o fornecedor 2 se chama Loja D'Água, com "Á" maiúsculo. A Ana procura por "água", em minúsculas:

SELECT nome
FROM fornecedores
WHERE nome LIKE '%água%';

Nada! O mesmo acontece com a cidade de São Paulo: cidade LIKE 'são paulo' acha os 7 clientes (o "ã" está igual, minúsculo, nos dois lados), mas cidade LIKE 'SÃO PAULO' não acha nenhum, porque "Ã" maiúsculo não casa com o "ã" guardado. E o acento em si sempre conta: '%agua%', sem acento, também não acha a Loja D'Água.

SELECT nome, cidade
FROM fornecedores
WHERE nome LIKE '%água%';

SELECT nome, cidade
FROM fornecedores
WHERE nome LIKE '%Água%';

4. NOT LIKE, NULL e números

NOT LIKE: o que não combina

Com NOT antes do LIKE (aula NOT), você fica com o que não combina. Os clientes cujo nome não termina com "a":

SELECT nome
FROM clientes
WHERE nome NOT LIKE '%a';

22 clientes; os outros 8 (José Ribamar Silva, Ana Beatriz Sousa, Carlos Eduardo Lima…) terminam com "a".

NULL não combina com nada

O padrão '%' combina com qualquer texto, até o texto vazio. Então quantos clientes têm um email que combina com '%'?

SELECT count(*)
FROM clientes
WHERE email LIKE '%';

27, e não 30. Os 3 clientes sem email (NULL) ficaram de fora: o NULL não é um texto, é "não sei", e "não sei" não combina com padrão nenhum. E eles também não aparecem no NOT LIKE: a armadilha é a mesma da aula NOT. (O count(*) conta as linhas; ele tem aula própria, COUNT().)

LIKE em números

O LIKE foi feito para texto, mas o SQLite aceita uma coluna de números: ele transforma o número em texto antes de comparar. Os produtos cujo preço termina em ",9":

SELECT nome, preco
FROM produtos
WHERE preco LIKE '%.9';

Funciona, mas é um truque: ele depende de como o número vira texto (4.9, e não 4.90). Para números, prefira as comparações (>, <, BETWEEN).

5. ESCAPE: procurando um % ou um _ de verdade

E se o texto que você procura tem um % ou um _? Por exemplo, um aviso "50% de desconto", ou um email com sublinhado (joao_silva@…). Dentro do padrão, esses símbolos são curingas, e o LIKE não os trata como letras. Veja a Ana procurando emails que têm um sublinhado:

SELECT count(*)
FROM clientes
WHERE email LIKE '%_%';

27, ou seja, todos os emails. Mas nenhum email da loja tem sublinhado! O que aconteceu: o _ do padrão é o curinga "uma letra qualquer", então '%_%' quer dizer "tem pelo menos uma letra", e todo email tem.

Para dizer "este _ é um sublinhado de verdade", escolha um caractere de escape com ESCAPE e ponha-o antes do símbolo:

SELECT count(*)
FROM clientes
WHERE email LIKE '%!_%' ESCAPE '!';

ESCAPE '!'

Avisa: neste padrão, o ! é o caractere de escape. Você escolhe qual; tem de ser um caractere só, que não apareça no texto procurado. !, \ e # são escolhas comuns.

!_

"Um _ de verdade", e não o curinga.

% … %

Continuam sendo curingas: "qualquer coisa" antes e depois.

Agora deu 0: de fato, nenhum email da loja tem sublinhado. Com o % é igual. Como a loja não tem nenhum texto com "%", veja o LIKE aplicado direto a textos de exemplo:

SELECT '50% de desconto' LIKE '50!%%' ESCAPE '!',
       '50 reais de desconto' LIKE '50!%%' ESCAPE '!',
       '50 reais de desconto' LIKE '50%';

O padrão '50!%%' quer dizer "50, um sinal de % de verdade, depois qualquer coisa": casa com "50% de desconto" (1) e não com "50 reais" (0). Sem o escape, '50%' casa com qualquer coisa que comece com 50, inclusive "50 reais" (1).

6. GLOB: a alternativa que diferencia maiúsculas

O SQLite tem um "primo" do LIKE, o GLOB (de global, o nome que o Unix dá para os padrões de nomes de arquivo, como *.txt). Ele faz o mesmo tipo de busca, com duas diferenças: os curingas são outros, e ele diferencia maiúsculas de minúsculas.

SELECT nome
FROM clientes
WHERE nome GLOB 'Ana *';

As mesmas duas clientes, mas agora com * no lugar de %. E com 'ana *', em minúsculas, o GLOB não acharia ninguém. A grande vantagem do GLOB são as listas entre colchetes. Os produtos que têm algum algarismo no nome:

SELECT nome
FROM produtos
WHERE nome GLOB '*[0-9]*';

[0-9] quer dizer "um caractere entre 0 e 9". Com o LIKE, não dá para dizer isso.

7. Formas diferentes de procurar

Quando dá errado

SELECT nome FROM clientes WHERE nome LIKE "Ana%";

SELECT nome FROM clientes WHERE nome LIKE Ana%;

SELECT nome FROM clientes WHERE nome LIKE 'Ana%' ESCAPE '!!';

SELECT nome FROM clientes WHERE nome LIKE 'Ana*';

-- PostgreSQL: LIKE diferencia maiúsculas; ILIKE não
SELECT nome FROM clientes WHERE nome ILIKE 'ana %';

-- SQL Server: lista de caracteres dentro do LIKE
SELECT nome FROM produtos WHERE nome LIKE '%[0-9]%';

Referência rápida

Exercícios

Missão final: o Rafael ou o Roberto?

SELECT nome, cidade, email
FROM clientes
WHERE cidade = 'São Paulo';

SELECT nome, cidade, email
FROM clientes
WHERE cidade = 'São Paulo'
  AND nome LIKE 'R%';

Resumo

• LIKE ("parecido com") compara um texto com um padrão. O % quer dizer "qualquer coisa" (até nada); o _, "uma letra qualquer" (próxima aula).
• 'abc%' começa com, '%abc' termina com, '%abc%' contém. Sem curinga, o padrão tem de casar com o texto inteiro.
• No SQLite, o LIKE ignora maiúsculas só de A a Z: 'a' LIKE 'A' é 1, mas 'á' LIKE 'Á' é 0. Escreva os acentos como estão guardados.
• NULL não combina com nenhum padrão, nem com '%', nem no NOT LIKE.
• Para achar um % ou _ de verdade, use ESCAPE: LIKE '%!_%' ESCAPE '!'.
• GLOB (só SQLite) usa *, ? e [0-9], e diferencia maiúsculas.
• O padrão vai entre aspas simples; entre aspas duplas, o SQLite procura uma coluna.