Guia de SQL LIKE

O LIKE verifica se um texto corresponde a um padrão, em que % representa qualquer sequência de caracteres e _ representa exatamente um. É assim que você encontra valores que contêm, começam ou terminam com algum texto. Os exemplos funcionam no PostgreSQL, MySQL, SQLite e SQL Server.

Como usar o LIKE

O LIKE compara um valor com um padrão. O padrão precisa corresponder ao valor inteiro, com dois curingas para preencher as lacunas: % corresponde a qualquer quantidade de caracteres (inclusive nenhum) e _ corresponde a exatamente um. NOT LIKE retorna o oposto.

expression [NOT] LIKE pattern [ESCAPE escape_character]

-- In SQL Server, LIKE only works in a condition, such as a WHERE clause
SELECT 'Joe Bloggs' LIKE 'Jo%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'J_e%';
-- Output: true

SELECT 'Joe Bloggs' LIKE 'Bloggs';
-- Output: false

O último é falso porque, sem curinga, o padrão precisa ser igual ao valor inteiro. Em uma consulta, o LIKE geralmente fica na cláusula WHERE:

-- Input: customers
-- id | name
-- ---+-------------
-- 1  | Joe Bloggs
-- 2  | Jane Doe
-- 3  | Joanna Smith
-- 4  | Bob Jones

SELECT name
FROM customers
WHERE name LIKE 'Jo%';

-- Output:
-- name
-- ------------
-- Joe Bloggs
-- Joanna Smith

Regras importantes

• O LIKE do PostgreSQL diferencia maiúsculas de minúsculas. Os outros bancos ignoram isso por padrão, mas no PostgreSQL 'Smith' LIKE 'smith' é falso. Converta os dois lados para minúsculas, como em LOWER(name) LIKE '%smith%', quando a caixa não importar.
• NULL nunca corresponde. NULL LIKE '%' é NULL, não verdadeiro, então linhas em que a coluna é NULL ficam de fora tanto no LIKE quanto no NOT LIKE. Adicione OR column IS NULL se quiser incluí-las.

SELECT NULL LIKE '%';
-- Output: NULL

• Escape % e _ para encontrá-los literalmente. Coloque um caractere de escape antes do curinga e indique-o com ESCAPE:

-- Input: discounts
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10
-- 3  | Up to 25% off shoes

-- Without escaping, the % after 50 is a wildcard
SELECT * FROM discounts
WHERE description LIKE '%50%%';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats
-- 2  | Spend 50, save 10

-- With ESCAPE '\', the \% matches a real percent sign
-- (in MySQL, write ESCAPE '\\': a single backslash escapes the quote)
SELECT * FROM discounts
WHERE description LIKE '%50\%%' ESCAPE '\';

-- Output:
-- id | description
-- ---+---------------------
-- 1  | 50% off winter coats

• Um % no início impede o uso de índice. Uma busca por prefixo como LIKE 'INV-2026-%' pode usar um índice na coluna, mas LIKE '%widget%' precisa verificar todas as linhas. Para buscar palavras em grandes volumes de texto, use a busca full-text do seu banco de dados.

Sintaxe alternativa

Você também vai encontrar estes extras específicos de cada banco:

-- PostgreSQL: ILIKE ignores case
SELECT 'SMITH' ILIKE 'smith';
-- Output: true

-- SQL Server: [ ] in a LIKE pattern matches one character from a set or range
SELECT CASE WHEN 'B12' LIKE '[A-C]%' THEN 'match' ELSE 'no match' END;
-- Output: match

-- MySQL: REGEXP for regular expressions (PostgreSQL uses ~)
SELECT 'A12-345' REGEXP '^A[0-9]{2}-[0-9]{3}$';
-- Output: 1

Para verificar se um texto contém uma string fixa, sem padrão, encontre a posição dela. O resultado é 0 quando a string não está lá:

SELECT INSTR('FinTech Corp', 'Tech');
-- Output: 4

-- PostgreSQL: POSITION('Tech' IN 'FinTech Corp')
-- SQL Server: CHARINDEX('Tech', 'FinTech Corp')

