Supongamos que quiere encontrar a unos clientes, pero no recuerda exactamente sus nombres. Sin embargo, recuerda que empiezan por "Jen".

¿Cómo localiza a los clientes exactos en la base de datos? Puede identificar a los clientes en la tabla cliente examinando la columna nombre para ver si algún valor empieza por Jen. Sin embargo, este proceso puede llevar mucho tiempo, sobre todo cuando la tabla customer tiene un gran número de filas.

Afortunadamente, puede utilizar el operador LIKE de PostgreSQL para hacer coincidir los nombres de pila de los clientes con una cadena utilizando la siguiente consulta:

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name LIKE 'Jen%';

Salida:

 first_name | last_name
------------+-----------
 Jennifer   | Davis
 Jennie     | Terry
 Jenny      | Castro
(3 rows)

La cláusula WHERE de la consulta contiene una expresión:

first_name LIKE 'Jen%'

Ta expresión está formada por el nombre, el operador LIKE y una cadena literal que contiene un signo de porcentaje (%). La cadena 'Jen% se denomina patrón.

La consulta devuelve las filas cuyos valores de la columna nombre empiezan por Jen y van seguidos de cualquier secuencia de caracteres. Esta técnica se denomina comparación de patrones.

Se construye un patrón combinando valores literales con caracteres comodín y utilizando el operador LIKE o NOT LIKE para encontrar las coincidencias.

PostgreSQL ofrece dos comodines:

• Signo de porcentaje ( %) coincide con cualquier secuencia de cero o más caracteres.
• El guión bajo (_) coincide con cualquier carácter.

Esta es la sintaxis básica del operador LIKE:

value LIKE pattern

El operador LIKE devuelve true si el value coincide con el pattern. Para negar el operador LIKE, utilice el operador NOT de la siguiente manera:

value NOT LIKE pattern

El operador NOT LIKE devuelve true cuando el value no coincide con el pattern.

Si el patrón no contiene ningún carácter comodín, el operador LIKE se comporta como el operador igual (=).

Ejemplos del operador LIKE en PostgreSQL¶

