Como o operador LIKE funciona no MariaDB

No MariaDB, o LIKE operador permite que você faça a correspondência de padrões. Ele determina se uma cadeia de caracteres específica corresponde a um padrão especificado. Ele retorna 1 (VERDADEIRO) ou 0 (FALSO).

Um padrão pode incluir caracteres regulares, bem como o % e _ caracteres curinga.

Esses caracteres curinga são explicados na tabela a seguir.

Caracter curinga	Descrição
`%`	Corresponde a qualquer string de zero ou mais caracteres. Ele pode ser usado como prefixo ou sufixo e também pode ser usado no meio de uma string.
`_`	Corresponde a qualquer caractere único.

Sintaxe

A sintaxe fica assim:

expr LIKE pat [ESCAPE 'escape_char']

Exemplo

Suponha que temos a seguinte tabela:

SELECT * FROM Pets;

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     3 |         2 |       2 | Scratch | 2018-10-01 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
|     7 |         3 |       2 | Bark    | NULL       |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

Aqui está um exemplo para demonstrar como o LIKE operador funciona.

SELECT *
FROM Pets
WHERE PetName LIKE 'F%';

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

Neste exemplo, usei o LIKE operador em conjunto com o % operador curinga para retornar animais de estimação cujo nome comece com a letra F .

Sensibilidade de maiúsculas e minúsculas

LIKE executa correspondências de subcadeia que não diferenciam maiúsculas de minúsculas se o agrupamento para a expressão e o padrão não diferenciam maiúsculas de minúsculas.

Portanto, podemos alterar o exemplo anterior para usar uma letra minúscula f , e ainda obter o mesmo resultado:

SELECT *
FROM Pets
WHERE PetName LIKE 'f%';

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

No entanto, podemos forçar uma correspondência que diferencia maiúsculas de minúsculas usando o COLLATE cláusula com um agrupamento binário. Alternativamente, você pode usar CAST() para coagi-lo a uma string binária.

Exemplo:

SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;

Resultado:

Empty set (0.000 sec)

Nenhum resultado é retornado.

Mas se mudarmos para um F maiúsculo :

SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

Temos três partidas, como esperado.

Argumentos numéricos

Os argumentos numéricos são forçados a strings binárias.

SELECT * 
FROM Pets 
WHERE PetId LIKE 7;

Resultado:

+-------+-----------+---------+---------+------+
| PetId | PetTypeId | OwnerId | PetName | DOB  |
+-------+-----------+---------+---------+------+
|     7 |         3 |       2 | Bark    | NULL |
+-------+-----------+---------+---------+------+

Datas

Aqui está um exemplo que corresponde ao ano de uma data:

SELECT * 
FROM Pets 
WHERE DOB LIKE '2020%';

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     4 |         3 |       3 | Wag     | 2020-03-15 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
|     6 |         3 |       4 | Fluffy  | 2020-09-17 |
+-------+-----------+---------+---------+------------+

Você também pode usar o LIKE operador contra o resultado de funções de data, como DAYNAME() , MONTHNAME() , etc

SELECT * 
FROM Pets 
WHERE MONTHNAME(DOB) LIKE 'Nov%';

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     1 |         2 |       3 | Fluffy  | 2020-11-20 |
|     5 |         1 |       1 | Tweet   | 2020-11-28 |
+-------+-----------+---------+---------+------------+

O `_` Operador curinga

O sublinhado (_ ) operador curinga corresponde a qualquer caractere único.

Exemplo:

SELECT *
FROM Pets
WHERE PetName LIKE '_e%';

Resultado:

+-------+-----------+---------+---------+------------+
| PetId | PetTypeId | OwnerId | PetName | DOB        |
+-------+-----------+---------+---------+------------+
|     2 |         3 |       3 | Fetch   | 2019-08-16 |
|     8 |         2 |       4 | Meow    | NULL       |
+-------+-----------+---------+---------+------------+

Nesse caso, combinamos nomes de animais de estimação em que o segundo caractere é um e .

O personagem de fuga

Às vezes, você pode se encontrar na situação em que precisa procurar um sublinhado ou um sinal de porcentagem. Nesses casos, você pode usar uma barra invertida (\ ) para escapar desses caracteres. Isso impedirá que eles sejam interpretados como caracteres curinga.

Suponha que temos a seguinte tabela:

SELECT * FROM Owners;

Resultado:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | [email protected]  |
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       3 | Nancy     | Simpson  | (489) 591-0408 | NULL               |
|       4 | Boris     | Trump    | (349) 611-8908 | NULL               |
|       5 | Woody     | Eastwood | (308) 555-0112 | [email protected]  |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

Observe que o Proprietário 2 (Bart) tem um endereço de e-mail que contém um sublinhado.

Aqui está um exemplo do que acontece quando não escapar de um sublinhado:

SELECT * FROM Owners
WHERE Email LIKE 'b_%';

Resultado:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

Nesse caso, ele correspondeu a duas linhas. Nesse caso, não importava qual era o segundo caractere - ele correspondia a qualquer personagem. O fato de a primeira linha conter um sublinhado para o segundo caractere é apenas uma coincidência. Teria correspondido mesmo que fosse outra coisa.

Mas e se quiséssemos corresponder apenas aos endereços de e-mail que têm um sublinhado real como segundo caractere?

É aí que entra o caractere de escape.

SELECT * FROM Owners
WHERE Email LIKE 'b\_%';

Resultado:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

Agora temos apenas uma linha – a linha que contém o sublinhado como o segundo caractere.

Mudando o caractere de escape

É possível alterar o caractere de escape. Você pode fazer isso com o ESCAPE argumento.

Exemplo:

SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';

Resultado:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
+---------+-----------+----------+----------------+--------------------+

Neste caso eu atribuí o asterisco (* ) como o caractere de escape.

Isso pode ser especialmente útil quando você precisa usar a barra invertida para outros fins, como codificar caracteres especiais. Nesses casos, você pode ter que “escapar duas vezes” esses personagens, o que pode se tornar confuso. Alterar o caractere de escape pode, portanto, ajudar em tais situações.

Valores NULOS

A porcentagem (% ) curinga corresponde a qualquer coisa – quase. Uma coisa que não corresponde é NULL .

SELECT * FROM Owners
WHERE Email LIKE '%';

Resultado:

+---------+-----------+----------+----------------+--------------------+
| OwnerId | FirstName | LastName | Phone          | Email              |
+---------+-----------+----------+----------------+--------------------+
|       1 | Homer     | Connery  | (308) 555-0100 | [email protected]  |
|       2 | Bart      | Pitt     | (231) 465-3497 | [email protected] |
|       5 | Woody     | Eastwood | (308) 555-0112 | [email protected]  |
|       6 | Burt      | Tyson    | (309) 565-0112 | [email protected]   |
+---------+-----------+----------+----------------+--------------------+

Em nossa tabela, existem duas linhas com NULL no Email coluna, mas esses não são retornados aqui.

Desempenho

Consultas que contêm o LIKE O operador pode ser executado muito mais lentamente do que outras consultas, e você provavelmente deve evitar usar o LIKE operador, a menos que você realmente precise dele. Usando o % operador como um prefixo pode ser particularmente lento.

Isso não quer dizer que você não deve usá-lo em tudo. O LIKE O operador é parte integrante do SQL e você encontrará muitos cenários em que será a única opção (ou pelo menos a melhor opção).