Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation d’instructions préparées
<a name="querying-with-prepared-statements-querying"></a>

Vous pouvez utiliser une instruction préparée pour l'exécution répétée d'une même requête avec des paramètres de requête différents. Une instruction préparée contient des paramètres dont les valeurs sont fournies au moment de l'exécution.

**Note**  
Le nombre maximal d'instructions préparées dans un groupe de travail est de 1 000.

**Topics**
+ [Syntaxe SQL](querying-with-prepared-statements-sql-statements.md)
+ [Utilisation de la console Athena](querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console.md)
+ [Utilisez le AWS CLI](querying-with-prepared-statements-cli-section.md)

# Syntaxe SQL pour les instructions préparées
<a name="querying-with-prepared-statements-sql-statements"></a>

Vous pouvez utiliser les instructions SQL `PREPARE`, `EXECUTE` et `DEALLOCATE PREPARE` pour exécuter des requêtes paramétrées dans l'éditeur de requête de la console Athena. 

 
+ Pour spécifier des paramètres là où vous utiliseriez normalement des valeurs littérales, utilisez des points d'interrogation dans l'instruction `PREPARE`.
+ Pour remplacer les paramètres par des valeurs lorsque vous exécutez la requête, utilisez la clause `USING` dans l'instruction `EXECUTE`.
+ Pour supprimer une instruction préparée des instructions préparées dans un groupe de travail, utilisez l'instruction `DEALLOCATE PREPARE`.

Les sections suivantes fournissent des détails supplémentaires sur chacune de ces instructions.

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

Prépare une instruction à exécuter ultérieurement. Les instructions préparées sont enregistrées dans le groupe de travail actif avec le nom que vous spécifiez. L'instruction peut inclure des paramètres à la place des libellés qui seront remplacés lors de l'exécution de la requête. Les paramètres à remplacer par des valeurs sont signalés par des points d'interrogation.

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

```
PREPARE statement_name FROM statement
```

Le tableau suivant décrit ces paramètres.


****  

| Paramètre | Description | 
| --- | --- | 
| statement\$1name | Nom de l'instruction à préparer. Le nom doit être unique au sein du groupe de travail. | 
| statement | Une requête SELECT, CTAS ou INSERT INTO. | 

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

Les exemples suivants montrent l'utilisation de l'instruction `PREPARE`. Les points d'interrogation indiquent les valeurs à fournir par l'instruction `EXECUTE` lors de l'exécution de la requête.

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

Exécute une instruction préparée. Les valeurs des paramètres sont spécifiées dans la clause `USING`.

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

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

*statement\$1name*est le nom de la déclaration préparée. *value1*et *value2* sont les valeurs à spécifier pour les paramètres de l'instruction.

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

L'exemple suivant exécute l'instruction préparée `my_select1`, qui ne contient aucun paramètre.

```
EXECUTE my_select1
```

L'exemple suivant exécute l'instruction préparée `my_select2`, qui contient un seul paramètre.

```
EXECUTE my_select2 USING 2012
```

L'exemple suivant exécute l'instruction préparée `my_select3`, qui contient deux paramètres.

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

L'exemple suivant fournit une valeur de chaîne pour un paramètre dans l'instruction préparée `my_insert`.

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

L'exemple suivant fournit une valeur numérique pour le paramètre `productid` dans l'instruction préparée `my_unload`.

```
EXECUTE my_unload USING 12
```

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

Supprime l'instruction préparée portant le nom spécifié de la liste des instructions préparées dans le groupe de travail actuel.

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

```
DEALLOCATE PREPARE statement_name
```

*statement\$1name*est le nom de la déclaration préparée à supprimer.

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

L'exemple suivant supprime l'instruction préparée `my_select1` du groupe de travail actuel.

```
DEALLOCATE PREPARE my_select1
```

# Exécution d’instructions préparées interactives dans la console Athena
<a name="querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console"></a>

Si vous exécutez une instruction préparée existante avec la syntaxe `EXECUTE` *prepared\$1statement* de l'éditeur de requêtes, Athena ouvre la boîte de dialogue **Enter** parameters afin que vous puissiez saisir les valeurs qui devraient normalement figurer dans la `USING` clause de l'`EXECUTE ... USING`instruction.

