Amazon Redshift unterstützt die Verwendung von Python-UDFs nach dem 30. Juni 2026 nicht mehr. Wir werden damit beginnen, es schrittweise durchzusetzen. Weitere Informationen zum Ende der Lebensdauer von Python und zu den Migrationsoptionen finden Sie im [ Blogbeitrag](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/), der am 30. Juni 2025 veröffentlicht wurde.
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.
# Übergeben von SQL-Anweisungen an ein Amazon Redshift Data Warehouse
Die Beispiele auf dieser Seite zeigen verschiedene Möglichkeiten, eine SQL-Anweisung an Ihr Data Warehouse zu übergeben
## Ausführen einer SQL-Anweisung
Verwenden Sie den `aws redshift-data execute-statement` AWS CLI Befehl, um eine SQL-Anweisung auszuführen.
Verwenden Sie den `WaitTimeSeconds` Parameter optional, um zusätzliche Zeit für den Abschluss der Anweisung einzuplanen, bevor die API eine Antwort zurückgibt. Wenn die Anweisung abgeschlossen ist, enthält die Antwort auch `Status``RedshiftPid`, und`HasResultSet`. Weitere Informationen finden Sie unter [Reduzieren Sie API-Aufrufe durch lange Abfragen](data-api-calling-considerations-long-polling.md).
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel wird die AWS Secrets Manager -Authentifizierungsmethode verwendet.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für eine serverlose Arbeitsgruppe aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel werden die Authentifizierungsmethode von AWS Secrets Manager und ein Idempotenz-Token verwendet.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
## Ausführen mehrerer SQL-Anweisungen
Verwenden Sie den Befehl, um mehrere SQL-Anweisungen mit einem `aws redshift-data batch-execute-statement` AWS CLI Befehl auszuführen.
Verwenden Sie den `WaitTimeSeconds` Parameter optional, um zusätzliche Zeit für die Fertigstellung des gesamten Batches einzuplanen, bevor die API eine Antwort zurückgibt. Weitere Informationen finden Sie unter [Reduzieren Sie API-Aufrufe durch lange Abfragen](data-api-calling-considerations-long-polling.md).
Der folgende AWS CLI Befehl führt drei SQL-Anweisungen für einen Cluster aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "set timezone to BST" "select * from mytable" "select * from another_table"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
Mit dem folgenden AWS CLI Befehl werden drei SQL-Anweisungen in separaten Transaktionen im `AUTO_COMMIT` Ausführungsmodus ausgeführt. Jede Anweisung wird unabhängig ausgeführt — ein Ausfall einer Anweisung verhindert nicht, dass die verbleibenden Anweisungen ausgeführt werden, und wirkt sich auch nicht auf bereits abgeschlossene Anweisungen aus.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "insert into mytable values (1)" "invalid sql statement" "insert into mytable values (3)"
--execution-mode AUTO_COMMIT
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": false,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"Status": "FAILED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": false,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "insert into mytable values (1)",
"RedshiftQueryId": -1,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 1195240,
"HasResultSet": false,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "invalid sql statement",
"RedshiftQueryId": -1,
"Error": "ERROR: syntax error at or near \"invalid\"",
"Status": "FAILED",
"UpdatedAt": 1623979777.503
},
{
"CreatedAt": 1623979777.274,
"Duration": 1095981,
"HasResultSet": false,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:3",
"QueryString": "insert into mytable values (3)",
"RedshiftQueryId": -1,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
}
],
"UpdatedAt": 1623979778.183
}
```
## Anweisungen mit Parametern ausführen
Sie können benannte Parameter sowohl für die Operationen als auch für `execute-statement` die `batch-execute-statement` Operationen verwenden. Bei Verwendung `batch-execute-statement` werden Parameter von allen SQL-Anweisungen im Batch gemeinsam genutzt. Jede SQL-Anweisung kann auf eine Teilmenge der bereitgestellten Parameter verweisen, aber jeder Parameter muss von mindestens einer SQL-Anweisung verwendet werden.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zurück, um die Ergebnisse abzurufen. In diesem Beispiel wird die AWS Secrets Manager -Authentifizierungsmethode verwendet. Der SQL-Text weist den benannten Parameter `distance` auf. In diesem Fall lautet die im Prädikat verwendete Entfernung `5`. In einer SELECT-Anweisung können benannte Parameter für Spaltennamen nur im Prädikat verwendet werden. Die Werte für benannte Parameter für die SQL-Anweisung werden in der Option `parameters` angegeben.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "SELECT ratecode FROM demo_table WHERE trip_distance > :distance"
--parameters "[{\"name\": \"distance\", \"value\": \"5\"}]"
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Im folgenden Beispiel wird die `EVENT`-Tabelle aus der Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [EVENT-Tabelle](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Wenn Ihre Datenbank noch nicht die `EVENT`-Tabelle enthält, können Sie mit der Data API eine wie folgt erstellen:
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "create table event( eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp)"
```
Mit dem folgenden Befehl wird eine Zeile in der `EVENT`-Tabelle eingefügt.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:eventid, :venueid::smallint, :catid, :dateid, :eventname, :starttime)"
--parameters "[{\"name\": \"eventid\", \"value\": \"1\"}, {\"name\": \"venueid\", \"value\": \"1\"},
{\"name\": \"catid\", \"value\": \"1\"},
{\"name\": \"dateid\", \"value\": \"1\"},
{\"name\": \"eventname\", \"value\": \"event 1\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"}]"
```
Mit dem folgenden Befehl wird eine zweite Zeile in der `EVENT`-Tabelle eingefügt. In diesem Beispiel werden die folgenden Aufgaben durchgeführt:
+ Der Parameter namens `id` wird viermal im SQL-Text verwendet.
+ Implizite Typumwandlung wird automatisch angewendet, wenn der Parameter eingefügt wird `starttime`.
+ Für die Spalte `venueid` wird die Typumwandlung in den SMALLINT-Datentyp durchgeführt.
+ Zeichenfolgen, die den Datentyp DATE darstellen, werden implizit in den Datentyp TIMESTAMP konvertiert.
+ Kommentare können in SQL-Text verwendet werden.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:id, :id::smallint, :id, :id, :eventname, :starttime) /*this is comment, and it won't apply parameterization for :id, :eventname or :starttime here*/"
--parameters "[{\"name\": \"eventname\", \"value\": \"event 2\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"},
{\"name\": \"id\", \"value\": \"2\"}]"
```
Hier sehen Sie die beiden eingefügten Zeilen:
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+-----------+---------------------
1 | 1 | 1 | 1 | event 1 | 2022-02-22 00:00:00
2 | 2 | 2 | 2 | event 2 | 2022-02-22 00:00:00
```
Der folgende Befehl verwendet einen benannten Parameter in einer WHERE-Klausel, um die Zeile abzurufen, in der `eventid` `1` ist.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "select * from event where eventid=:id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"}]"
```
Führen Sie den folgenden Befehl aus, um die SQL-Ergebnisse der vorherigen SQL-Anweisung abzurufen:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Bietet folgende Ergebnisse:
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"stringValue": "event 1"
},
{
"stringValue": "2022-02-22 00:00:00.0"
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "eventid",
"length": 0,
"name": "eventid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "venueid",
"length": 0,
"name": "venueid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "catid",
"length": 0,
"name": "catid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "dateid",
"length": 0,
"name": "dateid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "eventname",
"length": 0,
"name": "eventname",
"nullable": 1,
"precision": 200,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "varchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 1,
"precision": 29,
"scale": 6,
"schemaName": "public",
"tableName": "event",
"typeName": "timestamp"
}
],
"TotalNumRows": 1
}
```
Mit dem folgenden AWS CLI Befehl werden zwei SQL-Anweisungen mit gemeinsam genutzten benannten Parametern für einen Cluster ausgeführt. `batch-execute-statement` Der SQL-Text weist die benannten Parameter `id` und `name` auf. Die erste SQL-Anweisung verwendet den `id` Parameter und die zweite verwendet den `name` Parameter.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "SELECT * FROM mytable WHERE id = :id" "SELECT * FROM mytable WHERE name = :name"
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"name\", \"value\": \"Alice\"}]"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
Mit dem folgenden AWS CLI Befehl werden zwei SQL-Anweisungen ausgeführt, wobei in beiden Anweisungen derselbe Parameter verwendet wird. Der angegebene Parameter `id` wird in einer INSERT-Anweisung und einer SELECT-Anweisung verwendet.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "INSERT INTO mytable VALUES(:id, :name, :address)" "SELECT * FROM mytable WHERE id = :id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"},{\"name\": \"name\", \"value\": \"Alice\"},{\"name\": \"address\", \"value\": \"Seattle\"}]"
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```