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

# Funzione REGEXP\$1INSTR
<a name="REGEXP_INSTR"></a>

Cerca una stringa per un modello di espressione regolare e restituisce un integer che indica la posizione iniziale o finale della sottostringa corrispondente. Se non viene trovata alcuna corrispondenza, la funzione restituisce `0`. REGEXP\$1INSTR è simile alla funzione [POSITION](r_POSITION.md), ma consente di cercare una stringa per un modello di espressione regolare. Per ulteriori informazioni sulle espressioni regolari, consulta [Operatori POSIX](pattern-matching-conditions-posix.md) ed [Espressione regolare](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.

## Sintassi
<a name="REGEXP_INSTR-synopsis"></a>

```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```

## Arguments (Argomenti)
<a name="REGEXP_INSTR-arguments"></a>

 *source\$1string*   
Un'espressione di stringa, come ad esempio un nome di colonna, da cercare. 

 *pattern*   
Un valore letterale di stringa UTF-8 che rappresenta un modello di espressione regolare. Per ulteriori informazioni, consulta [Operatori POSIX](pattern-matching-conditions-posix.md).

 *posizione*   
(Facoltativo) Un valore `INTEGER` positivo che indica la posizione all'interno di *source\$1string* per iniziare la ricerca. La posizione si basa sul numero di caratteri, non di byte, pertanto i caratteri multibyte vengono contati come caratteri singoli. Il valore predefinito è `1`. Se *position* è inferiore a `1`, la ricerca inizia con il primo carattere di *source\$1string*. Se *position* è maggiore rispetto al numero di caratteri in *source\$1string*, il risultato è `0`.

 *occorrenza*   
(Facoltativo) Un valore `INTEGER` positivo che indica quale occorrenza del modello utilizzare. REGEXP\$1INSTR ignora le prime corrispondenze `occurrence-1`. Il valore predefinito è `1`. Se *occurrence* è inferiore a `1` oppure maggiore rispetto al numero di caratteri in *source\$1string*, la ricerca viene ignorata e il risultato è `0`.

 *option*   
(Facoltativo) Un valore che indica se restituire la posizione del primo carattere della corrispondenza (`0`) o la posizione del primo carattere dopo la fine della corrispondenza (`1`). Un valore diverso da zero equivale a `1`. Il valore predefinito è `0`. 

 *parameters*   
(Facoltativo) Uno o più letterali di stringa che indicano come la funzione corrisponde al modello. Di seguito sono riportati i valori possibili:  
+ c: eseguire una corrispondenza in base a maiuscole e minuscole. L'impostazione predefinita è utilizzare la corrispondenza con distinzione tra maiuscole e minuscole. 
+ i: eseguire una corrispondenza senza distinzione tra maiuscole e minuscole. 
+ e: estrarre una sottostringa usando una sottoespressione. 

  Se *modello* include una sottoespressione, REGEXP\$1INSTR corrisponde a una sottostringa che utilizza la prima sottoespressione in *modello*. REGEXP\$1INSTR considera solo la prima sottoespressione; le sottoespressioni aggiuntive vengono ignorate. Se il modello non ha una sottoespressione, REGEXP\$1INSTR ignora il parametro "e". 
+ p: interpreta il modello con il dialetto Perl Compatible Regular Expression (PCRE). Per ulteriori informazioni su PCRE, consulta [Perl Compatible Regular Expressions](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.

## Tipo restituito
<a name="REGEXP_INSTR-return-type"></a>

Numero intero

## Esempi
<a name="REGEXP_INSTR-examples"></a>

Negli esempi seguenti vengono utilizzati i dati della tabella USERS database di esempio TICKIT. Per ulteriori informazioni, consulta [Database di esempio](c_sampledb.md). 

Per ricercare il carattere `@` che inizia un nome di dominio e restituisce la posizione iniziale della prima corrispondenza, utilizza l'esempio seguente.

```
SELECT email, REGEXP_INSTR(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;

+-----------------------------------------------+--------------+
|                     email                     | regexp_instr |
+-----------------------------------------------+--------------+
| Etiam.laoreet.libero@sodalesMaurisblandit.edu |           21 |
| Suspendisse.tristique@nonnisiAenean.edu       |           22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca   |           17 |
| sed@lacusUtnec.ca                             |            4 |
+-----------------------------------------------+--------------+
```

Per ricercare le varianti della parola `Center` e restituire la posizione iniziale della prima corrispondenza, utilizza l'esempio seguente.

```
SELECT venuename, REGEXP_INSTR(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE REGEXP_INSTR(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;

+-----------------------+--------------+
|       venuename       | regexp_instr |
+-----------------------+--------------+
| The Home Depot Center |           16 |
| Izod Center           |            6 |
| Wachovia Center       |           10 |
| Air Canada Centre     |           12 |
+-----------------------+--------------+
```

Per trovare la posizione iniziale della prima occorrenza della stringa `FOX` utilizzando una logica di associazione senza distinzione tra maiuscole e minuscole, utilizza l'esempio seguente. 

```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');

+--------------+
| regexp_instr |
+--------------+
|            5 |
+--------------+
```

Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola di questo tipo.

```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');

+--------------+
| regexp_instr |
+--------------+
|           21 |
+--------------+
```

Per utilizzare un modello scritto in dialetto PCRE per individuare le parole contenenti almeno un numero e una lettera minuscola, utilizza l'esempio seguente. Utilizza l'operatore `?=`, che ha una connotazione look-ahead specifica in PCRE. In questo esempio viene trovata la posizione iniziale della seconda parola, ma differisce dall'esempio precedente in quanto utilizza la corrispondenza senza distinzione tra maiuscole e minuscole.

```
SELECT REGEXP_INSTR('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');

+--------------+
| regexp_instr |
+--------------+
|           15 |
+--------------+
```