No MariaDB, o
NOT LIKE operador é usado para testar se uma string não corresponder a um padrão. Ele retorna o inverso do LIKE operador. É o mesmo que aplicar o NOT operador contra todo o LIKE expressão. Um padrão pode incluir caracteres regulares, bem como o
% e _ caracteres curinga. Esses caracteres curinga são explicados na tabela a seguir.
| Caracter curinga | Descrição |
|---|---|
% | Corresponde a qualquer string de zero ou mais caracteres. Ele pode ser usado como prefixo ou sufixo, e também pode ser usado no meio de uma string. |
_ | Corresponde a qualquer caractere único. |
Sintaxe
A sintaxe fica assim:
expr NOT LIKE pat [ESCAPE 'escape_char']Exemplo
Suponha que temos a seguinte tabela:
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 | +-------+-----------+---------+---------+------------+
Aqui está um exemplo de como usar
NOT LIKE contra essa 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 | +-------+-----------+---------+---------+------------+
Neste exemplo, usei
NOT LIKE em conjunto com o % operador curinga para retornar animais de estimação cujo nome não comece com a letra F . Este é o conjunto de resultados oposto que teríamos se tivéssemos usado apenas
LIKE . Nesse caso, só obteríamos resultados onde o nome do animal começasse com a letra F . Sensibilidade de maiúsculas e minúsculas
NOT LIKE executa correspondências de subcadeia que não diferenciam maiúsculas de minúsculas se o agrupamento para a expressão e o padrão não diferenciam maiúsculas de minúsculas. Portanto, podemos alterar o exemplo anterior para usar uma letra minúscula
f , e ainda obter o mesmo 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 | +-------+-----------+---------+---------+------------+
No entanto, podemos forçar uma correspondência que diferencia maiúsculas de minúsculas usando o
COLLATE cláusula com um agrupamento binário. Alternativamente, você pode usar CAST() para coagi-lo a uma string binária. Exemplo:
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 | +-------+-----------+---------+---------+------------+
Desta vez, a mesa inteira foi devolvida. Isso ocorre porque nada correspondeu às letras minúsculas
f . Mas se mudarmos para um
F maiúsculo :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 | +-------+-----------+---------+---------+------------+
Temos cinco partidas, como esperado. As linhas onde o nome do animal de estimação começa com
F estão excluídos. Argumentos numéricos
Os argumentos numéricos são forçados a strings binárias.
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 | +-------+-----------+---------+---------+------------+
Datas
Aqui está um exemplo de data:
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 | +-------+-----------+---------+---------+------------+
Você também pode usar o
NOT LIKE operador contra o resultado de funções de data, 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 | +-------+-----------+---------+---------+------------+
O _ Operador curinga
O sublinhado (
_ ) operador curinga corresponde a qualquer caractere único. Exemplo:
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 | +-------+-----------+---------+---------+------------+
Nesse caso, retornamos nomes de animais de estimação em que o segundo caractere não um
e . O personagem de fuga
Às vezes, você pode se encontrar na situação em que precisa procurar um sublinhado ou um sinal de porcentagem. Nesses casos, você pode usar uma barra invertida (
\ ) para escapar desses caracteres. Isso impedirá que eles sejam interpretados como caracteres curinga. Suponha que temos a seguinte tabela:
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 o Proprietário 2 (Bart) tem um endereço de e-mail que contém um sublinhado.
Aqui está um exemplo do que acontece quando não escapar de um sublinhado:
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] | +---------+-----------+----------+----------------+-------------------+
Nesse caso, ele retornou apenas duas linhas. Ele excluiu as duas linhas em que o endereço de e-mail começa com um
b , e é seguido por um outro caractere e, em seguida, qualquer número de caracteres. Também excluiu as linhas com um null endereço de email. No entanto, como não escapamos do sublinhado, não importava qual fosse o segundo caractere - ele correspondia a qualquer personagem. O fato de a primeira linha conter um sublinhado para o segundo caractere é apenas uma coincidência. Teria correspondido mesmo que fosse outra coisa.
Mas e se quiséssemos corresponder apenas aos endereços de e-mail que têm um sublinhado real como segundo caractere?
É aí que entra o caractere 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 foi adicionado aos resultados.
Mudando o caractere de escape
É possível alterar o caractere de escape. Você pode fazer isso com o
ESCAPE argumento. Exemplo:
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] | +---------+-----------+----------+----------------+-------------------+
Neste caso eu atribuí o asterisco (
* ) como o caractere de escape. Isso pode ser útil quando você precisa usar a barra invertida para outros fins, como codificar caracteres especiais. Nesses casos, você pode ter que “escapar duas vezes” esses personagens, o que pode se tornar confuso. Alterar o caractere de escape pode, portanto, ajudar em tais situações.
