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/). 

# SIMILAR TO
<a name="pattern-matching-conditions-similar-to"></a>

El operador SIMILAR TO relaciona una expresión de cadena, como el nombre de una columna, con un patrón de expresión regular de SQL estándar. Un patrón de expresión regular de SQL estándar puede incluir un conjunto de metacaracteres de coincidencia de patrón, incluidos los dos admitidos por el operador [LIKE](r_patternmatching_condition_like.md). 

El operador SIMILAR TO devuelve true solo si su patrón coincide con la cadena completa, a diferencia del comportamiento de la expresión regular POSIX, donde el patrón puede coincidir con cualquier parte de la cadena. 

SIMILAR TO realiza una coincidencia de patrones que distingue entre mayúsculas y minúsculas. 

**nota**  
La coincidencia de expresiones regulares a través de SIMILAR TO es costosa informáticamente. Recomendamos utilizar LIKE cuando sea posible, especialmente cuando procesa una gran cantidad de filas. Por ejemplo, las siguientes consultas son idénticas desde el punto de vista funcional, pero la consulta que utiliza LIKE se ejecuta varias veces más rápido que la consulta que utiliza una expresión regular:  

```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%'; 
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```

## Sintaxis
<a name="pattern-matching-conditions-similar-to-synopsis"></a>

```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```

## Argumentos
<a name="pattern-matching-conditions-similar-to-arguments"></a>

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

SIMILAR TO  
SIMILAR TO ejecuta una coincidencia de patrones con distinción entre mayúsculas y minúsculas en la cadena completa de *expresión*. 

 *Patrón*   
Una expresión de carácter UTF-8 válido que representa un patrón de expresión regular de SQL estándar. 

 *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, el patrón solo representa la propia cadena.

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*. 

SIMILAR TO 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. | 
| \| | Denota una alternancia (cualquiera de dos alternativas). | 
| \* | Repite el elemento anterior cero o más veces. | 
| \+ | Repite el elemento anterior una o más veces. | 
| ?  | Repite el elemento anterior cero o una vez. | 
| {m} | Repite el elemento anterior exactamente m veces. | 
| {m,} | Repite el elemento anterior m o más veces. | 
| {m,n} | Repite el elemento anterior al menos m y no más de n veces. | 
|  () | Los paréntesis agrupan elementos en un único elemento lógico. | 
| [...] | Una expresión de corchetes especifica una clase de carácter, como en las expresiones regulares POSIX. | 

## Ejemplos
<a name="pattern-matching-conditions-similar-to-examples"></a>

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


| Expresión  | Devuelve  | 
| --- | --- | 
| 'abc' SIMILAR TO 'abc' | True | 
|  'abc' SIMILAR TO '\_b\_'  | True | 
| 'abc' SIMILAR TO '\_A\_' | False | 
| 'abc' SIMILAR TO '%(b\|d)%' | True | 
| 'abc' SIMILAR TO '(b\|c)%' | False | 
| 'AbcAbcdefgefg12efgefg12' SIMILAR TO '((Ab)?c)\+d((efg)\+(12))\+'  | True | 
| 'aaaaaab11111xy' SIMILAR TO 'a{6}\_ [0-9]{5}(x\|y){2}'  | True | 
| '$0.87' SIMILAR TO '$[0-9]\+(.[0-9][0-9])?'  | True | 

En el siguiente ejemplo, se encuentran las ciudades cuyos nombres contienen “E” o “H”: 

```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;

      city
-----------------
 Agoura Hills
 Auburn Hills
 Benton Harbor
 Beverly Hills
 Chicago Heights
```

En el siguiente ejemplo se usa la cadena de escape predeterminada ("`\\`") para buscar cadenas que incluyan "`_`":

```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;

        tablename         |       column
--------------------------+---------------------
 stcs_abort_idle          | idle_start_time
 stcs_abort_idle          | txn_start_time
 stcs_analyze_compression | start_time
 stcs_auto_worker_levels  | start_level
 stcs_auto_worker_levels  | start_wlm_occupancy
```

En el siguiente ejemplo se especifica "`^`" como la cadena de escape y, luego, se utiliza la cadena de escape para buscar cadenas que incluyan "`_`": 

```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;

        tablename         |       column
--------------------------+---------------------
 stcs_abort_idle          | idle_start_time
 stcs_abort_idle          | txn_start_time
 stcs_analyze_compression | start_time
 stcs_auto_worker_levels  | start_level
 stcs_auto_worker_levels  | start_wlm_occupancy
```