Dans MySQL, le LIKE L'opérateur effectue une correspondance de modèle à l'aide d'un modèle SQL.
Si la chaîne correspond au modèle fourni, le résultat est 1 , sinon c'est 0 .
Le modèle ne doit pas nécessairement être une chaîne littérale. Cette fonction peut être utilisée avec des expressions de chaîne et des colonnes de table.
Syntaxe
La syntaxe ressemble à ceci :
expr LIKE pat [ESCAPE 'escape_char']
Où expr est la chaîne d'entrée et pat est le modèle pour lequel vous testez la chaîne.
L'option ESCAPE La clause vous permet de spécifier un caractère d'échappement. Le caractère d'échappement par défaut est \ , vous pouvez donc omettre cette clause si vous n'avez pas besoin de la modifier.
Exemple 1 - Utilisation de base
Voici un exemple d'utilisation de cet opérateur dans un SELECT déclaration :
SELECT 'Charlie' LIKE 'Char%';
Résultat :
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
Dans ce cas, la valeur de retour est 1 ce qui signifie que la chaîne d'entrée correspondait au modèle. En particulier, nous avons spécifié que la chaîne d'entrée doit commencer par Char et finir avec n'importe quoi. Le % caractère correspond à n'importe quel nombre de caractères (y compris zéro caractère).
Voici ce qui se passe si nous supprimons le % :
SELECT 'Charlie' LIKE 'Char';
Résultat :
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
Le résultat renvoyé est 0 ce qui signifie pas de correspondance. C'est parce que nous n'avons pas utilisé de caractère générique pour spécifier d'autres caractères.
Exemple 2 – Le _ Caractère générique
Nous avons également la possibilité d'utiliser le _ caractère générique pour spécifier un seul caractère. Voici un exemple :
SELECT 'Charlie' LIKE 'Ch_rlie';
Résultat :
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
Les deux caractères génériques peuvent être combinés dans un modèle si nécessaire :
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Résultat :
+--------+ | Result | +--------+ | 1 | +--------+
En voici d'autres :
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Ch_rlie%nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Ch%rlie %likes %' AS 'Result 3', 'Charlie likes donuts' LIKE '% likes %' AS 'Result 4';
Résultat :
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Apportons quelques modifications à cet exemple afin que nous puissions voir des exemples de cas où ils ne correspondent pas :
SELECT 'Charlie likes donuts' LIKE 'Ch%rlie_donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Charlie_nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Charlie _likes donuts' AS 'Result 3', 'Charlie likes donuts' LIKE '_ likes _' AS 'Result 4';
Résultat :
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Exemple 3 - Un exemple de base de données
Le LIKE l'opérateur est souvent utilisé dans un WHERE clause d'un SELECT déclaration lors de l'interrogation d'une base de données. Lorsqu'il est utilisé de cette manière, il réduit les résultats aux seuls enregistrements qui correspondent, mais nous voyons les résultats réels (pas seulement un 1 ou 0 ).
Voici un exemple d'utilisation de cet opérateur dans une requête de base de données :
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Résultat :
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
Dans ce cas, il s'agissait d'une simple requête renvoyant tous les artistes dont le nom commence par la lettre B .
Voici la liste complète des artistes de ce tableau :
SELECT ArtistId, ArtistName FROM Artists;
Résultat :
+----------+------------------------+ | ArtistId | ArtistName | +----------+------------------------+ | 1 | Iron Maiden | | 2 | AC/DC | | 3 | Allan Holdsworth | | 4 | Buddy Rich | | 5 | Devin Townsend | | 6 | Jim Reeves | | 7 | Tom Jones | | 8 | Maroon 5 | | 9 | The Script | | 10 | Lit | | 11 | Black Sabbath | | 12 | Michael Learns to Rock | | 13 | Carabao | | 14 | Karnivool | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+------------------------+
Exemple 4 - Échappement avec le caractère barre oblique inverse
Que se passe-t-il si l'un des caractères génériques se trouve dans votre chaîne d'entrée et que vous devez effectuer une correspondance ? Vous pouvez l'échapper avec le caractère antislash (\ ). Voici un exemple d'une telle recherche avec et sans le caractère d'échappement :
SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Résultat :
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
Dans ce cas, ils correspondaient tous les deux, mais pour des raisons différentes. La première ligne correspondait car le caractère générique spécifiait que n'importe quel caractère correspondrait. La deuxième ligne correspondait également, mais uniquement parce que la chaîne d'entrée comportait un trait de soulignement au bon endroit.
Modifions légèrement la chaîne d'entrée afin d'obtenir un résultat différent :
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Résultat :
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
La version non échappée est revenue positive, car le caractère générique signifiait que nous pouvions avoir n'importe quel personnage à cet endroit. La version échappée indiquait explicitement que seul le caractère de soulignement (_ ) correspondra. La chaîne d'entrée n'avait pas de caractère de soulignement à cet endroit et le résultat était donc négatif.
Exemple 5 - Le ESCAPE Article
Vous pouvez également utiliser le ESCAPE clause pour spécifier votre propre caractère d'échappement personnalisé. Voici un exemple :
SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Résultat :
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Exemple 6 – Expressions numériques
L'implémentation MySQL du LIKE L'opérateur permet d'utiliser des expressions numériques. Voici un exemple :
SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Résultat :
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+