**Pour exécuter une instruction préparée à l'aide de la boîte de dialogue **Enter parameters (Saisir des paramètres)****

1. Dans l'éditeur de requêtes, au lieu d'utiliser la syntaxe `EXECUTE prepared_statement USING` *value1* `,` *value2*` ...`, utilisez la syntaxe `EXECUTE`*prepared\$1statement*.

1. Cliquez sur **Exécuter**. La boîte de dialogue **Enter parameters (Saisir des paramètres)**s'affiche.  
![\[Saisie des valeurs de paramètres pour une instruction préparée dans la console Athena.\]](http://docs.aws.amazon.com/fr_fr/athena/latest/ug/images/querying-with-prepared-statements-2.png)

1. Saisissez les valeurs dans l'ordre dans la boîte de dialogue **Execution parameters (Paramètres d'exécution)**. Comme le texte d'origine de la requête n'est pas visible, vous devez vous souvenir de la signification de chaque paramètre positionnel ou disposer de l'instruction préparée pour référence.

1. Cliquez sur **Exécuter**.

# Utilisez le AWS CLI pour créer, exécuter et répertorier les instructions préparées
<a name="querying-with-prepared-statements-cli-section"></a>

Vous pouvez utiliser le AWS CLI pour créer, exécuter et répertorier des instructions préparées.

**Topics**
+ [Créer](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)

# Créez des déclarations préparées à l'aide du AWS CLI
<a name="querying-with-prepared-statements-creating-prepared-statements-using-the-aws-cli"></a>

Pour utiliser le AWS CLI pour créer une instruction préparée, vous pouvez utiliser l'une des `athena` commandes suivantes :
+ Utilisez la commande `create-prepared-statement` et fournissez une instruction de requête qui a des paramètres d'exécution.
+ Utilisez la commande `start-query-execution` et fournissez une chaîne de requête qui utilise la syntaxe `PREPARE`.

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

Dans une commande `create-prepared-statement`, définissez le texte de la requête dans l'argument `query-statement`, comme dans l'exemple suivant.

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

## Utilisation start-query-execution et syntaxe PREPARE
<a name="querying-with-prepared-statements-cli-using-start-query-execution-and-the-prepare-syntax"></a>

Utilisez la commande `start-query-execution`. Placez l’instruction `PREPARE` dans l'argument `query-string`, comme dans l'exemple suivant :

```
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/..."}'
```

# Exécutez des instructions préparées à l'aide du AWS CLI
<a name="querying-with-prepared-statements-cli-executing-prepared-statements"></a>

Pour exécuter une instruction préparée avec le AWS CLI, vous pouvez fournir des valeurs pour les paramètres en utilisant l'une des méthodes suivantes :
+ Utilisez l'argument `execution-parameters`.
+ Utilisez la syntaxe SQL `EXECUTE ... USING` dans l’argument `query-string`.

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

Dans cette approche, vous utilisez la commande `start-query-execution` et saisissez le nom d'une instruction préparée existante dans l’argument `query-string`. Ensuite, dans l’argument `execution-parameters`, vous fournissez les valeurs des paramètres d'exécution. L'exemple suivant montre cette methode.

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

## Utilisation de la syntaxe EXECUTE… USING SQL
<a name="querying-with-prepared-statements-cli-using-the-execute-using-sql-syntax"></a>

Pour exécuter une instruction préparée existante à l'aide de la syntaxe `EXECUTE ... USING`, vous utilisez la commande `start-query-execution` et placez le nom de l'instruction préparée et les valeurs des paramètres dans l’argument `query-string`, comme dans l'exemple suivant :

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

# Dressez la liste des déclarations préparées à l'aide du AWS CLI
<a name="querying-with-prepared-statements-listing"></a>

Pour répertorier les instructions préparées pour un groupe de travail spécifique, vous pouvez utiliser la commande [list-prepared-statements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/list-prepared-statements.html) AWS CLI Athena ou l'action [ListPreparedStatements](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListPreparedStatements.html)Athena API. Le paramètre `--work-group` est obligatoire.

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