Fonctionnement de l'opérateur LIKE dans SQLite

Dans SQLite, vous pouvez utiliser le LIKE opérateur dans vos requêtes pour effectuer une comparaison de correspondance de modèle.

Par exemple, vous pouvez l'ajouter à votre WHERE clause afin de ne renvoyer que les lignes qui correspondent à un modèle donné.

Cependant, en l'ajoutant à WHERE La clause n'est pas la seule façon d'utiliser le LIKE opérateur. Vous pouvez également l'utiliser pour renvoyer une valeur booléenne.

Exemple de base

Voici un exemple de base qui utilise le LIKE opérateur dans un WHERE clause.

SELECT * FROM Artist
WHERE Name LIKE 'Black%'; 

Résultat :

ArtistId Name ---------- -------------------11 Black Label Society12 Black Sabbath 169 Black Eyed Peas 

Dans ce cas, je voulais renvoyer tous les artistes dont le nom commence par Black .

Le signe de pourcentage est un caractère générique qui correspond à zéro ou plus de n'importe quel caractère (y compris les espaces).

Sans le caractère générique

Si je n'avais pas utilisé le caractère générique, je n'aurais obtenu aucun résultat.

Voici un exemple de ce que je veux dire :

SELECT * FROM Artist
WHERE Name LIKE 'Black'; 

Résultat :

 

 (Ceci est intentionnellement vide, car il n'y a eu aucun résultat.)
 
Plusieurs caractères génériques
 

 Vous pouvez utiliser plusieurs caractères génériques si nécessaire. Dans cet exemple, j'en ajoute un autre à l'avant de mon motif.
 
SELECT * FROM Artist
WHERE Name LIKE '%Black%'; 
 

 Résultat :
 
ArtistId Name ---------- -------------------11 Black Label Society12 Black Sabbath 38 Banda Black Rio 137 The Black Crowes 169 Black Pois aux yeux 
 

 Cela entraîne le renvoi d'un plus grand nombre de lignes, car il y a deux lignes qui ont Noir en leur nom, mais pas au début.
 
Le trait de soulignement (_) générique
 

 Vous avez également la possibilité d'utiliser le trait de soulignement (_ ) caractère générique.
 

 Ce caractère générique correspond exactement à un caractère (n'importe quel caractère).
 

 Considérez le tableau suivant appelé Chats :
 
CatId CatName ---------- ----------1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff 
 

 Oui, certains de ces chats ont des noms bizarres, mais ils seront utiles.
 

 Voici un exemple d'utilisation du caractère générique de soulignement dans une requête sur cette table.
 
SELECT * FROM Cats
WHERE CatName LIKE 'Br_sh'; 
 

 Résultat :
 
CatId CatName ---------- ----------1 Brush 2 Brash 
 

 Remarquez que le chat nommé Broosh n'est pas inclus. 
 

 Pour inclure Broosh , j'aurais besoin d'utiliser deux traits de soulignement :
 
SELECT * FROM Cats
WHERE CatName LIKE 'Br__sh'; 
 

 Résultat :
 
CatId CatName ---------- ----------3 Broosh 
 

 Cependant, cela exclut les deux autres chats. 
 

 Je pourrais toujours utiliser un signe de pourcentage pour inclure les autres chats.
 
SELECT * FROM Cats
WHERE CatName LIKE 'Br%sh'; 
 

 Résultat :
 
CatId CatName ---------- ----------1 Brush 2 Brash 3 Broosh 
 

 Cependant, gardez à l'esprit que cela renverrait également les noms avec plus de deux caractères entre Br et chut .
 
La clause d'ÉVASION
 

 Parfois, vos données peuvent en fait inclure des caractères génériques. En d'autres termes, les données contiennent des traits de soulignement ou des signes de pourcentage.
 

 Cela peut poser problème si vous essayez de faire correspondre le trait de soulignement ou le signe de pourcentage en tant que caractère littéral et non en tant que caractère générique.
 

 Dans mon tableau des chats, vous remarquerez qu'un chat a un signe de pourcentage dans son nom. Un autre chat porte presque exactement le même nom, sauf qu'au lieu d'un signe de pourcentage, c'est un signe dollar.
 

 Voici à nouveau le tableau :
 
CatId CatName ---------- ----------1 Brush 2 Brash 3 Broosh 4 100%Fluff 5 100$Fluff 
 

 Si je voulais renvoyer uniquement les chats dont le nom commence par 100%F alors je devrais échapper au % . Si je n'y échappais pas, j'obtiendrais des résultats indésirables.
 

 Voici ce qui se passe si j'exécute une requête sans échapper au signe de pourcentage.
 
SELECT * FROM Cats
WHERE CatName LIKE '100%F'; 
 

 Résultat :
 
CatId CatName ---------- ----------4 100%Fluff 5 100$Fluff 
 

 Dans ce cas, le signe de pourcentage correspondait également au signe dollar, car le signe de pourcentage était traité comme un caractère générique.
 

 Pour s'assurer que le signe de pourcentage n'est pas traité comme un caractère générique, nous pouvons utiliser le ESCAPE clause.
 
SELECT * FROM Cats
WHERE CatName LIKE '100\%%F' ESCAPE '\'; 
 

 Résultat :
 
CatId CatName ---------- ----------4 100%Fluff 
 
Renvoyer une valeur booléenne
 

 Vous pouvez utiliser le LIKE opérateur pour renvoyer un 0 ou 1 , selon qu'il y a correspondance ou non.
 

 Voici un exemple.
 
SELECT 
  CatName,
  CatName LIKE 'Br%' 
FROM Cats; 
 

 Résultat :
 
CatName CatName LIKE 'Br%'---------- ------------------Brush 1 Brash 1 Broosh 1 100%Fluff 0 100$ Fluff 0 
 

 Dans ce cas, les trois premières lignes correspondent aux critères, et les deux dernières lignes non.
 
Sensibilité à la casse
 

 Par défaut, le SQLite LIKE L'opérateur est insensible à la casse pour les caractères ASCII. Cela signifie qu'il correspondra aux caractères majuscules et minuscules, quelle que soit la casse que vous utilisez dans votre modèle.
 

 Vous pouvez utiliser le case_sensitive_like Instruction PRAGMA pour effectuer des correspondances sensibles à la casse dans la plage ASCII. 
 

 Voir Comment rendre l'opérateur LIKE de SQLite sensible à la casse pour des exemples.
 
La fonction Like()
 

 Une autre façon de le faire est d'utiliser le like() une fonction. 
 

 Cette fonction fait exactement la même chose que le LIKE opérateur, sauf que vous devez utiliser une syntaxe légèrement différente. 
 

 Tous les exemples ci-dessus pourraient être réécrits pour utiliser le like() fonction si nécessaire.