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

# Utilizzare query parametrizzate
<a name="querying-with-prepared-statements"></a>

È possibile utilizzare le query con parametri Athena per rieseguire la stessa query con valori di parametri diversi in fase di esecuzione e contribuire a prevenire gli attacchi di iniezione SQL. In Athena, le query con parametri possono assumere la forma di parametri di esecuzione in qualsiasi query DML o istruzioni preparate in SQL.
+ Le query con parametri di esecuzione possono essere eseguite in un unico passaggio e non sono specifiche del gruppo di lavoro. È possibile inserire punti interrogativi in qualsiasi query DML per i valori che si desidera parametrizzare. Quando si esegue la query, si dichiarano i valori dei parametri di esecuzione in sequenza. La dichiarazione dei parametri e l'assegnazione dei valori per i parametri possono essere eseguite nella stessa query, ma in modo disaccoppiato. A differenza delle istruzioni preparate, è possibile selezionare il gruppo di lavoro quando si invia una query con parametri di esecuzione.
+ Le istruzioni preparate richiedono due istruzioni SQL separate: `PREPARE` e `EXECUTE`. In primo luogo, è necessario definire i parametri nel campo dell’istruzione `PREPARE`. Quindi, viene eseguita un’istruzione `EXECUTE` che fornisce i valori dei parametri definiti. Le istruzioni preparate sono specifiche del gruppo di lavoro; non è possibile eseguirle al di fuori del contesto del gruppo di lavoro a cui appartengono.

## Considerazioni e limitazioni
<a name="querying-with-prepared-statements-considerations-and-limitations"></a>
+ Le query parametrizzate sono supportate nella versione 2 del motore Athena e versioni successive. Per ulteriori informazioni sulle versioni del motore Athena, consulta [Controllo delle versioni del motore di Athena](engine-versions.md).
+ Attualmente, le query con parametri sono supportate solo per le istruzioni `SELECT`, `INSERT INTO`, `CTAS` e `UNLOAD`.
+ Nelle query con parametri, i parametri sono posizionali e sono indicati da `?`. Ai parametri vengono assegnati valori in base al loro ordine nella query. I parametri nominati non sono supportati.
+ Attualmente, i parametri `?` possono essere inseriti solo nella clausola `WHERE`. Sintassi come `SELECT ? FROM table` non è supportata.
+ I parametri del punto interrogativo non possono essere inseriti tra virgolette doppie o singole (ovvero,`'?'` e `"?"` non sono una sintassi valida).
+ I parametri di esecuzione SQL, affinché vengano trattati come stringhe, devono essere racchiusi tra virgolette singole anziché tra virgolette doppie.
+ Se necessario, puoi utilizzare la funzione `CAST` quando immetti un valore per un termine parametrizzato. Ad esempio, se hai una colonna del tipo `date` che è stata parametrizzata in una query e vuoi eseguire una query per la data `2014-07-05`, l'immissione `CAST('2014-07-05' AS DATE)` del valore del parametro restituirà il risultato.
+ Le istruzioni preparate sono specifiche del gruppo di lavoro e i nomi delle istruzioni preparate devono essere univoci all'interno del gruppo di lavoro.
+ Sono necessarie autorizzazioni IAM per le istruzioni preparate. Per ulteriori informazioni, consulta [Consenti l’accesso alle istruzioni preparate](security-iam-athena-prepared-statements.md).
+ Le query con parametri di esecuzione nella console Athena sono limitate a un massimo di 25 punti interrogativi.

