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

# Funzioni definite dall’utente in Amazon Redshift
<a name="user-defined-functions"></a>

Puoi creare una funzione scalare definita dall'utente personalizzata usando una clausola SQL SELECT o un programma Python. La nuova funzione è archiviata nel database ed è disponibile per qualsiasi utente con privilegi sufficienti per l'esecuzione. Una funzione definita dall'utente scalare personalizzata viene definita nello stesso modo in cui vengono eseguite le funzioni Amazon Redshift esistenti. 

Per Python UDFs, oltre a utilizzare la funzionalità Python standard, puoi importare i tuoi moduli Python personalizzati. Per ulteriori informazioni, consulta [Supporto del linguaggio Python per UDFs](udf-python-language-support.md). Nota che Python 3 non è disponibile per Python. UDFs Per ottenere il supporto di Python 3 per Amazon UDFs Redshift, usa invece. [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md)

Puoi anche creare AWS Lambda UDFs che utilizzano funzioni personalizzate definite in Lambda come parte delle tue query SQL. Lambda UDFs consente di scrivere testi complessi UDFs e integrarli con componenti di terze parti. Possono anche aiutarti a superare alcune delle limitazioni degli attuali Python e SQL. UDFs Ad esempio, possono aiutare ad accedere alle risorse di rete e di archiviazione e a scrivere istruzioni SQL più complete. Puoi creare Lambda UDFs in uno qualsiasi dei linguaggi di programmazione supportati da Lambda, come Java, Go, Node.js, C\$1 PowerShell, Python e Ruby. Oppure è possibile usare un runtime personalizzato.

Per impostazione predefinita, tutti gli utenti possono eseguire. UDFs Per ulteriori informazioni sui privilegi, consultare [Sicurezza e autorizzazioni delle UDF](udf-security-and-privileges.md).

