Hoe de LOCATE()-functie werkt in MySQL

In MySQL is de LOCATE() functie retourneert de positie van een subtekenreeks binnen een tekenreeks. Meer specifiek, het retourneert de positie van het eerste exemplaar binnen de tekenreeks, of het eerste exemplaar na een bepaald startpunt.

Syntaxis

Het kan op een van de volgende manieren worden gebruikt:

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

Waar substr is de substring die moet worden gevonden, en str is de string om te zoeken.

Bij gebruik van de tweede syntaxis, pos is de positie om te beginnen met zoeken.

Voorbeeld 1 – Eerste syntaxis

Hier is een voorbeeld waarin de eerste syntaxis wordt gebruikt:

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

Resultaat:

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

Voorbeeld 2 – Tweede syntaxis

Hier is een voorbeeld waarin we een startpositie specificeren om te beginnen met zoeken:

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

Resultaat:

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

In dit geval is het eerste voorkomen van cat begint op positie 5, maar ik heb opgegeven dat de zoekopdracht moet beginnen op positie 6. Daarom was de positie van de volgende instantie van die tekenreeks degene die werd geretourneerd.

Merk op dat, hoewel het zoeken begon op positie 6, de functie nog steeds de positie van de substring binnen de string retourneert – niet vanaf de startpositie.

Hier is nog een voorbeeld om dit te verduidelijken.

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

Resultaat:

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

Het resultaat is hetzelfde, waar we ook beginnen met zoeken.

Voorbeeld 3 – Een deel van een woord lokaliseren

De substring kan deel uitmaken van een langer woord:

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

Resultaat:

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

Het is zelfs niet vereist dat het een woord is (we zoeken tenslotte gewoon naar een string):

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

Resultaat:

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

Voorbeeld 4 – Geen overeenkomsten

Als de subtekenreeks niet wordt gevonden, 0 wordt geretourneerd:

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

Resultaat:

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

Voorbeeld 5 – Hoofdlettergevoeligheid

Deze functie is multibyte veilig en is alleen hoofdlettergevoelig als ten minste één argument een binaire tekenreeks is.

Daarom werkt het volgende op niet-binaire tekenreeksen, ook al komt de hoofdletter niet overeen:

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

Resultaat:

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

Maar als we een binaire string gebruiken, gebeurt dit:

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

Resultaat:

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

Maar als we het veranderen zodat de zaak overeenkomt, krijgen we natuurlijk een overeenkomst:

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

Resultaat:

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

Voorbeeld 6 – NULL-argumenten

Als een van de argumenten NULL . is , NULL wordt geretourneerd:

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

Resultaat:

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