En MariaDB, el LIKE operador le permite hacer coincidencia de patrones. Determina si una cadena de caracteres específica coincide con un patrón específico. Devuelve 1 (VERDADERO) o 0 (FALSO).
Un patrón puede incluir caracteres regulares, así como el % y _ caracteres comodín.
Esos caracteres comodín se explican en la siguiente tabla.
| Carácter comodín | Descripción |
|---|---|
% | Coincide con cualquier cadena de cero o más caracteres. Se puede usar como prefijo o sufijo, y también se puede usar en medio de una cadena. |
_ | Coincide con cualquier carácter individual. |
Sintaxis
La sintaxis es así:
expr LIKE pat [ESCAPE 'escape_char']Ejemplo
Supongamos que tenemos la siguiente tabla:
SELECT * FROM Pets;Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Aquí hay un ejemplo para demostrar cómo LIKE opera el operador.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
En este ejemplo, utilicé LIKE operador junto con el % operador comodín para devolver mascotas cuyo nombre comienza con la letra F .
Sensibilidad de mayúsculas y minúsculas
LIKE realiza coincidencias de subcadenas que no distinguen entre mayúsculas y minúsculas si la intercalación de la expresión y el patrón no distingue entre mayúsculas y minúsculas.
Por lo tanto, podemos cambiar el ejemplo anterior para usar una f minúscula , y sigue obteniendo el mismo resultado:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Sin embargo, podemos forzar una coincidencia entre mayúsculas y minúsculas usando COLLATE cláusula con una intercalación binaria. Alternativamente, puede usar CAST() forzarlo a una cadena binaria.
Ejemplo:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;Resultado:
Empty set (0.000 sec)
No se devuelven resultados.
Pero si lo cambiamos a mayúscula F :
SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Obtenemos tres coincidencias, como se esperaba.
Argumentos numéricos
Los argumentos numéricos se convierten en cadenas binarias.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Resultado:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Fechas
Aquí hay un ejemplo que coincide con el año a partir de una fecha:
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
También puedes usar el LIKE operador contra el resultado de las funciones de fecha, como DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
El _ Operador comodín
El guión bajo (_ ) el operador comodín coincide con cualquier carácter individual.
Ejemplo:
SELECT *
FROM Pets
WHERE PetName LIKE '_e%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
En este caso, emparejamos nombres de mascotas donde el segundo carácter es una e .
El personaje de la fuga
A veces puede encontrarse en la situación en la que necesita buscar un guión bajo o un signo de porcentaje. En tales casos, puede usar una barra invertida (\ ) para escapar de estos caracteres. Esto evitará que se interpreten como caracteres comodín.
Supongamos que tenemos la siguiente tabla:
SELECT * FROM Owners;Resultado:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Observe que el Propietario 2 (Bart) tiene una dirección de correo electrónico que contiene un guión bajo.
Este es un ejemplo de lo que sucede cuando no escape de un guión bajo:
SELECT * FROM Owners
WHERE Email LIKE 'b_%';Resultado:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
En este caso, coincidió con dos filas. En este caso, no importaba cuál era el segundo carácter:coincidía con cualquiera personaje. El hecho de que la primera fila contenga un guión bajo para el segundo carácter es solo una coincidencia. Hubiera coincidido incluso si fuera otra cosa.
Pero, ¿y si solo quisiéramos hacer coincidir las direcciones de correo electrónico que tienen un guión bajo como segundo carácter?
Ahí es donde entra el carácter de escape.
SELECT * FROM Owners
WHERE Email LIKE 'b\_%';Resultado:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Ahora solo tenemos una fila:la fila que contiene el guión bajo como segundo carácter.
Cambiar el carácter de escape
Es posible cambiar el carácter de escape. Puedes hacer esto con el ESCAPE argumento.
Ejemplo:
SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';Resultado:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
En este caso asigné el asterisco (* ) como carácter de escape.
Esto puede ser especialmente útil cuando necesita usar la barra invertida para otros fines, como codificar caracteres especiales. En tales casos, es posible que tenga que "doble escape" de estos caracteres, lo que podría volverse confuso. Por lo tanto, cambiar el carácter de escape puede ayudar en tales situaciones.
Valores NULOS
El porcentaje (% ) el comodín coincide con cualquier cosa, casi. Una cosa que no coincide es NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Resultado:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
En nuestra tabla, hay dos filas con NULL en el Email columna, pero no se devuelven aquí.
Rendimiento
Consultas que contienen el LIKE El operador puede ejecutarse mucho más lento que otras consultas, y probablemente debería evitar usar LIKE operador a menos que realmente lo necesite. Usando el % operador como prefijo puede ser particularmente lento.
Eso no quiere decir que no debas usarlo en absoluto. El LIKE operator es una parte integral de SQL, y encontrará muchos escenarios en los que será la única opción (o al menos, la mejor opción).
El NOT LIKE Operador
También puedes usar NOT LIKE para probar si una cadena no hacer coincidir un patrón.
