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.
# STV-Tabellen für Snapshot-Daten
STV-Tabellen sind virtuelle Systemtabellen, die Snapshots der aktuellen Systemdaten enthalten.
**Topics**
+ [STV\$1ACTIVE\$1CURSORS](r_STV_ACTIVE_CURSORS.md)
+ [STV\$1BLOCKLIST](r_STV_BLOCKLIST.md)
+ [STV\$1CURSOR\$1CONFIGURATION](r_STV_CURSOR_CONFIGURATION.md)
+ [STV\$1DB\$1ISOLATION\$1LEVEL](r_STV_DB_ISOLATION_LEVEL.md)
+ [STV\$1EXEC\$1STATE](r_STV_EXEC_STATE.md)
+ [STV\$1INFLIGHT](r_STV_INFLIGHT.md)
+ [STV\$1LOAD\$1STATE](r_STV_LOAD_STATE.md)
+ [STV\$1LOCKS](r_STV_LOCKS.md)
+ [STV\$1ML\$1MODEL\$1INFO](r_STV_ML_MODEL_INFO.md)
+ [STV\$1MV\$1DEPS](r_STV_MV_DEPS.md)
+ [STV\$1MV\$1INFO](r_STV_MV_INFO.md)
+ [STV\$1NODE\$1STORAGE\$1CAPACITY](r_STV_NODE_STORAGE_CAPACITY.md)
+ [STV\$1PARTITIONS](r_STV_PARTITIONS.md)
+ [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md)
+ [STV\$1RECENTS](r_STV_RECENTS.md)
+ [STV\$1SESSIONS](r_STV_SESSIONS.md)
+ [STV\$1SLICES](r_STV_SLICES.md)
+ [STV\$1STARTUP\$1RECOVERY\$1STATE](r_STV_STARTUP_RECOVERY_STATE.md)
+ [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)
+ [STV\$1TBL\$1TRANS](r_STV_TBL_TRANS.md)
+ [STV\$1WLM\$1CLASSIFICATION\$1CONFIG](r_STV_WLM_CLASSIFICATION_CONFIG.md)
+ [STV\$1WLM\$1QMR\$1CONFIG](r_STV_WLM_QMR_CONFIG.md)
+ [STV\$1WLM\$1QUERY\$1QUEUE\$1STATE](r_STV_WLM_QUERY_QUEUE_STATE.md)
+ [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md)
+ [STV\$1WLM\$1QUERY\$1TASK\$1STATE](r_STV_WLM_QUERY_TASK_STATE.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG](r_STV_WLM_SERVICE_CLASS_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1STATE](r_STV_WLM_SERVICE_CLASS_STATE.md)
+ [STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE](r_STV_XRESTORE_ALTER_QUEUE_STATE.md)
# STV\$1ACTIVE\$1CURSORS
STV\$1ACTIVE\$1CURSORS zeigt Details zu aktuell offenen Cursors an. Weitere Informationen finden Sie unter [DECLARE](declare.md).
STV\$1ACTIV\$1CURSORS ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data). Ein Benutzer kann nur Cursors sehen, die er selbst geöffnet hat. Ein Superuser kann alle Cursors sehen.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_ACTIVE_CURSORS.html)
# STV\$1BLOCKLIST
STV\$1BLOCKLIST enthält die Anzahl der 1 MB-Festplattenblöcke, die von jedem Slice, jeder Tabelle oder Spalte in einer Datenbank verwendet werden.
Verwenden Sie aggregierte Abfragen mit STV\$1BLOCKLIST, wie die folgenden Beispiele zeigen, um die Anzahl der 1 MB-Festplattenblöcke zu bestimmen, die pro Datenbank, Tabelle, Slice oder Spalte zugewiesen sind. Sie können auch [STV\$1PARTITIONS](r_STV_PARTITIONS.md) verwenden, um zusammenfassende Informationen zur Festplattennutzung anzuzeigen.
STV\$1BLOCKLIST ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
**Anmerkung**
STV\$1BLOCKLIST zeichnet nur Blöcke auf, die dem bereitgestellten Cluster oder Serverless-Namespace gehören. Wenn die Datenbank Blöcke enthält, die von einem Datashare-Produzentengemeinsam genutzt werden, sind diese Blöcke nicht in STV\$1BLOCKLIST enthalten. Weitere Informationen zu Datashares finden Sie unter [Datenfreigabe in Amazon Redshift](datashare-overview.md).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_BLOCKLIST.html)
## Beispielabfragen
STV\$1BLOCKLIST enthält eine Zeile pro zugewiesenem Festplattenblock, so dass eine Abfrage mit Auswahl aller Zeilen möglicherweise eine sehr große Zahl von Zeilen ausgibt. Wir empfehlen, nur aggregierte Abfragen mit STV\$1BLOCKLIST zu verwenden.
Die Ansicht [SVV\$1DISKUSAGE](r_SVV_DISKUSAGE.md) bietet ähnliche Informationen in einem benutzerfreundlichen Format – das folgende Beispiel illustriert eine Verwendung der STV\$1BLOCKLIST-Tabelle.
Um die Anzahl der 1 MB-Blöcke zu bestimmen, die jede Spalte in der VENUE-Tabelle enthält, geben Sie die folgende Abfrage ein:
```
select col, count(*)
from stv_blocklist, stv_tbl_perm
where stv_blocklist.tbl = stv_tbl_perm.id
and stv_blocklist.slice = stv_tbl_perm.slice
and stv_tbl_perm.name = 'venue'
group by col
order by col;
```
Diese Abfrage gibt die Anzahl der jeder Spalte in der VENUE-Tabelle zugeordneten 1 MB-Blöcke zurück, vgl. die folgenden Beispieldaten:
```
col | count
-----+-------
0 | 4
1 | 4
2 | 4
3 | 4
4 | 4
5 | 4
7 | 4
8 | 4
(8 rows)
```
Die folgende Abfrage zeigt, ob die Tabellendaten tatsächlich über alle Slices verteilt sind:
```
select trim(name) as table, stv_blocklist.slice, stv_tbl_perm.rows
from stv_blocklist,stv_tbl_perm
where stv_blocklist.tbl=stv_tbl_perm.id
and stv_tbl_perm.slice=stv_blocklist.slice
and stv_blocklist.id > 10000 and name not like '%#m%'
and name not like 'systable%'
group by name, stv_blocklist.slice, stv_tbl_perm.rows
order by 3 desc;
```
Diese Abfrage erstellt die folgende Beispielausgabe, die die gleichmäßige Verteilung der Daten für die Tabelle mit den meisten Zeilen anzeigt:
```
table | slice | rows
----------+-------+-------
listing | 13 | 10527
listing | 14 | 10526
listing | 8 | 10526
listing | 9 | 10526
listing | 7 | 10525
listing | 4 | 10525
listing | 17 | 10525
listing | 11 | 10525
listing | 5 | 10525
listing | 18 | 10525
listing | 12 | 10525
listing | 3 | 10525
listing | 10 | 10525
listing | 2 | 10524
listing | 15 | 10524
listing | 16 | 10524
listing | 6 | 10524
listing | 19 | 10524
listing | 1 | 10523
listing | 0 | 10521
...
(180 rows)
```
Die folgende Abfrage bestimmt, ob ein Tombstone-Block auf die Festplatte geschrieben wurde:
```
select slice, col, tbl, blocknum, newblock
from stv_blocklist
where tombstone > 0;
slice | col | tbl | blocknum | newblock
-------+-----+--------+----------+----------
4 | 0 | 101285 | 0 | 1
4 | 2 | 101285 | 0 | 1
4 | 4 | 101285 | 1 | 1
5 | 2 | 101285 | 0 | 1
5 | 0 | 101285 | 0 | 1
5 | 1 | 101285 | 0 | 1
5 | 4 | 101285 | 1 | 1
...
(24 rows)
```
# STV\$1CURSOR\$1CONFIGURATION
STV\$1CURSOR\$1CONFIGURATION zeigt Einschränkungen der Cursorkonfiguration an. Weitere Informationen finden Sie unter [Einschränkungen für Cursors](declare.md#declare-constraints).
STV\$1CURSOR\$1CONFIGURATION ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_CURSOR_CONFIGURATION.html)
# STV\$1DB\$1ISOLATION\$1LEVEL
STV\$1DB\$1ISOLATION\$1LEVEL zeigt die aktuelle Isolationsstufe für Datenbanken an. Weitere Hinweise zu Isolationsstufen finden Sie unter [Isolierungsstufen in Amazon Redshift](c_serial_isolation.md).
STV\$1DB\$1ISOLATION\$1LEVEL ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_DB_ISOLATION_LEVEL.html)
# STV\$1EXEC\$1STATE
Verwenden Sie die Tabelle STV\$1EXEC\$1STATE, um Informationen zu Abfragen und Abfrageschritten abzurufen, die derzeit aktiv auf Datenverarbeitungsknoten ausgeführt werden.
Diese Informationen werden normalerweise nur zur Behebung technischer Probleme verwendet. Die Ansichten SVV\$1QUERY\$1STATE und SVL\$1QUERY\$1SUMMARY extrahieren ihre Informationen aus STV\$1EXEC\$1STATE.
STV\$1EXEC\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_EXEC_STATE.html)
## Beispielabfragen
Anstelle einer direkten Abfrage von STV\$1EXEC\$1STATE empfiehlt Amazon Redshift die Abfrage von SVL\$1QUERY\$1SUMMARY oder SVV\$1QUERY\$1STATE, um die Informationen in STV\$1EXEC\$1STATE in einem benutzerfreundlicheren Format zu erhalten. Für weitere Einzelheiten vgl. die Dokumentation der Tabelle [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md) oder [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md).
# STV\$1INFLIGHT
Verwenden Sie die Tabelle STV\$1INFLIGHT, um festzustellen, welche Abfragen derzeit auf dem Cluster ausgeführt werden. Bei der Fehlerbehebung ist dies hilfreich, um den Status lang andauernder Abfragen zu überprüfen.
STV\$1INFLIGHT zeigt keine Abfragen nur mit Führungsknoten. Weitere Informationen finden Sie unter [Exklusive Führungsknotenfunktionen](c_SQL_functions_leader_node_only.md). STV\$1INFLIGHT ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Fehlerbehebung mit STV\$1INFLIGHT
Wenn Sie STV\$1INFLIGHT verwenden, um Fehler im Hinblick auf die Leistung einer Abfrage oder einer Sammlung von Abfragen zu beheben, beachten Sie Folgendes:
+ Lang andauernde offene Transaktionen erhöhen im Allgemeinen die Last. Diese offenen Transaktionen können zu längeren Laufzeiten für andere Abfragen führen.
+ Lang andauernde COPY- und ETL-Aufträge können sich auf andere Abfragen auswirken, die im Cluster ausgeführt werden, wenn sie viele Rechenressourcen in Anspruch nehmen. In den meisten Fällen erhöht das Verlagern dieser lang andauernden Aufträgen auf Zeiten geringer Auslastung die Leistung für Berichts- oder Analyse-Workloads.
+ Es gibt Ansichten, die verwandte Informationen zu STV\$1INFLIGHT bereitstellen. Dazu gehören [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), die den Abfragetext für SQL-Befehle erfasst, und [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md), die STV\$1INFLIGHT mit STL\$1QUERYTEXT verbindet. Sie können auch [STV\$1RECENTS](r_STV_RECENTS.md) mit STV\$1INFLIGHT zur Fehlerbehebung verwenden. STV\$1RECENTS kann beispielsweise angeben, ob sich bestimmte Abfragen im Status *Wird ausgeführt* oder *Fertig* befinden. Wenn Sie diese Informationen mit den Ergebnissen von STV\$1INFLIGHT kombinieren, erhalten Sie mehr Informationen über die Eigenschaften einer Abfrage und die Auswirkungen auf die Rechenressourcen.
Sie können laufende Abfragen auch mithilfe der Amazon-Redshift-Konsole überwachen.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_INFLIGHT.html)
## Beispielabfragen
Um alle derzeit auf der Datenbank ausgeführten Abfragen anzuzeigen, geben Sie die folgende Abfrage ein:
```
select * from stv_inflight;
```
Die Beispielausgabe unten zeigt zwei derzeit ausgeführte Abfragen, einschließlich der STV\$1INFLIGHT-Abfrage selbst und einer Abfrage, die mit einem Skript mit der Bezeichnung ausgeführt wurde `avgwait.sql`:
```
select slice, query, trim(label) querylabel, pid,
starttime, substring(text,1,20) querytext
from stv_inflight;
slice|query|querylabel | pid | starttime | querytext
-----+-----+-----------+-----+--------------------------+--------------------
1011 | 21 | | 646 |2012-01-26 13:23:15.645503|select slice, query,
1011 | 20 |avgwait.sql| 499 |2012-01-26 13:23:14.159912|select avg(datediff(
(2 rows)
```
Die folgende Abfrage wählt mehrere Spalten aus, einschließlich concurrency\$1scaling\$1status. Diese Spalte gibt an, ob Abfragen an den Nebenläufigkeitsskalierungs-Cluster gesendet werden. Wenn der Wert für einige Ergebnisse `1` lautet, ist dies ein Hinweis darauf, dass Rechenressourcen für die Nebenläufigkeitsskalierung verwendet werden. Weitere Informationen finden Sie unter [Nebenläufigkeitsskalierung](concurrency-scaling.md).
```
select userid,
query,
pid,
starttime,
text,
suspended,
concurrency_scaling_status
from STV_INFLIGHT;
```
Die Beispielausgabe zeigt, wie eine Abfrage an den Nebenläufigkeitsskalierungs-Cluster gesendet wird.
```
query | pid | starttime | text | suspended | concurrency_scaling_status
--------+---------+----------------------------|------------------------|---------------|-------------------------------
1234567 | 123456 | 2012-01-26 13:23:15.645503 | select userid, query... 0 1
2345678 | 234567 | 2012-01-26 13:23:14.159912 | select avg(datediff(... 0 0
(2 rows)
```
Weitere Tipps zur Fehlerbehebung bei der Abfrageleistung finden Sie unter [Fehlerbehebung für Abfragen](queries-troubleshooting.md).
# STV\$1LOAD\$1STATE
Verwenden Sie die Tabelle STV\$1LOAD\$1STATE, um Informationen zum aktuellen Status laufender COPY-Anweisungen zu finden.
Der COPY-Befehl aktualisiert diese Tabelle nach jeder Million geladener Datensätze.
STV\$1LOAD\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_LOAD_STATE.html)
## Beispielabfrage
Um den Fortschritt jedes Slices für einen COPY-Befehl anzuzeigen, geben Sie die folgende Abfrage ein. Dieses Beispiel verwendet die Funktion PG\$1LAST\$1COPY\$1ID(), um Informationen für den letzten COPY-Befehl abzurufen.
```
select slice , bytes_loaded, bytes_to_load , pct_complete from stv_load_state where query = pg_last_copy_id();
slice | bytes_loaded | bytes_to_load | pct_complete
-------+--------------+---------------+--------------
2 | 0 | 0 | 0
3 | 12840898 | 39104640 | 32
(2 rows)
```
# STV\$1LOCKS
Verwenden Sie die Tabelle STV\$1LOCKS zur Anzeige derzeitiger Aktualisierungen in den Tabellen der Datenbank.
Amazon Redshift sperrt Tabellen, um zu verhindern, dass zwei Benutzer gleichzeitig dieselbe Tabelle aktualisieren. Während die Tabelle STV\$1LOCKS alle derzeitigen Tabellenaktualisierungen anzeigt, fragen Sie die Tabelle [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md) ab, um ein Protokoll von Sperrkonflikten anzuzeigen. Verwenden Sie die Ansicht [SVV\$1TRANSACTIONS](r_SVV_TRANSACTIONS.md), um offene Transaktionen und Probleme mit Sperrkonflikten anzuzeigen.
STV\$1LOCKS ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_LOCKS.html)
## Beispielabfrage
Um alle Sperren in aktuellen Transaktionen anzuzeigen, geben Sie den folgenden Befehl ein:
```
select table_id, last_update, lock_owner, lock_owner_pid from stv_locks;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück, die drei derzeit aktive Sperren zeigt:
```
table_id | last_update | lock_owner | lock_owner_pid
----------+----------------------------+------------+----------------
100004 | 2008-12-23 10:08:48.882319 | 1043 | 5656
100003 | 2008-12-23 10:08:48.779543 | 1043 | 5656
100140 | 2008-12-23 10:08:48.021576 | 1043 | 5656
(3 rows)
```
# STV\$1ML\$1MODEL\$1INFO
Informationen zum aktuellen Zustand des Machine-Learning-Modells.
STV\$1ML\$1MODEL\$1INFO ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_ML_MODEL_INFO.html)
## Beispielabfrage
Die folgende Abfrage zeigt den aktuellen Status von Machine-Learning-Modellen an.
```
SELECT schema_name, model_name, model_state
FROM stv_ml_model_info;
schema_name | model_name | model_state
-------------+------------------------------+--------------------------------------
public | customer_churn_auto_model | Train Model On SageMaker In Progress
public | customer_churn_xgboost_model | Model is Ready
(2 row)
```
# STV\$1MV\$1DEPS
Die Tabelle STV\$1MV\$1DEPS zeigt die Abhängigkeiten materialisierter Ansichten von anderen materialisierten Ansichten in Amazon Redshift.
Weitere Hinweise zu materialisierten Ansichten finden Sie unter [Materialisierte Ansichten in Amazon Redshift](materialized-view-overview.md).
STV\$1MV\$1DEPS ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur materialisierte Ansichten auflisten, die sich in Schemata befinden, auf die sie Zugriff haben. Weitere Informationen finden Sie unter [Sichtbarkeit von Daten in Systemtabellen und Ansichten](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_MV_DEPS.html)
## Beispielabfrage
Die folgende Abfrage gibt eine Ausgabezeile zurück, die angibt, dass die materialisierte Ansicht `mv_over_foo` die materialisierte Ansicht `mv_foo` in ihrer Definition als Abhängigkeit verwendet.
```
CREATE SCHEMA test_ivm_setup;
CREATE TABLE test_ivm_setup.foo(a INT);
CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo;
CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo;
SELECT * FROM stv_mv_deps;
db_name | schema | name | ref_schema | ref_name | ref_database_name
---------+-----------------+-------------+----------------+----------+------------------
dev | test_ivm_setup | mv_over_foo | test_ivm_setup | mv_foo | dev
```
# STV\$1MV\$1INFO
Die Tabelle STV\$1MV\$1INFO enthält eine Zeile für jede materialisierte Ansicht, Angaben, ob die Daten veraltet sind, und Statusinformationen.
Weitere Hinweise zu materialisierten Ansichten finden Sie unter [Materialisierte Ansichten in Amazon Redshift](materialized-view-overview.md).
STV\$1MV\$1INFO ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur materialisierte Ansichten auflisten, die sich in Schemata befinden, auf die sie Zugriff haben. Weitere Informationen finden Sie unter [Sichtbarkeit von Daten in Systemtabellen und Ansichten](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_MV_INFO.html)
## Beispielabfrage
Führen Sie die folgende Abfrage aus, um den Status aller materialisierten Ansichten anzuzeigen.
```
select * from stv_mv_info;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück.
```
db_name | schema | name | updated_upto_xid | is_stale | owner_user_name | state | autorefresh | autorewrite
---------+--------------------+---------+------------------+----------+-----------------+-------+-------------+------------
dev | test_ivm_setup | mv | 1031 | f | catch-22 | 1 | 1 | 0
dev | test_ivm_setup | old_mv | 988 | t | lotr | 1 | 0 | 1
```
# STV\$1NODE\$1STORAGE\$1CAPACITY
Die Tabelle STV\$1NODE\$1STORAGE\$1CAPACITY zeigt Details zur Gesamtspeicherkapazität und der gesamten genutzten Kapazität für jeden Knoten in einem Cluster an. Sie enthält eine Zeile für jeden Knoten.
STV\$1NODE\$1STORAGE\$1CAPACITY ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_NODE_STORAGE_CAPACITY.html)
## Beispielabfragen
**Anmerkung**
Die Ergebnisse der folgenden Beispiele variieren je nach den Knotenspezifikationen Ihres Clusters. Fügen Sie SQL SELECT Spalte `capacity` hinzu, um die Kapazität Ihres Clusters abzurufen.
Die folgende Abfrage gibt den belegten Speicherplatz und die Gesamtkapazität in 1-MB-Speicherblöcken zurück. Dieses Beispiel wurde auf einem dc2.8xlarge-Cluster mit zwei Knoten ausgeführt.
```
select node, used from stv_node_storage_capacity order by node;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück.
```
node | used
------+-------
0 | 30597
1 | 27089
```
Die folgende Abfrage gibt den belegten Speicherplatz und die Gesamtkapazität in 1-MB-Speicherblöcken zurück. Dieses Beispiel wurde auf einem ra3.16xlarge-Cluster mit zwei Knoten ausgeführt.
```
select node, used from stv_node_storage_capacity order by node;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück.
```
node | used
------+-------
0 | 30591
1 | 27103
```
# STV\$1PARTITIONS
Verwenden Sie die Tabelle STV\$1PARTITIONS, um die Festplattengeschwindigkeitsleistung und die Festplattennutzung für Amazon Redshift zu bestimmen.
STV\$1PARTITIONS enthält eine Zeile pro Knoten und logischer Festplattenpartition.
STV\$1PARTITIONS ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_PARTITIONS.html)
## Beispielabfrage
Die folgende Abfrage gibt den verwendeten Festplattenspeicherplatz und die Festplattenkapazität (in 1 MB-Blöcken) aus und berechnet die Festplattennutzung als Prozentsatz des Roh-Festplattenspeicherplatzes. Der Roh-Festplattenspeicherplatz schließt den Platz ein, der von Amazon Redshift für die interne Verwendung reserviert ist, ist also größer als die nominelle Festplattenkapazität, bei der es sich um den Festplattenspeicherplatz handelt, der dem Benutzer zur Verfügung steht. Die Metrik **Percentage of Disk Space Used (Prozentsatz des verwendeten Datenträgerplatzes)** auf der Registerkarte **Performance (Leistung)** der Amazon-Redshift-Managementkonsole zeigt den Prozentsatz der nominellen Datenträgerkapazität an, die von Ihrem Cluster verwendet wird. Sie sollten die Metrik **Percentage of Disk Space Used (Prozentsatz des verwendeten Datenträgerplatzes)** überwachen, damit Ihre Nutzung innerhalb der nominellen Datenträgerkapazität Ihres Clusters bleibt.
**Wichtig**
Wir empfehlen nachdrücklich, die nominelle Festplattenkapazität Ihres Clusters nicht zu überschreiten. Auch wenn dies unter bestimmten Umständen technisch möglich ist, beeinträchtigt die Überschreitung der nominellen Datenträgerkapazität die Fehlertoleranz Ihres Clusters und erhöht das Risiko von Datenverlusten.
Dieses Beispiel wurde auf einem zwei-Knoten-Cluster mit sechs logischen Festplattenpartitionen pro Knoten ausgeführt. Der Platz wird gleichmäßig über die Festplatte hinweg verwendet, wobei ca. 25 % jeder Festplatte genutzt werden.
```
select owner, host, diskno, used, capacity,
(used-tossed)/capacity::numeric *100 as pctused
from stv_partitions order by owner;
owner | host | diskno | used | capacity | pctused
-------+------+--------+--------+----------+---------
0 | 0 | 0 | 236480 | 949954 | 24.9
0 | 0 | 1 | 236420 | 949954 | 24.9
0 | 0 | 2 | 236440 | 949954 | 24.9
0 | 1 | 2 | 235150 | 949954 | 24.8
0 | 1 | 1 | 237100 | 949954 | 25.0
0 | 1 | 0 | 237090 | 949954 | 25.0
1 | 1 | 0 | 236310 | 949954 | 24.9
1 | 1 | 1 | 236300 | 949954 | 24.9
1 | 1 | 2 | 236320 | 949954 | 24.9
1 | 0 | 2 | 237910 | 949954 | 25.0
1 | 0 | 1 | 235640 | 949954 | 24.8
1 | 0 | 0 | 235380 | 949954 | 24.8
(12 rows)
```
# STV\$1QUERY\$1METRICS
Enthält Metrikinformationen, etwa die Anzahl der verarbeiteten Zeilen, die CPU-Nutzung, Input/Output- und Festplattennutzung für aktive Abfragen, die in benutzerdefinierten Abfragewarteschlangen (Service-Klassen) ausgeführt werden. Für die Anzeige von Metriken für abgeschlossene Abfragen vgl. die Systemtabelle [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md).
Die Abfragemetriken werden in Intervallen von einer Sekunde erfasst. Daher können verschiedene Ausführungen einer Abfrage leicht abweichende Zeiten ergeben. Abfragesegmente, die in weniger als einer Sekunde ausgeführt werden, werden möglicherweise nicht aufgezeichnet.
STV\$1QUERY\$1METRICS verfolgt und aggregiert Metriken auf Abfrage-, Segment- und Schrittebene. Informationen zu Abfragesegmenten und Schritten finden Sie unter [Workflow der Abfrageplanung und -ausführung](c-query-planning.md). Viele Metriken (wie etwa `max_rows`, `cpu_time` u. dgl.) werden über Knoten-Slices hinweg summiert. Weitere Informationen über Knoten-Slices finden Sie unter [Architektur des Data Warehouse-Systems](c_high_level_system_architecture.md).
Um die Ebene festzustellen, auf der die Zeile die Metriken meldet, prüfen Sie die Spalten `segment` und `step_type`:
+ Wenn `segment` und `step_type` den Wert `-1` haben, meldet die Zeile die Metriken auf Abfrageebene.
+ Wenn `segment` nicht den Wert `-1` und `step_type` den Wert `-1` hat, meldet die Zeile die Metriken auf Segmentebene.
+ Wenn `segment` und `step_type` nicht den Wert `-1` haben, meldet die Zeile die Metriken auf Schrittebene.
STV\$1QUERY\$1METRICS ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## Schritttypen
Die folgende Tabelle listet die für Datenbankbenutzer relevanten Schritttypen auf. Die Tabelle führt die nur zur internen Verwendung gedachten Schritttypen nicht auf. Wenn der Schritttyp -1 ist, wird die Metrik nicht auf Schrittebene gemeldet.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## Beispielabfrage
Um aktive Abfragen mit einer hohen CPU-Zeit (über 1.000 Sekunden) zu finden, führen Sie die folgende Abfrage aus.
```
select query, cpu_time / 1000000 as cpu_seconds
from stv_query_metrics where segment = -1 and cpu_time > 1000000000
order by cpu_time;
query | cpu_seconds
------+------------
25775 | 9540
```
Um aktive Abfragen mit einem Nested Loop-Join zu finden, die mehr als eine Million Zeilen ausgegeben haben, führen Sie die folgende Abfrage aus.
```
select query, rows
from stv_query_metrics
where step_type = 15 and rows > 1000000
order by rows;
query | rows
------+-----------
25775 | 1580225854
```
Um aktive Abfragen zu finden, die länger als 60 Sekunden liefen und weniger als 10 Sekunden CPU-Zeit genutzt haben, führen Sie die folgende Abfrage aus.
```
select query, run_time/1000000 as run_time_seconds
from stv_query_metrics
where segment = -1 and run_time > 60000000 and cpu_time < 10000000;
query | run_time_seconds
------+-----------------
25775 | 114
```
# STV\$1RECENTS
Verwenden Sie die Tabelle STV\$1RECENTS, um Informationen zu den derzeit aktiven und kürzlich ausgeführten Abfragen gegen eine Datenbank zu erhalten.
STV\$1RECENTS ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Fehlerbehebung mit STV\$1RECENTS
STV\$1RECENTS ist besonders hilfreich, um festzustellen, ob eine Abfrage oder Sammlung von Abfragen gerade ausgeführt wird oder abgeschlossen ist. Dabei wird auch die Dauer angezeigt, wie lange eine Abfrage ausgeführt wurde. Dies ist hilfreich, um ein Gefühl dafür zu bekommen, welche Abfragen lange andauern.
Sie können STV\$1RECENTS mit anderen Systemansichten verbinden, z. B. [STV\$1INFLIGHT](r_STV_INFLIGHT.md), um zusätzliche Metadaten über laufende Abfragen zu sammeln. (Im Abschnitt mit den Beispielabfragen finden Sie ein Beispiel, das die Vorgehensweise zeigt.) Sie können auch zurückgegebene Datensätze aus dieser Ansicht zusammen mit den Überwachungsfunktionen in der Amazon-Redshift-Konsole für die Fehlerbehebung in Echtzeit verwenden.
Zu den Systemansichten, die STV\$1RECENTS ergänzen, gehören [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), die den Abfragetext für SQL-Befehle abruft, und [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md), die STV\$1INFLIGHT mit STL\$1QUERYTEXT verbindet.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_RECENTS.html)
## Beispielabfragen
Um festzustellen, welche Abfragen derzeit für die Datenbank ausgeführt werden, geben Sie die folgende Abfrage ein:
```
select user_name, db_name, pid, query
from stv_recents
where status = 'Running';
```
Die Beispielausgabe unten zeigt eine einzelne Abfrage, die auf der TICKIT-Datenbank ausgeführt wird:
```
user_name | db_name | pid | query
----------+---------+---------+-------------
dwuser | tickit | 19996 |select venuename, venueseats from
venue where venueseats > 50000 order by venueseats desc;
```
Das folgende Beispiel gibt eine Liste von Abfragen (falls vorhanden) zurück, die derzeit ausgeführt werden oder in einer Warteschlange auf ihre Ausführung warten:
```
select * from stv_recents where status<>'Done';
status | starttime | duration |user_name|db_name| query | pid
-------+---------------------+----------+---------+-------+-----------+------
Running| 2010-04-21 16:11... | 281566454| dwuser |tickit | select ...| 23347
```
Diese Abfrage gibt nur Ergebnisse zurück, wenn Sie eine Reihe gleichzeitiger Abfragen ausführen und sich einige davon in einer Warteschlange befinden.
Das folgende Beispiel ist eine Erweiterung des vorherigen Beispiels. In diesem Fall werden tatsächlich ausgeführte (nicht wartende) Abfragen aus dem Ergebnis ausgeschlossen:
```
select * from stv_recents where status<>'Done'
and pid not in (select pid from stv_inflight);
...
```
Weitere Tipps zur Fehlerbehebung bei der Abfrageleistung finden Sie unter [Fehlerbehebung für Abfragen](queries-troubleshooting.md).
# STV\$1SESSIONS
Verwenden Sie die Tabelle STV\$1SESSIONS zur Anzeige von Informationen zu den aktiven Benutzersitzungen für Amazon Redshift.
Verwenden Sie zur Anzeige des Sitzungsverlaufs die Tabelle [STL\$1SESSIONS](r_STL_SESSIONS.md) anstelle von STV\$1SESSIONS.
STV\$1SESSIONS ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_SESSIONS.html)
## Beispielabfragen
Um kurz zu prüfen, ob andere Benutzer derzeit bei Amazon Redshift angemeldet sind, geben Sie die folgende Abfrage ein:
```
select count(*)
from stv_sessions;
```
Wenn das Ergebnis größer als Eins ist, ist derzeit mindestens ein anderer Benutzer bei der Datenbank angemeldet.
Um alle aktiven Sitzungen für Amazon Redshift anzuzeigen, geben Sie die folgende Abfrage ein:
```
select *
from stv_sessions;
```
Das folgende Ergebnis zeigt vier aktive Sitzungen, die derzeit auf Amazon Redshift: ausgeführt werden:
```
starttime | process |user_name | db_name | timeout_sec
-------------------------+---------+----------------------------+----------------------------+-------------
2018-08-06 08:44:07.50 | 13779 | IAMA:aws_admin:admin_grp | dev | 0
2008-08-06 08:54:20.50 | 19829 | dwuser | dev | 120
2008-08-06 08:56:34.50 | 20279 | dwuser | dev | 120
2008-08-06 08:55:00.50 | 19996 | dwuser | tickit | 0
(3 rows)
```
Der Benutzername mit dem Präfix IAMA gibt an, dass sich der Benutzer mithilfe von verbundbasiertem Single Sign-On (SSO, Einmalanmeldung) angemeldet hat. Weitere Informationen finden Sie unter [Verwenden der IAM-Authentifizierung zur Erstellung von Benutzeranmeldeinformationen für die Datenbank](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html).
# STV\$1SLICES
Verwenden Sie die Tabelle STV\$1SLICES zur Anzeige der aktuellen Zuweisung eines Slices zu einem Knoten.
Die Informationen in STV\$1SLICES werden hauptsächlich für Untersuchungszwecke verwendet.
STV\$1SLICES ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_SLICES.html)
## Beispielabfrage
Um anzuzeigen, welche Cluster-Knoten welche Slices verwalten, geben Sie die folgende Abfrage ein:
```
select node, slice from stv_slices;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück:
```
node | slice
------+-------
0 | 2
0 | 3
0 | 1
0 | 0
(4 rows)
```
# STV\$1STARTUP\$1RECOVERY\$1STATE
Zeichnet den Status von Tabellen auf, die während Cluster-Neustartoperationen vorübergehend gesperrt sind. Amazon Redshift sperrt Tabellen vorübergehend, während sie bearbeitet werden, um angehaltene Transaktionen nach einem Cluster-Neustart aufzulösen.
STV\$1STARTUP\$1RECOVERY\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_STARTUP_RECOVERY_STATE.html)
## Beispielabfragen
Um zu überwachen, welche Tabellen vorübergehend gesperrt sind, führen Sie nach einem Cluster-Neustart die folgende Abfrage aus.
```
select * from STV_STARTUP_RECOVERY_STATE;
db_id | tbl_id | table_name
--------+--------+------------
100044 | 100058 | lineorder
100044 | 100068 | part
100044 | 100072 | customer
100044 | 100192 | supplier
(4 rows)
```
# STV\$1TBL\$1PERM
Die Tabelle STV\$1TBL\$1PERM enthält Informationen zu den permanenten Tabellen in Amazon Redshift, einschließlich der temporären Tabellen, die von einem Benutzer für die aktuelle Sitzung erstellt wurden. STV\$1TBL\$1PERM enthält Informationen für alle Tabellen in allen Datenbanken.
Diese Tabelle unterscheidet sich von [STV\$1TBL\$1TRANS](r_STV_TBL_TRANS.md), die Informationen über temporäre Datenbanktabellen enthält, die das System bei der Verarbeitung von Abfragen erstellt.
STV\$1TBL\$1PERM ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_TBL_PERM.html)
## Beispielabfragen
Die folgende Abfrage gibt eine Liste verschiedener Tabellen IDs und Namen zurück:
```
select distinct id, name
from stv_tbl_perm order by name;
id | name
--------+-------------------------
100571 | category
100575 | date
100580 | event
100596 | listing
100003 | padb_config_harvest
100612 | sales
...
```
Andere Systemtabellen verwenden Tabellen. IDs Daher kann es sehr nützlich sein, zu wissen, welche Tabellen-ID einer bestimmten Tabelle entspricht. In diesem Beispiel wird SELECT DISTINCT verwendet, um die Duplikate zu entfernen (die Tabellen sind über mehrere Slices verteilt).
Um die Anzahl der Blöcke zu bestimmen, die jede Spalte in der VENUE-Tabelle enthält, geben Sie die folgende Abfrage ein:
```
select col, count(*)
from stv_blocklist, stv_tbl_perm
where stv_blocklist.tbl = stv_tbl_perm.id
and stv_blocklist.slice = stv_tbl_perm.slice
and stv_tbl_perm.name = 'venue'
group by col
order by col;
col | count
-----+-------
0 | 8
1 | 8
2 | 8
3 | 8
4 | 8
5 | 8
6 | 8
7 | 8
(8 rows)
```
## Nutzungshinweise
Die Spalte ROWS enthält die Anzahl der gelöschten Zeilen, die nicht bereinigt wurden (oder die bereinigt wurden, jedoch mit der Option SORT ONLY). Daher kann es sein, dass der Wert SUM der Spalte ROWS in der Tabelle STV\$1TBL\$1PERM nicht dem COUNT(\$1)-Ergebnis entspricht, wenn Sie eine bestimmte Tabelle direkt abfragen. Zum Beispiel: Wenn zwei Zeilen von VENUE gelöscht werden, ist das COUNT(\$1)-Ergebnis 200, das SUM(ROWS)-Ergebnis ist aber nach wie vor 202:
```
delete from venue
where venueid in (1,2);
select count(*) from venue;
count
-------
200
(1 row)
select trim(name) tablename, sum(rows)
from stv_tbl_perm where name='venue' group by name;
tablename | sum
-----------+-----
venue | 202
(1 row)
```
Um die Daten in STV\$1TBL\$1PERM zu synchronisieren, führen Sie eine vollständige Bereinigung in der VENUE-Tabelle durch.
```
vacuum venue;
select trim(name) tablename, sum(rows)
from stv_tbl_perm
where name='venue'
group by name;
tablename | sum
-----------+-----
venue | 200
(1 row)
```
# STV\$1TBL\$1TRANS
Verwenden Sie die Tabelle STV\$1TBL\$1TRANS, um Informationen zu den temporären Datenbanktabellen zu erhalten, die sich derzeit im Speicher befinden.
Dabei handelt es sich typischerweise um temporäre Zeilensätze, die als Zwischenergebnisse verwendet werden, während eine Abfrage ausgeführt wird. STV\$1TBL\$1TRANS unterscheidet sich von [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md) darin, dass STV\$1TBL\$1PERM Informationen zu permanenten Datenbanktabellen enthält.
STV\$1TBL\$1TRANS ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_TBL_TRANS.html)
## Beispielabfragen
Um Informationen zu temporären Tabellen für eine Abfrage mit der Abfrage-ID 90 anzuzeigen, geben Sie den folgenden Befehl ein:
```
select slice, id, rows, size, query_id, ref_cnt
from stv_tbl_trans
where query_id = 90;
```
Diese Abfrage gibt die Informationen zur temporären Tabelle für Abfrage 90 aus, wie die folgende Beispielausgabe zeigt:
```
slice | id | rows | size | query_ | ref_ | from_ | prep_
| | | | id | cnt | suspended | swap
------+----+------+------+--------+------+-----------+-------
1013 | 95 | 0 | 0 | 90 | 4 | 0 | 0
7 | 96 | 0 | 0 | 90 | 4 | 0 | 0
10 | 96 | 0 | 0 | 90 | 4 | 0 | 0
17 | 96 | 0 | 0 | 90 | 4 | 0 | 0
14 | 96 | 0 | 0 | 90 | 4 | 0 | 0
3 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 99 | 0 | 0 | 90 | 4 | 0 | 0
9 | 96 | 0 | 0 | 90 | 4 | 0 | 0
5 | 96 | 0 | 0 | 90 | 4 | 0 | 0
19 | 96 | 0 | 0 | 90 | 4 | 0 | 0
2 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 98 | 0 | 0 | 90 | 4 | 0 | 0
13 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 96 | 0 | 0 | 90 | 4 | 0 | 0
6 | 96 | 0 | 0 | 90 | 4 | 0 | 0
11 | 96 | 0 | 0 | 90 | 4 | 0 | 0
15 | 96 | 0 | 0 | 90 | 4 | 0 | 0
18 | 96 | 0 | 0 | 90 | 4 | 0 | 0
```
In diesem Beispiel sehen Sie, dass die Abfragedaten die Tabellen 95, 96 und 98 betreffen. Da dieser Tabelle Null Bytes zugeordnet sind, kann diese Abfrage im Speicher ausgeführt werden.
# STV\$1WLM\$1CLASSIFICATION\$1CONFIG
Enthält die aktuellen Klassifizierungsregeln für WLM.
STV\$1WLM\$1CLASSIFICATION\$1CONFIG ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_CLASSIFICATION_CONFIG.html)
## Beispielabfrage
```
select * from STV_WLM_CLASSIFICATION_CONFIG;
id | condition | action_seq | action | action_service_class
---+---------------------------------------------+------------+--------+---------------------
1 | (system user) and (query group: health) | 0 | assign | 1
2 | (system user) and (query group: metrics) | 0 | assign | 2
3 | (system user) and (query group: cmstats) | 0 | assign | 3
4 | (system user) | 0 | assign | 4
5 | (super user) and (query group: superuser) | 0 | assign | 5
6 | (query group: querygroup1) | 0 | assign | 6
7 | (user group: usergroup1) | 0 | assign | 6
8 | (user group: usergroup2) | 0 | assign | 7
9 | (query group: querygroup3) | 0 | assign | 8
10 | (query group: querygroup4) | 0 | assign | 9
11 | (user group: usergroup4) | 0 | assign | 9
12 | (query group: querygroup*) | 0 | assign | 10
13 | (user group: usergroup*) | 0 | assign | 10
14 | (querytype: any) | 0 | assign | 11
(4 rows)
```
# STV\$1WLM\$1QMR\$1CONFIG
Zeichnet die Konfiguration für WLM-Abfrageüberwachungsregeln (QMR) auf. Weitere Informationen finden Sie unter [WLM-Abfrageüberwachungsregeln](cm-c-wlm-query-monitoring-rules.md).
STV\$1WLM\$1QMR\$1CONFIG ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_QMR_CONFIG.html)
## Beispielabfrage
Um die QMR-Regeldefinitionen für alle Service-Klassen über 5 (mit benutzerdefinierten Warteschlangen) anzuzeigen, führen Sie die folgende Abfrage aus. Eine Liste der Serviceklassen finden IDs Sie unter[WLM-Serviceklasse IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
```
Select *
from stv_wlm_qmr_config
where service_class > 5
order by service_class;
```
# STV\$1WLM\$1QUERY\$1QUEUE\$1STATE
Zeichnet den aktuellen Zustand der Abfragewarteschlangen für die Service-Klassen auf.
STV\$1WLM\$1QUERY\$1QUEUE\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_QUERY_QUEUE_STATE.html)
## Beispielabfrage
Die folgende Abfrage zeigt die Abfragen in der Warteschlange für Service-Klassen über 4.
```
select * from stv_wlm_query_queue_state
where service_class > 4
order by service_class;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück.
```
service_class | position | task | query | slot_count | start_time | queue_time
---------------+----------+------+-------+------------+----------------------------+------------
5 | 0 | 455 | 476 | 5 | 2010-10-06 13:18:24.065838 | 20937257
6 | 1 | 456 | 478 | 5 | 2010-10-06 13:18:26.652906 | 18350191
(2 rows)
```
# STV\$1WLM\$1QUERY\$1STATE
Zeigt den aktuellen Status der von WLM nachverfolgten Abfragen an.
STV\$1WLM\$1QUERY\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_QUERY_STATE.html)
## Beispielabfrage
Die folgende Abfrage zeigt alle derzeit ausgeführten Abfragen in Service-Klassen über 4 an. Eine Liste der Serviceklassen finden IDs Sie unter[WLM-Serviceklasse IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
```
select xid, query, trim(state) as state, queue_time, exec_time
from stv_wlm_query_state
where service_class > 4;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück:
```
xid | query | state | queue_time | exec_time
-------+-------+---------+------------+-----------
100813 | 25942 | Running | 0 | 1369029
100074 | 25775 | Running | 0 | 2221589242
```
# STV\$1WLM\$1QUERY\$1TASK\$1STATE
Enthält den derzeitigen Status von Service-Klassen-Abfrageaufgaben.
STV\$1WLM\$1QUERY\$1TASK\$1STATE ist für alle Benutzer sichtbar. Superuser können alle Zeilen sehen; reguläre Benutzer können nur ihre eigenen Daten sehen. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_QUERY_TASK_STATE.html)
## Beispielabfrage
Die folgende Abfrage zeigt den derzeitigen Status von Abfragen in Service-Klassen über 4 an. Eine Liste der Serviceklassen finden IDs Sie unter[WLM-Serviceklasse IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
```
select * from stv_wlm_query_task_state
where service_class > 4;
```
Diese Abfrage gibt die folgende Beispielausgabe zurück:
```
service_class | task | query | start_time | exec_time
--------------+------+-------+----------------------------+-----------
5 | 466 | 491 | 2010-10-06 13:29:23.063787 | 357618748
(1 row)
```
# STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG
Zeichnet die Service-Klassen-Konfigurationen für WLM auf.
STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_CONFIG.html)
## Beispielabfrage
Die erste benutzerdefinierte Service-Klasse ist Service-Klasse 6, die als Service-Klasse Nr. 1 bezeichnet wird. Die folgende Abfrage zeigt die aktuelle Konfiguration für Service-Klassen über 4 an. Eine Liste der Serviceklassen finden IDs Sie unter[WLM-Serviceklasse IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
```
select rtrim(name) as name,
num_query_tasks as slots,
query_working_mem as mem,
max_execution_time as max_time,
user_group_wild_card as user_wildcard,
query_group_wild_card as query_wildcard
from stv_wlm_service_class_config
where service_class > 4;
name | slots | mem | max_time | user_wildcard | query_wildcard
-----------------------------+-------+-----+----------+---------------+---------------
Service class for super user | 1 | 535 | 0 | false | false
Queue 1 | 5 | 125 | 0 | false | false
Queue 2 | 5 | 125 | 0 | false | false
Queue 3 | 5 | 125 | 0 | false | false
Queue 4 | 5 | 627 | 0 | false | false
Queue 5 | 5 | 125 | 0 | true | true
Default queue | 5 | 125 | 0 | false | false
```
Die folgende Abfrage zeigt den Status eines dynamischen WLM-Übergangs an. Während der Übergang läuft, werden `num_query_tasks` und `target_query_working_mem` aktualisiert, bis sie den Zielwerten entsprechen. Weitere Informationen finden Sie unter [Dynamische und statische WLM-Konfigurationseigenschaften](cm-c-wlm-dynamic-properties.md).
```
select rtrim(name) as name,
num_query_tasks as slots,
target_num_query_tasks as target_slots,
query_working_mem as memory,
target_query_working_mem as target_memory
from stv_wlm_service_class_config
where num_query_tasks > target_num_query_tasks
or query_working_mem > target_query_working_mem
and service_class > 5;
name | slots | target_slots | memory | target_mem
------------------+-------+--------------+--------+------------
Queue 3 | 5 | 15 | 125 | 375
Queue 5 | 10 | 5 | 250 | 125
(2 rows)
```
# STV\$1WLM\$1SERVICE\$1CLASS\$1STATE
Enthält den derzeitigen Status der Service-Klassen.
STV\$1WLM\$1SERVICE\$1CLASS\$1STATE ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_STATE.html)
## Beispielabfrage
Die folgende Abfrage zeigt den Status für Service-Klassen über 5 an. Eine Liste der Serviceklassen finden IDs Sie unter[WLM-Serviceklasse IDs](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
```
select service_class, num_executing_queries,
num_executed_queries
from stv_wlm_service_class_state
where service_class > 5
order by service_class;
```
```
service_class | num_executing_queries | num_executed_queries
---------------+-----------------------+----------------------
6 | 1 | 222
7 | 0 | 135
8 | 1 | 39
(3 rows)
```
# STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE
Verwenden Sie STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE, um den Migrationsfortschritt jeder Tabelle während einer klassischen Größenänderung zu überwachen. Dies gilt insbesondere, wenn der Zielknotentyp ist RA3. Weitere Informationen zur klassischen Größenänderung an RA3 Knoten finden Sie unter [Klassische Größenänderung](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster).
STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE ist nur für Superuser sichtbar. Weitere Informationen finden Sie unter [Sichtbarkeit der Daten in Systemtabellen und Ansichten](cm_chap_system-tables.md#c_visibility-of-data).
Einige oder alle Daten in dieser Tabelle sind auch in der SYS-Überwachungsansicht [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md) zu finden. Die Daten in der SYS-Überwachungsansicht sind so formatiert, dass sie leichter verwendbar und besser verständlich sind. Wir empfehlen Ihnen, für Ihre Abfragen die SYS-Überwachungsansicht zu verwenden.
## Tabellenspalten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/redshift/latest/dg/r_STV_XRESTORE_ALTER_QUEUE_STATE.html)
## Beispielabfrage
Die folgende Abfrage zeigt die Anzahl der Tabellen in einer Datenbank, die auf eine Größenänderung warten, deren Größe gerade geändert wird und deren Größenänderung abgeschlossen ist.
```
select db_id, status, count(*)
from stv_xrestore_alter_queue_state
group by 1,2 order by 3 desc
db_id | status | count
-------+------------+------
694325 | Waiting | 323
694325 | Finished | 60
694325 | Applying | 1
```