Veamos algunos ejemplos de uso del operador `LIKE

Ejemplos básicos del operador LIKE¶

La siguiente sentencia utiliza el operador LIKE con un patrón que no tiene caracteres comodín:

SELECT 'Apple' LIKE 'Apple' AS result;

Salida:

 result
--------
 t
(1 row)

En este ejemplo, el operador LIKE se comporta como el operador igual a (=). La consulta devuelve true porque 'Apple' = 'Apple' es true.

El siguiente ejemplo utiliza el operador LIKE para buscar cualquier cadena que empiece por la letra A:

SELECT 'Apple' LIKE 'A%' AS result;

Salida:

 result
--------
 t
(1 row)

La consulta devuelve verdadero porque la cadena 'Apple' empieza por la letra 'A'.

Uso del operador LIKE con datos de tabla¶

Utilizaremos la tabla customer de la base de datos de ejemplo:

El siguiente ejemplo utiliza el operador LIKE para buscar clientes cuyo nombre contenga la cadena er :

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name LIKE '%er%' 
ORDER BY 
  first_name;

Salida:

first_name  |  last_name
-------------+-------------
 Albert      | Crouse
 Alberto     | Henning
 Alexander   | Fennell
 Amber       | Dixon
 Bernard     | Colby
...

Utilizar el operador LIKE con un patrón que contenga ambos comodines¶

El siguiente ejemplo utiliza el operador LIKE con un patrón que contiene los comodines porcentaje ( %) y guión bajo (_):

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name LIKE '_her%' 
ORDER BY 
  first_name;

Salida:

 first_name | last_name
------------+-----------
 Cheryl     | Murphy
 Sherri     | Rhodes
 Sherry     | Marshall
 Theresa    | Watson
(4 rows)

El patrón _her% coincide con cualquier cadena que cumpla las siguientes condiciones:

• El primer carácter puede ser cualquier cosa.
• Los caracteres siguientes deben ser "ella".
• Puede haber cualquier número de caracteres (incluido cero) después de "ella".

Ejemplos de NOT LIKE en PostgreSQL¶

La siguiente consulta utiliza el operador NOT LIKE para encontrar clientes cuyo nombre no empiece por Jen:

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name NOT LIKE 'Jen%' 
ORDER BY 
  first_name;

Salida:

 first_name  |  last_name
-------------+--------------
 Aaron       | Selby
 Adam        | Gooch
 Adrian      | Clary
 Agnes       | Bishop
...

Extensiones PostgreSQL del operador LIKE¶

El operador ILIKE de PostgreSQL, que es similar al operador LIKE, pero permite coincidencias insensibles a mayúsculas/minúsculas. Por ejemplo:

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name ILIKE 'BAR%';

Salida:

 first_name | last_name
------------+-----------
 Barbara    | Jones
 Barry      | Lovelace
(2 rows)

En este ejemplo, el patrón BAR% coincide con cualquier cadena que empiece por BAR, Bar, BaR, etc. Si utiliza el operador LIKE en su lugar, la consulta no devolverá ninguna fila:

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name LIKE 'BAR%';

Salida:

 first_name | last_name
------------+-----------
(0 rows)

PostgreSQL también proporciona algunos operadores que reflejan la funcionalidad de LIKE, NOT LIKE, ILIKE, NOT ILIKE, como se muestra en la siguiente tabla:

Por ejemplo, la siguiente sentencia utiliza el operador ~~ para buscar un cliente cuyo nombre empiece por la cadena Dar:

SELECT 
  first_name, 
  last_name 
FROM 
  customer 
WHERE 
  first_name ~~ 'Dar%' 
ORDER BY 
  first_name;

Salida:

 first_name | last_name
------------+-----------
 Darlene    | Rose
 Darrell    | Power
 Darren     | Windham
 Darryl     | Ashcraft
 Daryl      | Larue
(5 rows)

Operador LIKE de PostgreSQL con opción ESCAPE¶

A veces, los datos que desea comparar contienen los caracteres comodín % y _. Por ejemplo:

The rents are now 10% higher than last month
The new film will have _ in the titleCode language: JavaScript (javascript)

Para indicar al operador LIKE que trate los caracteres comodín % y _ como caracteres literales normales, puede utilizar la opción ESCAPE en el operador LIKE:

string LIKE pattern ESCAPE escape_character;

Vamos a crear una tabla simple para demostración:

CREATE TABLE t(
   message text
);

INSERT INTO t(message) 
VALUES('The rents are now 10% higher than last month'), 
      ('The new film will have _ in the title');

SELECT message FROM t;

Ten en cuenta que aprenderás a crear una tabla y a insertar datos en ella en los próximos tutoriales.

Salida:

                   message
----------------------------------------------
 The rents are now 10% higher than last month
 The new film will have _ in the title
(2 rows)Code language: JavaScript (javascript)

La siguiente sentencia utiliza el operador LIKE con la opción ESCAPE para tratar el % seguido del número 10 como un carácter regular:

SELECT * FROM t 
WHERE message LIKE '%10$%%' ESCAPE '$';

Salida:

                   message
----------------------------------------------
 The rents are now 10% higher than last month
(1 row)

En el patrón %10$%%, el primer y el último % son los caracteres comodín, mientras que el % que aparece después del carácter de escape $ es un carácter regular.

Resumen¶

• Utilice el operador LIKE para hacer coincidir datos por patrones.
• Utilice el operador NOT LIKE para negar el operador LIKE.
• Use el comodín % para coincidir con cero o más caracteres.
• Utilice el comodín _ para buscar un único carácter.
• Utilice la opción ESCAPE para especificar el carácter de escape.
• Utilice el operador ILIKE para distinguir entre mayúsculas y minúsculas.