En MySQL, LOCATE() La función devuelve la posición de una subcadena dentro de una cadena. Más específicamente, devuelve la posición de la primera aparición dentro de la cadena, o la primera aparición después de un punto de inicio dado.
Sintaxis
Se puede utilizar de cualquiera de las siguientes formas:
LOCATE(substr,str) LOCATE(substr,str,pos)
Donde substr es la subcadena a localizar, y str es la cadena a buscar.
Al usar la segunda sintaxis, pos es la posición para comenzar a buscar.
Ejemplo 1:primera sintaxis
Aquí hay un ejemplo usando la primera sintaxis:
SELECT LOCATE('cat', 'One cat jumped over the other cat') AS Result; Resultado:
+--------+ | Result | +--------+ | 5 | +--------+
Ejemplo 2:segunda sintaxis
Aquí hay un ejemplo donde especificamos una posición de inicio para comenzar a buscar:
SELECT LOCATE('cat', 'One cat jumped over the other cat', 6) AS Result; Resultado:
+--------+ | Result | +--------+ | 31 | +--------+
En este caso, la primera aparición de cat comienza en la posición 5, pero especifiqué que la búsqueda comenzara en la posición 6. Por lo tanto, la posición de la siguiente aparición de esa cadena fue la que se devolvió.
Tenga en cuenta que, aunque la búsqueda comenzó en la posición 6, la función aún devuelve la posición de la subcadena dentro de la cadena, no desde la posición inicial.
Aquí hay otro ejemplo para ayudar a aclarar esto.
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'; Resultado:
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 5 | 5 | 5 | +----------+----------+----------+
El resultado es el mismo sin importar dónde comencemos a buscar.
Ejemplo 3:localizar parte de una palabra
La subcadena puede ser parte de una palabra más larga:
SELECT LOCATE('sing', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
De hecho, no es necesario que sea una palabra (después de todo, simplemente buscamos una cadena):
SELECT
LOCATE('z23!#', 'u_4, z23!#') AS 'Result 1',
LOCATE(' ', 'a b c') AS 'Result 2',
LOCATE(',', 'cat, dog, bird') AS 'Result 3'; Resultado:
+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | +----------+----------+----------+ | 6 | 2 | 4 | +----------+----------+----------+
Ejemplo 4:Sin coincidencias
Si no se encuentra la subcadena, 0 se devuelve:
SELECT LOCATE('Bat', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 0 | +--------+
Ejemplo 5:Sensibilidad entre mayúsculas y minúsculas
Esta función es segura para varios bytes y distingue entre mayúsculas y minúsculas solo si al menos un argumento es una cadena binaria.
Por lo tanto, lo siguiente funciona en cadenas no binarias, aunque las mayúsculas y minúsculas no coincidan:
SELECT LOCATE('Sing', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
Pero si usamos una cadena binaria, sucede esto:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('Sing', @str) AS Result; Resultado:
+--------+ | Result | +--------+ | 0 | +--------+
Pero, por supuesto, si lo cambiamos para que coincidan las mayúsculas y minúsculas, obtenemos una coincidencia:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('sing', @str) AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
Ejemplo 6:Argumentos NULL
Si alguno de los argumentos es NULL ,
NULO
se devuelve:
SELECT
LOCATE(NULL, 'Increasingly') a,
LOCATE('Bat', NULL) b,
LOCATE('Bat', 'Increasingly', NULL) c; Resultado:
+------+------+------+ | a | b | c | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
