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à.
# Scaricamento dei dati in Amazon Redshift
Per scaricare i dati dalle tabelle di database in un set di file in un bucket Amazon S3, è possibile usare il comando [UNLOAD](r_UNLOAD.md) con un'istruzione SELECT. Puoi scaricare i dati di testo in formato delimitato o a larghezza fissa, indipendentemente dal formato usato per caricare i dati. Puoi anche specificare se creare file GZIP compressi.
È possibile limitare l'accesso degli utenti al bucket Amazon S3 usando credenziali di sicurezza temporanee.
**Topics**
+ [Scaricamento dei dati in Amazon S3](t_Unloading_tables.md)
+ [Scaricamento di file di dati crittografati](t_unloading_encrypted_files.md)
+ [Scaricamento dei dati in formato delimitato o a larghezza fissa](t_unloading_fixed_width_data.md)
+ [Nuovo caricamento dei dati scaricati](t_Reloading_unload_files.md)
# Scaricamento dei dati in Amazon S3
Amazon Redshift suddivide i risultati di un'istruzione SELECT in un set di file, tra uno o più file per sezione del nodo, per semplificare il ricaricamento parallelo dei dati. In alternativa, puoi specificare che [UNLOAD](r_UNLOAD.md) deve scrivere i risultati in modo seriale in uno o più file aggiungendo l'opzione PARALLEL OFF. Puoi limitare le dimensioni dei file in Amazon S3 specificando il parametro MAXFILESIZE. UNLOAD esegue automaticamente la crittografia dei file di dati usando la crittografia lato server di Amazon S3 (SSE-S3).
Nel comando UNLOAD è possibile usare qualsiasi istruzione SELECT supportata da Amazon Redshift, ad eccezione di un'istruzione SELECT che usa la clausola LIMIT nella parte esterna. Puoi ad esempio usare un'istruzione SELECT che include colonne specifiche o che usa una clausola WHERE per unire più tabelle. Se la query contiene virgolette (ad esempio per racchiudere valori letterali), è necessario farle precedere da un carattere di escape (\$1') nel testo della query. Per ulteriori informazioni, consultare le informazioni di riferimento per il comando [SELECT](r_SELECT_synopsis.md). Per ulteriori informazioni sull'uso di una clausola LIMIT, consultare le [Note per l’utilizzo](r_UNLOAD.md#unload-usage-notes) per il comando UNLOAD.
Il comando UNLOAD seguente invia, ad esempio, i contenuti della tabella VENUE al bucket Amazon S3 `s3://amzn-s3-demo-bucket/tickit/unload/`.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/unload/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
I nomi dei file creati nell'esempio precedente includono il prefisso "`venue_`".
```
venue_0000_part_00
venue_0001_part_00
venue_0002_part_00
venue_0003_part_00
```
Per impostazione predefinita, UNLOAD scrive i dati in parallelo in più file, in base al numero di sezioni nel cluster. Per scrivere i dati in un singolo file, specifica PARALLEL OFF. UNLOAD scrive i dati in modo seriale, con un ordinamento assoluto in base alla clausola ORDER BY, se viene usata. Le dimensioni massime per un file di dati sono di 6,2 GB. Se le dimensioni dei dati superano il limite massimo, UNLOAD crea file aggiuntivi con dimensioni fino a 6,2 GB ognuno.
L'esempio seguente scrive i contenuti di VENUE in un singolo file. È richiesto un solo file perché le sue dimensioni sono inferiori a 6,2 GB.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/unload/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
parallel off;
```
**Nota**
Il comando UNLOAD è progettato per usare l'elaborazione parallela. Nella maggior parte dei casi, è consigliabile lasciare abilitata l'opzione PARALLEL, in particolare se i file verranno usati per caricare le tabelle usando un comando COPY.
Presupponendo che le dimensioni totali di VENUE siano di 5 GB, l'esempio seguente scrive i contenuti di VENUE in 50 file, ognuno di dimensioni di 100 MB.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/unload/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
parallel off
maxfilesize 100 mb;
```
Se si include un prefisso nella stringa del percorso Amazon S3, UNLOAD userà tale prefisso per i nomi di file.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/unload/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Puoi creare un file manifest che elenca i file scaricati specificando l'opzione MANIFEST nel comando UNLOAD. Il manifest è un file di testo in formato JSON che elenca in modo esplicito l'URL di ciascun file scritto in Amazon S3.
L'esempio seguente include l'opzione MANIFEST.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
L'esempio seguente mostra un manifest per quattro file scaricati.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/tickit/venue_0000_part_00"},
{"url":"s3://amzn-s3-demo-bucket/tickit/venue_0001_part_00"},
{"url":"s3://amzn-s3-demo-bucket/tickit/venue_0002_part_00"},
{"url":"s3://amzn-s3-demo-bucket/tickit/venue_0003_part_00"}
]
}
```
Il file manifest può essere usato per caricare gli stessi file usando un comando COPY con l'opzione MANIFEST. Per ulteriori informazioni, consultare [Utilizzo di un manifest per specificare i fili di dati](loading-data-files-using-manifest.md).
Dopo aver completato un'operazione UNLOAD, verificare che i dati siano stati scaricati correttamente passando al bucket Amazon S3 in cui UNLOAD ha scritto i file. Vedrai uno o più file numerati per sezione, a partire dal numero zero. Se hai specificato l'opzione MANIFEST, sarà presente anche un file che termina con "`manifest`". Esempio:
```
amzn-s3-demo-bucket/tickit/venue_0000_part_00
amzn-s3-demo-bucket/tickit/venue_0001_part_00
amzn-s3-demo-bucket/tickit/venue_0002_part_00
amzn-s3-demo-bucket/tickit/venue_0003_part_00
amzn-s3-demo-bucket/tickit/venue_manifest
```
È possibile ottenere un elenco dei file scritti su Amazon S3 a livello di programmazione chiamando un'operazione di elenco Amazon S3 dopo il completamento di UNLOAD. È inoltre possibile eseguire una query su STL\$1UNLOAD\$1LOG.
La query seguente restituisce il percorso per i file creati da un comando UNLOAD. La funzione [PG\$1LAST\$1QUERY\$1ID](PG_LAST_QUERY_ID.md) restituisce la query più recente.
```
select query, substring(path,0,40) as path
from stl_unload_log
where query=2320
order by path;
query | path
-------+--------------------------------------
2320 | s3://amzn-s3-demo-bucket/venue0000_part_00
2320 | s3://amzn-s3-demo-bucket/venue0001_part_00
2320 | s3://amzn-s3-demo-bucket/venue0002_part_00
2320 | s3://amzn-s3-demo-bucket/venue0003_part_00
(4 rows)
```
Se la quantità dei dati è molto elevata, Amazon Redshift può suddividere i file in più parti per sezione. Esempio:
```
venue_0000_part_00
venue_0000_part_01
venue_0000_part_02
venue_0001_part_00
venue_0001_part_01
venue_0001_part_02
...
```
Il comando UNLOAD seguente include una stringa tra virgolette nell'istruzione SELECT, pertanto per le virgolette viene eseguito l'escape (`=\'OH\' '`).
```
unload ('select venuename, venuecity from venue where venuestate=\'OH\' ')
to 's3://amzn-s3-demo-bucket/tickit/venue/ '
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Per impostazione predefinita, UNLOAD ha esito negativo se deve sovrascrivere i file esistenti nel bucket di destinazione. Per sovrascrivere i file esistenti, incluso il file manifest, specifica l'opzione ALLOWOVERWRITE.
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/venue_pipe_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest
allowoverwrite;
```
# Scaricamento di file di dati crittografati
Il comando UNLOAD crea automaticamente i file utilizzando la crittografia lato server di Amazon S3 con chiavi di crittografia gestite da AWS (SSE-S3). È inoltre possibile specificare la crittografia lato server con una AWS Key Management Service chiave (SSE-KMS) o la crittografia lato client con una chiave gestita dal cliente. UNLOAD non supporta la crittografia lato server di Amazon S3 con una chiave fornita dal cliente. Per ulteriori informazioni, consulta [Protezione dei dati con la crittografia lato server](https://docs.aws.amazon.com/AmazonS3/latest/userguide/serv-side-encryption.html).
Per eseguire lo scaricamento su Amazon S3 utilizzando la crittografia lato server con AWS KMS una chiave, utilizza il parametro KMS\$1KEY\$1ID per fornire l'ID della chiave, come mostrato nell'esempio seguente.
```
unload ('select venuename, venuecity from venue')
to 's3://amzn-s3-demo-bucket/encrypted/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
KMS_KEY_ID '1234abcd-12ab-34cd-56ef-1234567890ab'
encrypted;
```
Se si desidera fornire una chiave di crittografia personalizzata, è possibile creare file di dati con crittografia lato client in Amazon S3 usando il comando UNLOAD con l'opzione ENCRYPTED. UNLOAD usa lo stesso processo di crittografia envelope usato dalla crittografia lato client di Amazon S3. Puoi quindi usare il comando COPY con l'opzione ENCRYPTED per caricare i file crittografati.
Il processo avviene in questo modo:
1. Devi creare una chiave AES a 256 bit con codifica base64 da usare come chiave di crittografia privata o *chiave simmetrica root*.
1. Invia un comando UNLOAD che include la chiave simmetrica root e l'opzione ENCRYPTED.
1. UNLOAD genera una chiave one-time-use simmetrica (chiamata chiave simmetrica della *busta) e un vettore di inizializzazione (IV), che utilizza per* crittografare i dati.
1. UNLOAD esegue la crittografia della chiave simmetrica envelope usando la chiave simmetrica root.
1. UNLOAD archivia quindi i file di dati crittografati in Amazon S3 e archivia la chiave envelope crittografata e il vettore di inizializzazione come metadati degli oggetti con ogni file. La chiave envelope crittografata viene archiviata come metadati degli oggetti `x-amz-meta-x-amz-key` e il vettore di inizializzazione viene archiviato come metadati degli oggetti `x-amz-meta-x-amz-iv`.
Per ulteriori informazioni sul processo di crittografia delle buste, consulta l'articolo [Crittografia dei dati lato client con SDK for AWS Java e Amazon](https://aws.amazon.com/articles/2850096021478074) S3.
Per scaricare i file di dati crittografati, aggiungi il valore della chiave root alla stringa di credenziali e includi l'opzione ENCRYPTED. Se usi l'opzione MANIFEST, viene crittografato anche il file manifest.
```
unload ('select venuename, venuecity from venue')
to 's3://amzn-s3-demo-bucket/encrypted/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
master_symmetric_key ''
manifest
encrypted;
```
Per scaricare file di dati crittografati compressi in formato GZIP, includi l'opzione GZIP insieme al valore della chiave root e all'opzione ENCRYPTED.
```
unload ('select venuename, venuecity from venue')
to 's3://amzn-s3-demo-bucket/encrypted/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
master_symmetric_key ''
encrypted gzip;
```
Per caricare i file di dati crittografati, aggiungi il parametro MASTER\$1SYMMETRIC\$1KEY con lo stesso valore della chiave root e includi l'opzione ENCRYPTED.
```
copy venue from 's3://amzn-s3-demo-bucket/encrypted/venue_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
master_symmetric_key ''
encrypted;
```
# Scaricamento dei dati in formato delimitato o a larghezza fissa
Puoi scaricare i dati in formato delimitato o a larghezza fissa. L'output predefinito è delimitato da barra verticale (usando il carattere "\$1").
L'esempio seguente specifica la virgola come delimitatore:
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/venue/comma'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter ',';
```
I file di output risultanti avranno l'aspetto seguente:
```
20,Air Canada Centre,Toronto,ON,0
60,Rexall Place,Edmonton,AB,0
100,U.S. Cellular Field,Chicago,IL,40615
200,Al Hirschfeld Theatre,New York City,NY,0
240,San Jose Repertory Theatre,San Jose,CA,0
300,Kennedy Center Opera House,Washington,DC,0
...
```
Per scaricare lo stesso set di risultati in un file delimitato da tabulazioni, usa il comando seguente:
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/venue/tab'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter as '\t';
```
In alternativa, puoi usare una specifica FIXEDWIDTH. Questa specifica è costituita da un identificatore per ogni colonna di tabella e dalla larghezza della colonna (numero di caratteri). Il comando UNLOAD ha esito negativo se deve troncare i dati, quindi specifica una larghezza almeno equivalente alla voce più lunga per la colonna. Lo scaricamento di dati a larghezza fissa è analogo a quello di dati delimitati, ad eccezione del fatto che l'output risultante non contiene caratteri di delimitazione. Esempio:
```
unload ('select * from venue')
to 's3://amzn-s3-demo-bucket/tickit/venue/fw'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth '0:3,1:100,2:30,3:2,4:6';
```
L'output a larghezza fissa ha l'aspetto seguente:
```
20 Air Canada Centre Toronto ON0
60 Rexall Place Edmonton AB0
100U.S. Cellular Field Chicago IL40615
200Al Hirschfeld Theatre New York CityNY0
240San Jose Repertory TheatreSan Jose CA0
300Kennedy Center Opera HouseWashington DC0
```
Per ulteriori informazioni sulle specifiche FIXEDWIDTH, consultare il comando [UNLOAD](r_UNLOAD.md).
# Nuovo caricamento dei dati scaricati
Per ricaricare i risultati di un'operazione di scaricamento, puoi usare un comando COPY.
L'esempio seguente mostra un caso semplice in cui la tabella VENUE viene scaricata usando un file manifest, troncata e ricaricata.
```
unload ('select * from venue order by venueid')
to 's3://amzn-s3-demo-bucket/tickit/venue/reload_'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest
delimiter '|';
truncate venue;
copy venue
from 's3://amzn-s3-demo-bucket/tickit/venue/reload_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest
delimiter '|';
```
Dopo il ricaricamento, l'aspetto della tabella VENUE è simile al seguente:
```
select * from venue order by venueid limit 5;
venueid | venuename | venuecity | venuestate | venueseats
---------+---------------------------+-------------+------------+-----------
1 | Toyota Park | Bridgeview | IL | 0
2 | Columbus Crew Stadium | Columbus | OH | 0
3 | RFK Stadium | Washington | DC | 0
4 | CommunityAmerica Ballpark | Kansas City | KS | 0
5 | Gillette Stadium | Foxborough | MA | 68756
(5 rows)
```