Dans MySQL, le LOCATE() La fonction renvoie la position d'une sous-chaîne dans une chaîne. Plus précisément, il renvoie la position de la première occurrence dans la chaîne, ou la première occurrence après un point de départ donné.
Syntaxe
Il peut être utilisé de l'une des manières suivantes :
LOCATE(substr,str) LOCATE(substr,str,pos)
Où substr est la sous-chaîne à localiser, et str est la chaîne à rechercher.
Lors de l'utilisation de la deuxième syntaxe, pos est la position pour commencer la recherche.
Exemple 1 – Première syntaxe
Voici un exemple utilisant la première syntaxe :
SELECT LOCATE('cat', 'One cat jumped over the other cat') AS Result; Résultat :
+--------+ | Result | +--------+ | 5 | +--------+
Exemple 2 – Seconde syntaxe
Voici un exemple dans lequel nous spécifions une position de départ pour lancer la recherche :
SELECT LOCATE('cat', 'One cat jumped over the other cat', 6) AS Result; Résultat :
+--------+ | Result | +--------+ | 31 | +--------+
Dans ce cas, la première occurrence de cat commence à la position 5, mais j'ai spécifié que la recherche devait commencer à la position 6. Par conséquent, la position de la prochaine occurrence de cette chaîne était celle qui était renvoyée.
Notez que, bien que la recherche ait commencé à la position 6, la fonction renvoie toujours la position de la sous-chaîne dans la chaîne - pas à partir de la position de départ.
Voici un autre exemple pour aider à rendre cela plus clair.
SELECT
LOCATE('c', 'a b c', 1) AS 'Result 1',
LOCATE('c', 'a b c', 2) AS 'Result 2',
LOCATE('c', 'a b c', 4) AS 'Result 3'; Résultat :
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 5 | 5 | 5 | +----------+----------+----------+
Le résultat est le même, peu importe où nous commençons la recherche.
Exemple 3 - Localisation d'une partie d'un mot
La sous-chaîne peut faire partie d'un mot plus long :
SELECT LOCATE('sing', 'Increasingly') AS Result; Résultat :
+--------+ | Result | +--------+ | 7 | +--------+
En fait, il n'est même pas nécessaire qu'il s'agisse d'un mot (après tout, nous recherchons simplement une chaîne) :
SELECT
LOCATE('z23!#', 'u_4, z23!#') AS 'Result 1',
LOCATE(' ', 'a b c') AS 'Result 2',
LOCATE(',', 'cat, dog, bird') AS 'Result 3'; Résultat :
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 6 | 2 | 4 | +----------+----------+----------+
Exemple 4 – Aucune correspondance
Si la sous-chaîne est introuvable, 0 est renvoyé :
SELECT LOCATE('Bat', 'Increasingly') AS Result; Résultat :
+--------+ | Result | +--------+ | 0 | +--------+
Exemple 5 – Sensibilité à la casse
Cette fonction est sécurisée sur plusieurs octets et est sensible à la casse uniquement si au moins un argument est une chaîne binaire.
Par conséquent, ce qui suit fonctionne sur des chaînes non binaires, même si la casse ne correspond pas :
SELECT LOCATE('Sing', 'Increasingly') AS Result; Résultat :
+--------+ | Result | +--------+ | 7 | +--------+
Mais si nous utilisons une chaîne binaire, cela se produit :
SET @str = BINARY 'Increasingly';
SELECT LOCATE('Sing', @str) AS Result; Résultat :
+--------+ | Result | +--------+ | 0 | +--------+
Mais bien sûr, si nous le modifions pour que la casse corresponde, nous obtenons une correspondance :
SET @str = BINARY 'Increasingly';
SELECT LOCATE('sing', @str) AS Result; Résultat :
+--------+ | Result | +--------+ | 7 | +--------+
Exemple 6 – Arguments NULL
Si l'un des arguments est NULL ,
NUL
est renvoyé :
SELECT
LOCATE(NULL, 'Increasingly') a,
LOCATE('Bat', NULL) b,
LOCATE('Bat', 'Increasingly', NULL) c; Résultat :
+------+------+------+ | a | b | c | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