O CONTAINS() do SQL Server não é um teste de substring: é um predicado de busca full-text que exige um índice full-text.

Quando usar o LIKE?

Use o LIKE quando você conhece parte de um valor, mas não ele todo. A maioria dos usos se encaixa em um destes quatro casos.

Encontrar texto que contém uma palavra

Coloque % dos dois lados da palavra. '%Tech%' corresponde a “Tech Solutions Inc”, “FinTech Corp” e “Technology Partners”, porque também encontra a palavra dentro de palavras maiores.

Corresponder ao início ou ao fim de um valor

Coloque % só no final para corresponder a um prefixo, como 'INV-2026-%', ou só no início para corresponder a um sufixo, como '%.pdf' ou '%@gmail.com'. As buscas por prefixo são as que um índice consegue acelerar.

Corresponder a um formato fixo

_ representa exatamente um caractere, então um padrão pode descrever o formato de um valor: '___-___-____' para um telefone, 'A__-___' para um código de produto. Com NOT LIKE, o mesmo padrão encontra os valores fora do formato.

Buscar sem se preocupar com maiúsculas

O usuário digita “smith”; os dados dizem “Smith”. Converta os dois lados para minúsculas com LOWER() e a busca ignora a caixa, até no PostgreSQL.

Exemplos reais de LIKE

Buscar qualquer uma de várias palavras

Combine padrões com OR para encontrar produtos que correspondam a qualquer um deles:

-- Input: products
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 3  | Desk lamp
-- 4  | Desktop computer

SELECT * FROM products
WHERE name LIKE '%laptop%'
   OR name LIKE '%notebook%'
   OR name LIKE '%computer%';

-- Output:
-- id | name
-- ---+-----------------
-- 1  | Gaming laptop
-- 2  | Spiral notebook
-- 4  | Desktop computer

Encontrar as faturas deste ano

Os números das faturas começam com um tipo e um ano, então um padrão de prefixo seleciona as faturas de 2026 e ignora as notas de crédito:

-- Input: invoices
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2025-0981 | Contoso
-- CN-2026-0003  | Northwind
-- INV-2026-0040 | Fabrikam

SELECT * FROM invoices
WHERE invoice_no LIKE 'INV-2026-%';

-- Output:
-- invoice_no    | customer
-- --------------+----------
-- INV-2026-0012 | Northwind
-- INV-2026-0040 | Fabrikam

Encontrar telefones no formato errado

Um _ por caractere descreve o formato esperado, e o NOT LIKE lista as linhas a corrigir:

-- Input: customers
-- name      | phone
-- ----------+---------------
-- Ana Lima  | 555-010-1234
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321
-- Dev Rao   | 555-010-5555

SELECT name, phone FROM customers
WHERE phone NOT LIKE '___-___-____';

-- Output:
-- name      | phone
-- ----------+---------------
-- Ben Ode   | (555) 010-9876
-- Cara Diaz | 5550104321

Encontrar um sobrenome em qualquer caixa

Nomes digitados em maiúsculas ou minúsculas ainda aparecem quando os dois lados são convertidos para minúsculas:

-- Input: customers
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 3  | Dana Jones
-- 4  | carla smith

SELECT * FROM customers
WHERE LOWER(name) LIKE '%smith%';

-- Output:
-- id | name
-- ---+------------
-- 1  | Anna Smith
-- 2  | BEN SMITH
-- 4  | carla smith

Leitura complementar sobre LIKE

Neste blog:

• Guia de SQL SUBSTRING: extraia parte de uma string depois de encontrá-la
• Guia de SQL not equal: o NOT LIKE ao lado das outras formas de excluir linhas
• Guia da instrução SQL CASE: rotule linhas com condições, inclusive padrões LIKE
• Criando índices no PostgreSQL: os índices que deixam as buscas por prefixo rápidas
• Tutorial de MySQL CREATE INDEX: o mesmo para MySQL

Documentação oficial:

• PostgreSQL: LIKE
• MySQL: LIKE
• SQLite: os operadores LIKE, GLOB, REGEXP, MATCH e extract
• SQL Server: LIKE