Guía de SQL LIKE

LIKE comprueba si un texto coincide con un patrón, donde % representa cualquier secuencia de caracteres y _ exactamente uno. Así encuentras valores que contienen, empiezan o terminan con cierto texto. Los ejemplos funcionan en PostgreSQL, MySQL, SQLite y SQL Server.

Cómo usar LIKE

LIKE compara un valor con un patrón. El patrón tiene que coincidir con el valor completo, con dos comodines para llenar los huecos: % coincide con cualquier cantidad de caracteres (incluso ninguno) y _ coincide exactamente con uno. NOT LIKE devuelve lo contrario.

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

El último es falso porque, sin un comodín, el patrón tiene que ser igual al valor completo. En una consulta, LIKE normalmente va en la 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

Reglas que debes conocer

• En PostgreSQL, LIKE distingue mayúsculas y minúsculas. Las otras bases de datos las ignoran por defecto, pero en PostgreSQL 'Smith' LIKE 'smith' es falso. Pasa ambos lados a minúsculas, como en LOWER(name) LIKE '%smith%', cuando no deban importar.
• NULL nunca coincide. NULL LIKE '%' es NULL, no verdadero, así que las filas donde la columna es NULL quedan fuera tanto con LIKE como con NOT LIKE. Agrega OR column IS NULL si las quieres.

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

• Escapa % y _ para buscarlos literalmente. Pon un carácter de escape antes del comodín e indícalo con 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

• Un % al inicio no puede usar un índice. Una búsqueda por prefijo como LIKE 'INV-2026-%' puede usar un índice en la columna, pero LIKE '%widget%' tiene que revisar cada fila. Para buscar palabras en grandes cantidades de texto, mejor usa la búsqueda de texto completo de tu base de datos.

Sintaxis alternativa

También te vas a encontrar con estos extras específicos de cada base de datos:

-- 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 comprobar si un texto contiene una cadena fija, sin patrón, busca su posición. El resultado es 0 cuando la cadena no está:

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

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

CONTAINS() de SQL Server no es una prueba de subcadena: es un predicado de búsqueda de texto completo que necesita un índice de texto completo.

¿Cuándo deberías usar LIKE?

Usa LIKE cuando conoces parte de un valor, pero no todo. La mayoría de los usos caen en uno de estos cuatro.

Encontrar texto que contiene una palabra

Pon % a ambos lados de la palabra. '%Tech%' coincide con “Tech Solutions Inc”, “FinTech Corp” y “Technology Partners”, porque también coincide dentro de palabras más largas.

Coincidir con el inicio o el final de un valor

Pon % solo al final para buscar un prefijo, como 'INV-2026-%', o solo al inicio para buscar un sufijo, como '%.pdf' o '%@gmail.com'. Las búsquedas por prefijo son las que un índice puede acelerar.

Coincidir con un formato fijo

_ representa exactamente un carácter, así que un patrón puede describir la forma de un valor: '___-___-____' para un número de teléfono, 'A__-___' para un código de producto. Con NOT LIKE, el mismo patrón encuentra los valores que no cumplen el formato.

Buscar sin preocuparte por mayúsculas

Los usuarios escriben “smith”; los datos dicen “Smith”. Pasa ambos lados a minúsculas con LOWER() y la búsqueda ignora mayúsculas, incluso en PostgreSQL.

Ejemplos reales de LIKE

Buscar cualquiera de varias palabras

Combina patrones con OR para encontrar productos que coincidan con cualquiera de ellos:

-- 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 las facturas de este año

Los números de factura empiezan con un tipo y un año, así que un patrón de prefijo selecciona las facturas de 2026 y omite las 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 números de teléfono con formato incorrecto

Un _ por carácter describe el formato que esperas, y NOT LIKE lista las filas que hay que limpiar:

-- 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 un apellido sin importar mayúsculas

Los nombres escritos en mayúsculas o minúsculas aparecen igual cuando ambos lados se pasan a 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

Más lecturas sobre LIKE

En este blog:

• Guía de SQL SUBSTRING: extrae parte de una cadena una vez que la encontraste
• Guía de SQL not equal: NOT LIKE junto con las otras formas de excluir filas
• Guía de la sentencia SQL CASE: etiqueta filas con condiciones, incluidos patrones LIKE
• Crear índices en PostgreSQL: los índices que hacen rápidas las búsquedas por prefijo
• Tutorial de MySQL CREATE INDEX: lo mismo para MySQL

Documentación oficial:

• PostgreSQL: LIKE
• MySQL: LIKE
• SQLite: los operadores LIKE, GLOB, REGEXP, MATCH y extract
• SQL Server: LIKE