Categorias:

Funções de cadeia de caracteres e binários (Correspondência/Comparação)

[ NOT ] LIKE

Executa uma comparação que diferencia maiúsculas de minúsculas para determinar se uma cadeia de caracteres corresponde ou não a um padrão especificado. Para correspondência que não diferencia maiúsculas e minúsculas, use ILIKE em seu lugar.

LIKE, ILIKE e RLIKE executam operações semelhantes. No entanto, RLIKE usa sintaxe POSIX ERE (Extended Regular Expression, ou expressão regular estendida) em vez da sintaxe padrão SQL usada por LIKE e ILIKE.

Dica

Você pode usar o serviço de otimização de pesquisa para melhorar o desempenho de consultas que chamam essa função. Para obter mais detalhes, consulte Serviço de otimização de pesquisa.

Consulte também:

[ NOT ] ILIKE , [ NOT ] RLIKE , LIKE ALL, LIKE ANY

Sintaxe

<subject> [ NOT ] LIKE <pattern> [ ESCAPE <escape> ]

LIKE( <subject> , <pattern> [ , <escape> ] )
Copy

Argumentos

Obrigatório:

subject

Sujeito à correspondência. Este é normalmente um VARCHAR, embora alguns outros tipos de dados possam ser usados.

pattern

Padrão a atender. Este é normalmente um VARCHAR, embora alguns outros tipos de dados possam ser usados.

Opcional:

escape

Caractere(s) inserido(s) na frente de um curinga para indicar que o curinga deve ser interpretado como um caractere normal e não como um curinga.

Retornos

Retorna um BOOLEAN ou NULL.

  • Quando LIKE é especificado, o valor será TRUE se houver uma correspondência. Caso contrário, retorna FALSE.

  • Quando NOT LIKE é especificado, o valor será TRUE se não houver correspondência. Caso contrário, retorna FALSE.

  • Quando LIKE ou NOT LIKE é especificado, retorna NULL se algum argumento for NULL.

Usage Notes

  • Curingas SQL são suportados em pattern:

    • Um sublinhado (_) corresponde a qualquer caractere individual.

    • Um sinal de porcentagem (%) corresponde a qualquer sequência de zero ou mais caracteres.

  • Os caracteres curinga em pattern incluem caracteres de nova linha (n) em subject como correspondências.

  • LIKE pattern matching covers the entire string. To match a sequence anywhere within a string, start and end the pattern with %.

  • NULL não é compatível com NULL. Em outras palavras, se o assunto for NULL e o padrão for NULL, isso não é considerado uma correspondência.

  • Não há caractere de escape padrão.

  • If you use the backslash as an escape character, then you must specify escape the backslash in the ESCAPE clause. For example, the following command specifies that the escape character is the backslash, and then uses that escape character to search for “%” as a literal (without the escape character, the “%” would be treated as a wildcard):

    'SOMETHING%' LIKE '%\\%%' ESCAPE '\\';
    Copy

    Para exemplos de uso de caracteres de escape, e em particular a barra invertida como um caractere de escape, consulte Exemplos.

Collation Details

Somente as especificações de agrupamento upper, lower e trim são suportadas. Combinações com upper, lower e trim também são suportadas (por exemplo, upper-trim e lower-trim), exceto para combinações de localidade (por exemplo, en-upper).

Nota

To use this function with a column that has the upper, lower, or trim collation specifiers, you must enable the 2024_02 behavior change bundle in your account.

To enable this bundle in your account, execute the following statement:

SELECT SYSTEM$ENABLE_BEHAVIOR_CHANGE_BUNDLE('2024_02');
Copy

Exemplos

Os exemplos seguintes mostram o uso de LIKE, NOT LIKE e o caractere curinga %:

CREATE OR REPLACE TABLE like_ex(name VARCHAR(20));
INSERT INTO like_ex VALUES
    ('John  Dddoe'),
    ('Joe   Doe'),
    ('John_down'),
    ('Joe down'),
    ('Elaine'),
    (''),    -- empty string
    (null);
Copy
SELECT name
    FROM like_ex
    WHERE name LIKE '%Jo%oe%'
    ORDER BY name;
Copy
+-------------+                                                                 
| NAME        |
|-------------|
| Joe   Doe   |
| John  Dddoe |
+-------------+

SELECT name
    FROM like_ex
    WHERE name NOT LIKE '%Jo%oe%'
    ORDER BY name;
Copy
+-----------+
| NAME      |
|-----------|
|           |
| Elaine    |
| Joe down  |
| John_down |
+-----------+

SELECT name
    FROM like_ex
    WHERE name LIKE '%J%h%^_do%' ESCAPE '^'
    ORDER BY name;
Copy
+-----------+                                                                   
| NAME      |
|-----------|
| John_down |
+-----------+

SELECT name
    FROM like_ex
    WHERE name NOT LIKE 'John%'
    ORDER BY name;
Copy
+-----------+                                                                   
| NAME      |
|-----------|
|           |
| Elaine    |
| Joe   Doe |
| Joe down  |
+-----------+

SELECT name
    FROM like_ex
    WHERE name NOT LIKE ''
    ORDER BY name;
Copy
+-------------+                                                                 
| NAME        |
|-------------|
| Elaine      |
| Joe   Doe   |
| Joe down    |
| John  Dddoe |
| John_down   |
+-------------+

The following example uses an ESCAPE clause:

INSERT INTO like_ex (name) VALUES 
    ('100 times'),
    ('1000 times'),
    ('100%');
Copy

Without the escape character, the percent sign (“%”) is treated as a wildcard:

SELECT * FROM like_ex WHERE name LIKE '100%'
    ORDER BY 1;
Copy
+------------+                                                                  
| NAME       |
|------------|
| 100 times  |
| 100%       |
| 1000 times |
+------------+

With the escape character, the percent sign (“%”) is treated as a literal:

SELECT * FROM like_ex WHERE name LIKE '100^%' ESCAPE '^'
    ORDER BY 1;
Copy
+------+                                                                        
| NAME |
|------|
| 100% |
+------+

O exemplo a seguir usa uma cláusula ESCAPE na qual a barra invertida é o caractere de escape. Note que a barra invertida em si mesma deve ser evitada tanto na cláusula ESCAPE quanto na expressão:

SELECT * FROM like_ex WHERE name LIKE '100\\%' ESCAPE '\\'
    ORDER BY 1;
Copy
+------+                                                                        
| NAME |
|------|
| 100% |
+------+
Linguagem: Português