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.
# Ausführen von Befehlen, um eine Datenbank in Ihrem Data Warehouse zu definieren und zu verwenden
Sowohl Data Warehouses von Redshift Serverless als auch von Amazon Redshift bereitgestellte Data Warehouses enthalten Datenbanken. Nachdem Sie Ihr Data Warehouse gestartet haben, können Sie die meisten Datenbankaktionen mithilfe von SQL-Befehlen verwalten. Mit wenigen Ausnahmen sind Funktionalität und Syntax von SQL für alle Amazon-Redshift-Datenbanken identisch. Einzelheiten zu den in Amazon Redshift verfügbaren SQL-Befehlen finden Sie unter [SQL-Befehle](https://docs.aws.amazon.com/redshift/latest/dg/c_SQL_commands.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Wenn Sie Ihr Data Warehouse erstellen, erstellt Amazon Redshift in den meisten Szenarien auch die `dev`-Standarddatenbank. Nachdem Sie eine Verbindung mit der anfänglichen `dev`-Datenbank hergestellt haben, können Sie eine weitere Datenbank erstellten.
In den folgenden Abschnitten werden allgemeine Datenbankaufgaben bei der Arbeit mit Amazon-Redshift-Datenbanken beschrieben. Die Aufgaben beginnen mit dem Erstellen einer Datenbank. Wenn Sie mit der letzten Aufgabe fortfahren, können Sie alle von Ihnen erstellten Ressourcen löschen, indem Sie die Datenbank löschen.
Die Beispiele in diesem Abschnitt setzen Folgendes voraus:
+ Sie haben ein Data Warehouse von Amazon Redshift erstellt.
+ Sie haben von Ihrem SQL-Client-Tool wie dem Amazon Redshift Query Editor v2 eine Verbindung mit dem Data Warehouse hergestellt. Weitere Informationen zur Arbeit mit Query Editor v2 finden Sie unter [Abfragen einer Datenbank mit Amazon Redshift Query Editor v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) im *Managementleitfaden zu Amazon Redshift*.
**Topics**
+ [Herstellen einer Verbindung mit einem Data Warehouse von Amazon Redshift](#connection)
+ [Erstellen einer -Datenbank](t_creating_database.md)
+ [Erstellen eines Benutzers](t_adding_redshift_user_cmd.md)
+ [Erstellen eines Schemas](t_creating_schema.md)
+ [Erstellen einer Tabelle](t_creating_table.md)
+ [Laden von Daten](cm-dev-t-load-sample-data.md)
+ [Abfragen der Systemtabellen und Ansichten](t_querying_redshift_system_tables.md)
+ [Abbrechen einer Abfrage](cancel_query.md)
## Herstellen einer Verbindung mit einem Data Warehouse von Amazon Redshift
Um eine Verbindung mit Amazon-Redshift-Clustern herzustellen, erweitern Sie auf der Seite **Cluster** **Verbindung zu Amazon-Redshift-Clustern** und gehen dann folgendermaßen vor:
+ Verwenden Sie **Daten abfragen**, um in Query Editor v2 Abfragen für Datenbanken auszuführen, die von Ihrem Amazon-Redshift-Cluster gehostet werden. Nachdem Sie Ihren Cluster erstellt haben, können Sie mit dem Abfrageeditor v2 sofort Abfragen ausführen.
Weitere Informationen finden Sie unter [Abfragen einer Datenbank mit Amazon Redshift Query Editor v2](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html) im *Managementleitfaden zu Amazon Redshift*.
+ Wählen Sie unter **Arbeiten mit Ihren Client-Tools** Ihren Cluster, und stellen Sie mithilfe von JDBC- oder ODBC-Treibern eine Verbindung von Ihren Client-Tools zu Amazon Redshift her, indem Sie die URL des JDBC- oder ODBC-Treibers kopieren. Verwenden Sie diese URL von Ihrem Client-Computer oder Ihrer Instance aus. Schreiben Sie Ihre Anwendungen so, dass sie JDBC- oder ODBC-API-Operationen für den Zugriff auf Daten nutzen, oder verwenden Sie SQL-Client-Tools, die JDBC oder ODBC unterstützen.
Weitere Informationen darüber, wie Sie Ihre Cluster-Verbindungszeichenfolge finden, erhalten Sie unter [Suche der Zeichenfolge für die Verbindung mit dem Cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/configuring-connections.html#connecting-drivers.html).
+ Wenn Ihr SQL-Client-Tool einen Treiber benötigt, können Sie unter **Auswahl Ihres JDBC- oder ODBC-Treibers** einen betriebssystemspezifischen Treiber herunterladen, um sich von Ihren Client-Tools aus mit Amazon Redshift zu verbinden.
Weitere Informationen zur Installation des entsprechenden Treibers für Ihren SQL-Client finden Sie unter [Konfiguration einer JDBC-Treiberverbindung der Version 2.2](https://docs.aws.amazon.com/redshift/latest/mgmt/jdbc20-install.html).
Weitere Informationen zum Konfigurieren einer ODBC-Verbindung finden Sie unter [Konfigurierung einer ODBC-Verbindung](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-odbc-connection.html).
Gehen Sie auf der Seite **Serverless-Dashboard** der Amazon-Redshift-Konsole wie folgt vor, um eine Verbindung zum Data Warehouse von Redshift Serverless herzustellen:
+ Verwenden Sie Amazon Redshift Query Editor V2, um Abfragen für Datenbanken auszuführen, die von Ihrem Data Warehouse von Amazon Redshift Serverless gehostet werden. Nachdem Sie Ihr Data Warehouse erstellt haben, können Sie sofort mit Query Editor v2 Abfragen ausführen.
Weitere Informationen finden Sie unter [Abfragen einer Datenbank mit dem Abfrage-Editor v2 von Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2.html).
+ Stellen Sie mithilfe von JDBC- oder ODBC-Treibern eine Verbindung von Ihren Client-Tools zu Amazon Redshift her, indem Sie die URL des JDBC- oder ODBC-Treibers kopieren.
Um mit Daten in Ihrem Data Warehouse zu arbeiten, benötigen Sie JDBC- oder ODBC-Treiber, um Verbindungen von Ihrem Client-Computer oder Ihrer Instance aus herzustellen. Schreiben Sie Ihre Anwendungen so, dass sie JDBC- oder ODBC-API-Operationen für den Zugriff auf Daten nutzen, oder verwenden Sie SQL-Client-Tools, die JDBC oder ODBC unterstützen.
Weitere Informationen zum Auffinden Ihrer Verbindungszeichenfolge finden Sie unter [Verbindung zu Redshift Serverless](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-connecting) im *Managementleitfaden zu Amazon Redshift*.
# Erstellen einer -Datenbank
Nachdem Sie geprüft haben, ob Ihr Data Warehouse ausgeführt wird, können Sie eine Datenbank erstellen. In dieser Datenbank erstellen Sie Tabellen, laden Daten und führen Abfragen aus. Ein Data Warehouse kann mehrere Datenbanken hosten. Sie können beispielsweise eine Datenbank für Vertriebsdaten mit dem Namen `SALESDB` und eine Datenbank für Auftragsdaten mit dem Namen `ORDERSDB` in demselben Data Warehouse haben.
Um eine Datenbank mit dem Namen **SALESDB** zu erstellen, führen Sie den folgenden Befehl in Ihrem SQL-Client-Tool aus:
```
CREATE DATABASE salesdb;
```
**Anmerkung**
Stellen Sie nach der Ausführung des Befehls sicher, dass Sie die Liste der Objekte in Ihrem Data Warehouse in Ihrem SQL-Client-Tool aktualisieren, um die neuen `salesdb` zu sehen.
Für diese Übung übernehmen wir die Standardeinstellungen. Weitere Informationen über Befehlsoptionen finden Sie unter [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE) im *Datenbankentwicklerhandbuch zu Amazon Redshift*. Informationen zum Löschen einer Datenbank und ihres Inhalts finden Sie unter [DROP DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_DROP_DATABASE) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Nachdem Sie die SALESDB-Datenbank erstellt haben, können Sie von Ihrem SQL-Client aus eine Verbindung zu der neuen Datenbank herstellen. Verwenden Sie dieselben Verbindungsparameter wie für Ihre aktuelle Verbindung, ändern Sie aber den Namen der Datenbank in `SALESDB`.
# Erstellen eines Benutzers
Standardmäßig kann nur der Administratorbenutzer, den Sie beim Start des Data Warehouse eingerichtet haben, auf die Standarddatenbank in diesem Data Warehouse zugreifen. Um anderen Benutzern den Zugriff zu gewähren, erstellen Sie ein oder mehrere Benutzerkonten. Datenbankbenutzerkonten gelten global für alle Datenbanken in einem Data Warehouse und gehören nicht zu einzelnen Datenbanken.
Verwenden Sie den Befehl CREATE USER, um einen neuen Benutzer zu erstellen. Wenn Sie einen neuen Benutzer erstellen, geben Sie dessen Namen und ein Passwort an. Es wird empfohlen, dass Sie ein Passwort für den Benutzer angeben. Dies muss aus 8–64 Zeichen bestehen und mindestens einen Großbuchstaben, einen Kleinbuchstaben und eine Ziffer enthalten.
Führen Sie beispielsweise zur Erstellung eines Benutzers mit dem Namen **GUEST** und dem Passwort **ABCd4321** den folgenden Befehl aus:
```
CREATE USER GUEST PASSWORD 'ABCd4321';
```
Um eine Verbindung mit der `SALESDB`-Datenbank als der `GUEST`-Benutzer herzustellen, verwenden Sie das Passwort, das Sie bei der Benutzererstellung gewählt haben, zum Beispiel `ABCd4321`.
Informationen über weitere Befehlsoptionen finden Sie unter [CREATE USER](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_USER.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
# Erstellen eines Schemas
Nach dem Erstellen einer neuen Datenbank können Sie ein neues Schema in der aktuellen Datenbank erstellen. Ein *Schema* ist ein Namespace, der benannte Datenbankobjekte wie Tabellen, Ansichten und benutzerdefinierte Funktionen () enthält. UDFs Eine Datenbank kann ein oder mehrere Schemata enthalten, und jedes Schema gehört nur zu einer Datenbank. Zwei Schemata können verschiedene Objekte mit demselben Namen haben.
Sie können mehrere Schemata in derselben Datenbank erstellen, um Daten so zu organisieren, wie Sie möchten, oder um Ihre Daten funktional zu gruppieren. Sie können beispielsweise ein Schema erstellen, um alle Staging-Daten zu speichern, und ein anderes Schema zum Speichern aller Berichtstabellen. Sie können auch verschiedene Schemata erstellen, um Daten zu speichern, die für verschiedene Unternehmensgruppen relevant sind, die sich in derselben Datenbank befinden. Jedes Schema kann unterschiedliche Datenbankobjekte wie Tabellen, Ansichten und benutzerdefinierte Funktionen () speichern. UDFs Darüber hinaus können Sie Schemata mit der AUTHORIZATION-Klausel erstellen. Diese Klausel gewährt einem bestimmten angegebenen Benutzer Besitz oder legt ein Kontingent für den maximalen Speicherplatz fest, den das angegebene Schema verwenden kann.
Amazon Redshift erstellt automatisch ein Schema namens `public` für jede neue Datenbank. Wenn Sie den Schemanamen beim Erstellen von Datenbankobjekten nicht angeben, gehen die Objekte in das `public`-Schema über.
Um auf ein Objekt in einem Schema zuzugreifen, qualifizieren Sie das Objekt mithilfe der `schema_name.table_name`-Notation. Der qualifizierte Name des Schemas besteht aus dem Schemanamen und dem Tabellennamen, die durch einen Punkt getrennt sind. Zum Beispiel kann ein `sales`-Schema eine `price`-Tabelle und ein `inventory`-Schema eine `price`-Tabelle haben. Wenn Sie die `price`-Tabelle referenzieren, müssen Sie sie als `sales.price` oder `inventory.price` qualifizieren.
Im folgenden Beispiel wird ein Schema mit dem Namen **SALES** für den Benutzer `GUEST` erstellt.
```
CREATE SCHEMA SALES AUTHORIZATION GUEST;
```
Weitere Informationen über Befehlsoptionen finden Sie unter [CREATE SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_SCHEMA.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Führen Sie den folgenden Befehl aus, um die Liste der Schemata in Ihrer Datenbank anzuzeigen.
```
select * from pg_namespace;
```
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
nspname | nspowner | nspacl
----------------------+----------+--------------------------
sales | 100 |
pg_toast | 1 |
pg_internal | 1 |
catalog_history | 1 |
pg_temp_1 | 1 |
pg_catalog | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
public | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
information_schema | 1 | {rdsdb=UC/rdsdb,=U/rdsdb}
```
Weitere Informationen zum Abfragen von Katalogtabellen finden Sie unter [Abfragen der Katalogtabellen](https://docs.aws.amazon.com/redshift/latest/dg/c_join_PG.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Verwenden Sie die GRANT-Anweisung, um Benutzern Berechtigungen für die Schemata zu erteilen.
Im folgenden Beispiel werden dem Benutzer `GUEST` Berechtigungen gewährt, um Daten aus allen Tabellen oder Ansichten im Schema `SALES` mit einer SELECT-Anweisung auszuwählen.
```
GRANT SELECT ON ALL TABLES IN SCHEMA SALES TO GUEST;
```
Im folgenden Beispiel werden dem Benutzer `GUEST` alle verfügbaren Rechte auf einmal gewährt.
```
GRANT ALL ON SCHEMA SALES TO GUEST;
```
# Erstellen einer Tabelle
Nach dem Erstellen Ihrer neuen Datenbank erstellen Sie Tabellen für Ihre Daten. Geben Sie alle Spalteninformationen an, wenn Sie die Tabelle erstellen.
Zum Beispiel können Sie mit dem folgenden Befehl eine Tabelle namens **DEMO** erstellen.
```
CREATE TABLE Demo (
PersonID int,
City varchar (255)
);
```
Standardmäßig werden neue Datenbankobjekte wie Tabellen im Standardschema mit dem Namen `public` während der Erstellung des Data Warehouses erstellt. Sie können ein anderes Schema verwenden, um Datenbankobjekte zu erstellen. Weitere Informationen über Schemata finden Sie unter [Verwalten der Datenbanksicherheit](https://docs.aws.amazon.com/redshift/latest/dg/r_Database_objects.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
Darüber hinaus können Sie mit der `schema_name.object_name`-Notation auch eine Tabelle im `SALES`-Schema erstellen.
```
CREATE TABLE SALES.DEMO (
PersonID int,
City varchar (255)
);
```
Um Schemata und ihre Tabellen anzuzeigen und zu überprüfen, können Sie Amazon Redshift Query Editor v2 verwenden. Oder Sie können die Liste der Tabellen in Schemata mithilfe von Systemansichten ansehen. Weitere Informationen finden Sie unter [Abfragen der Systemtabellen und Ansichten](t_querying_redshift_system_tables.md).
Die Spalten `encoding`, `distkey` und `sortkey` werden von Amazon Redshift für die parallele Verarbeitung verwendet. Für weitere Informationen zum Entwurf von Tabellen mit diesen Elementen siehe [Bewährte Methoden für die Gestaltung von Tabellen mit Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/c_designing-tables-best-practices.html).
## Einfügen von Datenzeilen in eine Tabelle
Nach der Erstellung der Tabelle fügen Sie Datenzeilen darin ein.
**Anmerkung**
Zeilen werden mit dem Befehl [INSERT](https://docs.aws.amazon.com/redshift/latest/dg/r_INSERT_30.html) in Tabellen eingefügt. Verwenden Sie für Standard-Masseneinfügungen den Befehl [COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html). Weitere Informationen finden Sie unter [Verwenden eines COPY-Befehls zum Laden von Daten](https://docs.aws.amazon.com/redshift/latest/dg/c_best-practices-use-copy.html).
Um zum Beispiel Werte in die Tabelle `DEMO` einzufügen, führen Sie folgenden Befehl aus.
```
INSERT INTO DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
Führen Sie den folgenden Befehl aus, um Daten in eine Tabelle einzufügen, die sich in einem bestimmten Schema befindet.
```
INSERT INTO SALES.DEMO VALUES (781, 'San Jose'), (990, 'Palo Alto');
```
## Auswahl von Daten aus einer Tabelle
Nachdem Sie eine Tabelle erstellt und mit Daten gefüllt haben, verwenden Sie eine SELECT-Anweisung, um die in der Tabelle enthaltenen Daten anzuzeigen. Die Anweisung SELECT \$1 gibt alle Spaltennamen und Zeilenwerte für alle Daten in einer Tabelle zurück. Die Verwendung von SELECT ist eine gute Möglichkeit, um zu prüfen, ob kürzlich hinzugefügte Daten korrekt in die Tabelle eingefügt wurden.
Um die Daten anzuzeigen, die Sie in die Tabelle **DEMO** eingegeben haben, führen Sie den folgenden Befehl aus:
```
SELECT * from DEMO;
```
Das Ergebnis sollte wie das folgende aussehen.
```
personid | city
----------+-----------
781 | San Jose
990 | Palo Alto
(2 rows)
```
Weitere Informationen zur Verwendung der SELECT-Anweisung zur Abfrage von Tabellen finden Sie unter [SELECT](https://docs.aws.amazon.com/redshift/latest/dg/r_SELECT_synopsis.html).
# Laden von Daten
Viele der Beispiele in dieser Anleitung verwenden den Beispieldatensatz TICKIT. Sie können die Datei [tickitdb.zip](samples/tickitdb.zip) herunterladen. Diese enthält einzelne Beispieldatendateien. Sie können dann die Beispieldaten in Ihren eigenen Amazon-S3-Bucket laden.
Um die Beispieldaten für Ihre Datenbank zu laden, erstellen Sie zuerst die Tabellen. Verwenden Sie dann den COPY-Befehl, um die Tabellen mit Beispieldaten zu laden, die in einem Amazon S3 Bucket gespeichert sind. Weitere Informationen zu den Schritten für die Erstellung von Tabellen und das Laden von Beispieldaten finden Sie unter [Schritt 4: Daten aus Amazon S3 in Amazon Redshift laden](new-user.md#rs-gsg-create-sample-db).
# Abfragen der Systemtabellen und Ansichten
Zusätzlich zu den von Ihnen erstellten Tabellen enthält Ihr Data Warehouse eine Reihe von Systemtabellen und Ansichten. Diese Tabellen und Ansichten enthalten Informationen zu Ihrer Installation sowie zu den verschiedenen Abfragen und Prozessen, die auf dem System ausgeführt werden. Sie können diese Systemtabellen und Ansichten abfragen, um Informationen zu Ihrer Datenbank zu erhalten. Weitere Informationen finden Sie in der [Referenz zu Systemtabellen und Ansichten](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*. Die Beschreibung für jede Tabelle oder Ansicht gibt an, ob die Tabelle für alle Benutzer oder nur für Superuser sichtbar ist. Um nur für Superuser sichtbare Tabellen anzuzeigen, melden Sie sich als Superuser an.
## Anzeigen einer Liste von Tabellennamen
Um eine Liste aller Tabellen in einem Schema anzuzeigen, können Sie die Systemkatalogtabelle PG\$1TABLE\$1DEF abfragen. Sie können zunächst die Einstellung für prüfen `search_path`.
```
SHOW search_path;
```
Das Ergebnis sollte in etwa wie folgt aussehen.
```
search_path
---------------
$user, public
```
Im folgenden Beispiel wird das`SALES`-Schema dem Suchpfad hinzugefügt und es werden alle Tabellen im `SALES`-Schema angezeigt.
```
set search_path to '$user', 'public', 'sales';
SHOW search_path;
search_path
------------------------
"$user", public, sales
select * from pg_table_def where schemaname = 'sales';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
Im folgenden Beispiel wird eine Liste aller Tabellen mit dem Namen `DEMO` in allen Schemata der aktuellen Datenbank angezeigt.
```
set search_path to '$user', 'public', 'sales';
select * from pg_table_def where tablename = 'demo';
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
------------+-----------+----------+------------------------+----------+---------+---------+---------
public | demo | personid | integer | az64 | f | 0 | f
public | demo | city | character varying(255) | lzo | f | 0 | f
sales | demo | personid | integer | az64 | f | 0 | f
sales | demo | city | character varying(255) | lzo | f | 0 | f
```
Weitere Informationen finden Sie in der Tabelle [PG\$1TABLE\$1DEF](https://docs.aws.amazon.com/redshift/latest/dg/r_PG_TABLE_DEF.html).
Sie können auch Amazon Redshift Query Editor v2 verwenden, um alle Tabellen in einem angegebenen Schema anzuzeigen, indem Sie zuerst eine Datenbank auswählen, mit der Sie eine Verbindung herstellen möchten.
## Anzeigen von Benutzern
Sie können den Katalog PG\$1USER abfragen, um eine Liste aller Benutzer zusammen mit Benutzer-ID (USESYSID) und Benutzerberechtigungen anzuzeigen.
```
SELECT * FROM pg_user;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
rdsdb | 1 | true | true | true | ******** | infinity |
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
Der Benutzername `rdsdb` wird intern von Amazon Redshift für Routine-Verwaltungs- und Wartungsaufgaben verwendet. Sie können Ihre Abfrage so filtern, dass nur benutzerdefinierte Benutzernamen angezeigt werden, indem Sie Ihrer SELECT-Anweisung `where usesysid > 1` hinzufügen.
```
SELECT * FROM pg_user WHERE usesysid > 1;
usename | usesysid | usecreatedb | usesuper | usecatupd | passwd | valuntil | useconfig
------------+----------+-------------+----------+-----------+----------+----------+-----------
awsuser | 100 | true | true | false | ******** | |
guest | 104 | true | false | false | ******** | |
```
## Anzeigen aktueller Abfragen
Im vorherigen Beispiel ist die Benutzer-ID (user\$1id) für `adminuser` 100. Um die vier letzten von `adminuser` ausgeführten Abfragen aufzulisten, können Sie die Ansicht SYS\$1QUERY\$1HISTORY abfragen.
Anhand dieser Ansicht können Sie die Abfrage-ID (query\$1id) oder die Prozess-ID (session\$1id) für eine kürzlich ausgeführte Abfrage finden. Sie können diese Ansicht auch verwenden, um zu überprüfen, wie lange eine Abfrage in Anspruch nahm. SYS\$1QUERY\$1HISTORY enthält die ersten 4.000 Zeichen der Abfragezeichenfolge (query\$1text), damit Sie eine bestimmte Abfrage besser finden können. Verwenden Sie die LIMIT-Klausel mit Ihrer SELECT-Anweisung, um die Ergebnisse zu begrenzen.
```
SELECT query_id, session_id, elapsed_time, query_text
FROM sys_query_history
WHERE user_id = 100
ORDER BY start_time desc
LIMIT 4;
```
Das Ergebnis sieht in etwa wie folgt aus.
```
query_id | session_id | elapsed_time | query_text
----------+--------------+---------------+----------------------------------------------------------------
892 | 21046 | 55868 | SELECT query, pid, elapsed, substring from ...
620 | 17635 | 1296265 | SELECT query, pid, elapsed, substring from ...
610 | 17607 | 82555 | SELECT * from DEMO;
596 | 16762 | 226372 | INSERT INTO DEMO VALUES (100);
```
## Feststellen der Sitzungs-ID einer laufenden Abfrage
Sie müssen möglicherweise die zu einer Abfrage gehörende Sitzungs-ID (Prozess-ID) angeben, um Systemtabelleninformationen zu einer Abfrage abzurufen. Möglicherweise müssen Sie aber auch die Sitzungs-ID für eine Abfrage ermitteln, die noch ausgeführt wird. So brauchen Sie etwa die Sitzungs-ID, wenn Sie eine Abfrage abbrechen müssen, die auf einem bereitgestellten Cluster zu viel Zeit in Anspruch nimmt. Sie können die STV\$1RECENTS-Systemtabelle abfragen, um eine Liste der Sitzungen IDs für laufende Abfragen zusammen mit der entsprechenden Abfragezeichenfolge zu erhalten. Wenn Ihre Abfrage mehrere Sitzungs-IDs ausgibt, können Sie anhand des Abfragetextes bestimmen, welche Sitzungs-ID Sie benötigen.
Um die Sitzungs-ID einer laufenden Abfrage zu bestimmen, führen Sie die folgende SELECT-Anweisung aus.
```
SELECT session_id, user_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
# Abbrechen einer Abfrage
Wenn Sie eine Abfrage ausführen, die zu lange dauert oder zu viele Ressourcen verbraucht, brechen Sie sie ab. Zum Beispiel: Erstellen Sie eine Liste von Ticketverkäufern, die die Namen der Verkäufer und die Anzahl der verkauften Tickets enthält. Die folgende Abfrage wählt Daten aus der `SALES`-Tabelle und der `USERS`-Tabelle aus und verbindet beide Tabellen durch den Abgleich von SELLERID und USERID in der WHERE-Klausel.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
WHERE sales.sellerid = users.userid
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Das Ergebnis sieht in etwa wie folgt aus.
```
sellerid | firstname | lastname | sum
----------+-----------+----------+------
48950 | Nayda | Hood | 184
19123 | Scott | Simmons | 164
20029 | Drew | Mcguire | 164
36791 | Emerson | Delacruz | 160
13567 | Imani | Adams | 156
9697 | Dorian | Ray | 156
41579 | Harrison | Durham | 156
15591 | Phyllis | Clay | 152
3008 | Lucas | Stanley | 148
44956 | Rachel |Villarreal| 148
```
**Anmerkung**
Dies ist eine komplexe Abfrage. Für dieses Tutorial müssen Sie sich über den Aufbau dieser Abfrage keine Gedanken machen.
Die vorherige Abfrage dauert wenige Sekunden und gibt 2 102 Zeilen aus.
Angenommen, Sie hätten die WHERE-Klausel vergessen.
```
SELECT sellerid, firstname, lastname, sum(qtysold)
FROM sales, users
GROUP BY sellerid, firstname, lastname
ORDER BY 4 desc;
```
Der Ergebnissatz enthält dann alle Zeilen in der `SALES`-Tabelle, multipliziert mit allen Zeilen in der `USERS`-Tabelle (49989\$13766). Dies ist eine so genannte Cartesische Verbindung, die nicht zu empfehlen ist. Das Ergebnis sind mehr als 188 Millionen Zeichen, und die Verarbeitungszeit ist extrem lang.
Um eine laufende Abfrage abzubrechen, verwenden Sie den CANCEL-Befehl mit der Sitzungs-ID der Abfrage. Mit Amazon Redshift Query Editor v2 können Sie eine Abfrage abbrechen, indem Sie auf die Schaltfläche „Abbrechen“ klicken, während die Abfrage ausgeführt wird.
Um die Sitzungs-ID zu finden, starten Sie eine neue Sitzung und fragen Sie die Tabelle STV\$1RECENTS ab, wie im vorherigen Schritt gezeigt. Das folgende Beispiel zeigt, wie Sie die Ergebnisse lesbarer machen können. Verwenden Sie dazu die TRIM-Funktion, um nachfolgende Leerzeichen abzuschneiden, und zeigen Sie nur die ersten 20 Zeichen der Abfragezeichenfolge an.
Um die Sitzungs-ID einer laufenden Abfrage zu bestimmen, führen Sie die folgende SELECT-Anweisung aus.
```
SELECT user_id, session_id, start_time, query_text
FROM sys_query_history
WHERE status='running';
```
Das Ergebnis sieht in etwa wie folgt aus.
```
user_id | session_id | start_time | query_text
---------+---------------+----------------------------+----------------------------------------------------------------
100 | 1073791534 | 2024-03-19 22:26:21.205739 | SELECT user_id, session_id, start_time, query_text FROM ...
```
Führen Sie zum Abbrechen der Abfrage mit der Sitzungs-ID `1073791534` den folgenden Befehl aus.
```
CANCEL 1073791534;
```
**Anmerkung**
Der Befehl CANCEL stoppt eine Transaktion nicht. Um eine Transaktion zu stoppen oder rückgängig zu machen, müssen Sie den Befehl ABORT oder ROLLBACK verwenden. Um eine mit einer Transaktion verbundene Abfrage abzubrechen, brechen Sie zuerst die Abfrage ab und stoppen Sie dann die Transaktion.
Wenn die abgebrochene Abfrage mit einer Transaktion verbunden ist, verwenden Sie den Befehl ABORT oder ROLLBACK, um die Transaktion abzubrechen und alle an den Daten vorgenommen Änderungen zu verwerfen:
```
ABORT;
```
Sie können nur Ihre eigenen Abfragen abbrechen, sofern Sie nicht als Superuser angemeldet sind. Superuser können alle Abfragen abbrechen.
Wenn Ihr Abfragetool nicht die gleichzeitige Ausführung von Abfragen unterstützt, starten Sie zum Abbruch der Abfrage eine weitere Sitzung.
Weitere Informationen zum Abbrechen einer Abfrage finden Sie unter [CANCEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CANCEL.html) im *Datenbankentwicklerhandbuch zu Amazon Redshift*.
## Abbrechen einer Abfrage mit der Superuser-Warteschlange
Wenn in Ihrer aktuellen Sitzung zu viele Abfragen gleichzeitig ausgeführt werden, können Sie möglicherweise erst dann den CANCEL-Befehl ausführen, wenn eine andere Abfrage abgeschlossen ist. Führen Sie in diesem Fall den CANCEL-Befehl mit einer anderen Workload-Verwaltungs-Abfragewarteschlange aus.
Workload-Verwaltung ermöglicht Ihnen die Ausführung von Abfragen in verschiedenen Abfragewarteschlangen, so dass Sie nicht warten müssen, bis eine andere Abfrage abgeschlossen ist. Der Workload Manager erstellt eine separate Warteschlange mit der Bezeichnung „Superuser-Warteschlange“, die Sie für Fehlerbehebungszwecke verwenden können. Um die Superuser-Warteschlange verwenden zu können, melden Sie sich als Superuser an und setzen Sie die Abfragegruppe mit dem SET-Befehl auf „Superuser“. Setzen Sie nach der Ausführung Ihrer Befehle die Abfragegruppe mit dem RESET-Befehl wieder zurück.
Führen Sie diese Befehle aus, um eine Abfrage mithilfe der Superuser-Warteschlange abzubrechen:
```
SET query_group TO 'superuser';
CANCEL 1073791534;
RESET query_group;
```