In MySQL, il LOCATE() La funzione restituisce la posizione di una sottostringa all'interno di una stringa. Più specificamente, restituisce la posizione della prima occorrenza all'interno della stringa, o la prima occorrenza dopo un determinato punto di partenza.
Sintassi
Può essere utilizzato in uno dei seguenti modi:
LOCATE(substr,str) LOCATE(substr,str,pos)
Dove substr è la sottostringa da individuare e str è la stringa da cercare.
Quando si utilizza la seconda sintassi, pos è la posizione da cui iniziare la ricerca.
Esempio 1 – Prima sintassi
Ecco un esempio usando la prima sintassi:
SELECT LOCATE('cat', 'One cat jumped over the other cat') AS Result; Risultato:
+--------+ | Result | +--------+ | 5 | +--------+
Esempio 2 – Seconda sintassi
Ecco un esempio in cui specifichiamo una posizione iniziale per iniziare la ricerca:
SELECT LOCATE('cat', 'One cat jumped over the other cat', 6) AS Result; Risultato:
+--------+ | Result | +--------+ | 31 | +--------+
In questo caso, la prima occorrenza di cat inizia dalla posizione 5, ma ho specificato che la ricerca inizia dalla posizione 6. Pertanto, la posizione dell'occorrenza successiva di quella stringa era quella che è stata restituita.
Si noti che, sebbene la ricerca sia iniziata alla posizione 6, la funzione restituisce comunque la posizione della sottostringa all'interno della stringa, non dalla posizione iniziale.
Ecco un altro esempio per renderlo più chiaro.
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'; Risultato:
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 5 | 5 | 5 | +----------+----------+----------+
Il risultato è lo stesso, indipendentemente da dove iniziamo la ricerca.
Esempio 3 – Individuazione di parte di una parola
La sottostringa può far parte di una parola più lunga:
SELECT LOCATE('sing', 'Increasingly') AS Result; Risultato:
+--------+ | Result | +--------+ | 7 | +--------+
In effetti, non è necessario che sia nemmeno una parola (dopotutto, stiamo semplicemente cercando una stringa):
SELECT
LOCATE('z23!#', 'u_4, z23!#') AS 'Result 1',
LOCATE(' ', 'a b c') AS 'Result 2',
LOCATE(',', 'cat, dog, bird') AS 'Result 3'; Risultato:
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 6 | 2 | 4 | +----------+----------+----------+
Esempio 4 – Nessuna corrispondenza
Se la sottostringa non viene trovata, 0 viene restituito:
SELECT LOCATE('Bat', 'Increasingly') AS Result; Risultato:
+--------+ | Result | +--------+ | 0 | +--------+
Esempio 5:distinzione tra maiuscole e minuscole
Questa funzione è multibyte sicura e distingue tra maiuscole e minuscole solo se almeno un argomento è una stringa binaria.
Pertanto, quanto segue funziona su stringhe non binarie, anche se il caso non corrisponde:
SELECT LOCATE('Sing', 'Increasingly') AS Result; Risultato:
+--------+ | Result | +--------+ | 7 | +--------+
Ma se utilizziamo una stringa binaria, questo accade:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('Sing', @str) AS Result; Risultato:
+--------+ | Result | +--------+ | 0 | +--------+
Ma ovviamente, se lo cambiamo in modo che il caso corrisponda, otteniamo una corrispondenza:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('sing', @str) AS Result; Risultato:
+--------+ | Result | +--------+ | 7 | +--------+
Esempio 6 – Argomenti NULL
Se uno qualsiasi degli argomenti è NULL ,
NULL
viene restituito:
SELECT
LOCATE(NULL, 'Increasingly') a,
LOCATE('Bat', NULL) b,
LOCATE('Bat', 'Increasingly', NULL) c; Risultato:
+------+------+------+ | a | b | c | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
