Dans MariaDB, le NOT LIKE L'opérateur est utilisé pour tester si oui ou non une chaîne ne fait pas correspondre à un motif. Il renvoie l'inverse du LIKE opérateur. C'est la même chose que d'appliquer le NOT opérateur contre l'ensemble LIKE expression.
Un modèle peut inclure des caractères réguliers, ainsi que le % et _ caractères génériques.
Ces caractères génériques sont expliqués dans le tableau suivant.
| Caractère générique | Description |
|---|---|
% | Correspond à n'importe quelle chaîne de zéro ou plusieurs caractères. Il peut être utilisé comme préfixe ou suffixe, et il peut également être utilisé au milieu d'une chaîne. |
_ | Correspond à n'importe quel caractère unique. |
Syntaxe
La syntaxe ressemble à ceci :
expr NOT LIKE pat [ESCAPE 'escape_char']Exemple
Supposons que nous ayons le tableau suivant :
SELECT * FROM Pets;Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Voici un exemple d'utilisation de NOT LIKE contre cette table :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Dans cet exemple, j'ai utilisé NOT LIKE en conjonction avec le % opérateur générique pour renvoyer les animaux dont le nom ne correspond pas commencer par la lettre F .
C'est l'ensemble de résultats opposé que nous aurions obtenu si nous avions simplement utilisé LIKE . Dans ce cas, nous n'obtiendrions que des résultats où le nom de l'animal commence par la lettre F .
Sensibilité à la casse
NOT LIKE effectue des correspondances de sous-chaînes insensibles à la casse si le classement de l'expression et du modèle est insensible à la casse.
Par conséquent, nous pouvons modifier l'exemple précédent pour utiliser un f minuscule , et toujours le même résultat :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Cependant, nous pouvons forcer une correspondance sensible à la casse en utilisant le COLLATE clause avec une collation binaire. Alternativement, vous pouvez utiliser CAST() pour le contraindre à une chaîne binaire.
Exemple :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'f%' COLLATE utf8_bin;Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Cette fois, tout le tableau était retourné. C'est parce que rien ne correspond à la minuscule f .
Mais si nous le changeons en un F majuscule :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Nous obtenons cinq matches, comme prévu. Les lignes où le nom de l'animal commence par F sont exclus.
Arguments numériques
Les arguments numériques sont convertis en chaînes binaires.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Dates
Voici un exemple de date :
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Résultat :
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Vous pouvez également utiliser le NOT LIKE opérateur par rapport au résultat des fonctions de date, telles que DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Le _ Opérateur générique
Le trait de soulignement (_ ) l'opérateur générique correspond à n'importe quel caractère unique.
Exemple :
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Dans ce cas, nous avons renvoyé les noms d'animaux où le deuxième caractère n'est pas un e .
Le caractère d'échappement
Parfois, vous pouvez vous retrouver dans une situation où vous devez rechercher un trait de soulignement ou un signe de pourcentage. Dans ce cas, vous pouvez utiliser une barre oblique inverse (\ ) pour échapper à ces caractères. Cela les empêchera d'être interprétés comme des caractères génériques.
Supposons que nous ayons le tableau suivant :
SELECT * FROM Owners;Résultat :
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Notez que le propriétaire 2 (Bart) a une adresse e-mail qui contient un trait de soulignement.
Voici un exemple de ce qui se passe lorsque nous ne le faisons pas échapper un trait de soulignement :
SELECT * FROM Owners
WHERE Email NOT LIKE 'b_%';Résultat :
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
Dans ce cas, il n'a renvoyé que deux lignes. Il a exclu les deux lignes où l'adresse e-mail commence par un b , et est suivi d'un autre caractère, puis de n'importe quel nombre de caractères. Il a également exclu les lignes avec un null adresse e-mail.
Cependant, comme nous n'avons pas échappé au trait de soulignement, le deuxième caractère n'avait pas d'importance - il correspondait à n'importe lequel personnage. Le fait que la première ligne contienne un trait de soulignement pour le deuxième caractère n'est qu'une coïncidence. Ça aurait correspondu même si c'était autre chose.
Mais que se passerait-il si nous voulions uniquement faire correspondre les adresses e-mail qui ont un trait de soulignement réel comme deuxième caractère ?
C'est là qu'intervient le caractère d'échappement.
SELECT * FROM Owners
WHERE Email NOT LIKE 'b\_%';Résultat :
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
Nous pouvons voir que Burt a été ajouté aux résultats.
Modifier le caractère d'échappement
Il est possible de changer le caractère d'échappement. Vous pouvez le faire avec le ESCAPE arguments.
Exemple :
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Résultat :
+---------+-----------+----------+----------------+-------------------+ | 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] | +---------+-----------+----------+----------------+-------------------+
Dans ce cas, j'ai attribué l'astérisque (* ) comme caractère d'échappement.
Cela peut être pratique lorsque vous devez utiliser la barre oblique inverse à d'autres fins, telles que l'encodage de caractères spéciaux. Dans de tels cas, vous devrez peut-être "double-échapper" ces caractères, ce qui pourrait devenir déroutant. Changer le caractère d'échappement peut donc aider dans de telles situations.
