Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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
Sie können die Daten-API oder die aufrufen AWS CLI , um SQL-Anweisungen auf Ihrem Cluster oder Ihrer serverlosen Arbeitsgruppe auszuführen. Die primären Operationen zum Ausführen von SQL-Anweisungen sind [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) und [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) in der *Amazon-Redshift-Daten-API-Referenz*. Die Daten-API unterstützt die Programmiersprachen, die AWS vom SDK unterstützt werden. Weitere Informationen finden Sie unter [Tools für AWS](https://aws.amazon.com/tools/).
Codebeispiele für den Aufruf der Daten-API finden Sie unter [Erste Schritte mit der Redshift Data API](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) in *GitHub*. Dieses Repository enthält Beispiele für AWS Lambda den Zugriff auf Amazon Redshift Redshift-Daten aus Amazon EC2 und Amazon AWS Glue Data Catalog SageMaker Runtime. Beispiele für Programmiersprachen sind Python, Go, Java und Javascript.
Sie können die Daten-API über die aufrufe AWS CLI.
In den folgenden Beispielen wird die AWS CLI zum Aufrufen der Daten-API verwendet. Um die Beispiele auszuführen, bearbeiten Sie die Parameterwerte entsprechend Ihrer Umgebung. In vielen Beispielen wird eine `cluster-identifier` gegeben, die gegen einen Cluster ausgeführt wird. Wenn Sie mit einer Serverless-Arbeitsgruppe arbeiten, geben Sie stattdessen einen `workgroup-name` an. Diese Beispiele veranschaulichen einige der Data-API-Vorgänge. Weitere Informationen finden Sie in der *AWS CLI -Befehlsreferenz*.
Die Befehle in den folgenden Beispielen wurden zur besseren Lesbarkeit aufgeteilt und formatiert. Nicht alle Parameter und Antworten werden in allen Beispielen gezeigt. Die API-Definition der vollständigen Anforderungssyntax, der Anforderungsparameter, der Antwortsyntax und der Antwortelemente finden Sie in der [Amazon Redshift Data API Reference](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Ü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.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. 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 zum Abrufen der Ergebnisse zurück. 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 zum Abrufen der Ergebnisse zurück. 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 zum Abrufen der Ergebnisse zurück. 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 einer SQL-Anweisung mit Parametern
Verwenden Sie den `aws redshift-data execute-statement` AWS CLI Befehl, um eine SQL-Anweisung auszuführen.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. 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
}
```
## Ausführen mehrerer SQL-Anweisungen
Um mehrere SQL-Anweisungen mit einem Befehl auszuführen, verwenden Sie den `aws redshift-data batch-execute-statement` AWS CLI Befehl.
Der folgende AWS CLI Befehl führt drei SQL-Anweisungen für einen Cluster aus und gibt einen Bezeichner zum Abrufen der Ergebnisse zurück. 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"
}
```
# Auflisten von Metadaten über SQL-Anweisungen
Verwenden Sie den `aws redshift-data list-statements` AWS CLI Befehl, um Metadaten zu SQL-Anweisungen aufzulisten. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Der folgende AWS CLI Befehl listet die ausgeführten SQL-Anweisungen auf.
```
aws redshift-data list-statements
--status ALL
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Statements": [
{
"CreatedAt": 1598306924.632,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
},
{
"CreatedAt": 1598311717.437,
"Id": "e0ebd578-58b3-46cc-8e52-8163fd7e01aa",
"QueryString": "select * from stl_query limit 1",
"Status": "FAILED",
"UpdatedAt": 1598311719.008
},
{
"CreatedAt": 1598313683.65,
"Id": "c361d4f7-8c53-4343-8c45-6b2b1166330c",
"QueryString": "select * from stl_query limit 1",
"Status": "ABORTED",
"UpdatedAt": 1598313685.495
},
{
"CreatedAt": 1598306653.333,
"Id": "a512b7bd-98c7-45d5-985b-a715f3cfde7f",
"QueryString": "select 1",
"Status": "FINISHED",
"UpdatedAt": 1598306653.992
}
]
}
```
# Beschreiben von Metadaten über eine SQL-Anweisung
Verwenden Sie den Befehl, um Beschreibungen der Metadaten für eine SQL-Anweisung `aws redshift-data describe-statement` AWS CLI abzurufen. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Der folgende AWS CLI Befehl beschreibt eine SQL-Anweisung.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Duration": 1095981511,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"RedshiftPid": 20859,
"RedshiftQueryId": 48879,
"ResultRows": 1,
"ResultSize": 4489,
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
}
```
Es folgt ein Beispiel für eine `describe-statement`-Antwort nach dem Ausführen eines `batch-execute-statement`-Befehls mit mehreren SQL-Anweisungen.
```
{
"ClusterIdentifier": "mayo",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"ResultRows": 2,
"ResultSize": 22,
"Status": "FINISHED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "select 1;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 3195240,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "select 2;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979778.076
}
],
"UpdatedAt": 1623979778.183
}
```
# Abrufen der Ergebnisse einer SQL-Anweisung
Verwenden Sie den `redshift-data get-statement-result-v2` AWS CLI Befehl `redshift-data get-statement-result` or, um das Ergebnis einer ausgeführten SQL-Anweisung abzurufen. Die Ergebnisse von `get-statement-result` liegen im JSON-Format vor. Die Ergebnisse von `get-statement-result-v2` liegen im CSV-Format vor. Sie können eine `Id` angeben, die Sie als Antwort auf `execute-statement` oder `batch-execute-statement` erhalten. Der `Id`-Wert für eine SQL-Anweisung, die von `batch-execute-statement` ausgeführt wurde, kann im Ergebnis von `describe-statement` abgerufen werden und erhält einen Doppelpunkt und eine Sequenznummer wie `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2` als Suffix. Wenn Sie mehrere SQL-Anweisungen mit `batch-execute-statement` ausführen, hat jede SQL-Anweisung einen `Id`-Wert wie in `describe-statement` gezeigt. Die Autorisierung zum Ausführen dieses Befehls basiert auf den IAM-Berechtigungen des Aufrufers.
Die folgende Anweisung gibt das Ergebnis einer SQL-Anweisung zurück, die von `execute-statement` ausgeführt wurde und bei der `ResultFormat` standardmäßig auf `JSON` gesetzt wurde. Rufen Sie die Operation `get-statement-result` auf, um die Ergebnisse abzurufen.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Die folgende Anweisung gibt das Ergebnis einer zweiten SQL-Anweisung zurück, die von ausgeführt wurde `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result`. Das SQL-Ergebnis wird hier im JSON-Format im `Records`-Schlüssel der Antwort zurückgegeben.
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "userid",
"length": 0,
"name": "userid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "query",
"length": 0,
"name": "query",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "label",
"length": 0,
"name": "label",
"nullable": 0,
"precision": 320,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "xid",
"length": 0,
"name": "xid",
"nullable": 0,
"precision": 19,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int8"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "pid",
"length": 0,
"name": "pid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "database",
"length": 0,
"name": "database",
"nullable": 0,
"precision": 32,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "querytxt",
"length": 0,
"name": "querytxt",
"nullable": 0,
"precision": 4000,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "endtime",
"length": 0,
"name": "endtime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"type": 93,
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "aborted",
"length": 0,
"name": "aborted",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "insert_pristine",
"length": 0,
"name": "insert_pristine",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "concurrency_scaling_status",
"length": 0,
"name": "concurrency_scaling_status",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
}
],
"Records": [
[
{
"longValue": 1
},
{
"longValue": 3
},
{
"stringValue": "health"
},
{
"longValue": 1023
},
{
"longValue": 15279
},
{
"stringValue": "dev"
},
{
"stringValue": "select system_status from stv_gui_status;"
},
{
"stringValue": "2020-08-21 17:33:51.88712"
},
{
"stringValue": "2020-08-21 17:33:52.974306"
},
{
"longValue": 0
},
{
"longValue": 0
},
{
"longValue": 6
}
]
],
"TotalNumRows": 1
}
```
Das folgende Beispiel zeigt eine SQL-Anweisung, die von `execute-statement` ausgeführt wird, um Ergebnisse im JSON-Format zurückzugeben. Die Tabelle `testingtable` enthält drei Ganzzahlspalten (col1, col2, col3) und es gibt drei Zeilen mit Werten (1, 2, 3), (4, 5, 6) und (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format JSON
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result`. Das SQL-Ergebnis wird hier im JSON-Format im `Records`-Schlüssel der Antwort zurückgegeben.
```
aws redshift-data get-statement-result
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 2
},
{
"longValue": 3
}
],
[
{
"longValue": 4
},
{
"longValue": 5
},
{
"longValue": 6
}
],
[
{
"longValue": 7
},
{
"longValue": 8
},
{
"longValue": 9
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3
}
```
Das folgende Beispiel zeigt eine SQL-Anweisung, die von `execute-statement` ausgeführt wird, um Ergebnisse im CSV-Format zurückzugeben. Die Tabelle `testingtable` enthält drei Ganzzahlspalten (col1, col2, col3) und es gibt drei Zeilen mit Werten (1, 2, 3), (4, 5, 6) und (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format CSV
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Im Folgenden sehen Sie ein Beispiel für die Antwort auf einen Aufruf an `get-statement-result-v2`. Das SQL-Ergebnis wird hier im CSV-Format im `Records`-Schlüssel der Antwort zurückgegeben. Zeilen werden durch Wagenrücklauf und Zeilenvorschub (\$1r\$1n) getrennt. Die erste Zeile, die in `Records` zurückgegeben wird, sind die Spaltenüberschriften. Die Ergebnisse im CSV-Format werden in 1-MB-Blöcken zurückgegeben, wobei in jedem Block eine beliebige Anzahl von Zeilen bis zu 1 MB gespeichert werden kann.
```
aws redshift-data get-statement-result-v2
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
{
"CSVRecords": "col1,col2,col3\r\n1,2,3\r\n4,5,6\r\n7,8,9\r\n"
}
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3,
"ResultFormat": "csv"
}
```
# Beschreiben einer Tabelle
Verwenden Sie den `aws redshift-data describe-table` AWS CLI Befehl, um Metadaten abzurufen, die eine Tabelle beschreiben.
Der folgende AWS CLI Befehl führt eine SQL-Anweisung für einen Cluster aus und gibt Metadaten zurück, die eine Tabelle beschreiben. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data describe-table
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, der eine Tabelle beschreibt. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_supported",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_verified_by",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "comments",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
# Auflisten von Datenbanken in einem Cluster
Verwenden Sie den `aws redshift-data list-databases` AWS CLI Befehl, um die Datenbanken in einem Cluster aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Datenbanken aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Databases": [
"dev"
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Datenbanken aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Databases": [
"dev"
]
}
```
# Auflisten von Schemata in einer Datenbank
Verwenden Sie den `aws redshift-data list-schemas` AWS CLI Befehl, um die Schemas in einer Datenbank aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Schemas in einer Datenbank aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Schemas in einer Datenbank aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Auflisten von Tabellen in einer Datenbank
Verwenden Sie den `aws redshift-data list-tables` AWS CLI Befehl, um die Tabellen in einer Datenbank aufzulisten.
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Tabellen in einer Datenbank aufzulisten. In diesem Beispiel wird die AWS Secrets Manager Authentifizierungsmethode verwendet.
```
aws redshift-data list-tables
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
Mit dem folgenden AWS CLI Befehl wird eine SQL-Anweisung für einen Cluster ausgeführt, um Tabellen in einer Datenbank aufzulisten. In diesem Beispiel wird die Authentifizierungsmethode mit temporären Anmeldeinformationen verwendet.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Im Folgenden sehen Sie ein Beispiel für die Antwort.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```