LIKE en SQL: qué es, cómo funciona y ejemplos prácticos

El operador LIKE en SQL se utiliza para realizar búsquedas por patrones en columnas de texto.
A diferencia del operador = (igual), que busca coincidencias exactas, LIKE permite encontrar filas que cumplen un patrón parcial.

👉 Es muy útil cuando no sabemos el valor exacto de un campo, pero sí una parte de él.

Sintaxis básica de LIKE

SELECT columnas
FROM tabla
WHERE columna LIKE patrón;
  • columna: el campo de texto donde se busca.
  • patrón: incluye letras y comodines (%, _) que definen la búsqueda.

Comodines principales en LIKE

  1. % → representa cero o más caracteres.
  2. _ → representa un único carácter.

Ejemplos rápidos:

  • 'A%' → comienza con «A».
  • '%A' → termina con «A».
  • '%A%' → contiene «A».
  • 'A_B' → «A» seguido de cualquier carácter y luego «B».

Ejemplo básico de LIKE

Tabla clientes:

idnombre
1Ana
2Andrés
3Beatriz
4Carla

Consulta:

SELECT * FROM clientes
WHERE nombre LIKE 'A%';

Resultado:

idnombre
1Ana
2Andrés

👉 Devuelve nombres que empiezan con “A”.

Ejemplos prácticos con LIKE

1) Buscar nombres que terminan en «a»

SELECT nombre FROM clientes
WHERE nombre LIKE '%a';

👉 Devuelve “Ana”, “Carla”.

2) Buscar nombres que contienen «dre»

SELECT nombre FROM clientes
WHERE nombre LIKE '%dre%';

👉 Devuelve “Andrés”.

3) Buscar palabras de 4 letras que empiezan con “C”

SELECT nombre FROM clientes
WHERE nombre LIKE 'C___';

👉 El patrón 'C___' significa «C» + 3 caracteres cualquiera.

4) Buscar emails en Gmail

SELECT email FROM usuarios
WHERE email LIKE '%@gmail.com';

👉 Devuelve todos los correos de Gmail.

5) Buscar teléfonos con prefijo

SELECT telefono FROM contactos
WHERE telefono LIKE '351%';

👉 Devuelve teléfonos que comienzan con el prefijo 351.

LIKE y sensibilidad a mayúsculas/minúsculas

Depende del motor de base de datos:

  • MySQL: por defecto LIKE no distingue mayúsculas/minúsculas (Ana = ana).
  • PostgreSQL: LIKE distingue mayúsculas. Para búsqueda insensible, se usa ILIKE.
  • SQL Server: depende de la collation configurada.

Ejemplo en PostgreSQL:

SELECT nombre FROM clientes
WHERE nombre ILIKE 'ana%';

👉 Devuelve «Ana» y «ana».

Escapar caracteres especiales en LIKE

Si necesitamos buscar literalmente % o _, debemos usar ESCAPE:

SELECT codigo FROM productos
WHERE codigo LIKE 'A\_%' ESCAPE '\';

👉 Devuelve códigos que empiezan con «A_» (subrayado literal).

Comparación: LIKE vs expresiones regulares

  • LIKE: sencillo, solo % y _.
  • Expresiones regulares (REGEXP en MySQL, ~ en PostgreSQL): más potentes, permiten patrones avanzados.

Ejemplo en MySQL:

SELECT nombre FROM clientes
WHERE nombre REGEXP '^A.*a$';

👉 Devuelve nombres que empiezan con «A» y terminan en «a».

LIMITACIONES de LIKE

  • Es más lento en búsquedas con % al inicio ('%abc'), porque el motor no puede usar índices fácilmente.
  • No es adecuado para búsquedas avanzadas (ej. coincidencias fonéticas, búsqueda por palabras).
  • Para grandes volúmenes de texto, conviene usar full-text search.

Errores comunes al usar LIKE

  1. Olvidar usar comodines
-- ❌ Busca coincidencia exacta, no parcial
WHERE nombre LIKE 'Ana';

👉 Equivalente a = 'Ana'.

  1. Usar % al inicio de patrones en tablas grandes
-- ❌ Muy costoso en millones de filas
WHERE nombre LIKE '%ana';

👉 Impide el uso de índices.

  1. Confundir _ con %
  • % → varios caracteres.
  • _ → solo uno.
  1. Esperar que LIKE ignore mayúsculas en PostgreSQL
    👉 En PostgreSQL, LIKE 'ana%' no encuentra «Ana». Debe usarse ILIKE.

Buenas prácticas con LIKE

  • Siempre que sea posible, evitar el comodín al inicio ('%texto').
  • Usar ILIKE en PostgreSQL si no importa mayúscula/minúscula.
  • Para búsquedas de texto complejas, usar subconsultas o full-text search.
  • Escapar caracteres especiales si son parte del patrón real.
  • Si la búsqueda es exacta, usar = en lugar de LIKE.

Ejemplo avanzado: clientes que no son Gmail ni Yahoo

SELECT nombre, email
FROM clientes
WHERE email NOT LIKE '%@gmail.com'
  AND email NOT LIKE '%@yahoo.com';

👉 Devuelve clientes con otros dominios de correo.

Preguntas frecuentes (FAQ)

1. ¿LIKE distingue mayúsculas?
Depende del motor: MySQL no, PostgreSQL sí (usa ILIKE para ignorarlas).

2. ¿Cuál es la diferencia entre % y _?

  • % representa cualquier número de caracteres.
  • _ representa exactamente un carácter.

3. ¿LIKE es rápido en tablas grandes?
No siempre. Si el patrón comienza con %, puede ser lento porque no se usan índices.

4. ¿Se pueden combinar varios LIKE en una consulta?
Sí, con AND y OR.

5. ¿LIKE es parte del estándar SQL?
Sí, forma parte de SQL estándar.

Conclusión

El operador LIKE en SQL es una herramienta fundamental para realizar búsquedas parciales en columnas de texto.
Permite encontrar coincidencias con patrones flexibles usando comodines (%, _), aunque con limitaciones en rendimiento en tablas muy grandes.

Es clave entender cuándo usar LIKE, cuándo preferir búsquedas exactas con = y cuándo dar el salto a búsquedas full-text.

Aprende búsquedas por patrón en WHERE y condiciones y consulta el Glosario SQL completo.

Scroll al inicio