No MySQL, o
LIKE O operador executa a correspondência de padrões usando um padrão SQL. Se a string corresponder ao padrão fornecido, o resultado será
1 , caso contrário é 0 . O padrão não precisa necessariamente ser uma string literal. Esta função pode ser usada com expressões de string e colunas de tabela.
Sintaxe
A sintaxe fica assim:
expr LIKE pat [ESCAPE 'escape_char']
Onde
expr é a string de entrada e pat é o padrão para o qual você está testando a string. O opcional
ESCAPE cláusula permite que você especifique um caractere de escape. O caractere de escape padrão é \ , então você pode omitir esta cláusula se não precisar alterá-la. Exemplo 1 – Uso básico
Aqui está um exemplo de como usar este operador em um
SELECT demonstração:SELECT 'Charlie' LIKE 'Char%';
Resultado:
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
Neste caso, o valor de retorno é
1 o que significa que a string de entrada correspondeu ao padrão. Especificamente, especificamos que a string de entrada deve começar com Char e terminar com qualquer coisa. O % caractere corresponde a qualquer número de caracteres (incluindo zero caracteres). Veja o que acontece se descartarmos o
% :SELECT 'Charlie' LIKE 'Char';
Resultado:
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
O resultado de retorno é
0 o que significa que não há correspondência. Isso ocorre porque não usamos um caractere curinga para especificar outros caracteres. Exemplo 2 – O _ Curinga
Também temos a opção de usar o
_ caractere curinga para especificar apenas um único caractere. Aqui está um exemplo:SELECT 'Charlie' LIKE 'Ch_rlie';
Resultado:
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
Os dois caracteres curinga podem ser combinados em um padrão, se necessário:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Resultado:
+--------+ | Result | +--------+ | 1 | +--------+
Aqui estão mais alguns:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Ch_rlie%nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Ch%rlie %likes %' AS 'Result 3', 'Charlie likes donuts' LIKE '% likes %' AS 'Result 4';
Resultado:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Vamos fazer algumas alterações nesse exemplo para que possamos ver alguns exemplos de quando eles não correspondem:
SELECT 'Charlie likes donuts' LIKE 'Ch%rlie_donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Charlie_nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Charlie _likes donuts' AS 'Result 3', 'Charlie likes donuts' LIKE '_ likes _' AS 'Result 4';
Resultado:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Exemplo 3 – Um exemplo de banco de dados
O
LIKE O operador geralmente é usado dentro de um WHERE cláusula de um SELECT declaração ao consultar um banco de dados. Quando usado dessa maneira, ele restringe os resultados apenas aos registros que correspondem, mas vemos os resultados reais (não apenas um 1 ou 0 ). Aqui está um exemplo de como podemos usar esse operador em uma consulta de banco de dados:
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Resultado:
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
Neste caso, foi uma consulta simples que retorna todos os artistas cujos nomes começam com a letra B .
Aqui está a lista completa de artistas nessa tabela:
SELECT ArtistId, ArtistName FROM Artists;
Resultado:
+----------+------------------------+ | ArtistId | ArtistName | +----------+------------------------+ | 1 | Iron Maiden | | 2 | AC/DC | | 3 | Allan Holdsworth | | 4 | Buddy Rich | | 5 | Devin Townsend | | 6 | Jim Reeves | | 7 | Tom Jones | | 8 | Maroon 5 | | 9 | The Script | | 10 | Lit | | 11 | Black Sabbath | | 12 | Michael Learns to Rock | | 13 | Carabao | | 14 | Karnivool | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+------------------------+
Exemplo 4 – Fuga com o caractere de barra invertida
O que acontece se um dos caracteres curinga estiver em sua string de entrada e você precisar fazer uma correspondência com ele? Você pode escapar com o caractere de barra invertida (
\ ). Aqui está um exemplo de uma pesquisa com e sem o caractere de escape:SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Resultado:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
Neste caso, ambos combinaram, mas por razões diferentes. A primeira linha correspondeu porque o curinga especificou que qualquer caractere corresponderá. A segunda linha também correspondeu, mas apenas porque a string de entrada tinha um sublinhado no lugar certo.
Vamos alterar um pouco a string de entrada para obtermos um resultado diferente:
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Resultado:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
A versão sem escape retornou positivo, porque o curinga significava que poderíamos ter qualquer personagem naquele local. A versão com escape declarou explicitamente que apenas o caractere sublinhado (
_ ) corresponderá. A string de entrada não tinha um caractere de sublinhado nesse ponto e, portanto, o resultado foi negativo. Exemplo 5 – O ESCAPE Cláusula
Você também pode usar o
ESCAPE cláusula para especificar seu próprio caractere de escape personalizado. Aqui está um exemplo:SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Resultado:
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Exemplo 6 – Expressões Numéricas
A implementação do MySQL do
LIKE operador permite que expressões numéricas sejam usadas. Aqui está um exemplo:SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Resultado:
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+
