O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# LIKE
<a name="r_patternmatching_condition_like"></a>

O operador LIKE compara uma expressão de string, tal como um nome de coluna, a um padrão que usa os caracteres curinga % (por cento) e \$1 (sublinhado). A correspondência de padrão LIKE sempre abrange toda a string. Para corresponder uma sequência em qualquer lugar de uma string, o padrão deve começar e terminar com um sinal de por cento. 

LIKE diferencia entre maiúsculas e minúsculas; ILIKE não diferencia entre maiúsculas e minúsculas.

## Sintaxe
<a name="r_patternmatching_condition_like-synopsis"></a>

```
expression [ NOT ] LIKE | ILIKE pattern [ ESCAPE 'escape_char' ]
```

## Argumentos
<a name="r_patternmatching_condition_like-arguments"></a>

 *expressão*   
Uma expressão de caractere UTF-8 válida, tal como um nome de coluna. 

LIKE \$1 ILIKE   
LIKE executa uma correspondência de padrão com diferenciação entre maiúsculas e minúsculas. ILIKE realiza uma correspondência de padrão sem diferenciação entre maiúsculas e minúsculas para caracteres de byte único UTF-8 (ASCII). Para realizar uma correspondência de padrões sem distinção entre maiúsculas e minúsculas para caracteres de vários bytes, use a função [LOWER](r_LOWER.md) em *expressão* e *padrão* com uma condição LIKE.  
Em contraste com predicados de comparação, como = e <>, predicados LIKE e ILIKE não ignoram implicitamente os espaços à direita. Para ignorar espaços à direita, use RTRIM ou converta explicitamente uma coluna CHAR em VARCHAR.  
O operador `~~` é equivalente a LIKE, e `~~*` é equivalente a ILIKE. Além disso, os operadores `!~~` e `!~~*` são equivalentes a NOT LIKE e NOT ILIKE.

 *Padrão*   
Uma expressão de caractere UTF-8 válida com o padrão a ser correspondido. 

 *escape\$1char*   
Uma expressão de caractere que irá escapar caracteres de metacaracteres no padrão. O padrão é duas barras invertidas ('\$1\$1'). 

Se o *padrão* não contém metacaracteres, o padrão representa somente a própria string; nesse caso, LIKE age da mesma forma que o operador de igualdade.

Qualquer uma das expressões de caracteres pode ser de tipos de dados CHAR ou VARCHAR. Se eles forem diferentes, o Amazon Redshift converterá o *padrão* no tipo de dados da *expressão*. 

LIKE é compatível com os seguintes metacaracteres de correspondência de padrão: 

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_patternmatching_condition_like.html)

## Exemplos
<a name="r_patternmatching_condition_like-examples"></a>

A seguinte tabela mostra exemplos de correspondência de padrão usando LIKE:

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_patternmatching_condition_like.html)

O seguinte exemplo localiza todas as cidades cujos nomes começam com “E”: 

```
select distinct city from users
where city like 'E%' order by city;
city
---------------
East Hartford
East Lansing
East Rutherford
East St. Louis
Easthampton
Easton
Eatontown
Eau Claire
...
```

O seguinte exemplo localiza usuários cujos sobrenomes contêm “ten”:

```
select distinct lastname from users
where lastname like '%ten%' order by lastname;
lastname
-------------
Christensen
Wooten
...
```

O exemplo a seguir demonstra como combinar vários padrões.

```
select distinct lastname from tickit.users
where lastname like 'Chris%' or lastname like '%Wooten' order by lastname;
lastname
-------------
Christensen
Christian
Wooten
...
```

O seguinte exemplo localiza as cidades cujos terceiros e quartos caracteres são “ea”. O comando usa ILIKE para demonstrar a não diferenciação entre maiúsculas e minúsculas: 

```
select distinct city from users where city ilike '__EA%' order by city;
city
-------------
Brea
Clearwater
Great Falls
Ocean City
Olean
Wheaton
(6 rows)
```

O seguinte exemplo usa a string de escape padrão (\$1\$1) para pesquisar strings que incluem “start\$1” (o texto `start` seguido por um sublinhado `_`): 

```
select tablename, "column" from pg_table_def 
where "column" like '%start\\_%'
limit 5;

     tablename     |    column
-------------------+---------------
 stl_s3client      | start_time
 stl_tr_conflict   | xact_start_ts
 stl_undone        | undo_start_ts
 stl_unload_log    | start_time
 stl_vacuum_detail | start_row
(5 rows)
```

O seguinte exemplo especifica “^” como caractere de escape e o utiliza para pesquisar strings que incluem “start\$1” (o texto `start` seguido por um sublinhado `_`): 

```
select tablename, "column" from pg_table_def 
where "column" like '%start^_%' escape '^' 
limit 5;

     tablename     |    column
-------------------+---------------
 stl_s3client      | start_time
 stl_tr_conflict   | xact_start_ts
 stl_undone        | undo_start_ts
 stl_unload_log    | start_time
 stl_vacuum_detail | start_row
(5 rows)
```

O exemplo a seguir usa o operador `~~*` para fazer uma pesquisa sem distinção entre maiúsculas e minúsculas (ILIKE) de cidades que começam com “Ag”. 

```
select distinct city from users where city ~~* 'Ag%' order by city;
                   
city
------------
Agat	
Agawam	
Agoura Hills	
Aguadilla
```