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.
# Diagnoseabfragen zur Abfrageoptimierung
Verwenden Sie die folgenden Abfragen, um Probleme bei Abfragen oder bei den zugrundeliegenden Tabellen zu identifizieren, die zu einer Beeinträchtigung der Abfrageleistung führen können. Wir empfehlen, diese Abfragen zusammen mit dem Abfrageoptimierungsprozess in [Analyse und Verbesserung von Abfragen](c-query-tuning.md) zu verwenden.
**Anmerkung**
Diese Abfragen beziehen sich auf von Amazon Redshift bereitgestellte Cluster. Diese Abfragen sind nicht zur Verwendung mit Redshift Serverless-Arbeitsgruppen vorgesehen.
**Topics**
+ [Identifizieren der Top-Kandidaten zur Optimierung unter den Abfragen](identify-queries-that-are-top-candidates-for-tuning.md)
+ [Identifizieren von Tabellen mit verzerrter Datenverteilung oder unsortierten Zeilen](identify-tables-with-data-skew-or-unsorted-rows.md)
+ [Identifizieren von Abfragen mit verschachtelten Schleifen](identify-queries-with-nested-loops.md)
+ [Überprüfen der Wartezeiten von Abfragen in Warteschlangen](review-queue-wait-times-for-queries.md)
+ [Überprüfen von Abfragewarnungen nach Tabelle](review-query-alerts-by-table.md)
+ [Identifizieren von Tabellen mit fehlender Tabellenstatistik](identify-tables-with-missing-statistics.md)
# Identifizieren der Top-Kandidaten zur Optimierung unter den Abfragen
Die folgende Abfrage identifiziert die 50 zeitaufwändigsten Anweisungen, die in den letzten 7 Tagen ausgeführt wurden. Sie können die Ergebnisse verwenden, um Abfragen zu identifizieren, die ungewöhnlich lange dauern. Sie können auch Abfragen identifizieren, die häufig ausgeführt wurden (die mehrmals in der Ergebnismenge vorkommen). Diese Abfragen sind häufig gute Kandidaten für Abfragen, deren Optimierung die Systemleistung verbessern kann.
Diese Abfrage zählt außerdem die Warnereignisse für die einzelnen identifizierten Abfragen. Diese Warnmeldungen können Detailinformationen enthalten, mit denen Sie die Abfrageleistung verbessern können. Weitere Informationen finden Sie unter [Überprüfen von Abfragewarnungen](c-reviewing-query-alerts.md).
```
select trim(database) as db, count(query) as n_qry,
max(substring (qrytext,1,80)) as qrytext,
min(run_minutes) as "min" ,
max(run_minutes) as "max",
avg(run_minutes) as "avg", sum(run_minutes) as total,
max(query) as max_query_id,
max(starttime)::date as last_run,
sum(alerts) as alerts, aborted
from (select userid, label, stl_query.query,
trim(database) as database,
trim(querytxt) as qrytext,
md5(trim(querytxt)) as qry_md5,
starttime, endtime,
(datediff(seconds, starttime,endtime)::numeric(12,2))/60 as run_minutes,
alrt.num_events as alerts, aborted
from stl_query
left outer join
(select query, 1 as num_events from stl_alert_event_log group by query ) as alrt
on alrt.query = stl_query.query
where userid <> 1 and starttime >= dateadd(day, -7, current_date))
group by database, label, qry_md5, aborted
order by total desc limit 50;
```
# Identifizieren von Tabellen mit verzerrter Datenverteilung oder unsortierten Zeilen
Mit der folgenden Abfrage können Sie Tabellen identifizieren, die eine ungleichmäßige („verzerrte“) Datenverteilung oder einen hohen Prozentsatz an unsortierten Zeilen aufweisen.
Ein geringer `skew`-Wert weist darauf hin, das die Tabellendaten ordnungsgemäß verteilt sind. Wenn eine Tabelle für `skew` einen Wert von 4,00 oder höher hat, sollten Sie erwägen, den Datenverteilungsstil zu ändern. Weitere Informationen finden Sie unter [Suboptimale Datenverteilung](query-performance-improvement-opportunities.md#suboptimal-data-distribution).
Wenn eine Tabelle für `pct_unsorted` einen Wert über 20 Prozent hat, sollten Sie ggf. den Befehl [VACUUM](r_VACUUM_command.md) ausführen. Weitere Informationen finden Sie unter [Unsortierte oder falsch sortierte Zeilen](query-performance-improvement-opportunities.md#unsorted-or-mis-sorted-rows).
Sie sollten auch die `mbytes`- und `pct_of_total`-Werte für jede Tabelle überprüfen. Diese Spalten geben die Größe einer Tabelle an, sowie den Prozentsatz des verfügbaren Bruttospeicherplatzes auf dem Datenträger, den die Tabelle verbraucht. 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. Verwenden Sie diese Informationen, um zu verifizieren, dass der verfügbare Speicherplatz auf dem Datenträger mindestens um den Faktor 2,5 größer ist als Ihre größte Tabelle. Dieser verfügbare Speicherplatz reicht dafür aus, dass das System bei der Verarbeitung von komplexen Abfragen Zwischenergebnisse auf den Datenträger schreiben kann.
```
select trim(pgn.nspname) as schema,
trim(a.name) as table, id as tableid,
decode(pgc.reldiststyle,0, 'even',1,det.distkey ,8,'all') as distkey, dist_ratio.ratio::decimal(10,4) as skew,
det.head_sort as "sortkey",
det.n_sortkeys as "#sks", b.mbytes,
decode(b.mbytes,0,0,((b.mbytes/part.total::decimal)*100)::decimal(5,2)) as pct_of_total,
decode(det.max_enc,0,'n','y') as enc, a.rows,
decode( det.n_sortkeys, 0, null, a.unsorted_rows ) as unsorted_rows ,
decode( det.n_sortkeys, 0, null, decode( a.rows,0,0, (a.unsorted_rows::decimal(32)/a.rows)*100) )::decimal(5,2) as pct_unsorted
from (select db_id, id, name, sum(rows) as rows,
sum(rows)-sum(sorted_rows) as unsorted_rows
from stv_tbl_perm a
group by db_id, id, name) as a
join pg_class as pgc on pgc.oid = a.id
join pg_namespace as pgn on pgn.oid = pgc.relnamespace
left outer join (select tbl, count(*) as mbytes
from stv_blocklist group by tbl) b on a.id=b.tbl
inner join (select attrelid,
min(case attisdistkey when 't' then attname else null end) as "distkey",
min(case attsortkeyord when 1 then attname else null end ) as head_sort ,
max(attsortkeyord) as n_sortkeys,
max(attencodingtype) as max_enc
from pg_attribute group by 1) as det
on det.attrelid = a.id
inner join ( select tbl, max(mbytes)::decimal(32)/min(mbytes) as ratio
from (select tbl, trim(name) as name, slice, count(*) as mbytes
from svv_diskusage group by tbl, name, slice )
group by tbl, name ) as dist_ratio on a.id = dist_ratio.tbl
join ( select sum(capacity) as total
from stv_partitions where part_begin=0 ) as part on 1=1
where mbytes is not null
order by mbytes desc;
```
# Identifizieren von Abfragen mit verschachtelten Schleifen
Die folgende Abfrage identifiziert Abfragen, für die Warnereignisse zu verschachtelten Schleifen protokolliert wurden. Informationen zur Vorgehensweise, um Probleme bei verschachtelten Schleifen zu beheben, finden Sie unter [Verschachtelte Schleife](query-performance-improvement-opportunities.md#nested-loop).
```
select query, trim(querytxt) as SQL, starttime
from stl_query
where query in (
select distinct query
from stl_alert_event_log
where event like 'Nested Loop Join in the query plan%')
order by starttime desc;
```
# Überprüfen der Wartezeiten von Abfragen in Warteschlangen
Die folgende Abfrage zeigt, wie lange kürzlich ausgeführte Abfragen auf einen freien Platz in einer Abfragewarteschlange gewartet haben, bis sie ausgeführt wurden. Wenn Sie eine Tendenz erkennen, dass die Wartezeiten eher lang sind, können Sie die Abfragewarteschlangen modifizieren, um den Durchsatz zu verbessern. Weitere Informationen finden Sie unter [Implementieren von manuellem WLM](cm-c-defining-query-queues.md).
```
select trim(database) as DB , w.query,
substring(q.querytxt, 1, 100) as querytxt, w.queue_start_time,
w.service_class as class, w.slot_count as slots,
w.total_queue_time/1000000 as queue_seconds,
w.total_exec_time/1000000 exec_seconds, (w.total_queue_time+w.total_Exec_time)/1000000 as total_seconds
from stl_wlm_query w
left join stl_query q on q.query = w.query and q.userid = w.userid
where w.queue_start_Time >= dateadd(day, -7, current_Date)
and w.total_queue_Time > 0 and w.userid >1
and q.starttime >= dateadd(day, -7, current_Date)
order by w.total_queue_time desc, w.queue_start_time desc limit 35;
```
# Überprüfen von Abfragewarnungen nach Tabelle
Die folgende Abfrage identifiziert Tabellen, für die Warnereignisse protokolliert wurden, und gibt an, welche Arten von Warnungen am häufigsten ausgelöst wurden.
Wenn in einer aufgeführten Tabelle der `minutes`-Wert für eine Zeile besonders hoch ist, überprüfen Sie, ob für die betreffende Tabelle routinemäßige Wartungsaufgaben durchgeführt werden können, beispielsweise durch Ausführen von [ANALYZE](r_ANALYZE.md) oder [VACUUM](r_VACUUM_command.md) für die betreffende Tabelle.
Wenn der Wert `count` für eine Zeile hoch ist, gleichzeitig der Wert `table` aber Null, führen Sie für den zugehörigen `event`-Wert eine Abfrage über STL\$1ALERT\$1EVENT\$1LOG durch, um herauszufinden, warum die Warnung so oft ausgelöst wird.
```
select trim(s.perm_table_name) as table,
(sum(abs(datediff(seconds, s.starttime, s.endtime)))/60)::numeric(24,0) as minutes, trim(split_part(l.event,':',1)) as event, trim(l.solution) as solution,
max(l.query) as sample_query, count(*)
from stl_alert_event_log as l
left join stl_scan as s on s.query = l.query and s.slice = l.slice
and s.segment = l.segment and s.step = l.step
where l.event_time >= dateadd(day, -7, current_Date)
group by 1,3,4
order by 2 desc,6 desc;
```
# Identifizieren von Tabellen mit fehlender Tabellenstatistik
Die folgende Abfrage zählt die Abfragen, die über Tabellen mit fehlender Tabellenstatistik ausgeführt wurden. Wenn diese Abfrage Zeilen zurückgibt, achten Sie auf den Wert von `plannode`, um die betreffende Tabelle zu ermitteln, und führen Sie dann über dieser Tabelle den Befehl [ANALYZE](r_ANALYZE.md) aus.
```
select substring(trim(plannode),1,100) as plannode, count(*)
from stl_explain
where plannode like '%missing statistics%'
group by plannode
order by 2 desc;
```