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.
# Aufrufen der Daten-API von Amazon RDS
Wenn die Daten-API von Amazon RDS (Daten-API) auf Ihrem Aurora-DB-Cluster aktiviert ist, können Sie SQL-Anweisungen auf dem Aurora-DB-Cluster ausführen, indem Sie die Daten-API oder die AWS CLI verwenden. Die Daten-API unterstützt die von den AWS SDKs unterstützten Programmiersprachen. Weitere Informationen finden Sie unter [Tools für AWS](https://aws.amazon.com/tools/).
**Topics**
+ [Referenz zu Operationen mit der Amazon-RDS-Daten-API](data-api-operations.md)
+ [Aufrufen der Daten-API von Amazon RDS über die AWS CLI](data-api.calling.cli.md)
+ [Aufrufen der Daten-API von Amazon RDS aus einer Python-Anwendung](data-api.calling.python.md)
+ [Aufrufen der Daten-API von Amazon RDS aus einer Java-Anwendung](data-api.calling.java.md)
+ [Steuern des Timeout-Verhaltens der Daten-API](data-api-timeouts.md)
# Referenz zu Operationen mit der Amazon-RDS-Daten-API
Die Amazon-RDS-Daten-API bietet die folgenden Operationen zur Ausführung von SQL-Anweisungen.
****
| Daten-API-Operation | AWS CLI Befehl | Description |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_ExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/execute-statement.html) | Führt eine SQL-Anweisung in einer Datenbank aus. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BatchExecuteStatement.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/batch-execute-statement.html) | Führt eine Batch-SQL-Anweisung über ein Array von Daten für Massen-Update- und -Einfügeoperationen aus. Sie können eine DML-Anweisung (Data Manipulation Language) mit einem Array von Parametersätzen ausführen. Eine Batch-SQL-Anweisung kann gegenüber einzelnen Einfügungs- und Aktualisierungsanweisungen eine erhebliche Leistungsverbesserung bieten. |
Sie können beide Vorgänge verwenden, um einzelne SQL-Anweisungen oder Transaktionen auszuführen. Für Transaktionen bietet die Daten-API die folgenden Operationen.
****
| Daten-API-Operation | AWS CLI Befehl | Description |
| --- | --- | --- |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_BeginTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/begin-transaction.html) | Startet eine SQL-Transaktion. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_CommitTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/commit-transaction.html) | Beendet eine SQL-Transaktion und schreibt die Änderungen fest. |
| [https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_RollbackTransaction.html) | [https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html](https://docs.aws.amazon.com/cli/latest/reference/rds-data/rollback-transaction.html) | Führt ein Rollback einer Transaktion durch. |
Die Operationen zur Ausführung von SQL-Anweisungen und zur Unterstützung von Transaktionen haben die folgenden gemeinsamen Daten-API-Parameter und AWS CLI -Optionen. Einige Operationen unterstützen andere Parameter oder Optionen.
****
| Daten-API-Operationsparameter | AWS CLI Befehlsoption | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `resourceArn` | `--resource-arn` | Ja | Der Amazon-Ressourcenname (ARN) für den Aurora-DB-Cluster. Der Cluster muss sich in derselben AWS-Konto IAM-Rolle oder dem IAM-Benutzer befinden, der die Daten-API aufruft. Um auf einen Cluster in einem anderen Konto zuzugreifen, nehmen Sie eine Rolle in diesem Konto an. |
| `secretArn` | `--secret-arn` | Ja | Der Name oder ARN des Secrets, das Zugriff auf das DB-Cluster ermöglicht. |
Die RDS-Daten-API unterstützt die folgenden Datentypen für Aurora MySQL:
+ `TINYINT(1)`, `BOOLEAN`, `BOOL`
+ `TINYINT`
+ `SMALLINT` [`SIGNED` \$1 `UNSIGNED`]
+ `MEDIUMINT` [`SIGNED` \$1 `UNSIGNED`]
+ `INT` [`SIGNED` \$1 `UNSIGNED`]
+ `BIGINT` [`SIGNED` \$1 `UNSIGNED`]
+ `FLOAT`
+ `DOUBLE`
+ `VARCHAR`, `CHAR`, `TEXT`, `ENUM`
+ `VARBINARY`, `BINARY`, `BLOB`
+ `DATE`, `TIME`, `DATETIME`, `TIMESTAMP`
+ `DECIMAL`
+ `JSON`
+ `BIT`, `BIT(N)`
Die RDS-Daten-API unterstützt die folgenden skalaren Typen für Aurora-PostgreSQL:
+ `BOOL`
+ `BYTEA`
+ `DATE`
+ `CIDR`
+ `DECIMAL`, `NUMERIC`
+ `ENUM`
+ `FLOAT8`, `DOUBLE PRECISION`
+ `INET`
+ `INT`, `INT4`, `SERIAL`
+ `INT2`, `SMALLINT`, `SMALLSERIAL`
+ `INT8`, `BIGINT`, `BIGSERIAL`
+ `JSONB`, `JSON`
+ `REAL`, `FLOAT`
+ `TEXT`, `CHAR(N)`, `VARCHAR`, `NAME`
+ `TIME`
+ `TIMESTAMP`
+ `UUID`
+ `VECTOR`
Die RDS-Daten-API unterstützt die folgenden Array-Typen für Aurora PostgreSQL:
+ `BOOL[]`, `BIT[]`
+ `DATE[]`
+ `DECIMAL[]`, `NUMERIC[]`
+ `FLOAT8[]`, `DOUBLE PRECISION[]`
+ `INT[]`, `INT4[]`
+ `INT2[]`
+ `INT8[]`, `BIGINT[]`
+ `JSON[]`
+ `REAL[]`, `FLOAT[]`
+ `TEXT[]`, `CHAR(N)[]`, `VARCHAR[]`, `NAME[]`
+ `TIME[]`
+ `TIMESTAMP[]`
+ `UUID[]`
Sie können Parameter in Daten-API-Aufrufen an `ExecuteStatement` und und verwenden`BatchExecuteStatement`, wenn Sie die AWS CLI Befehle `execute-statement` und ausführen. `batch-execute-statement` Um einen Parameter zu verwenden, geben Sie ein Name-Wert-Paar im Datentyp `SqlParameter` an. Den Wert geben Sie mit dem Datentyp `Field` an. In der folgenden Tabelle sind den Datentypen, die Sie in Daten-API-Aufrufen angeben, JDBC-Datentypen (Java Database Connectivity) zugeordnet.
****
| JDBC-Datentyp | Daten-API-Datentyp |
| --- | --- |
| `INTEGER, TINYINT, SMALLINT, BIGINT` | `LONG` (oder `STRING`) |
| `FLOAT, REAL, DOUBLE` | `DOUBLE` |
| `DECIMAL` | `STRING` |
| `BOOLEAN, BIT` | `BOOLEAN` |
| `BLOB, BINARY, LONGVARBINARY, VARBINARY` | `BLOB` |
| `CLOB` | `STRING` |
| Andere Typen (einschließlich datums- und zeitbezogener Typen) | `STRING` |
**Anmerkung**
Sie können den Datentyp `LONG` oder `STRING` in Ihrem Daten-API-Aufruf für von der Datenbank zurückgegebene `LONG`-Werte angeben. Wir empfehlen Ihnen, dies zu tun, um zu vermeiden, dass bei extrem großen Zahlen die Genauigkeit verloren geht, was bei der Arbeit mit auftreten kann JavaScript.
Bestimmte Typen, wie `DECIMAL` und `TIME`, erfordern einen Hinweis, damit die Daten-API `String`-Werte als richtigen Typ an die Datenbank weiterleitet. Um einen Hinweis zu verwenden, schließen Sie Werte für `typeHint` in den Datentyp `SqlParameter` ein. Die folgenden Werte sind für `typeHint` möglich:
+ `DATE` – Der entsprechende `String`-Parameter wird als Objekt des Typs `DATE` an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD`.
+ `DECIMAL` – Der entsprechende `String`-Parameter wird als Objekt des Typs `DECIMAL` an die Datenbank gesendet.
+ `JSON` – Der entsprechende `String`-Parameter wird als Objekt des Typs `JSON` an die Datenbank gesendet.
+ `TIME` – Der entsprechende `String`-Parameter wird als Objekt des Typs `TIME` an die Datenbank gesendet. Das akzeptierte Format ist `HH:MM:SS[.FFF]`.
+ `TIMESTAMP` – Der entsprechende `String`-Parameter wird als Objekt des Typs `TIMESTAMP` an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `UUID` – Der entsprechende `String`-Parameter wird als Objekt des Typs `UUID` an die Datenbank gesendet.
**Anmerkung**
Derzeit unterstützt die Daten-API keine Arrays von Universal Unique Identifiers ()UUIDs.
**Anmerkung**
Für Amazon Aurora PostgreSQL gibt die Daten-API immer den Aurora PostgreSQL Datentyp `TIMESTAMPTZ` in der UTC-Zeitzone zurück.
# Aufrufen der Daten-API von Amazon RDS über die AWS CLI
Sie können die RDS-Daten-API (Daten-API) über die AWS CLI aufrufen.
In den folgenden Beispielen wird die AWS CLI für die Daten-API verwendet. Weitere Informationen finden Sie in der [AWS CLI-Referenz für die Daten-API](https://docs.aws.amazon.com/cli/latest/reference/rds-data/index.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Anmerkung**
Die AWS CLI kann Antworten in JSON formatieren.
**Topics**
+ [Starten einer SQL-Transaktion](#data-api.calling.cli.begin-transaction)
+ [Ausführen einer SQL-Anweisung](#data-api.calling.cli.execute-statement)
+ [Ausführen einer Stapel-SQL-Anweisung über ein Daten-Array](#data-api.calling.cli.batch-execute-statement)
+ [Übergeben einer SQL-Transaktion](#data-api.calling.cli.commit-transaction)
+ [Rollback einer SQL-Transaktion](#data-api.calling.cli.rollback-transaction)
## Starten einer SQL-Transaktion
Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Der Aufruf gibt eine Transaktions-ID zurück.
**Wichtig**
Auf der Daten-API kommt es bei einer Transaktion zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, setzt die Daten-API die Transaktion automatisch zurück.
MySQL Data Definition Language (DDL)-Anweisungen innerhalb einer Transaktion führen zu einem impliziten Commit. Wir empfehlen Ihnen, die einzelnen MySQL-DDL-Anweisungen jeweils in einem separaten Befehl `execute-statement` mit der Option `--continue-after-timeout` auszuführen.
Geben Sie zusätzlich zu den allgemeinen Optionen die Option `--database` an, die den Namen der Datenbank enthält.
Der folgende CLI-Befehl beispielsweise startet eine SQL-Transaktion.
Für Linux, macOS oder Unix:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Für Windows:
```
aws rds-data begin-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionId": "ABC1234567890xyz"
}
```
## Ausführen einer SQL-Anweisung
Sie können mittels des CLI-Befehls `aws rds-data execute-statement` eine SQL-Anweisung ausführen.
Sie können die SQL-Anweisung in einer Transaktion ausführen, indem Sie die Transaktions-ID mit der Option `--transaction-id` angeben. Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Sie können eine Transaktion beenden und übergeben, indem Sie den CLI-Befehl `aws rds-data commit-transaction` verwenden.
**Wichtig**
Wenn Sie die Option `--transaction-id` nicht angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgenden Optionen an:
+ `--sql` (erforderlich) – eine SQL-Anweisung, die auf dem DB-Cluster ausgeführt werden soll.
+ `--transaction-id` (optional) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, in die Sie die SQL-Anweisung einfügen möchten.
+ `--parameters` (optional) – die Parameter für die SQL-Anweisung.
+ `--include-result-metadata | --no-include-result-metadata` (optional) – ein Wert, der angibt, ob Metadaten in die Ergebnisse eingefügt werden sollen. Der Standardwert ist `--no-include-result-metadata`.
+ `--database` (optional) – der Name der Datenbank.
Die `--database`-Option funktioniert möglicherweise nicht, wenn Sie eine SQL-Anweisung ausführen, nachdem Sie bei der vorherige Anfrage `--sql "use database_name;"` ausgeführt haben. Es wird empfohlen, die `--database`-Option zu verwenden statt `--sql "use database_name;"`-Anweisungen auszuführen.
+ `--continue-after-timeout | --no-continue-after-timeout` (optional) – ein Wert, der angibt, ob die Anweisung weiter ausgeführt werden soll, wenn der Aufruf das Daten-API-Zeitintervall von 45 Sekunden überschreitet. Der Standardwert ist `--no-continue-after-timeout`.
Im Fall von Data Definition Language (DDL)-Anweisungen sollten Sie die Anweisung nach Ablauf des Aufrufs weiter ausführen, um Fehler und die Möglichkeit beschädigter Datenstrukturen zu vermeiden.
+ `--format-records-as "JSON"|"NONE"` – Ein optionaler Wert, der angibt, ob die Ergebnismenge als JSON-Zeichenfolge formatiert werden soll. Der Standardwert ist `"NONE"`. Nutzungsinformationen über die Verarbeitung von JSON-Ergebnismengen finden Sie unter [Verarbeiten von Abfrageergebnissen der Amazon-RDS-Data-API im JSON-Format](data-api-json.md).
Das DB-Cluster gibt für den Aufruf eine Antwort zurück.
**Anmerkung**
Das Limit für Antwortgrößen beträgt 1 MiB. Wenn der Aufruf mehr als 1 MiB an Antwortdaten zurückgibt, wird der Aufruf beendet.
Für Aurora Serverless v1 beträgt die maximale Anzahl der Anforderungen pro Sekunde 1 000. Für alle anderen unterstützten Datenbanken gibt es kein Limit.
Der folgende CLI-Befehl führt beispielsweise eine einzelne SQL-Anweisung aus und lässt die Metadaten in den Ergebnissen weg (Standard).
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "select * from mytable"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "select * from mytable"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 0,
"records": [
[
{
"longValue": 1
},
{
"stringValue": "ValueOne"
}
],
[
{
"longValue": 2
},
{
"stringValue": "ValueTwo"
}
],
[
{
"longValue": 3
},
{
"stringValue": "ValueThree"
}
]
]
}
```
Der folgende CLI-Befehl führt eine einzelne SQL-Anweisung in einer Transaktion aus, indem die Option `--transaction-id` angegeben wird.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "update mytable set quantity=5 where id=201" --transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 1
}
```
Der folgende CLI-Befehl führt eine einzelne SQL-Anweisung mit Parametern aus.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" --parameters "[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"value1\"}}]"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"numberOfRecordsUpdated": 1
}
```
Der folgende CLI-Befehl führt eine Data Definition Language (DDL)-SQL-Anweisung aus. Die DDL-Anweisung benennt die Spalte `job` in die Spalte `role` um.
**Wichtig**
Im Fall von DDL-Anweisungen sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, geben Sie die Option `--continue-after-timeout` an.
Für Linux, macOS oder Unix:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Für Windows:
```
aws rds-data execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "alter table mytable change column job role varchar(100)" --continue-after-timeout
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"generatedFields": [],
"numberOfRecordsUpdated": 0
}
```
**Anmerkung**
Die `generatedFields`-Daten werden von Aurora PostgreSQL nicht unterstützt. Zum Abrufen der Werte von generierten Feldern verwenden Sie die `RETURNING`-Klausel. Weitere Informationen finden Sie in unter [ Returning Data From Modified Rows](https://www.postgresql.org/docs/10/dml-returning.html) in der PostgreSQL-Dokumentation.
## Ausführen einer Stapel-SQL-Anweisung über ein Daten-Array
Sie können eine Batch-SQL-Anweisung über ein Daten-Array ausführen, indem Sie den CLI-Befehl `aws rds-data batch-execute-statement` verwenden. Sie können dieses Befehl verwenden, um einen Massenimport oder eine Update-Operation auszuführen.
Sie können die SQL-Anweisung in einer Transaktion ausführen, indem Sie die Transaktions-ID mit der Option `--transaction-id` angeben. Sie können eine SQL-Transaktion mit dem CLI-Befehl `aws rds-data begin-transaction` starten. Sie können eine Transaktion mit dem CLI-Befehl `aws rds-data commit-transaction` beenden und übergeben.
**Wichtig**
Wenn Sie die Option `--transaction-id` nicht angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgenden Optionen an:
+ `--sql` (erforderlich) – eine SQL-Anweisung, die auf dem DB-Cluster ausgeführt werden soll.
**Tipp**
Fügen Sie bei MySQL-kompatiblen Anweisungen kein Semikolon am Ende des `--sql`-Parameters ein. Ein abschließendes Semikolon kann einen Syntaxfehler verursachen.
+ `--transaction-id` (optional) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, in die Sie die SQL-Anweisung einfügen möchten.
+ `--parameter-set` (optional) – die Parametersätze für die Batch-Operation.
+ `--database` (optional) – der Name der Datenbank.
Das DB-Cluster gibt für den Aufruf eine Antwort zurück.
**Anmerkung**
Es gibt keine feste Obergrenze für die Anzahl der Parametersätze. Die maximale Größe der HTTP-Anforderung, die über die Daten-API gesendet wird, beträgt jedoch 4 MiB. Wenn die Anforderung dieses Limit überschreitet, gibt die Daten-API einen Fehler zurück und die Anfrage wird nicht verarbeitet. Dieses 4-MiB-Limit umfasst die Größe der HTTP-Header und der JSON-Notation in der Anforderung. Die Anzahl der Parametersätze, die Sie einbinden können, hängt demnach von mehreren Faktoren ab, z. B. von der Größe der SQL-Anweisung und der Größe der individuellen Parametersätze.
Das Limit für Antwortgrößen beträgt 1 MiB. Wenn der Aufruf mehr als 1 MiB an Antwortdaten zurückgibt, wird der Aufruf beendet.
Für Aurora Serverless v1 beträgt die maximale Anzahl der Anforderungen pro Sekunde 1 000. Für alle anderen unterstützten Datenbanken gibt es kein Limit.
Der folgende CLI-Befehl führt beispielsweise eine Batch-SQL-Anweisung für ein Daten-Array mit einem Parametersatz aus.
Für Linux, macOS oder Unix:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--sql "insert into mytable values (:id, :val)" \
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
Für Windows:
```
aws rds-data batch-execute-statement --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--database "mydb" --secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--sql "insert into mytable values (:id, :val)" ^
--parameter-sets "[[{\"name\": \"id\", \"value\": {\"longValue\": 1}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueOne\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 2}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueTwo\"}}],
[{\"name\": \"id\", \"value\": {\"longValue\": 3}},{\"name\": \"val\", \"value\": {\"stringValue\": \"ValueThree\"}}]]"
```
**Anmerkung**
Verwenden Sie in der Option `--parameter-sets` keine Zeilenumbrüche.
## Übergeben einer SQL-Transaktion
Mit dem CLI-Befehl `aws rds-data commit-transaction` können Sie eine SQL-Transaktion beenden, die mit `aws rds-data begin-transaction` gestartet wurde, und die Änderungen übergeben.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgende Option an:
+ `--transaction-id` (erforderlich) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, die Sie beenden und übergeben möchten.
Der folgende CLI-Befehl beendet beispielsweise eine SQL-Transaktion und übergibt die Änderungen.
Für Linux, macOS oder Unix:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data commit-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionStatus": "Transaction Committed"
}
```
## Rollback einer SQL-Transaktion
Mit dem CLI-Befehl `aws rds-data rollback-transaction` können Sie einen Rollback für eine SQL-Transaktion ausführen, die mit `aws rds-data begin-transaction` gestartet wurde. Durch das Rollback einer Transaktion werden für sie ausgeführte Änderungen rückgängig gemacht.
**Wichtig**
Wenn die Transaktions-ID abgelaufen ist, wurde automatisch ein Rollback für die Transaktion ausgeführt. In diesem Fall gibt ein `aws rds-data rollback-transaction`-Befehl, der die abgelaufene Transaktions-ID angibt, einen Fehler zurück.
Geben Sie zusätzlich zu den allgemeinen Optionen die folgende Option an:
+ `--transaction-id` (erforderlich) – die ID einer Transaktion, die über den CLI-Befehl `begin-transaction` gestartet wurde. Geben Sie die Transaktions-ID der Transaktion an, für die Sie ein Rollback ausführen möchten.
Der folgende AWS CLI-Befehl führt beispielsweise einen Rollback für eine SQL-Transaktion aus.
Für Linux, macOS oder Unix:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" \
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" \
--transaction-id "ABC1234567890xyz"
```
Für Windows:
```
aws rds-data rollback-transaction --resource-arn "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster" ^
--secret-arn "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret" ^
--transaction-id "ABC1234567890xyz"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"transactionStatus": "Rollback Complete"
}
```
# Aufrufen der Daten-API von Amazon RDS aus einer Python-Anwendung
Sie können die Daten-API von Amazon RDS (Daten-API) aus einer Python-Anwendung aufrufen.
Die folgenden Beispiele verwenden das AWS SDK for Python (Boto). Weitere Informationen zu Boto finden Sie in der [AWS SDK for Python (Boto 3)-Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Topics**
+ [Ausführen einer SQL-Abfrage](#data-api.calling.python.run-query)
+ [Ausführen einer DML SQL-Anweisung](#data-api.calling.python.run-inert)
+ [Ausführen einer SQL-Transaktion](#data-api.calling.python.run-transaction)
## Ausführen einer SQL-Abfrage
Sie können eine `SELECT`-Anweisung ausführen und die Ergebnisse mit einer Python-Anwendung abrufen.
Im folgenden Beispiel wird eine SQL-Abfrage ausgeführt.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
response1 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'select * from employees limit 3')
print (response1['records'])
[
[
{
'longValue': 1
},
{
'stringValue': 'ROSALEZ'
},
{
'stringValue': 'ALEJANDRO'
},
{
'stringValue': '2016-02-15 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'DOE'
},
{
'stringValue': 'JANE'
},
{
'stringValue': '2014-05-09 04:34:33.0'
}
],
[
{
'longValue': 1
},
{
'stringValue': 'STILES'
},
{
'stringValue': 'JOHN'
},
{
'stringValue': '2017-09-20 04:34:33.0'
}
]
]
```
## Ausführen einer DML SQL-Anweisung
Sie können eine Data Manipulation Language (DML)-Anweisung ausführen, um in Ihrer Datenbank Daten einzufügen, zu aktualisieren oder zu löschen. Sie können in DML-Anweisungen auch Parameter verwenden.
**Wichtig**
Wenn ein Aufruf kein Teil einer Transaktion ist, da er den Parameter `transactionID` nicht enthält, werden Änderungen, die sich aus dem Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel werden eine SQL Insert-Anweisung ausgeführt und Parameter verwendet.
```
import boto3
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
rdsData = boto3.client('rds-data')
param1 = {'name':'firstname', 'value':{'stringValue': 'JACKSON'}}
param2 = {'name':'lastname', 'value':{'stringValue': 'MATEO'}}
paramSet = [param1, param2]
response2 = rdsData.execute_statement(resourceArn=cluster_arn,
secretArn=secret_arn,
database='mydb',
sql='insert into employees(first_name, last_name) VALUES(:firstname, :lastname)',
parameters = paramSet)
print (response2["numberOfRecordsUpdated"])
```
## Ausführen einer SQL-Transaktion
Sie können eine SQL-Transaktion starten, eine oder mehrere SQL-Anweisungen ausführen und anschließend die Änderungen mit einer Python-Anwendung übergeben.
**Wichtig**
Bei einer Transaktion kommt es zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, wird die Transaktion automatisch zurückgesetzt.
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine SQL-Transaktion ausgeführt, die eine Zeile in eine Tabelle einfügt.
```
import boto3
rdsData = boto3.client('rds-data')
cluster_arn = 'arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster'
secret_arn = 'arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret'
tr = rdsData.begin_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb')
response3 = rdsData.execute_statement(
resourceArn = cluster_arn,
secretArn = secret_arn,
database = 'mydb',
sql = 'insert into employees(first_name, last_name) values('XIULAN', 'WANG')',
transactionId = tr['transactionId'])
cr = rdsData.commit_transaction(
resourceArn = cluster_arn,
secretArn = secret_arn,
transactionId = tr['transactionId'])
cr['transactionStatus']
'Transaction Committed'
response3['numberOfRecordsUpdated']
1
```
**Anmerkung**
Wenn Sie eine DDL-Anweisung ausführen, sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, legen Sie den Parameter `continueAfterTimeout` auf `true` fest.
# Aufrufen der Daten-API von Amazon RDS aus einer Java-Anwendung
Sie können die Daten-API von Amazon RDS (Daten-API) aus einer Java-Anwendung aufrufen.
Die folgenden Beispiele verwenden das AWS SDK for Java. Weitere Informationen finden Sie im [AWS SDK für Java-Entwicklerhandbuch](https://docs.aws.amazon.com/sdk-for-java/latest/developer-guide/welcome.html).
Ersetzen Sie in jedem Beispiel den Amazon-Ressourcennamen (ARN) des DB-Clusters durch den ARN Ihres Aurora-DB-Clusters. Ersetzen Sie außerdem den geheimen ARN durch den ARN des geheimen Schlüssels in Secrets Manager, der den Zugriff auf den DB-Cluster ermöglicht.
**Topics**
+ [Ausführen einer SQL-Abfrage](#data-api.calling.java.run-query)
+ [Ausführen einer SQL-Transaktion](#data-api.calling.java.run-transaction)
+ [Ausführen einer Stapel-SQL-Operation](#data-api.calling.java.run-batch)
## Ausführen einer SQL-Abfrage
Sie können eine `SELECT`-Anweisung ausführen und die Ergebnisse mit einer Java-Anwendung abrufen.
Im folgenden Beispiel wird eine SQL-Abfrage ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementResult;
import com.amazonaws.services.rdsdata.model.Field;
import java.util.List;
public class FetchResultsExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
ExecuteStatementRequest request = new ExecuteStatementRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb")
.withSql("select * from mytable");
ExecuteStatementResult result = rdsData.executeStatement(request);
for (List fields: result.getRecords()) {
String stringValue = fields.get(0).getStringValue();
long numberValue = fields.get(1).getLongValue();
System.out.println(String.format("Fetched row: string = %s, number = %d", stringValue, numberValue));
}
}
}
```
## Ausführen einer SQL-Transaktion
Sie können eine SQL-Transaktion starten, eine oder mehrere SQL-Anweisungen ausführen und anschließend die Änderungen mit einer Java-Anwendung übergeben.
**Wichtig**
Bei einer Transaktion kommt es zu einer Zeitüberschreitung, wenn es innerhalb von drei Minuten keine Aufrufe gibt, die ihre Transaktions-ID verwenden. Wenn es zu einer Zeitüberschreitung kommt, bevor die Transaktion festgeschrieben wird, wird die Transaktion automatisch zurückgesetzt.
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine SQL-Transaktion ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BeginTransactionRequest;
import com.amazonaws.services.rdsdata.model.BeginTransactionResult;
import com.amazonaws.services.rdsdata.model.CommitTransactionRequest;
import com.amazonaws.services.rdsdata.model.ExecuteStatementRequest;
public class TransactionExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BeginTransactionRequest beginTransactionRequest = new BeginTransactionRequest()
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withDatabase("mydb");
BeginTransactionResult beginTransactionResult = rdsData.beginTransaction(beginTransactionRequest);
String transactionId = beginTransactionResult.getTransactionId();
ExecuteStatementRequest executeStatementRequest = new ExecuteStatementRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table VALUES ('hello world!')");
rdsData.executeStatement(executeStatementRequest);
CommitTransactionRequest commitTransactionRequest = new CommitTransactionRequest()
.withTransactionId(transactionId)
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN);
rdsData.commitTransaction(commitTransactionRequest);
}
}
```
**Anmerkung**
Wenn Sie eine DDL-Anweisung ausführen, sollten Sie die Anweisung auch nach Ablauf des Aufrufs weiter ausführen. Wenn eine DDL-Anweisung vor Ende der Ausführung beendet wird, kann dies zu Fehlern und möglicherweise beschädigten Datenstrukturen führen. Um eine Anweisung weiter auszuführen, nachdem ein Aufruf das für die RDS-Daten-API geltende Zeitintervall von 45 Sekunden überschritten hat, legen Sie den Parameter `continueAfterTimeout` auf `true` fest.
## Ausführen einer Stapel-SQL-Operation
Sie können mit einer Java-Anwendung Operationen für Masseneinfügungen und -aktualisierungen für ein Daten-Array ausführen. Sie können eine DML-Anweisung mit einem Array von Parametersätzen ausführen.
**Wichtig**
Wenn Sie keine Transaktions-ID angeben, werden Änderungen, die sich durch den Aufruf ergeben, automatisch übergeben.
Im folgenden Beispiel wird eine Batch-Einfügungs-Operation ausgeführt.
```
package com.amazonaws.rdsdata.examples;
import com.amazonaws.services.rdsdata.AWSRDSData;
import com.amazonaws.services.rdsdata.AWSRDSDataClient;
import com.amazonaws.services.rdsdata.model.BatchExecuteStatementRequest;
import com.amazonaws.services.rdsdata.model.Field;
import com.amazonaws.services.rdsdata.model.SqlParameter;
import java.util.Arrays;
public class BatchExecuteExample {
public static final String RESOURCE_ARN = "arn:aws:rds:us-east-1:123456789012:cluster:mydbcluster";
public static final String SECRET_ARN = "arn:aws:secretsmanager:us-east-1:123456789012:secret:mysecret";
public static void main(String[] args) {
AWSRDSData rdsData = AWSRDSDataClient.builder().build();
BatchExecuteStatementRequest request = new BatchExecuteStatementRequest()
.withDatabase("test")
.withResourceArn(RESOURCE_ARN)
.withSecretArn(SECRET_ARN)
.withSql("INSERT INTO test_table2 VALUES (:string, :number)")
.withParameterSets(Arrays.asList(
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("Hello")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(1L))
),
Arrays.asList(
new SqlParameter().withName("string").withValue(new Field().withStringValue("World")),
new SqlParameter().withName("number").withValue(new Field().withLongValue(2L))
)
));
rdsData.batchExecuteStatement(request);
}
}
```
# Steuern des Timeout-Verhaltens der Daten-API
Alle Aufrufe der Daten-API erfolgen synchron. Angenommen, Sie führen eine Daten-API-Operation durch, die eine SQL-Anweisung wie `INSERT` oder `CREATE TABLE` ausführt. Wenn der Daten-API-Aufruf erfolgreich Ergebnisse zurückgibt, ist die SQL-Verarbeitung abgeschlossen.
Standardmäßig bricht die Daten-API eine Operation ab und gibt einen Timeout-Fehler zurück, wenn sie nicht innerhalb von 45 Sekunden abgeschlossen wird. In diesem Fall werden die Daten nicht eingefügt, die Tabelle wird nicht erstellt usw.
Sie können die Daten-API verwenden, um lang andauernde Operationen auszuführen, die nicht innerhalb von 45 Sekunden abgeschlossen werden können. Wenn Sie davon ausgehen, dass ein Vorgang, z. B. eine Massen-`INSERT`- oder DDL-Operation an einer großen Tabelle, länger als 45 Sekunden dauert, können Sie für die Operation `ExecuteStatement` den Parameter `continueAfterTimeout` angeben. Ihre Anwendung erhält weiterhin den Timeout-Fehler. Die Operation wird jedoch weiter ausgeführt und nicht abgebrochen. Ein Beispiel finden Sie unter [Ausführen einer SQL-Transaktion](data-api.calling.java.md#data-api.calling.java.run-transaction).
Wenn das AWS SDK für Ihre Programmiersprache über einen eigenen Timeout-Zeitraum für API-Aufrufe oder HTTP-Socket-Verbindungen verfügt, stellen Sie sicher, dass alle diese Timeout-Zeiträume mehr als 45 Sekunden betragen. Bei einigen SDKs beträgt der Timeout-Zeitraum standardmäßig weniger als 45 Sekunden. Wir empfehlen, alle SDK-spezifischen oder Client-spezifischen Timeout-Zeiträume auf mindestens eine Minute festzulegen. Dadurch wird die Möglichkeit vermieden, dass Ihre Anwendung einen Timeout-Fehler erhält, während der Daten-API-Vorgang noch erfolgreich abgeschlossen wird. Auf diese Weise können Sie sicher sein, ob Sie den Vorgang wiederholen sollten oder nicht.
Nehmen wir beispielsweise an, dass das SDK einen Timeout-Fehler an Ihre Anwendung zurückgibt, die Daten-API-Operation aber trotzdem innerhalb des Daten-API-Timeout-Intervalls abgeschlossen wird. In diesem Fall könnte ein erneuter Ausführungsversuch der Operation Datenduplikate verursachen oder auf andere Weise zu falschen Ergebnissen führen. Das SDK wiederholt die Operation möglicherweise automatisch, wodurch falsche Daten entstehen, ohne dass Ihre Anwendung etwas unternommen hat.
Das Timeout-Intervall ist besonders wichtig für das Java-2-SDK. In diesem SDK betragen das API-Aufruf-Timeout und das HTTP-Socket-Timeout standardmäßig beide 30 Sekunden. In diesem Beispiel wird für das Timeout ein höherer Wert festgelegt:
```
public RdsDataClient createRdsDataClient() {
return RdsDataClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.httpClientBuilder(createHttpClientBuilder())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return ApacheHttpClient.builder() // Change this to your desired HttpClient
.socketTimeout(Duration.ofSeconds(60));
}
```
In diesem äquivalenten Beispiel wird der asynchrone Daten-Client verwendet:
```
public static RdsDataAsyncClient createRdsDataAsyncClient() {
return RdsDataAsyncClient.builder()
.region(Region.US_EAST_1) // Change this to your desired Region
.overrideConfiguration(createOverrideConfiguration())
.credentialsProvider(defaultCredentialsProvider()) // Change this to your desired credentials provider
.build();
}
private static ClientOverrideConfiguration createOverrideConfiguration() {
return ClientOverrideConfiguration.builder()
.apiCallAttemptTimeout(Duration.ofSeconds(60))
.build();
}
private HttpClientBuilder createHttpClientBuilder() {
return NettyNioAsyncHttpClient.builder() // Change this to your desired AsyncHttpClient
.readTimeout(Duration.ofSeconds(60));
}
```