**Topics**
+ [Sicurezza e autorizzazioni delle UDF](udf-security-and-privileges.md)
+ [Prevenzione dei conflitti di denominazione delle funzioni definite dall'utente](udf-naming-udfs.md)
+ [SQL scalare UDFs](udf-creating-a-scalar-sql-udf.md)
+ [Python scalare UDFs](udf-creating-a-scalar-udf.md)
+ [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md)
+ [Esempi di casi d'uso per funzioni definite dall'utente () UDFs](udf-example-uses.md)

# Sicurezza e autorizzazioni delle UDF
<a name="udf-security-and-privileges"></a>

Per creare una UDF devi disporre dell'autorizzazione per l'utilizzo nel linguaggio per SQL o plpythonu (Python). Per impostazione predefinita, USAGE ON LANGUAGE SQL viene concesso a PUBLIC, ma devi concedere esplicitamente USAGE ON LANGUAGE PLPYTHONU a utenti o gruppi specifici. 

Per revocare l'utilizzo per SQL, revoca innanzitutto l'utilizzo da PUBLIC. Quindi concedi l'utilizzo di SQL solo agli utenti o ai gruppi specifici autorizzati a creare SQL UDFs. L'esempio seguente revoca l'utilizzo su SQL da PUBLIC. Concede quindi l'utilizzo al gruppo di utenti `udf_devs`.

```
revoke usage on language sql from PUBLIC;
grant usage on language sql to group udf_devs;
```

Per eseguire una funzione definita dall'utente, è necessario disporre dell'autorizzazione di esecuzione per ciascuna funzione. Per impostazione predefinita, l'autorizzazione a eseguire new UDFs viene concessa a PUBLIC. Per limitare l'utilizzo, revocare l'autorizzazione da PUBLIC. Quindi concedi il privilegio a specifici individui o gruppi. 

L'esempio seguente revoca l'esecuzione su una funzione `f_py_greater` da PUBLIC. Concede quindi l'utilizzo al gruppo di utenti `udf_devs`.

```
revoke execute on function f_py_greater(a float, b float) from PUBLIC;
grant execute on function f_py_greater(a float, b float) to group udf_devs;
```

Per impostazione predefinita gli utenti con privilegi avanzati hanno tutti i privilegi. 

Per ulteriori informazioni, consultare [GRANT](r_GRANT.md) e [REVOKE](r_REVOKE.md).

# Prevenzione dei conflitti di denominazione delle funzioni definite dall'utente
<a name="udf-naming-udfs"></a>

Puoi evitare possibili conflitti e risultati imprevisti valutando con attenzione le convenzioni di denominazione delle funzioni definite dall'utente prima dell'implementazione. Poiché i nomi delle funzioni possono essere soggetti a overload, possono entrare in conflitto con nomi di funzioni Amazon Redshift esistenti e future. Questo argomento descrive l'overload e presenta una strategia per evitare i conflitti.

## Overload dei nomi delle funzioni
<a name="udf-naming-overloading-function-names"></a>

Una funzione è identificata dal proprio nome e da una *firma*, che corrisponde al numero di argomenti di input e ai tipi di dati degli argomenti. Due funzioni nello stesso schema possono avere lo stesso nome se hanno firme diverse. In altri termini, i nomi delle funzioni possono essere in *overload*.

Quando si esegue una query, il motore di query determina quale funzione chiamare in base al numero di argomenti specificati e ai tipi di dati degli argomenti. È possibile usare l'overload per simulare funzioni con un numero variabile di argomenti, fino al limite consentito dal comando [CREATE FUNCTION](r_CREATE_FUNCTION.md). 

## Evitare conflitti con le funzioni Amazon Redshift integrate
<a name="udf-naming-preventing-udf-naming-conflicts"></a>

Si consiglia di denominare tutti UDFs utilizzando il prefisso`f_`. Amazon Redshift riserva il `f_` prefisso esclusivamente per i nomi UDF UDFs e, anteponendo ai nomi UDF`f_`, ti assicuri che il nome UDF non entri in conflitto con nomi di funzione SQL integrati di Amazon Redshift esistenti o futuri. Ad esempio, assegnando a una nuova funzione definita dall'utente `f_sum`, si evita il conflitto con la funzione SUM di Amazon Redshift. Analogamente, se si assegna il nome `f_fibonacci` a una nuova funzione, è possibile evitare un conflitto se Amazon Redshift aggiungerà una funzione denominata FIBONACCI in una versione futura.

È possibile creare una funzione definita dall'utente con lo stesso nome e la stessa firma di una funzione SQL predefinita di Amazon Redshift esistente senza che avvenga l'overload del nome della funzione se la funzione definita dall'utente e la funzione predefinita si trovano in schemi diversi. Poiché le funzioni predefinite si trovano nello schema del catalogo di sistema pg\$1catalog, puoi creare una funzione definita dall'utente con lo stesso nome in un altro schema, ad esempio uno schema pubblico o definito dall'utente. In alcuni casi, è possibile chiamare una funzione non qualificata esplicitamente con un nome di schema. In tal caso, Amazon Redshift cerca prima lo schema pg\$1catalog per impostazione predefinita. Pertanto, una funzione incorporata viene eseguita prima di una nuova funzione definita dall'utente con lo stesso nome.

È possibile modificare questo comportamento impostando il percorso di ricerca in modo da aggiungere pg\$1catalog alla fine. In tal caso, l'utente ha la precedenza sulle funzioni integrate, ma la pratica UDFs può portare a risultati inaspettati. L'adozione di una strategia di denominazione univoca, ad esempio usando il prefisso riservato `f_`, è un approccio più affidabile. Per ulteriori informazioni, consultare [SET](r_SET.md) e [search\$1path](r_search_path.md).

# SQL scalare UDFs
<a name="udf-creating-a-scalar-sql-udf"></a>

Una funzione definita dall'utente SQL scalare integra una clausola SQL SELECT che viene eseguita quando la funzione viene chiamata e restituisce un singolo valore. Il comando [CREATE FUNCTION](r_CREATE_FUNCTION.md) definisce i parametri seguenti:
+ Argomenti di input (facoltativi). Ogni argomento deve avere un tipo di dati. 
+ Un tipo di dati restituito.
+ Una clausola SQL SELECT. Nella clausola SELECT fai riferimento agli argomenti di input usando \$11, \$12 e così via, in base all'ordine degli argomenti nella definizione della funzione. 

Il tipo di dati di input e il tipo di dati restituito possono essere qualsiasi tipo di dati di Amazon Redshift standard.

Non includere una clausola FROM nella clausola SELECT. Includi invece la clausola FROM nell'istruzione SQL che chiama la funzione definita dall'utente SQL. 

La clausola SELECT non può includere nessuno dei seguenti tipi di clausole:
+ FROM
+ INTO
+ WHERE
+ GROUP BY
+ ORDER BY
+ LIMIT

# Esempio di funzione SQL scalare
<a name="udf-scalar-sql-function-example"></a>

L'esempio seguente crea una funzione che confronta due numeri e restituisce il valore più grande. Per ulteriori informazioni, consultare [CREATE FUNCTION](r_CREATE_FUNCTION.md).

```
create function f_sql_greater (float, float)
  returns float
stable
as $$
  select case when $1 > $2 then $1
    else $2
  end
$$ language sql;
```

La query seguente chiama la nuova funzione f\$1sql\$1greater per eseguire una query sulla tabella SALES e restituire il valore di COMMISSION o il 20% di PRICEPAID, a seconda di quale valore è più grande.

```
select f_sql_greater(commission, pricepaid*0.20) from sales;
```

# Python scalare UDFs
<a name="udf-creating-a-scalar-udf"></a>

Una funzione definita dall'utente Python integra un programma Python che viene eseguito quando la funzione viene chiamata e restituisce un singolo valore. Il comando [CREATE FUNCTION](r_CREATE_FUNCTION.md) definisce i parametri seguenti:
+ Argomenti di input (facoltativi). Ogni argomento deve avere un nome e un tipo di dati. 
+ Un tipo di dati restituito.
+ Un programma Python eseguibile.

I tipi di dati di input e di ritorno per Python UDFs possono essere uno dei seguenti tipi:
+  SMALLINT 
+  INTEGER 
+  BIGINT 
+  DECIMAL 
+  REAL 
+  DOUBLE PRECISION 
+  BOOLEAN 
+  CHAR 
+  VARCHAR 
+  DATE 
+  TIMESTAMP 
+  ANYELEMENT 

Anche gli alias per questi tipi sono validi. Per un elenco completo dei tipi di dati e dei relativi alias, consulta [Tipi di dati](c_Supported_data_types.md).

Quando Python UDFs utilizza il tipo di dati ANYELEMENT, Amazon Redshift converte automaticamente in un tipo di dati standard in base agli argomenti forniti in fase di esecuzione. Per ulteriori informazioni, consulta [Tipo di dati ANYELEMENT](udf-data-types.md#udf-anyelement-data-type).

Quando una query di Amazon Redshift chiama una funzione definita dall'utente scalare, si verifica quanto segue in fase di runtime.

1. La funzione converte gli argomenti di input in tipi di dati Python.

   Per una mappatura dei tipi di dati di Amazon Redshift a tipi di dati Python, consultare [Tipi di dati delle funzioni definite dall'utente Python](udf-data-types.md).

1. La funzione esegue il programma Python, passando gli argomenti di input convertiti.

1. Il codice Python restituisce un singolo valore. Il tipo di dati del valore restituito deve corrispondere al tipo di dati RETURNS specificato dalla definizione della funzione.

1. La funzione converte il valore restituito da Python nel tipo di dati di Amazon Redshift specificato e quindi restituisce il valore alla query.

**Nota**  
Python 3 non è disponibile per Python. UDFs Per ottenere il supporto di Python 3 per Amazon UDFs Redshift, usa invece. [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md)

# Esempio di funzione definita dall'utente Python scalare
<a name="udf-scalar-function-example"></a>

L'esempio seguente crea una funzione che confronta due numeri e restituisce il valore più grande. Tenere presente che il rientro del codice tra i segni di doppio dollaro (\$1\$1) è un requisito di Python. Per ulteriori informazioni, consultare [CREATE FUNCTION](r_CREATE_FUNCTION.md).

```
create function f_py_greater (a float, b float)
  returns float
stable
as $$
  if a > b:
    return a
  return b
$$ language plpythonu;
```

La query seguente chiama la nuova funzione `f_greater` per eseguire una query sulla tabella SALES e restituire il valore di COMMISSION o il 20% di PRICEPAID, a seconda di quale valore è più grande.

```
select f_py_greater (commission, pricepaid*0.20) from sales;
```

# Tipi di dati delle funzioni definite dall'utente Python
<a name="udf-data-types"></a>

Python UDFs può utilizzare qualsiasi tipo di dati Amazon Redshift standard per gli argomenti di input e il valore restituito dalla funzione. Oltre ai tipi di dati standard, UDFs supporta il tipo di dati *ANYELEMENT*, che Amazon Redshift converte automaticamente in un tipo di dati standard in base agli argomenti forniti in fase di esecuzione. Scalar UDFs può restituire un tipo di dati ANYELEMENT. Per ulteriori informazioni, consulta [Tipo di dati ANYELEMENT](#udf-anyelement-data-type).

Durante l'esecuzione, Amazon Redshift converte gli argomenti da tipi di dati Amazon Redshift a tipi di dati Python per l'elaborazione. Quindi converte il valore restituito dal tipo di dati Python al tipo di dati Amazon Redshift corrispondente. Per ulteriori informazioni sui tipi di dati di Amazon Redshift, consultare [Tipi di dati](c_Supported_data_types.md).

La tabella seguente indica la mappatura dei tipi di dati Amazon Redshift ai tipi di dati Python.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/udf-data-types.html)

## Tipo di dati ANYELEMENT
<a name="udf-anyelement-data-type"></a>

ANYELEMENT è un *tipo di dati polimorfico*. Ciò significa che se una funzione viene dichiarata usando ANYELEMENT come tipo di dati di un argomento, la funzione può accettare qualsiasi tipo di dati Amazon Redshift standard come input per l'argomento quando viene chiamata. L'argomento ANYELEMENT viene impostato sul tipo di dati effettivamente passato all'argomento quando viene chiamata la funzione.

Se una funzione usa più tipi di dati ANYELEMENT, questi devono tutti essere risolti nello stesso tipo di dati effettivo quando viene chiamata la funzione. Tutti i tipi di dati dell'argomento ANYELEMENT sono impostati sull'effettivo tipo di dati del primo argomento passato a ANYELEMENT. Ad esempio, una funzione dichiarata come `f_equal(anyelement, anyelement)` accetta uno qualsiasi tra due valori di input, purché abbiano lo stesso tipo di dati.

Se il valore restituito di una funzione viene dichiarato come ANYELEMENT, almeno un argomento di input deve essere ANYELEMENT. Il tipo di dati effettivo per il valore restituito sarà lo stesso del tipo di dati effettivo specificato per l'argomento di input ANYELEMENT. 

# Supporto del linguaggio Python per UDFs
<a name="udf-python-language-support"></a>

Puoi creare una funzione definita dall'utente personalizzata basata sul linguaggio di programmazione Python. La [libreria standard Python 2.7](https://docs.python.org/2/library/index.html) è disponibile per l'uso in UDFs, ad eccezione dei seguenti moduli:
+ ScrolledText
+ Tix
+ Tkinter
+ tk
+ turtle
+ smtpd

Oltre alla libreria standard Python, i moduli seguenti fanno parte dell'implementazione di Amazon Redshift:
+ [numpy 1.8.2](http://www.numpy.org/)
+ [pandas 0.14.1](https://pandas.pydata.org/)
+ [python-dateutil 2.2](https://dateutil.readthedocs.org/en/latest/)
+ [pytz 2014.7](https://pypi.org/project/pytz/2014.7/)
+ [scipy 0.12.1](https://www.scipy.org/)
+ [six 1.3.0](https://pypi.org/project/six/1.3.0/)
+ [wsgiref 0.1.2](https://pypi.python.org/pypi/wsgiref)

Puoi anche importare i tuoi moduli Python personalizzati e renderli disponibili per l'uso UDFs eseguendo un [CREATE LIBRARY](r_CREATE_LIBRARY.md) comando. Per ulteriori informazioni, consulta [Esempio: importazione di moduli di libreria Python personalizzati](udf-importing-custom-python-library-modules.md).

**Importante**  
Amazon Redshift blocca tutti gli accessi alla rete e gli accessi in scrittura al file system tramite. UDFs

**Nota**  
Python 3 non è disponibile per Python. UDFs Per ottenere il supporto di Python 3 per Amazon UDFs Redshift, usa invece. [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md)

# Esempio: importazione di moduli di libreria Python personalizzati
<a name="udf-importing-custom-python-library-modules"></a>

Puoi definire funzioni scalari usando la sintassi del linguaggio Python. È possibile utilizzare i moduli di libreria Python standard e i moduli Amazon Redshift preinstallati. Inoltre è possibile creare moduli di libreria Python personalizzati e importare le librerie nei cluster oppure usare librerie esistenti da Python o da terze parti. 

Non è possibile creare una libreria che contiene un modulo con lo stesso nome di un modulo della libreria standard Python o un modulo Python preinstallato in Amazon Redshift. Se una libreria installata dall'utente esistente usa lo stesso pacchetto Python di una libreria creata da te, devi eliminare la libreria esistente prima di installare quella nuova. 

Per installare librerie personalizzate, devi essere un utente con privilegi avanzati o avere il privilegio `USAGE ON LANGUAGE plpythonu`. Tuttavia, qualsiasi utente con privilegi sufficienti per la creazione di funzioni può usare le librerie installate. Puoi eseguire query sul catalogo di sistema [PG\$1LIBRARY](r_PG_LIBRARY.md) per visualizzare informazioni sulle librerie installate nel cluster.

## Importazione di un modulo Python personalizzato nel cluster
<a name="udf-import-custom-python-module-procedure"></a>

Questa sezione presenta un esempio di importazione di un modulo Python personalizzato nel cluster. Per completare la procedura in questa sezione, è necessario disporre di un bucket Amazon S3 in cui caricare il pacchetto della libreria. Devi quindi installare il pacchetto nel cluster. Per ulteriori informazioni sulla creazione di un bucket, consultare [Creazione di un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/CreatingaBucket.html) nella *Guida per l'utente di Amazon Simple Storage Service*.

In questo esempio, supponiamo che tu crei UDFs per lavorare con posizioni e distanze nei tuoi dati. Connettersi al cluster Amazon Redshift da uno strumento client SQL ed eseguire i comandi seguenti per creare le funzioni. 

```
CREATE FUNCTION f_distance (x1 float, y1 float, x2 float, y2 float) RETURNS float IMMUTABLE as $$
    def distance(x1, y1, x2, y2):
        import math
        return math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
 
    return distance(x1, y1, x2, y2)
$$ LANGUAGE plpythonu;
 
CREATE FUNCTION f_within_range (x1 float, y1 float, x2 float, y2 float) RETURNS bool IMMUTABLE as $$ 
    def distance(x1, y1, x2, y2):
        import math
        return math.sqrt((y2 - y1) ** 2 + (x2 - x1) ** 2)
 
    return distance(x1, y1, x2, y2) < 20
$$ LANGUAGE plpythonu;
```

Come puoi notare, nell'esempio precedente alcune righe di codice sono duplicate. Queste righe duplicate sono necessarie, perché una funzione definita dell'utente non può fare riferimento al contenuto di un'altra funzione definita dall'utente ed entrambe le funzioni devono avere le stesse funzionalità. Tuttavia, invece di duplicare il codice in più funzioni, puoi creare una libreria personalizzata e configurare le funzioni perché la usino. 

A questo scopo, crea prima di tutto il pacchetto della libreria completando questa procedura: 

1. Creare una cartella denominata **geometry**. Questa cartella è il pacchetto di primo livello della libreria.

1. Nella cartella **geometry** creare un file denominato `__init__.py`. Notare che il nome del file contiene due caratteri di sottolineatura doppi. Questo file indica a Python che il pacchetto può essere inizializzato.

1. Nella cartella **geometry** creare una cartella denominata **trig**. Questa cartella è il sottopacchetto della libreria.

1. Nella cartella **trig** creare un altro file denominato `__init__.py` e un file denominato `line.py`. In questa cartella `__init__.py` indica a Python che il sottopacchetto può essere inizializzato e che `line.py` è il file che contiene il codice della libreria.

   La struttura dei file e delle cartelle deve essere uguale alla seguente: 

   ```
   geometry/
      __init__.py
      trig/
         __init__.py
         line.py
   ```

    Per ulteriori informazioni sulla struttura dei pacchetti, consultare la pagina relativa ai [moduli](https://docs.python.org/2/tutorial/modules.html) nel tutorial su Python nel sito Web Python. 

1.  Il codice seguente contiene una classe e funzioni membro per la libreria. Copiare e incollare il codice in `line.py`. 

   ```
   class LineSegment:
     def __init__(self, x1, y1, x2, y2):
       self.x1 = x1
       self.y1 = y1
       self.x2 = x2
       self.y2 = y2
     def angle(self):
       import math
       return math.atan2(self.y2 - self.y1, self.x2 - self.x1)
     def distance(self):
       import math
       return math.sqrt((self.y2 - self.y1) ** 2 + (self.x2 - self.x1) ** 2)
   ```

 Dopo aver creato il pacchetto, completare le operazioni seguenti per prepararlo e caricarlo in Amazon S3. 

1. Comprimere il contenuto della cartella **geometry** in un file ZIP denominato **geometry.zip**. Non includere la cartella **geometry** stessa, ma solo il contenuto della cartella, come mostrato di seguito: 

   ```
   geometry.zip
      __init__.py
      trig/
         __init__.py
         line.py
   ```

1. Caricare **geometry.zip** sul bucket Amazon S3.
**Importante**  
 Se il bucket Amazon S3 non si trova nella stessa regione del cluster Amazon Redshift, è necessario utilizzare l'opzione REGION per specificare la regione in cui si trovano i dati. Per ulteriori informazioni, consultare [CREATE LIBRARY](r_CREATE_LIBRARY.md).

1.  Dallo strumento client SQL eseguire il comando seguente per installare la libreria. Sostituiscilo *<bucket\$1name>* con il nome del bucket e sostituiscilo *<secret key>* con una chiave di accesso *<access key id>* e una chiave di accesso segreta ricavate dalle tue credenziali utente AWS Identity and Access Management (IAM). 

   ```
   CREATE LIBRARY geometry LANGUAGE plpythonu FROM 's3://<bucket_name>/geometry.zip' CREDENTIALS 'aws_access_key_id=<access key id>;aws_secret_access_key=<secret key>';
   ```

 Dopo aver installato la libreria nel cluster, devi configurare le funzioni per l'uso della libreria. A questo scopo, esegui i comandi seguenti. 

```
CREATE OR REPLACE FUNCTION f_distance (x1 float, y1 float, x2 float, y2 float) RETURNS float IMMUTABLE as $$ 
    from trig.line import LineSegment
 
    return LineSegment(x1, y1, x2, y2).distance()
$$ LANGUAGE plpythonu;
 
CREATE OR REPLACE FUNCTION f_within_range (x1 float, y1 float, x2 float, y2 float) RETURNS bool IMMUTABLE as $$ 
    from trig.line import LineSegment
 
    return LineSegment(x1, y1, x2, y2).distance() < 20
$$ LANGUAGE plpythonu;
```

Nei comandi precedenti `import trig/line` elimina il codice duplicato dalle funzioni originali in questa sezione. È possibile riutilizzare le funzionalità fornite da questa libreria in più modi. UDFs Tieni presente che per importare il modulo, devi solo specificare il percorso del sottopacchetto e il nome del modulo (`trig/line`). 

# Vincoli delle UDF Python
<a name="udf-constraints"></a>

Entro i limiti elencati in questo argomento, puoi utilizzare UDFs ovunque utilizzi le funzioni scalari integrate di Amazon Redshift. Per ulteriori informazioni, consulta [Informazioni di riferimento sulle funzioni SQL](c_SQL_functions.md).

Amazon Redshift Python UDFs presenta i seguenti vincoli:
+ Python UDFs non può accedere alla rete o leggere o scrivere nel file system.
+ Le dimensioni totali delle librerie Python installate dall'utente non possono superare 100 MB.
+ Amazon Redshift può eseguire solo una UDF Python alla volta per cluster con provisioning che utilizzano la gestione dei carichi di lavoro (WLM) automatica e per gruppi di lavoro serverless. Se tenti di eseguire più di un UDF contemporaneamente, Amazon Redshift mette in coda il UDFs Python rimanente da eseguire nelle code di gestione del carico di lavoro. SQL UDFs non ha un limite di concorrenza quando utilizza il WLM automatico. 
+  Quando si utilizza WLM manuale per i cluster con provisioning, il numero di Python UDFs che possono essere eseguiti contemporaneamente per cluster è limitato a un quarto del livello di concorrenza totale del cluster. Ad esempio, un cluster fornito con una concorrenza di 15 può eseguire un massimo di tre Python simultanei. UDFs 
+ Quando si utilizza Python UDFs, Amazon Redshift non supporta i tipi di dati SUPER e HLLSKETCH.

# Registrazione di errori e avvisi in Python UDFs
<a name="udf-logging-messages"></a>

Puoi usare il modulo di registrazione Python per creare messaggi di errore e avviso definiti dall'utente nel tuo. UDFs In seguito all'esecuzione della query, puoi eseguire una query sulla vista di sistema [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md) per recuperare i messaggi registrati.

**Nota**  
Il logging di funzioni definite dall'utente utilizza risorse del cluster e può influire sulle prestazioni del sistema. Ti consigliamo di implementare il logging solo per scopi di sviluppo e risoluzione dei problemi. 

Durante l'esecuzione delle query, il gestore dei log scrive messaggi nella vista di sistema SVL\$1UDF\$1LOG, insieme a nome, nodo e sezione della funzione corrispondente. Il gestore dei log scrive una riga nella vista di sistema SVL\$1UDF\$1LOG per ogni messaggio e per ogni sezione. I messaggi vengono troncati a 4096 byte. I log delle funzioni definite dall'utente è limitato a 500 righe per sezione. Quando il log è pieno, il gestore dei log elimina i messaggi meno recenti e aggiunge un messaggio di avviso in SVL\$1UDF\$1LOG.

**Nota**  
Il gestore dei log delle funzioni definite dall'utente di Amazon Redshift aggiunge a caratteri di nuova riga (`\n`), caratteri di barra verticale (`|`) e caratteri di barra rovesciata (`\`) un carattere di barra rovesciata (`\`) per l'escape.

Per impostazione predefinita, il livello di log delle funzioni definite dall'utente è impostato su WARNING. I messaggi con livello di log WARNING, ERROR e CRITICAL vengono registrati. I messaggi con gravità minore, come INFO, DEBUG e NOTSET, vengono ignorati. Per impostare il livello di log delle funzioni definite dall'utente, usa il metodo logger Python. Ad esempio, il codice seguente imposta il livello di log su INFO.

```
logger.setLevel(logging.INFO)
```

Per ulteriori informazioni sull'uso del modulo di logging Python, consultare la pagina relativa all'[utilità di logging per Python](https://docs.python.org/2.7/library/logging.html) nella documentazione di Python.

L'esempio seguente crea una funzione denominata f\$1pyerror che importa il modulo di logging Python, crea un'istanza del logger e registra un errore.

```
CREATE OR REPLACE FUNCTION f_pyerror() 
RETURNS INTEGER
VOLATILE AS
$$
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)
logger.info('Your info message here') 
return 0
$$ language plpythonu;
```

L'esempio seguente esegue una query su SVL\$1UDF\$1LOG per visualizzare il messaggio registrato nell'esempio precedente.

```
select funcname, node, slice, trim(message) as message 
from svl_udf_log;

  funcname  | query | node | slice |   message  
------------+-------+------+-------+------------------
  f_pyerror | 12345 |     1|     1 | Your info message here
```

# Lambda scalare UDFs
<a name="udf-creating-a-lambda-sql-udf"></a>

Amazon Redshift può utilizzare funzioni personalizzate definite AWS Lambda come parte delle query SQL. Puoi scrivere UDFs Lambda scalare in qualsiasi linguaggio di programmazione supportato da Lambda, come Java, Go, Node.js, C\$1 PowerShell, Python e Ruby. Oppure è possibile usare un runtime personalizzato.

Il comando [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md) crea i seguenti parametri:
+ (Facoltativo) Un elenco di argomenti con tipo di dati. 
+ Un tipo di dati restituito.
+ Un nome di funzione della funzione esterna chiamata da Amazon Redshift. 
+ Un ruolo IAM che il cluster Amazon Redshift è autorizzato ad assumere e chiamare Lambda.
+ Il nome di una funzione Lambda richiamato dalla funzione Lambda definita dall'utente.

Per informazioni su CREATE EXTERNAL FUNCTION, consultare [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md).

I tipi di dati di input e di ritorno per Lambda UDFs possono essere uno dei seguenti tipi:
+  SMALLINT 
+  INTEGER 
+  BIGINT 
+  DECIMAL 
+  REAL 
+  DOUBLE PRECISION 
+  CHAR 
+  VARCHAR 
+  BOOLEAN 
+  DATE 
+  TIMESTAMP 

Anche gli alias per questi tipi sono validi. Per un elenco completo dei tipi di dati e dei relativi alias, consulta [Tipi di dati](c_Supported_data_types.md).

Amazon Redshift assicura che la funzione esterna possa inviare e ricevere argomenti e risultati in batch. 

Le Lambda UDFs sono definite e gestite in Lambda e puoi controllare i privilegi di accesso per richiamarle in Amazon Redshift. UDFs È possibile richiamare più funzioni Lambda nella stessa query o richiamare la stessa funzione più volte.

Usa Lambda UDFs in tutte le clausole delle istruzioni SQL in cui sono supportate le funzioni scalari. Puoi anche usare Lambda UDFs in qualsiasi istruzione SQL come SELECT, UPDATE, INSERT o DELETE. 

**Nota**  
L'utilizzo di Lambda UDFs può comportare costi aggiuntivi derivanti dal servizio Lambda. Ciò dipende da fattori quali il numero di richieste Lambda (richiami alle funzioni definite dall'utente) e la durata totale dell'esecuzione del programma Lambda. Tuttavia, non sono previsti costi aggiuntivi per l'utilizzo di Lambda UDFs in Amazon Redshift. [Per informazioni sui prezzi di AWS Lambda, consulta AWS Lambda Prezzi.](https://aws.amazon.com/lambda/pricing)  
Il numero di richieste Lambda varia a seconda della clausola di istruzione SQL specifica in cui viene utilizzata la funzioni Lambda definite dall'utente. Si supponga, ad esempio, che la funzione sia utilizzata in una clausola WHERE come la seguente. ``  
`SELECT a, b FROM t1 WHERE lambda_multiply(a, b) = 64; SELECT a, b FROM t1 WHERE a*b = lambda_multiply(2, 32) `  
In questo caso, Amazon Redshift chiama la prima istruzione SELECT per ogni clausola e chiama la seconda istruzione SELECT una sola volta.  
Tuttavia, l'utilizzo di una funzione definita dall'utente nella parte di proiezione della query potrebbe richiamare la funzione Lambda una sola volta per ogni riga qualificata o aggregata nel set di risultati. 

## Sicurezza e autorizzazioni delle UDF
<a name="udf-lambda-security"></a>

Per creare una funzione Lambda definita dall'utente, assicurati di disporre delle autorizzazioni per l'utilizzo su LANGUAGE EXFUNC. È necessario concedere o revocare esplicitamente USE ON LANGUAGE EXFUNC a utenti, gruppi o pubblici specifici.

Nell'esempio seguente viene concesso l'utilizzo su EXFUNC a PUBLIC.

```
grant usage on language exfunc to PUBLIC; 
```

Nell'esempio seguente viene revocato l'utilizzo su exfunc da PUBLIC, quindi viene concesso al gruppo di utenti lambda\$1udf\$1devs.

```
revoke usage on language exfunc from PUBLIC;
grant usage on language exfunc to group lambda_udf_devs;
```

Per eseguire una funzione Lambda definita dall'utente, assicurarsi di disporre delle autorizzazioni per ogni funzione chiamata. Per impostazione predefinita, l'autorizzazione a eseguire una nuova Lambda UDFs è concessa a PUBLIC. Per limitare l'utilizzo, revocare l'autorizzazione da PUBLIC. Quindi concedere il privilegio a individui o gruppi specifici.

Nell'esempio seguente viene revocata l'esecuzione su una funzione exfunc\$1sum da PUBLIC. Concede quindi l'utilizzo al gruppo di utenti lambda\$1udf\$1devs.

```
revoke execute on function exfunc_sum(int, int) from PUBLIC;
grant execute on function exfunc_sum(int, int) to group lambda_udf_devs;
```

Per impostazione predefinita gli utenti con privilegi avanzati hanno tutti i privilegi.

Per ulteriori informazioni su come concedere e revocare privilegi, consultare [GRANT](r_GRANT.md) e [REVOKE](r_REVOKE.md).

## Configurazione del parametro di autorizzazione per Lambda UDFs
<a name="udf-lambda-authorization"></a>

Il comando CREATE EXTERNAL FUNCTION richiede l'autorizzazione per richiamare le funzioni Lambda AWS Lambda. Per avviare l'autorizzazione, specifica un ruolo AWS Identity and Access Management (IAM) quando esegui il comando CREATE EXTERNAL FUNCTION. Per ulteriori informazioni sui ruoli IAM, consultare [Ruoli IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles.html) nella *Guida per l'utente di IAM*.

Se è presente un ruolo IAM esistente per richiamare funzioni Lambda collegate al cluster, è possibile sostituire l'Amazon Resource Name (ARN) del ruolo nel parametro IAM\$1ROLE per il comando. Nelle sezioni seguenti vengono descritti i passaggi per l'uso di un ruolo IAM nel comando CREATE EXTERNAL FUNCTION.

### Creazione di un ruolo IAM per Lambda
<a name="udf-lambda-create-iam"></a>

Il ruolo IAM richiede l'autorizzazione per richiamare le funzioni Lambda. Durante la creazione del ruolo IAM, fornire l'autorizzazione in uno dei modi seguenti:
+ Collegare la policy `AWSLambdaRole` sulla pagina **Collega policy di autorizzazioni** durante la creazione di un ruolo IAM. La policy `AWSLambdaRole` concede le autorizzazioni per richiamare funzioni Lambda, che è il requisito minimo. Per ulteriori informazioni e altre policy, consultare [Policy IAM basate sull'identità per AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/access-control-identity-based.html) nella *Guida per gli sviluppatori di AWS Lambda *.
+ Creare policy personalizzate da associare al ruolo IAM con l'autorizzazione `lambda:InvokeFunction` di tutte le risorse o di una particolare funzione Lambda con l'ARN di tale funzione. Per informazioni sulla creazione di policy IAM, consultare [Creazione di policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html) nella *Guida per l'utente di IAM*.

  La seguente policy di esempio consente di richiamare Lambda su una particolare funzione Lambda.

------
#### [ JSON ]

****  

  ```
  {
      "Version":"2012-10-17",		 	 	 
      "Statement": [
          {
              "Sid": "Invoke",
              "Effect": "Allow",
              "Action": [
                  "lambda:InvokeFunction"
              ],
              "Resource": "arn:aws:lambda:us-west-2:123456789012:function:my-function"
          }
      ]
  }
  ```

------

  Per ulteriori informazioni sulle risorse per le funzioni Lambda, consultare [Risorse e condizioni per operazioni Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-api-permissions-ref.html) in *Documentazione di riferimento dell'API IAM*.

  Dopo aver creato la policy personalizzata con le autorizzazioni richieste, è possibile collegare la policy al ruolo IAM sulla pagina **Collega policy di autorizzazioni** durante la creazione di un ruolo IAM.

Per i passaggi per creare un ruolo IAM, consulta [Autorizzazione di Amazon Redshift ad accedere ad AWS altri servizi per tuo conto](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) nella *Amazon Redshift* Management Guide.

Se non si desidera creare un nuovo ruolo IAM, è possibile aggiungere le autorizzazioni menzionate in precedenza al ruolo IAM esistente.

### Associazione di un ruolo IAM al cluster
<a name="udf-lambda-associate-iam"></a>

Collegare il ruolo IAM al cluster. È possibile aggiungere un ruolo a un cluster o visualizzare i ruoli associati a un cluster utilizzando la Console di gestione, la CLI o l'API di Amazon Redshift. Per ulteriori informazioni, consulta [Associazione di un ruolo IAM a un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) nella *Guida alla gestione di Amazon Redshift*.

### Inclusione del ruolo IAM nel comando
<a name="udf-lambda-include-iam"></a>

Includere l'ARN del ruolo IAM nel comando CREATE EXTERNAL FUNCTION. Quando crei un ruolo IAM, IAM restituisce un Amazon Resource Name (ARN) per il ruolo. Per specificare un ruolo IAM, fornire l'ARN del ruolo con il parametro `IAM_ROLE`. Di seguito è mostrata la sintassi del parametro `IAM_ROLE`.

```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```

Per richiamare le funzioni Lambda che risiedono in altri account all'interno della stessa regione, consultare [Concatenazione di ruoli IAM in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html#authorizing-redshift-service-chaining-roles.html).

## Utilizzo dell'interfaccia JSON tra Amazon Redshift e AWS Lambda
<a name="udf-lambda-json"></a>

Amazon Redshift utilizza un'interfaccia comune per tutte le funzioni Lambda con cui Amazon Redshift comunica.

La tabella seguente mostra l'elenco dei campi di input che le funzioni Lambda designate possono aspettarsi per il payload JSON.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/udf-creating-a-lambda-sql-udf.html)

L'ordine dell'array JSON determina l'ordine di elaborazione batch. La funzione Lambda deve elaborare gli argomenti in maniera iterativa e produrre il numero esatto di record. Di seguito è riportato un esempio di payload. 

```
{
  "request_id" : "23FF1F97-F28A-44AA-AB67-266ED976BF40",
  "cluster" : "arn:aws:redshift:xxxx",
  "user" : "adminuser",
  "database" : "db1",
  "external_function": "public.foo",
  "query_id" : 5678234,
  "num_records" : 4,
  "arguments" : [
     [ 1, 2 ],
     [ 3, null],
     null,
     [ 4, 6]
   ]
 }
```

L'output restituito dalla funzione Lambda contiene i seguenti campi.

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/udf-creating-a-lambda-sql-udf.html)

Di seguito è riportato un esempio di output di una funzione Lambda:

```
{
  "success": true,   // true indicates the call succeeded
  "error_msg" : "my function isn't working",  // shall only exist when success != true
  "num_records": 4,      // number of records in this payload
  "results" : [
     1,
     4,
     null,
     7
   ]
}
```

Quando vengono richiamate le funzioni Lambda da query SQL, Amazon Redshift garantisce la sicurezza della connessione con le seguenti considerazioni:
+ Autorizzazioni GRANT e REVOKE. Per informazioni sulle sicurezza e sulle autorizzazioni delle UDF, consulta [Sicurezza e autorizzazioni delle UDF](udf-security-and-privileges.md).
+ Amazon Redshift invia alla funzione Lambda designata solo il set minimo di dati.
+ Amazon Redshift chiama solo la funzione Lambda designata con il ruolo IAM designato.

# Esempi di casi d'uso per funzioni definite dall'utente () UDFs
<a name="udf-example-uses"></a>

**Nota**  
A partire dal 1° novembre 2025, Amazon Redshift non supporterà più la creazione di nuovi Python. UDFs Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. A partire dal 1° luglio 2026, Amazon Redshift non supporterà più Python. UDFs Ti consigliamo di migrare il tuo UDFs Python esistente a UDFs Lambda prima del 1° novembre 2025. Per informazioni sulla creazione e l'utilizzo di Lambda UDFs, consulta. [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md) [Per informazioni sulla conversione di UDFs Python esistente in UDFs Lambda, 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 funzioni definite dall'utente possono essere utilizzate per risolvere i problemi aziendali integrando Amazon Redshift con altri componenti. Di seguito sono riportati alcuni esempi di come altri lo hanno utilizzato UDFs per i propri casi d'uso: 
+ [Accesso a componenti esterni tramite Amazon Redshift Lambda UDFs](https://aws.amazon.com/blogs/big-data/accessing-external-components-using-amazon-redshift-lambda-udfs/): descrive come UDFs funziona Amazon Redshift Lambda e illustra come creare una UDF Lambda.
+ [Traduci e analizza il testo utilizzando le funzioni SQL con Amazon Redshift, Amazon Translate e Amazon Comprehend: offre Amazon](https://aws.amazon.com/blogs/machine-learning/translate-and-analyze-text-using-sql-functions-with-amazon-redshift-amazon-translate-and-amazon-comprehend/) Redshift UDFs Lambda preconfigurato che puoi installare con pochi clic per tradurre, redigere e analizzare campi di testo.
+ [Accedi ad Amazon Location Service da Amazon Redshift](https://aws.amazon.com/blogs/big-data/access-amazon-location-service-from-amazon-redshift/): descrive come utilizzare Amazon Redshift UDFs Lambda per l'integrazione con Amazon Location Service.
+ [Tokenizzazione dei dati con Amazon Redshift e](https://aws.amazon.com/blogs/apn/data-tokenization-with-amazon-redshift-and-protegrity/) Protegrity: descrive come integrare Amazon Redshift Lambda con il prodotto Protegrity Serverless. UDFs 
+ [Amazon Redshift UDFs](https://github.com/aws-samples/amazon-redshift-udfs): una raccolta di Amazon Redshift SQL, Lambda e Python. UDFs