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.

# Parametrisierte Abfragen verwenden
<a name="querying-with-prepared-statements"></a>

Sie können parametrisierte Athena-Abfragen verwenden, um dieselbe Abfrage mit unterschiedlichen Parameterwerten zur Ausführungszeit erneut auszuführen und SQL-Injection-Angriffe zu verhindern. In Athena können parametrisierte Abfragen in beliebigen DML-Abfragen oder vorbereiteten SQL-Anweisungen die Form von Ausführungsparametern annehmen.
+ Abfragen mit Ausführungsparametern können in einem einzigen Schritt durchgeführt werden und sind nicht arbeitsgruppenspezifisch. Sie platzieren Fragezeichen in jeder DML-Abfrage für die Werte, die Sie parametrisieren möchten. Wenn Sie die Abfrage ausführen, deklarieren Sie die Werte der Ausführungsparameter sequenziell. Die Deklaration von Parametern und die Zuweisung von Werten für die Parameter können in derselben Abfrage erfolgen, jedoch entkoppelt. Im Gegensatz zu vorbereiteten Anweisungen können Sie die Arbeitsgruppe auswählen, wenn Sie eine Abfrage mit Ausführungsparametern senden.
+ Vorbereitete Anweisungen erfordern zwei separate SQL-Anweisungen: `PREPARE` und `EXECUTE`. Zunächst definieren Sie die Parameter in der `PREPARE`-Anweisung. Dann führen Sie eine `EXECUTE`-Anweisung aus, die Werte für die von Ihnen definierten Parameter bereitstellt. Vorbereitete Anweisungen sind arbeitsgruppenspezifisch. Sie können sie nicht außerhalb des Kontextes der Arbeitsgruppe, zu der sie gehören, ausführen.

## Überlegungen und Einschränkungen
<a name="querying-with-prepared-statements-considerations-and-limitations"></a>
+ Parametrisierte Abfragen werden in Athena-Engine-Version 2 und höheren Versionen unterstützt. Weitere Informationen über Athena-Engine-Versionen finden Sie unter [Athena-Engine-Versionierung](engine-versions.md).
+ Derzeit werden parametrisierte Abfragen nur für `SELECT`-, `INSERT INTO`-, `CTAS`- und `UNLOAD`-Anweisungen.
+ In parametrisierten Abfragen sind Parameter positionell und werden mit `?` angegeben. Parametern werden Werte nach ihrer Reihenfolge in der Abfrage zugewiesen. Benannte Parameter werden nicht unterstützt.
+ Derzeit können `?`-Parameter nur in der `WHERE`-Klausel platziert werden. Syntax wie `SELECT ? FROM table` wird nicht unterstützt.
+ Fragezeichen-Parameter können nicht in doppelte oder einfache Anführungszeichen gesetzt werden (d. h. `'?'` und `"?"` sind keine gültige Syntax).
+ Damit SQL-Ausführungsparameter als Zeichenfolgen behandelt werden, müssen sie in einfache Anführungszeichen und nicht in doppelte Anführungszeichen eingeschlossen werden.
+ Bei Bedarf können Sie die `CAST`-Funktion verwenden, wenn Sie einen Wert für einen parametrisierten Begriff eingeben. Wenn Sie beispielsweise über eine Spalte des `date`-Typs verfügen, den Sie in einer Abfrage parametrisiert haben, und Sie das Datum `2014-07-05` abfragen möchten, wird `CAST('2014-07-05' AS DATE)` bei Eingabe des Parameterwerts das Ergebnis zurückgegeben.
+ Vorbereitete Anweisungen sind arbeitsgruppenspezifisch und die Namen vorbereiteter Anweisungen müssen innerhalb der Arbeitsgruppe eindeutig sein.
+ IAM-Berechtigungen für vorbereitete Anweisungen sind erforderlich. Weitere Informationen finden Sie unter [Zugriff auf vorbereitete Anweisungen konfigurieren](security-iam-athena-prepared-statements.md).
+ Abfragen mit Ausführungsparametern in der Athena-Konsole sind auf maximal 25 Fragezeichen beschränkt.

