SQL LIKE: filtros por prefijo, sufijo y subcadena

SQL LIKE filtra filas al comparar una columna de texto contra un patrón con comodines SQL. El comodín % coincide con cero o más caracteres, y _ coincide con exactamente un carácter. Úsalo para filtros de inicio en SQL ('prefijo%'), filtros de sufijo ('%sufijo') y filtros de subcadena ('%termino%').

Ejemplo de SQL LIKE para coincidencia por prefijo

Salida:

+--------+--------------------+
| nombre | correo             |
+--------+--------------------+
| Alicia | [email protected] |
| Alina  | [email protected]  |
+--------+--------------------+
2 row(s)

Cómo LIKE ‘Al%’ filtra filas

1. CREATE TABLE e INSERT cargan clientes con cuatro filas.
2. nombre LIKE 'Al%' conserva nombres que empiezan por Al; % coincide con los caracteres restantes.
3. Con un índice B-tree normal en nombre, un patrón de prefijo como 'Al%' puede usar un escaneo de rango por índice.

¿Qué es el operador SQL LIKE?

SQL LIKE compara una columna de texto con un patrón. LIKE coincide con la cadena completa (no con una subcadena) salvo que agregues % en uno o ambos lados. Sin comodines, LIKE 'texto' se comporta como = 'texto'. Si la columna es NULL, LIKE y NOT LIKE se evalúan como desconocido y la fila queda fuera por WHERE.

Patrones comodín: %, _, y ESCAPE

% y _ cubren la mayoría de necesidades de filtrado. En un patrón comodín de SQL WHERE, combina texto fijo con % y _ para expresar coincidencias por prefijo/sufijo/subcadena:

Para buscar un % o _ literal, define un carácter de escape con la cláusula ESCAPE:

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

\ se declara como carácter de escape, así que \% coincide con un % real en lugar de actuar como comodín.

SQL NOT LIKE: excluir filas coincidentes

NOT LIKE invierte la coincidencia. Una consulta SQL con NOT LIKE devuelve cada fila donde el patrón no coincide:

SELECT nombre FROM clientes
WHERE correo NOT LIKE '%empresa%';

Esto devuelve Bruno y Carla, cualquier persona cuyo correo no contiene empresa. Las filas donde la columna es NULL se excluyen tanto en LIKE como en NOT LIKE. Para incluir NULL, agrega un OR columna IS NULL explícito.

Errores comunes con SQL LIKE

Error: Suponer que LIKE 'termino' coincide con subcadenas.

Incorrecto:

WHERE nombre LIKE 'li'

Correcto:

WHERE nombre LIKE '%li%'

Por qué: LIKE coincide con la cadena completa. Sin % en ambos lados, el patrón exige una coincidencia exacta con li.

Error: Buscar un % literal sin ESCAPE.

Incorrecto:

WHERE descuento LIKE '100%'

Correcto:

WHERE descuento LIKE '100\%' ESCAPE '\'

Por qué: Sin ESCAPE, % actúa como comodín y coincide con 100, 1000, 100USD y cualquier otra cosa que empiece con 100.

Rendimiento de LIKE: prefijo vs comodín inicial

Con un índice B-tree normal, LIKE 'abc%' puede usar un escaneo de rango por índice. Los patrones que empiezan con % (como '%abc' o '%abc%') impiden una búsqueda por índice, así que el motor normalmente escanea muchas más filas.

Para búsquedas de subcadenas a gran escala, usa búsqueda de texto completo (FTS) en lugar de LIKE '%termino%'.

Sensibilidad a mayúsculas por motor

El comportamiento de mayúsculas/minúsculas de LIKE varía según el motor de base de datos:

SQLite trata LIKE 'al%' y LIKE 'Al%' como equivalentes para ASCII. PRAGMA case_sensitive_like = ON cambia a coincidencia exacta por mayúsculas. ILIKE de PostgreSQL es una extensión que no forma parte del estándar SQL.

Aplicar LOWER() a columnas funciona entre motores, pero evita el uso de índices. Cuando el rendimiento importa, prefiere una intercalación no sensible a mayúsculas o operadores específicos del motor.