Sådan fungerer LOCATE()-funktionen i MySQL

I MySQL er LOCATE() funktion returnerer positionen af en understreng i en streng. Mere specifikt returnerer den positionen for den første forekomst i strengen, eller den første forekomst efter et givet startpunkt.

Syntaks

Det kan bruges på en af følgende måder:

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

Hvor substr er den understreng, der skal lokaliseres, og str er strengen til at søge.

Når du bruger den anden syntaks, pos er positionen til at begynde at søge.

Eksempel 1 – Første syntaks

Her er et eksempel, der bruger den første syntaks:

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

Resultat:

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

Eksempel 2 – Anden syntaks

Her er et eksempel, hvor vi angiver en startposition for at begynde at søge:

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

Resultat:

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

I dette tilfælde er den første forekomst af cat begynder ved position 5, men jeg specificerede søgningen til at starte ved position 6. Derfor var positionen for den næste forekomst af den streng den, der blev returneret.

Bemærk, at selvom søgningen startede ved position 6, returnerer funktionen stadig understrengens position i strengen – ikke fra startpositionen.

Her er endnu et eksempel for at gøre dette klarere.

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 er det samme, uanset hvor vi begynder at søge.

Eksempel 3 – Find en del af et ord

Understrengen kan være en del af et længere ord:

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

Resultat:

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

Faktisk er der intet krav om, at det overhovedet skal være et ord (trods alt søger vi blot efter en streng):

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 |
+----------+----------+----------+

Eksempel 4 – Ingen match

Hvis understrengen ikke findes, 0 returneres:

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

Resultat:

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

Eksempel 5 – Versalfølsomhed

Denne funktion er multibytesikker og skelner kun mellem store og små bogstaver, hvis mindst ét argument er en binær streng.

Derfor virker følgende på ikke-binære strenge, selvom sagen ikke matcher:

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

Resultat:

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

Men hvis vi bruger en binær streng, sker dette:

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

Resultat:

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

Men hvis vi ændrer det, så sagen matcher, får vi selvfølgelig et match:

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

Resultat:

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

Eksempel 6 – NULL-argumenter

Hvis nogle af argumenterne er NULL , NULL returneres:

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

Resultat:

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