Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del 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>

El operador LIKE compara una expresión de cadena, como el nombre de una columna, con un patrón que usa caracteres comodines % (porcentaje) y \_ (guion bajo). La coincidencia de patrones LIKE siempre cubre la cadena completa. Para relacionar una secuencia en cualquier lugar dentro de una cadena, el patrón debe comenzar y finalizar con un signo de porcentaje. 

LIKE distingue entre mayúsculas y minúsculas; ILIKE no distingue entre mayúsculas y minúsculas.

## Sintaxis
<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>

 *expresión*   
Una expresión de carácter UTF-8 válido, como un nombre de columna. 

LIKE \| ILIKE   
LIKE realiza una coincidencia de patrones que distingue entre mayúsculas y minúsculas. ILIKE ejecuta una coincidencia de patrones sin distinción entre mayúsculas y minúsculas para caracteres UTF-8 (ASCII) de un byte. Para ejecutar una coincidencia de patrones sin distinguir entre mayúsculas y minúsculas con caracteres multibyte, utilice la función [LOWER](r_LOWER.md) de *expresión* y *patrón* con una condición LIKE.  
Al contrario que los predicados de comparación, como = y <>, los predicados LIKE e ILIKE no omiten implícitamente los espacios finales. Para omitir los espacios finales, utilice RTRIM o convierta explícitamente una columna CHAR en VARCHAR.  
El operador `~~` es equivalente a LIKE y `~~*` es equivalente a ILIKE. Además, los operadores `!~~` y `!~~*` son equivalentes a NOT LIKE y NOT ILIKE.

 *Patrón*   
Una expresión de carácter UTF-8 válido con el patrón que se relacionará. 

 *escape\_char (carácter\_de\_escape*   
Una expresión de carácter que aplicará escape a metacaracteres en el patrón. La predeterminada es dos barras diagonales invertidas ("\\\\"). 

Si el *patrón* no contiene metacaracteres, solo representa la propia cadena; en ese caso, LIKE actúa igual que el operador de igualdad.

Cualquiera de las expresiones de carácter pueden ser tipos de datos CHAR o VARCHAR. Si son diferentes, Amazon Redshift convierte el *patrón* al tipo de datos de la *expresión*. 

LIKE admite los siguientes metacaracteres de coincidencia de patrón: 


| Operador  | Descripción  | 
| --- | --- | 
| %  | Coincide con cualquier secuencia de cero o más caracteres. | 
| \_ | Coincide con cualquier carácter. | 

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

En la tabla siguiente se muestran ejemplos de coincidencia de patrones a través de LIKE:


| Expresión  | Devuelve  | 
| --- | --- | 
| 'abc' LIKE 'abc' | True | 
| 'abc' LIKE 'a%' | True | 
| 'abc' LIKE '\_B\_' | False | 
| 'abc' ILIKE '\_B\_' | True | 
| 'abc' LIKE 'c%' | False | 

En el siguiente ejemplo se encuentran todas las ciudades cuyos nombres comienzan con "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
...
```

En el siguiente ejemplo se encuentran usuarios cuyos apellidos contienen "ten":

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

En el siguiente ejemplo se muestra cómo hacer coincidir varios patrones.

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

En el siguiente ejemplo se encuentran todas las ciudades cuyos terceros y cuartos caracteres son "ea". El comando usa ILIKE para demostrar que no distingue entre mayúsculas y 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)
```

En el siguiente ejemplo se usa la cadena de escape predeterminada (\\\\) para buscar cadenas que incluyan “start\_” (el texto `start` seguido de un guion bajo `_`): 

```
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)
```

En el siguiente ejemplo se especifica “^” como el carácter de escape y, luego, se utiliza el carácter de escape para buscar cadenas que incluyan “start\_” (el texto `start` seguido de un guion bajo `_`): 

```
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)
```

En el siguiente ejemplo, se utiliza el operador `~~*` para realizar una búsqueda que no distinga mayúsculas de minúsculas (ILIKE) de ciudades que comiencen por "Ag". 

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