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à.

# Identificazione delle tabelle con differenza di dati o con righe non ordinate
<a name="identify-tables-with-data-skew-or-unsorted-rows"></a>

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;
```