

 Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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

L'operatore SIMILAR TO associa un'espressione di stringa, come il nome di colonna, a un modello di espressione regolare standard SQL. Un modello di espressione regolare SQL può comprendere un set di metacaratteri di corrispondenza di modelli, compresi i due supportati dall'operatore LIKE [LIKE](r_patternmatching_condition_like.md). 

L'operatore SIMILAR TO restituisce true solo se il modello corrisponde all'intera stringa, a differenza del comportamento dell'espressione regolare POSIX, in cui il modello può corrispondere a qualsiasi porzione della stringa. 

SIMILAR TO esegue una corrispondenza che fa distinzione tra maiuscole e minuscole. 

**Nota**  
La corrispondenza di espressioni regolari usando SIMILAR TO è costosa in termini di calcolo. Consigliamo di usare LIKE quando possibile, soprattutto se si elaborano grandi quantità di righe. Ad esempio, le query seguenti sono identiche dal punto di vista funzionale, ma la query che usa LIKE viene eseguita molto più velocemente rispetto alla query che usa un'espressione regolare:  

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

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

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

## Arguments (Argomenti)
<a name="pattern-matching-conditions-similar-to-arguments"></a>

 *espressione*   
Un'espressione di caratteri UTF-8 valida, come un nome di colonna. 

SIMILAR TO  
SIMILAR TO esegue una corrispondenza di modello che distingue tra maiuscole e minuscole per l'intera stringa nell'*espressione*. 

 *pattern*   
Un'espressione di caratteri UTF-8 valida che rappresenta un modello di espressione regolare standard SQL. 

 *escape\$1char*   
Un'espressione di caratteri che eseguirà l'escape dei metacaratteri nel modello. Per impostazione predefinita sono due barre rovesciate ("\$1\$1"). 

Se il *modello* non contiene metacaratteri, allora il modello rappresenta solo la stringa stessa.

Entrambe le espressioni di caratteri possono essere tipi di dati CHAR o VARCHAR. Se differiscono, Amazon Redshift converte il *modello* al tipo di dati dell'*espressione*. 

SIMILAR TO supporta i seguenti metacaratteri di corrispondenza di modelli: 

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-similar-to.html)

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

La tabella riportata di seguito mostra esempi di corrispondenza di modelli usando SIMILAR TO:

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/pattern-matching-conditions-similar-to.html)

L'esempio seguente trova tutte le città il cui nome contiene "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
```

Nell'esempio seguente viene usata la stringa di escape predefinita ("`\\`") per cercare stringhe che contengono "`_`":

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

L'esempio seguente specifica "`^`" come stringa di escape, quindi usa la stringa di escape per cercare stringhe che contengono "`_`": 

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