Hur LOCATE()-funktionen fungerar i MySQL

I MySQL, LOCATE() funktion returnerar positionen för en delsträng i en sträng. Mer specifikt returnerar den positionen för den första förekomsten i strängen, eller den första förekomsten efter en given startpunkt.

Syntax

Den kan användas på något av följande sätt:

LOCATE(substr,str)
LOCATE(substr,str,pos)

Där substr är delsträngen som ska lokaliseras och str är strängen att söka.

När du använder den andra syntaxen, pos är platsen för att börja söka.

Exempel 1 – Första syntax

Här är ett exempel med den första syntaxen:

SELECT LOCATE('cat', 'One cat jumped over the other cat') AS Result;

Resultat:

+--------+
| Result |
+--------+
|      5 |
+--------+

Exempel 2 – Andra syntax

Här är ett exempel där vi anger en startposition för att börja söka:

SELECT LOCATE('cat', 'One cat jumped over the other cat', 6) AS Result;

Resultat:

+--------+
| Result |
+--------+
|     31 |
+--------+

I det här fallet, den första förekomsten av cat börjar vid position 5, men jag angav att sökningen skulle börja vid position 6. Därför var positionen för nästa förekomst av den strängen den som returnerades.

Observera att även om sökningen startade vid position 6, returnerar funktionen fortfarande understrängens position inom strängen – inte från startpositionen.

Här är ett annat exempel för att göra detta tydligare.

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';

Resultat:

+----------+----------+----------+
| Result 1 | Result 2 | Result 3 |
+----------+----------+----------+
|        5 |        5 |        5 |
+----------+----------+----------+

Resultatet är detsamma oavsett var vi börjar söka.

Exempel 3 – Hitta en del av ett ord

Delsträngen kan vara en del av ett längre ord:

SELECT LOCATE('sing', 'Increasingly') AS Result;

Resultat:

+--------+
| Result |
+--------+
|      7 |
+--------+

Det finns faktiskt inget krav på att det ens ska vara ett ord (trots allt söker vi bara efter en sträng):

SELECT 
  LOCATE('z23!#', 'u_4, z23!#') AS 'Result 1',
  LOCATE(' ', 'a b c') AS 'Result 2',
  LOCATE(',', 'cat, dog, bird') AS 'Result 3';

Resultat:

+----------+----------+----------+
| Result 1 | Result 2 | Result 3 |
+----------+----------+----------+
|        6 |        2 |        4 |
+----------+----------+----------+

Exempel 4 – Inga matchningar

Om delsträngen inte hittas, 0 returneras:

SELECT LOCATE('Bat', 'Increasingly') AS Result;

Resultat:

+--------+
| Result |
+--------+
|      0 |
+--------+

Exempel 5 – skiftlägeskänslighet

Den här funktionen är multibyte säker och är skiftlägeskänslig endast om minst ett argument är en binär sträng.

Därför fungerar följande på icke-binära strängar, även om fallet inte matchar:

SELECT LOCATE('Sing', 'Increasingly') AS Result;

Resultat:

+--------+
| Result |
+--------+
|      7 |
+--------+

Men om vi använder en binär sträng händer detta:

SET @str = BINARY 'Increasingly'; 
SELECT LOCATE('Sing', @str) AS Result;

Resultat:

+--------+
| Result |
+--------+
|      0 |
+--------+

Men visst, om vi ändrar det så att fallet matchar får vi en matchning:

SET @str = BINARY 'Increasingly'; 
SELECT LOCATE('sing', @str) AS Result;

Resultat:

+--------+
| Result |
+--------+
|      7 |
+--------+

Exempel 6 – NULL-argument

Om något av argumenten är NULL , NULL returneras:

SELECT 
  LOCATE(NULL, 'Increasingly') a,
  LOCATE('Bat', NULL) b,
  LOCATE('Bat', 'Increasingly', NULL) c;

Resultat:

+------+------+------+
| a    | b    | c    |
+------+------+------+
| NULL | NULL | NULL |
+------+------+------+