No MySQL, o
LOCATE() A função retorna a posição de uma substring dentro de uma string. Mais especificamente, ele retorna a posição da primeira ocorrência dentro da string, ou a primeira ocorrência após um determinado ponto de partida. Sintaxe
Ele pode ser usado de uma das seguintes maneiras:
LOCATE(substr,str) LOCATE(substr,str,pos)
Onde
substr é a substring a ser localizada e str é a string a ser pesquisada. Ao usar a segunda sintaxe,
pos é a posição para começar a procurar. Exemplo 1 – Primeira Sintaxe
Aqui está um exemplo usando a primeira sintaxe:
SELECT LOCATE('cat', 'One cat jumped over the other cat') AS Result; Resultado:
+--------+ | Result | +--------+ | 5 | +--------+
Exemplo 2 – Segunda Sintaxe
Aqui está um exemplo em que especificamos uma posição inicial para iniciar a pesquisa:
SELECT LOCATE('cat', 'One cat jumped over the other cat', 6) AS Result; Resultado:
+--------+ | Result | +--------+ | 31 | +--------+
Neste caso, a primeira ocorrência de
cat começa na posição 5, mas especifiquei a busca para iniciar na posição 6. Portanto, a posição da próxima ocorrência dessa string foi a que foi retornada. Observe que, embora a pesquisa tenha começado na posição 6, a função ainda retorna a posição da substring dentro da string – não a partir da posição inicial.
Aqui está outro exemplo para ajudar a tornar isso mais claro.
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 | +----------+----------+----------+
O resultado é o mesmo, não importa onde começamos a procurar.
Exemplo 3 – Localizando parte de uma palavra
A substring pode ser parte de uma palavra mais longa:
SELECT LOCATE('sing', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
Na verdade, não há exigência de que seja uma palavra (afinal, estamos simplesmente pesquisando uma string):
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 | +----------+----------+----------+
Exemplo 4 – Sem correspondências
Se a substring não for encontrada, 0 é retornado:
SELECT LOCATE('Bat', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 0 | +--------+
Exemplo 5 - Sensibilidade entre maiúsculas e minúsculas
Essa função é multibyte segura e diferencia maiúsculas de minúsculas somente se pelo menos um argumento for uma string binária.
Portanto, o seguinte funciona em strings não binárias, mesmo que o caso não corresponda:
SELECT LOCATE('Sing', 'Increasingly') AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
Mas se usarmos uma string binária, isso acontece:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('Sing', @str) AS Result; Resultado:
+--------+ | Result | +--------+ | 0 | +--------+
Mas é claro que, se alterarmos para que o case corresponda, obteremos uma correspondência:
SET @str = BINARY 'Increasingly';
SELECT LOCATE('sing', @str) AS Result; Resultado:
+--------+ | Result | +--------+ | 7 | +--------+
Exemplo 6 – Argumentos NULL
Se algum dos argumentos for
NULL ,
NULO
é retornado:SELECT
LOCATE(NULL, 'Increasingly') a,
LOCATE('Bat', NULL) b,
LOCATE('Bat', 'Increasingly', NULL) c; Resultado:
+------+------+------+ | a | b | c | +------+------+------+ | NULL | NULL | NULL | +------+------+------+
