Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Vorbereitete Anweisungen verwenden
<a name="querying-with-prepared-statements-querying"></a>

Sie können eine vorbereitete Anweisung für die wiederholte Ausführung derselben Abfrage mit unterschiedlichen Abfrageparametern verwenden. Eine vorbereitete Anweisung enthält Parameterplatzhalter, deren Werte zur Ausführungszeit angegeben werden.

**Anmerkung**  
Die maximale Anzahl vorbereiteter Anweisungen in einer Arbeitsgruppe beträgt 1 000.

**Topics**
+ [SQL-Syntax](querying-with-prepared-statements-sql-statements.md)
+ [Athena-Konsole verwenden](querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console.md)
+ [Verwenden Sie den AWS CLI](querying-with-prepared-statements-cli-section.md)

# SQL-Syntax für vorbereitete Anweisungen
<a name="querying-with-prepared-statements-sql-statements"></a>

Sie können die SQL-Anweisungen `PREPARE`, `EXECUTE` und `DEALLOCATE PREPARE` verwenden, um parametrisierte Abfragen im Abfrage-Editor der Athena-Konsole auszuführen. 

 
+ Um Parameter anzugeben, bei denen Sie normalerweise Literalwerte verwenden würden, verwenden Sie Fragezeichen in der `PREPARE`-Anweisung.
+ Um die Parameter beim Ausführen der Abfrage durch Werte zu ersetzen, verwenden Sie die `USING`-Klausel in der `EXECUTE`-Anweisung.
+ Um eine vorbereitete Anweisung aus den vorbereiteten Anweisungen in einer Arbeitsgruppe zu entfernen, verwenden Sie die `DEALLOCATE PREPARE`-Anweisung.

Die folgenden Abschnitte enthalten zusätzliche Details zu jeder dieser Aussagen.

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

Bereitet eine Anweisung vor, die zu einem späteren Zeitpunkt ausgeführt werden soll. Vorbereitete Anweisungen werden in der aktuellen Arbeitsgruppe mit dem von Ihnen angegebenen Namen gespeichert. Die Anweisung kann Parameter anstelle von Literalen enthalten, die beim Ausführen der Abfrage ersetzt werden sollen. Parameter, die durch Werte ersetzt werden sollen, werden durch Fragezeichen gekennzeichnet.

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

```
PREPARE statement_name FROM statement
```

In der Tabelle unten werden diese Parameter beschrieben.


****  

| Parameter | Description | 
| --- | --- | 
| statement\$1name | Der Name der zu erstellenden Anweisung. Der Name muss innerhalb der Arbeitsgruppe eindeutig sein. | 
| statement | SELECT-, CTAS- oder INSERT INTO-Abfrage. | 

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

Die folgenden Beispiele zeigen die Verwendung der `PREPARE`-Anweisung. Fragezeichen kennzeichnen die Werte, die von der `EXECUTE`-Anweisung beim Ausführen der Abfrage geliefert werden sollen.

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

Führt eine vorbereitete Anweisung aus. Werte für Parameter werden in der `USING`-Klausel angegeben.

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

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

*statement\$1name*ist der Name der vorbereiteten Anweisung. *value1*und *value2* sind die Werte, die für die Parameter in der Anweisung angegeben werden müssen.

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

Im folgenden Beispiel wird die vorbereitete Anweisung `my_select1` ausgeführt, die keine Parameter enthält.

```
EXECUTE my_select1
```

Im folgenden Beispiel wird die vorbereitete Anweisung `my_select2` ausgeführt, die einen einzelnen Parameter enthält.

```
EXECUTE my_select2 USING 2012
```

Im folgenden Beispiel wird die vorbereitete Anweisung `my_select3` ausgeführt, die über zwei Parameter verfügt.

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

Das folgende Beispiel liefert einen Zeichenfolgenwert für einen Parameter in der vorbereiteten Anweisung `my_insert`.

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

Das folgende Beispiel liefert einen Zahlenwert für den `productid`-Parameter in der vorbereiteten Anweisung `my_unload`.

```
EXECUTE my_unload USING 12
```

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

Entfernt die vorbereitete Anweisung mit dem angegebenen Namen aus der Liste der vorbereiteten Anweisungen in der aktuellen Arbeitsgruppe.

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

```
DEALLOCATE PREPARE statement_name
```

*statement\$1name*ist der Name der vorbereiteten Anweisung, die entfernt werden soll.

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

Im folgenden Beispiel wird die vorbereitete Anweisung `my_select1` aus der aktuellen Arbeitsgruppe entfernt.

```
DEALLOCATE PREPARE my_select1
```

# Interaktive vorbereitete Anweisungen in der Athena-Konsole ausführen
<a name="querying-with-prepared-statements-executing-prepared-statements-without-the-using-clause-athena-console"></a>

