Dans MariaDB, le LIKE L'opérateur vous permet d'effectuer une correspondance de modèle. Il détermine si une chaîne de caractères spécifique correspond à un modèle spécifié. Il renvoie soit 1 (VRAI) ou 0 (FAUX).
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 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 pour montrer comment le LIKE l'opérateur fonctionne.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Dans cet exemple, j'ai utilisé le LIKE opérateur en conjonction avec le % opérateur générique pour renvoyer les animaux dont le nom commence par la lettre F .
Sensibilité à la casse
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 LIKE 'f%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
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 LIKE 'f%' COLLATE utf8_bin;Résultat :
Empty set (0.000 sec)
Aucun résultat n'est renvoyé.
Mais si nous le changeons en un F majuscule :
SELECT *
FROM Pets
WHERE PetName 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 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Nous obtenons trois matches, comme prévu.
Arguments numériques
Les arguments numériques sont convertis en chaînes binaires.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Résultat :
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Dates
Voici un exemple qui correspond à l'année à partir d'une date :
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Résultat :
+-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Vous pouvez également utiliser le LIKE opérateur par rapport au résultat des fonctions de date, telles que DAYNAME() , MONTHNAME() , etc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Résultat :
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
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 LIKE '_e%';Résultat :
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Dans ce cas, nous avons fait correspondre les noms d'animaux où le deuxième caractère est 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 LIKE 'b_%';Résultat :
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Dans ce cas, il correspondait à deux lignes. Dans ce cas, 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 LIKE 'b\_%';Résultat :
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Maintenant, nous n'obtenons qu'une seule ligne - la ligne qui contient le trait de soulignement comme deuxième caractère.
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 LIKE 'b*_%' ESCAPE '*';Résultat :
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Dans ce cas, j'ai attribué l'astérisque (* ) comme caractère d'échappement.
Cela peut être particulièrement 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.
Valeurs NULLES
Le pourcentage (% ) le caractère générique correspond à n'importe quoi - presque. Une chose qui ne correspond pas est NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Résultat :
+---------+-----------+----------+----------------+--------------------+ | 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] | +---------+-----------+----------+----------------+--------------------+
Dans notre table, il y a deux lignes avec NULL dans le Email colonne, mais ceux-ci ne sont pas renvoyés ici.
Performances
Requêtes contenant le LIKE L'opérateur peut s'exécuter beaucoup plus lentement que les autres requêtes, et vous devriez probablement éviter d'utiliser le LIKE opérateur sauf si vous en avez vraiment besoin. Utilisation du % l'opérateur en tant que préfixe peut être particulièrement lent.
Cela ne veut pas dire que vous ne devriez pas l'utiliser du tout. Le LIKE L'opérateur fait partie intégrante de SQL, et vous rencontrerez de nombreux scénarios où ce sera la seule option (ou du moins, la meilleure option).
Le NOT LIKE Opérateur
Vous pouvez également utiliser NOT LIKE pour tester si oui ou non une chaîne ne le fait pas correspondre à un motif.