**Topics**
+ [Considerazioni e limitazioni](#querying-with-prepared-statements-considerations-and-limitations)
+ [Utilizzare parametri di esecuzione](querying-with-prepared-statements-querying-using-execution-parameters.md)
+ [Utilizzare istruzioni preparate](querying-with-prepared-statements-querying.md)
+ [Risorse aggiuntive](querying-with-prepared-statements-additional-resources.md)

# Utilizzare parametri di esecuzione
<a name="querying-with-prepared-statements-querying-using-execution-parameters"></a>

È possibile utilizzare i placeholder del punto interrogativo in qualsiasi query DML per creare una query con parametri senza creare prima un'istruzione preparata. Per eseguire queste query, puoi utilizzare la console Athena oppure utilizzare AWS CLI l'SDK AWS e dichiarare le variabili nell'argomento. `execution-parameters`

**Topics**
+ [Utilizzare la console Athena.](querying-with-prepared-statements-running-queries-with-execution-parameters-in-the-athena-console.md)
+ [Usa il AWS CLI](querying-with-prepared-statements-running-queries-with-execution-parameters-using-the-aws-cli.md)

# Eseguire query con parametri di esecuzione nella console Athena
<a name="querying-with-prepared-statements-running-queries-with-execution-parameters-in-the-athena-console"></a>

Quando si esegue una query con parametri che include parametri di esecuzione (punti interrogativi) nella console Athena, vengono richiesti i valori nell'ordine in cui si trovano i punti interrogativi nella query.

**Per eseguire una query con parametri di esecuzione**

1. Inserisci una query con placeholder con punti interrogativi nell'editor di Athena, come nell'esempio seguente.

   ```
   SELECT * FROM "my_database"."my_table"
   WHERE year = ? and month= ? and day= ?
   ```

1. Scegli **Esegui**.

1. Nella finestra di dialogo **Enter parameters (inserisci parametri)**, inserisci un valore in ordine per ciascuno dei punti interrogativi nella query.  
![\[Inserisci i valori per i parametri della query in ordine\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-with-prepared-statements-1.png)

1. Una volta inseriti i parametri, seleziona **Run (esegui)**. L'editor mostra i risultati della query per i valori dei parametri inseriti.

In questo caso, puoi:
+ Inserire valori di parametro diversi per la stessa query, quindi selezionare **Run again (esegui nuovamente)**.
+ Per cancellare tutti i valori inseriti contemporaneamente, seleziona **Clear (annulla)**.
+ Per modificare direttamente la query (ad esempio, per aggiungere o rimuovere punti interrogativi), chiudi innanzitutto la finestra di dialogo **Enter parameters (inserisci parametri)**.
+ Per salvare la query con parametri per un uso successivo, seleziona **Save (salva)** o **Save as (salva con nome)** e assegna un nome alla query. Per ulteriori informazioni sull'utilizzo di query salvate, consulta [Utilizzo di query salvate](saved-queries.md).

Per comodità, la finestra di dialogo **Enter parameters (inserisci parametri)** memorizza i valori inseriti in precedenza per la query purché venga utilizzata la stessa scheda nell'editor di query.

# Esegui query con parametri di esecuzione utilizzando il AWS CLI
<a name="querying-with-prepared-statements-running-queries-with-execution-parameters-using-the-aws-cli"></a>

Per utilizzare il AWS CLI per eseguire query con parametri di esecuzione, utilizzate il `start-query-execution` comando e fornite una query con parametri nell'argomento. `query-string` Poi, nell’argomento `execution-parameters` fornisci i valori per i parametri di esecuzione. Nell'esempio seguente viene descritta tale tecnica.

```
aws athena start-query-execution 
--query-string "SELECT * FROM table WHERE x = ? AND y = ?"
--query-execution-context "Database"="default" 
--result-configuration "OutputLocation"="s3://amzn-s3-demo-bucket;/..."
--execution-parameters "1" "2"
```

# Utilizzare istruzioni preparate
<a name="querying-with-prepared-statements-querying"></a>

È possibile utilizzare le istruzioni preparate per eseguire ripetutamente una stessa query con parametri diversi. Un’istruzione preparata contiene segnaposto di parametro i cui valori vengono forniti al momento dell’esecuzione.

**Nota**  
Il numero massimo di istruzioni preparate in un gruppo di lavoro è 1.000.

**Topics**
+ [Sintassi SQL](querying-with-prepared-statements-sql-statements.md)
+ [Utilizzare la console Athena](querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console.md)
+ [Usa il AWS CLI](querying-with-prepared-statements-cli-section.md)

# Sintassi SQL per istruzioni preparate
<a name="querying-with-prepared-statements-sql-statements"></a>

Puoi utilizzare le istruzioni SQL `PREPARE`, `EXECUTE` e `DEALLOCATE PREPARE` per eseguire query parametrizzate nell'editor di query della console Athena. 

 
+ Per specificare i parametri in cui normalmente si utilizzano valori letterali, utilizzare i punti interrogativi nell'istruzione `PREPARE`.
+ Per sostituire i parametri con i valori quando si esegue la query, utilizzare la clausola `USING` nell'istruzione `EXECUTE`.
+ Per rimuovere un'istruzione preparata dall'elenco delle istruzioni preparate in un gruppo di lavoro, utilizzare l'istruzione `DEALLOCATE PREPARE`.

Nelle sezioni seguenti vengono forniti ulteriori dettagli su ciascuna di queste istruzioni.

**Topics**
+ [PREPARE](querying-with-prepared-statements-prepare.md)
+ [EXECUTE](querying-with-prepared-statements-execute.md)
+ [DEALLOCATE PREPARE](querying-with-prepared-statements-deallocate-prepare.md)

# PREPARE
<a name="querying-with-prepared-statements-prepare"></a>

Prepara un'istruzione da eseguire in un secondo momento. Le istruzioni preparate vengono salvate nel gruppo di lavoro corrente con il nome specificato. L'istruzione può includere parametri al posto dei valori letterali da sostituire quando viene eseguita la query. I parametri da sostituire con valori sono denotati da punti interrogativi.

## Sintassi
<a name="querying-with-prepared-statements-prepare-syntax"></a>

```
PREPARE statement_name FROM statement
```

Nella tabella seguente vengono descritti questi parametri.


****  

| Parametro | Description | 
| --- | --- | 
| statement\$1name | Il nome dell'istruzione da preparare. Il nome deve essere univoco all'interno del gruppo di lavoro. | 
| statement | Una query SELECT, CTAS o INSERT INTO. | 

## Esempi PREPARE
<a name="querying-with-prepared-statements-prepare-examples"></a>

I seguenti esempi mostrano l'uso dell'istruzione `PREPARE`. I punti interrogativi indicano i valori che devono essere forniti dall'istruzione `EXECUTE` quando viene eseguita la query.

```
PREPARE my_select1 FROM
SELECT * FROM nation
```

```
PREPARE my_select2 FROM
SELECT * FROM "my_database"."my_table" WHERE year = ?
```

```
PREPARE my_select3 FROM
SELECT order FROM orders WHERE productid = ? and quantity < ?
```

```
PREPARE my_insert FROM
INSERT INTO cities_usa (city, state)
SELECT city, state
FROM cities_world
WHERE country = ?
```

```
PREPARE my_unload FROM
UNLOAD (SELECT * FROM table1 WHERE productid < ?)
TO 's3://amzn-s3-demo-bucket/'
WITH (format='PARQUET')
```

# EXECUTE
<a name="querying-with-prepared-statements-execute"></a>

Esegue un'istruzione preparata. I valori per i parametri sono specificati nella clausola `USING`.

## Sintassi
<a name="querying-with-prepared-statements-execute-syntax"></a>

```
EXECUTE statement_name [USING value1 [ ,value2, ... ] ]
```

*statement\$1name*è il nome della dichiarazione preparata. *value1*e *value2* sono i valori da specificare per i parametri dell'istruzione.

## Esempi EXECUTE
<a name="querying-with-prepared-statements-execute-examples"></a>

L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select1`, che non contiene parametri.

```
EXECUTE my_select1
```

L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select2`, che contiene un parametro singolo.

```
EXECUTE my_select2 USING 2012
```

L'esempio seguente esegue l'esecuzione dell'istruzione preparata `my_select3`, che contiene due parametri.

```
EXECUTE my_select3 USING 346078, 12
```

Nell'esempio seguente viene fornito un valore stringa per un parametro nell'istruzione preparata `my_insert`.

```
EXECUTE my_insert USING 'usa'
```

Nell'esempio seguente viene fornito un valore stringa per un parametro `productid` nell'istruzione preparata `my_unload`.

```
EXECUTE my_unload USING 12
```

# DEALLOCATE PREPARE
<a name="querying-with-prepared-statements-deallocate-prepare"></a>

Rimuove l'istruzione preparata con il nome specificato dall'elenco delle istruzioni preparate nel gruppo di lavoro corrente.

## Sintassi
<a name="querying-with-prepared-statements-deallocate-prepare-syntax"></a>

```
DEALLOCATE PREPARE statement_name
```

*statement\$1name*è il nome dell'istruzione preparata da rimuovere.

## Esempio
<a name="querying-with-prepared-statements-deallocate-prepare-examples"></a>

L'esempio seguente rimuove l'istruzione preparata `my_select1` dal gruppo di lavoro corrente.

```
DEALLOCATE PREPARE my_select1
```

# Eseguire istruzioni preparate interattive nella console Athena
<a name="querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console"></a>

Se si esegue un'istruzione preparata esistente con la sintassi `EXECUTE` *prepared\$1statement* dell'editor di query, Athena apre **la finestra di dialogo Inserisci** parametri in modo da poter inserire i valori che normalmente verrebbero inseriti nella clausola `USING` dell'istruzione. `EXECUTE ... USING`

**Eseguire un’istruzione preparata utilizzando la finestra di dialogo **Enter parameters (inserisci parametri)****

1. Nell'editor di query, anziché utilizzare la sintassi `EXECUTE prepared_statement USING` *value1* `,` *value2*` ...`, utilizzate la sintassi. `EXECUTE` *prepared\$1statement*

1. Scegli **Esegui**. Apparirà la finestra di dialogo **Enter parameters (inserisci parametri)**.  
![\[Immissione di valori di parametri per un’istruzione preparata nella console Athena.\]](http://docs.aws.amazon.com/it_it/athena/latest/ug/images/querying-with-prepared-statements-2.png)

1. Inserisci i valori in ordine nella finestra di dialogo **Execution parameters (parametri di esecuzione)**. Poiché il testo originale della query non è visibile, è necessario ricordare il significato di ciascun parametro posizionale o avere l’istruzione preparata disponibile come riferimento.

1. Scegli **Esegui**.

# Utilizzate il AWS CLI per creare, eseguire ed elencare le istruzioni preparate
<a name="querying-with-prepared-statements-cli-section"></a>

È possibile utilizzare il AWS CLI per creare, eseguire ed elencare le istruzioni preparate.

**Topics**
+ [Crea](querying-with-prepared-statements-creating-prepared-statements-using-the-aws-cli.md)
+ [Execute](querying-with-prepared-statements-cli-executing-prepared-statements.md)
+ [List](querying-with-prepared-statements-listing.md)

# Creare dichiarazioni preparate utilizzando il AWS CLI
<a name="querying-with-prepared-statements-creating-prepared-statements-using-the-aws-cli"></a>

Per utilizzare la AWS CLI per creare un'istruzione preparata, è possibile utilizzare uno dei seguenti `athena` comandi:
+ Utilizza il comando `create-prepared-statement` e fornisci un'istruzione di query con parametri di esecuzione.
+ Utilizza il comando `start-query-execution` e fornisci una stringa di query che utilizzi la sintassi `PREPARE`.

## Usa create-prepared-statement
<a name="querying-with-prepared-statements-cli-using-create-prepared-statement"></a>

In un comando `create-prepared-statement`, definisci il testo della query nell’argomento `query-statement`, come nell'esempio seguente.

```
aws athena create-prepared-statement 
--statement-name PreparedStatement1 
--query-statement "SELECT * FROM table WHERE x = ?" 
--work-group athena-engine-v2
```

## Uso start-query-execution e sintassi PREPARE
<a name="querying-with-prepared-statements-cli-using-start-query-execution-and-the-prepare-syntax"></a>

Utilizza il comando `start-query-execution`. Inserisci l’istruzione `PREPARE` nell’argomento `query-string`, come nell’esempio seguente:

```
aws athena start-query-execution 
--query-string "PREPARE PreparedStatement1 FROM SELECT * FROM table WHERE x = ?" 
--query-execution-context '{"Database": "default"}' 
--result-configuration '{"OutputLocation": "s3://amzn-s3-demo-bucket/..."}'
```

# Eseguite le istruzioni preparate utilizzando il AWS CLI
<a name="querying-with-prepared-statements-cli-executing-prepared-statements"></a>

Per eseguire un'istruzione preparata con AWS CLI, è possibile fornire valori per i parametri utilizzando uno dei seguenti metodi:
+ Utilizzo dell’argomento `execution-parameters`.
+ Utilizzo della sintassi SQL `EXECUTE ... USING` nell’argomento `query-string`.

## Utilizzare l’argomento execution-parameters
<a name="querying-with-prepared-statements-cli-using-the-execution-parameters-argument"></a>

In questo caso, è necessario fornire il comando `start-query-execution` e fornire il nome di un’istruzione preparata esistente nell’argomento `query-string`. Poi, nell’argomento `execution-parameters` fornisci i valori per i parametri di esecuzione. Di seguito viene illustrato un esempio di policy che mostra questo approccio:

```
aws athena start-query-execution 
--query-string "Execute PreparedStatement1" 
--query-execution-context "Database"="default" 
--result-configuration "OutputLocation"="s3://amzn-s3-demo-bucket/..."
--execution-parameters "1" "2"
```

## Utilizzare EXECUTE… Utilizzo della sintassi SQL
<a name="querying-with-prepared-statements-cli-using-the-execute-using-sql-syntax"></a>

Per eseguire un'istruzione preparata esistente utilizzando la sintassi `EXECUTE ... USING`, utilizza il comando `start-query-execution` e inserisci il nome dell'istruzione preparata e i valori dei parametri nell’argomento `query-string`, come nell’esempio:

```
aws athena start-query-execution 
--query-string "EXECUTE PreparedStatement1 USING 1"
--query-execution-context '{"Database": "default"}' 
--result-configuration '{"OutputLocation": "s3://amzn-s3-demo-bucket/..."}'
```

# Elenca le istruzioni preparate utilizzando il AWS CLI
<a name="querying-with-prepared-statements-listing"></a>

Per elencare le istruzioni preparate per un gruppo di lavoro specifico, puoi utilizzare il comando [list-prepared-statements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/list-prepared-statements.html) AWS CLI Athena o l'azione API [ListPreparedStatements](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListPreparedStatements.html)Athena. Il parametro `--work-group` è obbligatorio.

```
aws athena list-prepared-statements --work-group primary
```

# Risorse aggiuntive
<a name="querying-with-prepared-statements-additional-resources"></a>

Vedi i seguenti post correlati nel AWS Big Data Blog.
+ [Migliora la riusabilità e la sicurezza utilizzando le query parametrizzate di Amazon Athena](https://aws.amazon.com/blogs/big-data/improve-reusability-and-security-using-amazon-athena-parameterized-queries/) 
+ [Utilizzare le query parametrizzate di Amazon Athena per fornire dati come servizio](https://aws.amazon.com/blogs/big-data/use-amazon-athena-parameterized-queries-to-provide-data-as-a-service/)