**Topics**
+ [Überlegungen und Einschränkungen](#querying-with-prepared-statements-considerations-and-limitations)
+ [Ausführungsparameter verwenden](querying-with-prepared-statements-querying-using-execution-parameters.md)
+ [Vorbereitete Anweisungen verwenden](querying-with-prepared-statements-querying.md)
+ [Weitere Ressourcen](querying-with-prepared-statements-additional-resources.md)

# Ausführungsparameter verwenden
<a name="querying-with-prepared-statements-querying-using-execution-parameters"></a>

Sie können Fragezeichen-Platzhalter in jeder DML-Abfrage verwenden, um eine parametrisierte Abfrage zu erstellen, ohne zuerst eine vorbereitete Anweisung zu erstellen. Um diese Abfragen auszuführen, können Sie die Athena-Konsole oder das AWS CLI oder das AWS-SDK verwenden und die Variablen im `execution-parameters` Argument deklarieren.

**Topics**
+ [Athena-Konsole verwenden](querying-with-prepared-statements-running-queries-with-execution-parameters-in-the-athena-console.md)
+ [Verwenden Sie den AWS CLI](querying-with-prepared-statements-running-queries-with-execution-parameters-using-the-aws-cli.md)

# Ausführen von Abfragen mit Ausführungsparametern in der Athena-Konsole
<a name="querying-with-prepared-statements-running-queries-with-execution-parameters-in-the-athena-console"></a>

Wenn Sie eine parametrisierte Abfrage ausführen, die Ausführungsparameter (Fragezeichen) in der Athena-Konsole enthält, werden Sie aufgefordert, die Werte in der Reihenfolge einzugeben, in der die Fragezeichen in der Abfrage auftreten.

**So führen Sie eine Abfrage mit Ausführungsparametern aus**

1. Geben Sie im Athena-Editor eine Abfrage mit Fragezeichen-Platzhaltern ein, wie im folgenden Beispiel gezeigt.

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

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

1. In dem Dialogfeld **Enter parameters** (Parameter eingeben) geben Sie für jedes der Fragezeichen in der Abfrage einen Wert in der richtigen Reihenfolge ein.  
![\[Geben Sie nacheinander Werte für die Abfrageparameter ein\]](http://docs.aws.amazon.com/de_de/athena/latest/ug/images/querying-with-prepared-statements-1.png)

1. Wenn Sie alle Parameter eingegeben haben, wählen Sie **Run** (Ausführen) aus. Der Editor zeigt die Abfrageergebnisse für die von Ihnen eingegebenen Parameterwerte an.

Jetzt können Sie einen der folgenden Schritte ausführen:
+ Geben Sie verschiedene Parameterwerte für dieselbe Abfrage ein und wählen Sie anschließend **Run again** (Erneut ausführen) aus.
+ Um alle Werte, die Sie eingegeben haben, gleichzeitig zu löschen, wählen Sie **Clear** (Löschen) aus.
+ Um die Abfrage direkt zu bearbeiten (z. B. um Fragezeichen hinzuzufügen oder zu entfernen), schließen Sie zunächst das Dialogfeld **Enter parameters** (Parameter eingeben).
+ Um die parametrisierte Abfrage für eine spätere Verwendung zu speichern, wählen Sie **Save** (Speichern) oder **Save as** (Speichern als) aus und geben Sie der Abfrage dann einen Namen. Weitere Informationen zur Verwendung von gespeicherten Abfragen finden Sie unter [Gespeicherte Abfragen verwenden](saved-queries.md).

Als Annehmlichkeit merkt sich das Dialogfeld **Enter parameters** (Parameter eingeben) die Werte, die Sie zuvor für die Abfrage eingegeben haben, solange Sie dieselbe Registerkarte im Abfrage-Editor verwenden.

# Führen Sie Abfragen mit Ausführungsparametern mit dem AWS CLI
<a name="querying-with-prepared-statements-running-queries-with-execution-parameters-using-the-aws-cli"></a>

Um Abfragen mit Ausführungsparametern auszuführen, verwenden Sie den `start-query-execution` Befehl und geben Sie im Argument eine parametrisierte Abfrage an`query-string`. AWS CLI Geben Sie daraufhin im `execution-parameters`-Argument die Werte für die Ausführungsparameter an. Das folgende Beispiel illustriert diese Technik.

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

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

# Weitere Ressourcen
<a name="querying-with-prepared-statements-additional-resources"></a>

Lesen Sie die folgenden verwandten Beiträge im AWS Big Data-Blog.
+ [Die Wiederverwendbarkeit und Sicherheit mithilfe von in Amazon Athena parametrisierten Abfragen verbessern](https://aws.amazon.com/blogs/big-data/improve-reusability-and-security-using-amazon-athena-parameterized-queries/) 
+ [In Amazon Athena parametrisierte Abfragen verwenden, um Daten als Service bereitzustellen](https://aws.amazon.com/blogs/big-data/use-amazon-athena-parameterized-queries-to-provide-data-as-a-service/)