Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Query di diagnostica per l'ottimizzazione di query
Utilizza le seguenti query per rilevare problemi con le query o con le loro tabelle sottostanti, che possono influenzare le prestazioni delle query. Consigliamo l'uso di queste query in combinazione con i processi di ottimizzazione della query illustrati su [Analisi e miglioramento delle query](c-query-tuning.md).
**Nota**
Queste query riguardano i cluster con provisioning Amazon Redshift. Queste query non possono essere utilizzate con i gruppi di lavoro Redshift serverless.
**Topics**
+ [Identificazione delle migliori query per l'ottimizzazione](identify-queries-that-are-top-candidates-for-tuning.md)
+ [Identificazione delle tabelle con differenza di dati o con righe non ordinate](identify-tables-with-data-skew-or-unsorted-rows.md)
+ [Identificazione di query con loop nidificati](identify-queries-with-nested-loops.md)
+ [Revisione dei tempi di attesa della coda per le query](review-queue-wait-times-for-queries.md)
+ [Revisione degli avvisi di query per tabella](review-query-alerts-by-table.md)
+ [Identificazione delle tabelle con statistiche mancanti](identify-tables-with-missing-statistics.md)
# Identificazione delle migliori query per l'ottimizzazione
Le seguenti query identificano le 50 istruzioni più dispendiose in termini di tempo, che sono state eseguite negli ultimi 7 giorni. È possibile utilizzare i risultati per identificare le query che impiegano un tempo insolitamente lungo. È possibile anche identificare le query che vengono eseguite frequentemente (ovvero quelle che appaiono più di una volta nell'insieme di risultati). Queste sono spesso buone query da ottimizzare per migliorare le prestazioni del sistema.
Questa query fornisce inoltre un numero di eventi di avviso associati a ogni query rilevata. Questi avvisi forniscono dettagli che puoi utilizzare per migliorare le prestazioni della query. Per ulteriori informazioni, consultare [Revisione degli avvisi di query](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;
```
# Identificazione delle tabelle con differenza di dati o con righe non ordinate
La seguente query identifica le tabelle che dispongono di una distribuzione di dati non uniforme (differenza di dati) o di un'alta percentuale di righe non ordinate.
Un valore `skew` basso indica che i dati della tabella sono distribuiti in modo idoneo. Se una tabella ha un valore `skew` maggiore o uguale a 4.00, considera la modifica del suo stile di distribuzione dei dati. Per ulteriori informazioni, consultare [Distribuzione dei dati non ottimale](query-performance-improvement-opportunities.md#suboptimal-data-distribution).
Se una tabella ha un valore `pct_unsorted` maggiore del 20 percento, considera l'esecuzione del comando [VACUUM](r_VACUUM_command.md). Per ulteriori informazioni, consultare [Righe non ordinate o ordinate in modo errato](query-performance-improvement-opportunities.md#unsorted-or-mis-sorted-rows).
Dovresti anche rivedere i valori `mbytes` e `pct_of_total` di ogni tabella. Queste colonne identificano le dimensioni della tabella e la percentuale dello spazio del disco non elaborato che consuma la tabella. Questo spazio include lo spazio riservato da Amazon Redshift per uso interno, di conseguenza è superiore alla capacità nominale del disco, ovvero lo spazio su disco disponibile per l'utente. Utilizza queste informazioni per essere sicuro di disporre di uno spazio libero del disco pari ad almeno due volte e mezza la dimensione della tabella più grande. La disponibilità di questo spazio, permette al sistema di scrivere risultati intermedi sul disco quando si elaborano query complesse.
```
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;
```
# Identificazione di query con loop nidificati
La query seguente identifica le query che hanno registrato eventi di avviso per loop nidificati. Per informazioni su come risolvere la condizione del loop nidificato, consultare [Loop nidificato](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;
```
# Revisione dei tempi di attesa della coda per le query
La seguente query illustra il tempo di attesa di query recenti per aprire uno slot nella coda della query, prima che potessero essere eseguite. Se i tempi di attesa sono tendenzialmente alti, potresti voler modificare la configurazione della coda della query per un migliore throughput. Per ulteriori informazioni, consultare [Implementazione di WLM manuale](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;
```
# Revisione degli avvisi di query per tabella
La query seguente identifica le tabella che hanno registrato eventi di avviso e, inoltre, identifica che tipo di avvisi vengono attivati più di frequente.
Se il valore `minutes` di una riga con una tabella identificata è alto, verifica se è necessario eseguire manutenzione di routine, su questa tabella, come l'esecuzione del comando [ANALYZE](r_ANALYZE.md) o [VACUUM](r_VACUUM_command.md).
Se il valore `count` di una riga è alto ma il valore `table` è nullo, eseguire una query con STL\$1ALERT\$1EVENT\$1LOG per il valore `event` associato, al fine di investigare sul motivo per il quale l'avviso viene attivato così di frequente.
```
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;
```
# Identificazione delle tabelle con statistiche mancanti
La seguente query fornisce un conteggio delle query che stai eseguendo con tabelle a cui mancano delle statistiche. Se questa query restituisce delle righe, controlla il valore `plannode` per determinare le tabelle in questione, quindi esegui su di esse il comando [ANALYZE](r_ANALYZE.md).
```
select substring(trim(plannode),1,100) as plannode, count(*)
from stl_explain
where plannode like '%missing statistics%'
group by plannode
order by 2 desc;
```