En MariaDB, el NOT LIKE El operador se usa para probar si una cadena no hacer coincidir un patrón. Devuelve el inverso de LIKE operador. Es lo mismo que aplicar el NOT operador contra todo LIKE expresión.
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 NOT 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 del uso de NOT LIKE contra esa mesa:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
En este ejemplo, usé NOT LIKE junto con el % operador comodín para devolver mascotas cuyo nombre no comienza con la letra F .
Este es el conjunto de resultados opuesto que habríamos obtenido si hubiéramos usado LIKE . En ese caso, solo obtendremos resultados donde el nombre de la mascota comience con la letra F .
Sensibilidad de mayúsculas y minúsculas
NOT 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 NOT LIKE 'f%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
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 NOT 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 | | 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 | +-------+-----------+---------+---------+------------+
Esta vez, se devolvió toda la tabla. Esto se debe a que nada coincide con la minúscula f .
Pero si lo cambiamos a mayúscula F :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Tenemos cinco partidos, como se esperaba. Las filas donde el nombre de la mascota comienza con F están excluidos.
Argumentos numéricos
Los argumentos numéricos se convierten en cadenas binarias.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Fechas
Aquí hay un ejemplo de fecha:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
También puedes usar el NOT LIKE operador contra el resultado de las funciones de fecha, como DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
El _ Operador comodín
El guión bajo (_ ) el operador comodín coincide con cualquier carácter individual.
Ejemplo:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Resultado:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 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 | +-------+-----------+---------+---------+------------+
En este caso, devolvimos nombres de mascotas donde el segundo carácter es no un 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 NOT LIKE 'b_%';Resultado:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
En este caso, devolvió solo dos filas. Excluyó las dos filas donde la dirección de correo electrónico comienza con b , y es seguido por otro carácter, y luego cualquier número de caracteres. También excluyó las filas con un null dirección de correo electrónico.
Sin embargo, debido a que no escapamos del guión bajo, no importaba cuál era el segundo carácter:coincidía con cualquier 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 NOT LIKE 'b\_%';Resultado:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
Podemos ver que Burt se ha agregado a los resultados.
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 NOT LIKE 'b*_%' ESCAPE '*';Resultado:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
En este caso asigné el asterisco (* ) como carácter de escape.
Esto puede ser ú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.