Wenn Sie eine bestehende vorbereitete Anweisung mit der Syntax `EXECUTE` *prepared\$1statement* im Abfrage-Editor ausführen, öffnet Athena das Dialogfeld „**Parameter eingeben**“, sodass Sie die Werte eingeben können, die normalerweise in der `USING` Klausel der `EXECUTE ... USING` Anweisung enthalten wären.

**So führen Sie eine vorbereitete Anweisung mit dem Dialogfeld **Enter parameters** (Parameter eingeben) aus**

1. Verwenden Sie im Abfrage-Editor statt der Syntax `EXECUTE prepared_statement USING` *value1* `,` *value2* ` ...` die Syntax `EXECUTE`*prepared\$1statement*.

1. Klicken Sie auf **Ausführen**. Das Dialogfeld **Enter parameters** (Parameter eingeben) wird angezeigt.  
![\[Geben Sie die Parameter für eine vorbereitete Anweisung in der Athena-Konsole ein.\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/querying-with-prepared-statements-2.png)

1. Geben Sie die Werte der Reihe nach in das Dialogfeld **Execution parameters** (Ausführungsparameter) ein. Da der Originaltext der Abfrage nicht sichtbar ist, müssen Sie sich an die Bedeutung der einzelnen Positionsparameter erinnern oder die vorbereitete Anweisung als Referenz zur Verfügung haben.

1. Klicken Sie auf **Ausführen**.

# Verwenden Sie die, AWS CLI um vorbereitete Anweisungen zu erstellen, auszuführen und aufzulisten
<a name="querying-with-prepared-statements-cli-section"></a>

Sie können den verwenden, AWS CLI um vorbereitete Anweisungen zu erstellen, auszuführen und aufzulisten.

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

# Erstellen Sie vorbereitete Anweisungen mit dem AWS CLI
<a name="querying-with-prepared-statements-creating-prepared-statements-using-the-aws-cli"></a>

Um eine vorbereitete Anweisung AWS CLI zu erstellen, können Sie einen der folgenden `athena` Befehle verwenden:
+ Verwenden Sie den `create-prepared-statement`-Befehl und geben Sie eine Abfrageanweisung mit Ausführungsparametern an.
+ Verwenden Sie den `start-query-execution`-Befehl und geben Sie eine Abfragezeichenfolge an, die die `PREPARE`-Syntax verwendet.

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

Definieren Sie in einem `create-prepared-statement`-Befehl den Abfragetext im `query-statement`-Argument, wie im folgenden Beispiel.

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

## Verwenden Sie start-query-execution und die PREPARE-Syntax
<a name="querying-with-prepared-statements-cli-using-start-query-execution-and-the-prepare-syntax"></a>

Verwenden Sie den Befehl `start-query-execution`. Setzen Sie die `PREPARE`-Anweisung in das `query-string`-Argument, wie im folgenden Beispiel gezeigt:

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

# Führen Sie vorbereitete Anweisungen mit dem aus AWS CLI
<a name="querying-with-prepared-statements-cli-executing-prepared-statements"></a>

Um eine vorbereitete Anweisung mit dem auszuführen AWS CLI, können Sie Werte für die Parameter angeben, indem Sie eine der folgenden Methoden verwenden:
+ Verwenden Sie das `execution-parameters`-Argument.
+ Verwenden Sie die `EXECUTE ... USING`-SQL-Syntax im `query-string`-Argument.

## Verwenden sie das Argument execution-parameters
<a name="querying-with-prepared-statements-cli-using-the-execution-parameters-argument"></a>

Bei diesem Ansatz verwenden Sie den `start-query-execution`-Befehl und geben den Namen einer vorhandenen vorbereiteten Anweisung im `query-string`-Argument ein. Geben Sie daraufhin im `execution-parameters`-Argument die Werte für die Ausführungsparameter an. Die folgende Beispielrichtlinie zeigt diese 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"
```

## Verwenden von EXECUTE... VERWENDEN der SQL-Syntax
<a name="querying-with-prepared-statements-cli-using-the-execute-using-sql-syntax"></a>

Um eine vorhandene vorbereitete Anweisung mithilfe der `EXECUTE ... USING`-Syntax auszuführen, verwenden Sie den `start-query-execution`-Befehl und platzieren sowohl den Namen der vorbereiteten Anweisung als auch die Parameterwerte in das `query-string`-Argument, wie im folgenden Beispiel:

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

# Listet vorbereitete Anweisungen auf, indem Sie AWS CLI
<a name="querying-with-prepared-statements-listing"></a>

Um die vorbereiteten Anweisungen für eine bestimmte Arbeitsgruppe aufzulisten, können Sie den [list-prepared-statements](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/athena/list-prepared-statements.html) AWS CLI Befehl Athena oder die [ListPreparedStatements](https://docs.aws.amazon.com/athena/latest/APIReference/API_ListPreparedStatements.html)Athena-API-Aktion verwenden. Der Parameter `--work-group` muss angegeben werden.

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