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à.
# Comandi SQL
Il linguaggio SQL è composto da comandi che usi per creare e manipolare oggetti di database, eseguire query, caricare tabelle e modificare i dati nelle tabelle.
Amazon Redshift è basato su PostgreSQL. Amazon Redshift e PostgreSQL si differenziano per un certo numero di aspetti molto importanti, di cui bisogna tener conto mentre si progettano e sviluppano le applicazioni di data warehouse. Per informazioni sulle differenze tra Amazon Redshift SQL e PostgreSQL, consultare [Amazon Redshift e PostgreSQL](c_redshift-and-postgres-sql.md).
**Nota**
Le dimensioni massime per una istruzione SQL è di 16 MB.
**Topics**
+ [ABORT](r_ABORT.md)
+ [ALTER DATABASE](r_ALTER_DATABASE.md)
+ [ALTER DATASHARE](r_ALTER_DATASHARE.md)
+ [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)
+ [ALTER EXTERNAL SCHEMA](r_ALTER_EXTERNAL_SCHEMA.md)
+ [ALTER EXTERNAL VIEW](r_ALTER_EXTERNAL_VIEW.md)
+ [ALTER FUNCTION](r_ALTER_FUNCTION.md)
+ [ALTER GROUP](r_ALTER_GROUP.md)
+ [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md)
+ [ALTER MASKING POLICY](r_ALTER_MASKING_POLICY.md)
+ [ALTER MATERIALIZED VIEW](r_ALTER_MATERIALIZED_VIEW.md)
+ [ALTER RLS POLICY](r_ALTER_RLS_POLICY.md)
+ [ALTER ROLE](r_ALTER_ROLE.md)
+ [ALTER PROCEDURE](r_ALTER_PROCEDURE.md)
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [ALTER SYSTEM](r_ALTER_SYSTEM.md)
+ [ALTER TABLE](r_ALTER_TABLE.md)
+ [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md)
+ [MODIFICA MODELLO](r_ALTER_TEMPLATE.md)
+ [ALTER USER](r_ALTER_USER.md)
+ [ANALYZE](r_ANALYZE.md)
+ [ANALYZE COMPRESSION](r_ANALYZE_COMPRESSION.md)
+ [ATTACH MASKING POLICY](r_ATTACH_MASKING_POLICY.md)
+ [ATTACH RLS POLICY](r_ATTACH_RLS_POLICY.md)
+ [BEGIN](r_BEGIN.md)
+ [CALL](r_CALL_procedure.md)
+ [CANCEL](r_CANCEL.md)
+ [CLOSE](close.md)
+ [COMMENT](r_COMMENT.md)
+ [COMMIT](r_COMMIT.md)
+ [COPY](r_COPY.md)
+ [CREATE DATABASE](r_CREATE_DATABASE.md)
+ [CREARE DATASHARE](r_CREATE_DATASHARE.md)
+ [CREATE EXTERNAL FUNCTION](r_CREATE_EXTERNAL_FUNCTION.md)
+ [CREATE EXTERNAL MODEL](r_create_external_model.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)
+ [CREATE EXTERNAL VIEW](r_CREATE_EXTERNAL_VIEW.md)
+ [CREATE FUNCTION](r_CREATE_FUNCTION.md)
+ [CREATE GROUP](r_CREATE_GROUP.md)
+ [CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md)
+ [CREATE LIBRARY](r_CREATE_LIBRARY.md)
+ [CREATE MASKING POLICY](r_CREATE_MASKING_POLICY.md)
+ [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md)
+ [CREATE MODEL](r_CREATE_MODEL.md)
+ [CREATE PROCEDURE](r_CREATE_PROCEDURE.md)
+ [CREATE RLS POLICY](r_CREATE_RLS_POLICY.md)
+ [CREATE ROLE](r_CREATE_ROLE.md)
+ [CREATE SCHEMA](r_CREATE_SCHEMA.md)
+ [CREATE TABLE](r_CREATE_TABLE_NEW.md)
+ [CREATE TABLE AS](r_CREATE_TABLE_AS.md)
+ [CREARE UN MODELLO](r_CREATE_TEMPLATE.md)
+ [CREA UTENTE](r_CREATE_USER.md)
+ [CREATE VIEW](r_CREATE_VIEW.md)
+ [DEALLOCATE](r_DEALLOCATE.md)
+ [DECLARE](declare.md)
+ [DELETE](r_DELETE.md)
+ [DESC DATASHARE](r_DESC_DATASHARE.md)
+ [DESC IDENTITY PROVIDER](r_DESC_IDENTITY_PROVIDER.md)
+ [DETACH MASKING POLICY](r_DETACH_MASKING_POLICY.md)
+ [DETACH RLS POLICY](r_DETACH_RLS_POLICY.md)
+ [DROP DATABASE](r_DROP_DATABASE.md)
+ [DROP DATASHARE](r_DROP_DATASHARE.md)
+ [DROP EXTERNAL VIEW](r_DROP_EXTERNAL_VIEW.md)
+ [DROP FUNCTION](r_DROP_FUNCTION.md)
+ [DROP GROUP](r_DROP_GROUP.md)
+ [DROP IDENTITY PROVIDER](r_DROP_IDENTITY_PROVIDER.md)
+ [DROP LIBRARY](r_DROP_LIBRARY.md)
+ [DROP MASKING POLICY](r_DROP_MASKING_POLICY.md)
+ [DROP MODEL](r_DROP_MODEL.md)
+ [DROP MATERIALIZED VIEW](materialized-view-drop-sql-command.md)
+ [DROP PROCEDURE](r_DROP_PROCEDURE.md)
+ [DROP RLS POLICY](r_DROP_RLS_POLICY.md)
+ [DROP ROLE](r_DROP_ROLE.md)
+ [DROP SCHEMA](r_DROP_SCHEMA.md)
+ [DROP TABLE](r_DROP_TABLE.md)
+ [RILASCIA UN MODELLO](r_DROP_TEMPLATE.md)
+ [DROP USER](r_DROP_USER.md)
+ [DROP VIEW](r_DROP_VIEW.md)
+ [END](r_END.md)
+ [EXECUTE](r_EXECUTE.md)
+ [EXPLAIN](r_EXPLAIN.md)
+ [FETCH](fetch.md)
+ [GRANT](r_GRANT.md)
+ [INSERT](r_INSERT_30.md)
+ [INSERT (tabella esterna)](r_INSERT_external_table.md)
+ [LOCK](r_LOCK.md)
+ [MERGE](r_MERGE.md)
+ [PREPARE](r_PREPARE.md)
+ [REFRESH MATERIALIZED VIEW](materialized-view-refresh-sql-command.md)
+ [RESET](r_RESET.md)
+ [REVOKE](r_REVOKE.md)
+ [ROLLBACK](r_ROLLBACK.md)
+ [SELECT](r_SELECT_synopsis.md)
+ [SELECT INTO](r_SELECT_INTO.md)
+ [SET](r_SET.md)
+ [SET SESSION AUTHORIZATION](r_SET_SESSION_AUTHORIZATION.md)
+ [SET SESSION CHARACTERISTICS](r_SET_SESSION_CHARACTERISTICS.md)
+ [MOSTRA](r_SHOW.md)
+ [MOSTRA LE CONCESSIONI ALLE COLONNE](r_SHOW_COLUMN_GRANTS.md)
+ [SHOW COLUMNS](r_SHOW_COLUMNS.md)
+ [MOSTRA I VINCOLI](r_SHOW_CONSTRAINTS.md)
+ [SHOW EXTERNAL TABLE](r_SHOW_EXTERNAL_TABLE.md)
+ [SHOW DATABASES](r_SHOW_DATABASES.md)
+ [MOSTRA LE FUNZIONI](r_SHOW_FUNCTIONS.md)
+ [SHOW GRANTS](r_SHOW_GRANTS.md)
+ [SHOW MODEL](r_SHOW_MODEL.md)
+ [SHOW DATASHARES](r_SHOW_DATASHARES.md)
+ [MOSTRA PARAMETRI](r_SHOW_PARAMETERS.md)
+ [MOSTRA LE POLITICHE](r_SHOW_POLICIES.md)
+ [SHOW PROCEDURE](r_SHOW_PROCEDURE.md)
+ [MOSTRA PROCEDURE](r_SHOW_PROCEDURES.md)
+ [SHOW SCHEMAS](r_SHOW_SCHEMAS.md)
+ [SHOW TABLE](r_SHOW_TABLE.md)
+ [SHOW TABLES](r_SHOW_TABLES.md)
+ [MOSTRA MODELLO](r_SHOW_TEMPLATE.md)
+ [MOSTRA MODELLI](r_SHOW_TEMPLATES.md)
+ [SHOW VIEW](r_SHOW_VIEW.md)
+ [START TRANSACTION](r_START_TRANSACTION.md)
+ [TRUNCATE](r_TRUNCATE.md)
+ [UNLOAD](r_UNLOAD.md)
+ [UPDATE](r_UPDATE.md)
+ [USE](r_USE_command.md)
+ [VACUUM](r_VACUUM_command.md)
# ABORT
Interrompe la transazione attualmente in esecuzione ed elimina tutti gli aggiornamenti apportati da quella transazione. ABORT non ha alcun effetto sulle transazioni già completate.
Questo comando esegue la stessa funzione del comando ROLLBACK. Per informazioni, consultare [ROLLBACK](r_ROLLBACK.md).
## Sintassi
```
ABORT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Parola chiave facoltativa.
TRANSACTION
Parola chiave facoltativa; WORK e TRANSACTION sono sinonimi.
## Esempio
L'esempio seguente crea una tabella quindi avvia una transazione in cui i dati vengono inseriti nella tabella. Il comando ABORT esegue quindi il rollback dell'inserimento dei dati per lasciare vuota la tabella.
Il seguente comando crea una tabella di esempio chiamata MOVIE\$1GROSS:
```
create table movie_gross( name varchar(30), gross bigint );
```
Il prossimo set di comandi avvia una transazione che inserisce due righe di dati nella tabella:
```
begin;
insert into movie_gross values ( 'Raiders of the Lost Ark', 23400000);
insert into movie_gross values ( 'Star Wars', 10000000 );
```
Successivamente, il seguente comando seleziona i dati dalla tabella per mostrare che è stato inserito:
```
select * from movie_gross;
```
L'output del comando mostra che entrambe le righe sono state inserite:
```
name | gross
------------------------+----------
Raiders of the Lost Ark | 23400000
Star Wars | 10000000
(2 rows)
```
Questo comando esegue ora il rollback delle modifiche dei dati dove è iniziata la transazione:
```
abort;
```
Selezionando i dati dalla tabella ora mostra una tabella vuota:
```
select * from movie_gross;
name | gross
------+-------
(0 rows)
```
# ALTER DATABASE
Cambia gli attributi di un database.
## Privilegi richiesti
Per utilizzare ALTER DATABASE, è richiesto uno dei seguenti privilegi.
+ Superuser
+ Utenti con il privilegio ALTER DATABASE
+ Proprietario del database
## Sintassi
```
ALTER DATABASE database_name
{
RENAME TO new_name
| OWNER TO new_owner
| [ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
| INTEGRATION
{
REFRESH { { ALL | INERROR } TABLES [ IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] }
| SET
[ QUERY_ALL_STATES [=] { TRUE | FALSE } ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE } ]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} [ FOR { {ALL} TABLES [IN SCHEMA schema [, ...] ] | TABLE schema.table [, ...] } ] ]
}
}
```
## Parameters
*database\$1name*
Nome del database da modificare. In genere, si modifica un database a cui non si è attualmente connessi; in ogni caso, le modifiche hanno effetto solo nelle sessioni successive. Puoi modificare il proprietario del database corrente, ma non è possibile rinominarlo:
```
alter database tickit rename to newtickit;
ERROR: current database may not be renamed
```
RENAME TO
Rinomina il database specificato. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md). Non puoi rinominare i database dev, padb\$1harvest, template0, template1 o sys:internal e non puoi rinominare il database corrente. Solo il proprietario del database o un [superuser](r_superusers.md#def_superusers) può rinominare un database; i proprietari che non sono utenti con privilegi avanzati devono inoltre avere il privilegio CREATEDB.
*new\$1name*
Nuovo nome del database.
OWNER TO
Cambia il proprietario del database specificato. Puoi modificare il proprietario del database corrente o di un altro database. Solo un utente con privilegi avanzati può cambiare il proprietario.
*new\$1owner*
Nuovo proprietario del database. Il nuovo proprietario deve essere un utente di database esistente con privilegi di scrittura. Per ulteriori informazioni sui privilegi degli utenti, consultare [GRANT](r_GRANT.md).
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
Numero massimo di connessioni di database che gli utenti possono aprire contemporaneamente. Il limite non viene applicato per gli utenti con privilegi avanzati. Utilizza la parola chiave UNLIMITED per consentire il numero massimo di connessioni simultanee. È possibile che venga applicato anche un limite al numero di connessioni per ciascun utente. Per ulteriori informazioni, consultare [CREA UTENTE](r_CREATE_USER.md). Il valore predefinito è UNLIMITED. Per visualizzare le connessioni correnti, eseguire una query sulla vista di sistema [STV\$1SESSIONS](r_STV_SESSIONS.md).
Se si applicano entrambi i limiti di connessione utente e database, deve essere disponibile uno slot di connessione inutilizzato che rientra in entrambi i limiti quando un utente tenta di connettersi.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Una clausola che specifica se la ricerca o il confronto tra stringhe fa distinzione tra maiuscole e minuscole o meno.
Puoi modificare la distinzione tra maiuscole e minuscole del database corrente anche se è vuoto.
Per modificare la distinzione tra maiuscole e minuscole, devi disporre dell’autorizzazione ALTER per il database corrente. Gli utenti con privilegi avanzati o i proprietari di database con l’autorizzazione CREATE DATABASE possono anche modificare la distinzione tra maiuscole e minuscole per i database.
CASE\$1SENSITIVE e CS sono intercambiabili e producono gli stessi risultati. Allo stesso modo CASE\$1INSENSITIVE e CI sono intercambiabili e producono gli stessi risultati.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Una clausola che specifica il livello di isolamento utilizzato quando vengono eseguite query su un database. Per ulteriori informazioni sui livello di isolamento, consulta [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
+ Isolamento SNAPSHOT: fornisce un livello di isolamento con protezione contro i conflitti di aggiornamento ed eliminazione.
+ Isolamento SERIALIZABLE: fornisce la serializzabilità completa per le transazioni simultanee.
Considerare quanto segue durante la modifica del livello di isolamento di un database:
+ Per modificare il livello di isolamento del database, è necessario disporre del privilegio utente con privilegi avanzati o del privilegio CREATE DATABASE per il database corrente.
+ Non è possibile modificare il livello di isolamento del database `dev`.
+ Non è possibile modificare il livello di isolamento all'interno di un blocco di transazioni.
+ Il comando alter isolation level non riesce se altri utenti sono connessi al database.
+ Il comando alter isolation level può modificare le impostazioni del livello di isolamento della sessione corrente.
INTEGRATION
Modifica un database di integrazione Zero-ETL.
REFRESH \$1\$1 ALL \$1 INERROR \$1 TABLES [IN SCHEMA *schema* [, ...]] \$1 TABLE *schema.table* [, ...]\$1
Una clausola che specifica se Amazon Redshift aggiorna tutte le tabelle o le tabelle con errori nello schema o nella tabella specificati. L'aggiornamento attiverà la replica completa delle tabelle nello schema o nella tabella specificati dal database di origine.
Per ulteriori informazioni, consulta [Integrazioni Zero-ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html) nella *Guida alla gestione di Amazon Redshift*. Per ulteriori informazioni sugli stati di integrazione, consulta [SVV\$1INTEGRATION\$1TABLE\$1STATE](r_SVV_INTEGRATION_TABLE_STATE.md) e [SVV\$1INTEGRATION](r_SVV_INTEGRATION.md).
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
La clausola QUERY\$1ALL\$1STATES imposta se è possibile eseguire query sulle tabelle di integrazione Zero-ETL in tutti gli stati (`Synced`, `Failed`, `ResyncRequired` e `ResyncInitiated`). Per impostazione predefinita puoi eseguire query su una tabella di integrazione Zero-ETL solo nello stato `Synced`.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
La clausola ACCEPTINVCHARS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando per il tipo di dati VARCHAR vengono rilevati caratteri non validi. Quando vengono rilevati caratteri non validi, il carattere non valido viene sostituito con un carattere `?` predefinito.
REFRESH\$1INTERVAL
La clausola REFRESH\$1INTERVAL imposta l’intervallo di tempo approssimativo, in secondi, per aggiornare i dati dall’origine zero-ETL al database di destinazione. Il valore `interval` può essere impostato su un numero compreso tra 0 e 432.000 secondi (5 giorni) per le integrazioni Zero-ETL il cui tipo di origine è Aurora MySQL, Aurora PostgreSQL o RDS per MySQL. Per le integrazioni Zero-ETL di Amazon DynamoDB, il valore `interval` può essere impostato su un numero compreso tra 900 e 432.000 secondi (15 minuti – 5 giorni).
Per ulteriori informazioni sulla creazione di database con integrazioni Zero-ETL, consulta [Creazione di database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) nella *Guida alla gestione di Amazon Redshift*.
TRUNCATECOLUMNS [=] \$1TRUE \$1 FALSE\$1
La clausola TRUNCATECOLUMNS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando i valori per gli attributi della colonna VARCHAR o della colonna SUPER superano il limite. Quando è `TRUE`, i valori vengono troncati per adattarsi alla colonna e i valori degli attributi JSON in overflow vengono troncati per adattarsi alla colonna SUPER.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1 [ FOR \$1 \$1ALL\$1 TABLES [IN SCHEMA schema [, ...]] \$1 TABLE schema.table [, ...]\$1 ]
Una clausola che specifica se Amazon Redshift imposterà la modalità cronologia per tutte le tabelle o le tabelle nello schema specificato che partecipano all’integrazione Zero-ETL. Questa opzione è applicabile solo ai database creati per l’integrazione Zero-ETL.
La clausola HISTORY\$1MODE può essere impostata su `TRUE` o `FALSE`. Il valore predefinito è `FALSE`. L’attivazione e la disattivazione della modalità cronologia sono applicabili solo alle tabelle che si trovano nello stato `Synced`. Per informazioni su HISTORY\$1MODE, consulta [Modalità cronologia](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) nella *Guida alla gestione di Amazon Redshift*.
## Note per l'utilizzo
I comandi di ALTER DATABASE si applicano alle sessioni successive e non alle sessioni correnti. Devi riconnetterti al database modificato per vedere l'effetto della modifica.
## Esempi
L'esempio seguente rinomina un database denominato TICKIT\$1SANDBOX in TICKIT\$1TEST:
```
alter database tickit_sandbox rename to tickit_test;
```
L'esempio seguente modifica il proprietario del database TICKIT (il database corrente) in DWUSER:
```
alter database tickit owner to dwuser;
```
L'esempio seguente modifica la distinzione tra maiuscole e minuscole del database sampledb:
```
ALTER DATABASE sampledb COLLATE CASE_INSENSITIVE;
```
Nell'esempio seguente viene modificato un database denominato **sampledb** con livello di isolamento SNAPSHOT.
```
ALTER DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
L'esempio seguente aggiorna le tabelle **schema1.sample\$1table1** e **schema2.sample\$1table2** del database **sample\$1integration\$1db** nell'integrazione Zero-ETL.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH TABLE schema1.sample_table1, schema2.sample_table2;
```
L'esempio seguente aggiorna tutte le tabelle sincronizzate e non riuscite nell'integrazione Zero-ETL.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH ALL tables;
```
L’esempio seguente imposta l’intervallo di aggiornamento per le integrazioni Zero-ETL su 600 secondi.
```
ALTER DATABASE sample_integration_db INTEGRATION SET REFRESH_INTERVAL 600;
```
L’esempio seguente aggiorna tutte le tabelle con `ErrorState` presenti nello schema **sample\$1schema**.
```
ALTER DATABASE sample_integration_db INTEGRATION REFRESH INERROR TABLES in SCHEMA sample_schema;
```
L’esempio seguente attiva la modalità cronologia per la tabella `myschema.table1`.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true FOR TABLE myschema.table1
```
L’esempio seguente attiva la modalità cronologia per tutte le tabelle in `myschema`.
```
ALTER DATABASE sample_integration_db INTEGRATION SET HISTORY_MODE = true for ALL TABLES IN SCHEMA myschema
```
# ALTER DATASHARE
Cambia la definizione di una unità di condivisione dati. È possibile aggiungere o rimuovere oggetti utilizzando ALTER DATASHARE. È possibile modificare una unità di condivisione dati solo nel database corrente. Aggiunta o rimozione di oggetti dal database associato a una unità di condivisione dati. Il proprietario dell'unità di condivisione dati con le autorizzazioni necessarie per gli oggetti dell'unità di condivisione dati da aggiungere o rimuovere può modificare l'unità.
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per ALTER DATASHARE:
+ Utente con privilegi avanzati.
+ Utente con il privilegio ALTER DATASHARE.
+ Utenti con privilegio ALTER o ALL sull'unità di condivisione dati.
+ Per aggiungere oggetti specifici a una unità di condivisione dati, gli utenti devono avere il privilegio sugli oggetti. Per questo caso, gli utenti devono essere i proprietari degli oggetti o disporre dei privilegi SELECT, USAGE o ALL sugli oggetti.
## Sintassi
La sintassi seguente illustra come aggiungere o rimuovere oggetti nell'unità unità di condivisione dati.
```
ALTER DATASHARE datashare_name { ADD | REMOVE } {
TABLE schema.table [, ...]
| SCHEMA schema [, ...]
| FUNCTION schema.sql_udf (argtype,...) [, ...]
| ALL TABLES IN SCHEMA schema [, ...]
| ALL FUNCTIONS IN SCHEMA schema [, ...] }
```
La sintassi seguente illustra come configurare le proprietà dell'unità unità di condivisione dati.
```
ALTER DATASHARE datashare_name {
[ SET PUBLICACCESSIBLE [=] TRUE | FALSE ]
[ SET INCLUDENEW [=] TRUE | FALSE FOR SCHEMA schema ] }
```
## Parameters
*datashare\$1name*
Il nome della unità di condivisione dati da modificare.
ADD \$1 REMOVE
Una clausola che specifica se aggiungere o rimuovere oggetti dall'unità di condivisione dati.
TABLE *schema*.*table* [, ...]
Il nome della tabella o della vista nello schema specificato da aggiungere all'unità di condivisione dati.
SCHEMA *schema* [, ...]
Il nome dello schema da aggiungere all'unità di condivisione dati.
FUNZIONE *schema*.*sql\$1udf* (argtype,...) [, ...]
Il nome della funzione SQL definita dall'utente da aggiungere all'unità di condivisione dati.
ALL TABLES IN SCHEMA *schema* [, ...]
Una clausola che specifica se aggiungere tutte le tabelle e le viste nello schema specificato all'unità di condivisione dati.
ALL FUNCTIONS IN SCHEMA *schema* [, ...] \$1
Una clausola che specifica l'aggiunta di tutte le funzioni dello schema specificato all'unità di condivisione dati.
[ SET PUBLICACCESSIBLE [=] TRUE \$1 FALSE ]
Una clausola che specifica se una unità di condivisione dati può essere condivisa in un cluster accessibile pubblicamente.
[ SET INCLUDENEW [=] TRUE \$1 FALSE FOR SCHEMA *schema* ]
Una clausola che specifica se aggiungere al datashare eventuali future tabelle, viste o funzioni SQL definite dall'utente (UDFs) create nello schema specificato. Le tabelle, le viste o il codice SQL UDFs correnti nello schema specificato non vengono aggiunti al datashare. Solo gli utenti con privilegi avanzati possono modificare questa proprietà per ogni coppia unità di condivisione dati-schema. Per impostazione predefinita, la clausola INCLUDENEW è false.
## Note per l'utilizzo di ALTER DATASHARE
+ I seguenti utenti possono modificare una unità di condivisione dati:
+ Un utente con privilegi avanzati
+ Il proprietario dell'unità di condivisione dati
+ Utenti con privilegio ALTER o ALL sull'unità di condivisione dati
+ Per aggiungere oggetti specifici a una unità di condivisione dati, gli utenti devono avere il privilegio sugli oggetti. Gli utenti devono essere i proprietari degli oggetti o disporre dei privilegi SELECT, USAGE o ALL sugli oggetti.
+ È possibile condividere schemi, tabelle, viste regolari, viste con associazione tardiva, viste materializzate e funzioni SQL definite dall'utente (). UDFs Aggiungere uno schema all'unità di condivisione dati prima di aggiungere altri oggetti nello schema.
Quando si aggiunge uno schema, Amazon Redshift non aggiunge tutti gli oggetti sotto di esso. È necessario aggiungerli esplicitamente.
+ Ti consigliamo di creare condivisioni di AWS Data Exchange dati con l'impostazione accessibile al pubblico attivata.
+ In generale, si consiglia di non modificare un AWS Data Exchange datashare per disattivare l'accessibilità pubblica utilizzando l'istruzione ALTER DATASHARE. Se lo si farà, gli Account AWS che hanno accesso all'unità di condivisione dati perderanno l'accesso se i cluster sono accessibili pubblicamente. L'esecuzione di questo tipo di alterazione può violare i termini del prodotto dei dati in AWS Data Exchange. Per un'eccezione a questa raccomandazione, vedere di seguito.
L'esempio seguente mostra un errore quando viene creato un AWS Data Exchange datashare con l'impostazione disattivata.
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
ERROR: Alter of ADX-managed datashare salesshare requires session variable datashare_break_glass_session_var to be set to value 'c670ba4db22f4b'
```
Per consentire la modifica di un AWS Data Exchange datashare per disattivare l'impostazione accessibile al pubblico, impostate la variabile seguente ed eseguite nuovamente l'istruzione ALTER DATASHARE.
```
SET datashare_break_glass_session_var to 'c670ba4db22f4b';
```
```
ALTER DATASHARE salesshare SET PUBLICACCESSIBLE FALSE;
```
In questo caso, Amazon Redshift genera un valore casuale una tantum per impostare la variabile di sessione per consentire ALTER DATASHARE SET PUBLICACCESSIBLE FALSE per un'unità unità di condivisione dati AWS Data Exchange .
## Esempi
Nell’esempio seguente viene aggiunto lo schema `public` all’unità di condivisione dati `salesshare`.
```
ALTER DATASHARE salesshare ADD SCHEMA public;
```
Nell'esempio seguente vengono aggiunte le tabelle `public.tickit_sales_redshift` all'unità di condivisione dati `salesshare`.
```
ALTER DATASHARE salesshare ADD TABLE public.tickit_sales_redshift;
```
Nell'esempio seguente vengono aggiunte tutte le tabelle all'unità di condivisione dati `salesshare`
```
ALTER DATASHARE salesshare ADD ALL TABLES IN SCHEMA PUBLIC;
```
Nell'esempio seguente vengono rimosse le tabelle `public.tickit_sales_redshift` dall'unità di condivisione dati `salesshare`.
```
ALTER DATASHARE salesshare REMOVE TABLE public.tickit_sales_redshift;
```
# ALTER DEFAULT PRIVILEGES
Definisce il set predefinito di autorizzazioni di accesso da applicare agli oggetti che verranno creati in futuro dall’utente specificato. Per impostazione predefinita, gli utenti possono modificare solo le proprie autorizzazioni di accesso di default. Solo l’utente con privilegi avanzati può specificare le autorizzazioni predefinite per gli altri utenti.
È possibile applicare i privilegi predefiniti a ruoli, utenti o a gruppi di utenti. Puoi impostare le autorizzazioni predefinite a livello globale per tutti gli oggetti creati nel database corrente o per gli oggetti creati solo negli schemi specificati.
Le autorizzazioni predefinite si applicano solo ai nuovi oggetti. L’esecuzione di ALTER DEFAULT PRIVILEGES non modifica le autorizzazioni per gli oggetti esistenti. Per concedere le autorizzazioni per tutti gli oggetti correnti e futuri creati da qualsiasi utente all’interno di un database o uno schema, consulta [Autorizzazioni con ambito.](https://docs.aws.amazon.com/redshift/latest/dg/t_scoped-permissions.html)
Per visualizzare le informazioni sui privilegi predefiniti per gli utenti del database, eseguire una query sulla tabella del catalogo di sistema [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md).
Per ulteriori informazioni sui privilegi, consultare [GRANT](r_GRANT.md).
## Privilegi richiesti
Di seguito sono elencati i privilegi richiesti per ALTER DEFAULT PRIVILEGES:
+ Superuser
+ Utenti con il privilegio ALTER DEFAULT PRIVILEGES
+ Gli utenti che modificano i propri privilegi di accesso di default
+ Utenti che definiscono i privilegi per gli schemi per i quali dispongono di privilegi di accesso
## Sintassi
```
ALTER DEFAULT PRIVILEGES
[ FOR USER target_user [, ...] ]
[ IN SCHEMA schema_name [, ...] ]
grant_or_revoke_clause
where grant_or_revoke_clause is one of:
GRANT { { SELECT | INSERT | UPDATE | DELETE | DROP | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
TO { user_name [ WITH GRANT OPTION ] | ROLE role_name | GROUP group_name | PUBLIC } [, ...]
REVOKE [ GRANT OPTION FOR ] { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { { SELECT | INSERT | UPDATE | DELETE | REFERENCES | TRUNCATE } [,...] | ALL [ PRIVILEGES ] }
ON TABLES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTIONS
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
REVOKE [ GRANT OPTION FOR ] { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM user_name [, ...] [ RESTRICT ]
REVOKE { EXECUTE | ALL [ PRIVILEGES ] }
ON PROCEDURES
FROM { ROLE role_name | GROUP group_name | PUBLIC } [, ...] [ RESTRICT ]
```
## Parameters
FOR USER *target\$1user*
Opzionale. Il nome dell'utente per il quale sono definiti i privilegi predefiniti. Solo l'utente con privilegi avanzati può specificare i privilegi predefiniti per gli altri utenti. Il valore di default è l'utente corrente.
IN SCHEMA *schema\$1name*
Opzionale. Se viene visualizzata una clausola IN SCHEMA, i privilegi predefiniti specificati vengono applicati ai nuovi oggetti creati nel *schema\$1name* indicato. In questo caso, l'utente o il gruppo di utenti che costituisce il target di ALTER DEFAULT PRIVILEGES deve disporre del privilegio CREATE per lo schema specificato. I privilegi predefiniti specifici di uno schema vengono aggiunti ai privilegi predefiniti globali esistenti. Per impostazione predefinita, i privilegi predefiniti vengono applicati a livello globale all'intero database.
GRANT
L’insieme di privilegi da concedere agli utenti o ai gruppi specificati per tutte le nuove tabelle e viste, funzioni o stored procedure create dall’utente indicato. Con la clausola GRANT puoi impostare gli stessi privilegi e opzioni disponibili per il comando [GRANT](r_GRANT.md).
WITH GRANT OPTION
Clausola che indica che l'utente che riceve i privilegi può a sua volta concedere gli stessi privilegi agli altri. Non puoi concedere WITH GRANT OPTION a un gruppo o a PUBLIC.
TO *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Il nome dell'utente, del ruolo o del gruppo di utenti a cui vengono applicati i privilegi predefiniti specificati.
REVOKE
L'insieme di privilegi da revocare agli utenti o ai gruppi specificati per tutte le nuove tabelle, funzioni o procedure archiviate create dall'utente indicato. Con la clausola REVOKE puoi impostare gli stessi privilegi e opzioni disponibili per il comando [REVOKE](r_REVOKE.md).
GRANT OPTION FOR
Clausola che revoca solo l'opzione per concedere un privilegio specificato ad altri utenti e non revoca il privilegio stesso. Non puoi revocare GRANT OPTION a un gruppo o a PUBLIC.
FROM *user\$1name* \$1 ROLE *role\$1name* \$1 GROUP *group\$1name*
Il nome dell'utente, del ruolo o del gruppo di utenti a cui vengono revocati per impostazione predefinita i privilegi specificati.
RESTRICT
L'opzione RESTRICT revoca solo i privilegi che l'utente ha concesso direttamente. Questa è l’impostazione predefinita.
## Esempi
Supponiamo che si desideri consentire a un utente nel gruppo di utenti `report_readers` di visualizzare tutte le tabelle e le viste create dall’utente `report_admin`. In questo caso, emettere il seguente comando come utente con privilegi avanzati.
```
alter default privileges for user report_admin grant select on tables to group report_readers;
```
Nell’esempio seguente, il primo comando concede i privilegi SELECT per tutte le nuove tabelle create. Ogni volta che crei una nuova vista, devi concedere esplicitamente i privilegi alla vista o eseguire nuovamente il comando `alter default privileges`.
```
alter default privileges grant select on tables to public;
```
L'esempio seguente concede il privilegio INSERT al gruppo di utenti `sales_admin` per tutte le nuove tabelle e viste create nello schema `sales`.
```
alter default privileges in schema sales grant insert on tables to group sales_admin;
```
L'esempio seguente inverte il comando ALTER DEFAULT PRIVILEGES dell'esempio precedente.
```
alter default privileges in schema sales revoke insert on tables from group sales_admin;
```
Per impostazione predefinita, il gruppo di utenti PUBLIC dispone dell'autorizzazione execute per tutte le nuove funzioni definite dall'utente. Per revocare le autorizzazioni execute `public` per le nuove funzioni e quindi concedere l'autorizzazione execute solo al gruppo di utenti `dev_test`, eseguire i seguenti comandi.
```
alter default privileges revoke execute on functions from public;
alter default privileges grant execute on functions to group dev_test;
```
# ALTER EXTERNAL SCHEMA
Modifica uno schema esterno esistente nel database corrente. Solo i proprietari dello schema, gli utenti con privilegi avanzati o gli utenti con i privilegi ALTER per lo schema possono modificarlo. È possibile modificare solo gli schemi esterni creati da DATA CATALOG, KAFKA o MSK.
Il proprietario di questo schema è l'emittente del comando CREATE EXTERNAL SCHEMA. Per trasferire la proprietà di uno schema esterno, utilizza ALTER SCHEMA per cambiare il proprietario. Per concedere l’accesso allo schema ad altri utenti o gruppi di utenti, utilizza il comando GRANT.
Non puoi utilizzare i comandi GRANT o REVOKE per le autorizzazioni su una tabella esterna. Puoi invece concedere o revocare le autorizzazioni per lo schema esterno.
Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [ALTER SCHEMA](r_ALTER_SCHEMA.md)
+ [GRANT](r_GRANT.md)
+ [REVOKE](r_REVOKE.md)
+ [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)
+ [Abilitazione dell’autenticazione mTLS per uno schema esterno esistente](materialized-view-streaming-ingestion-mtls.md#materialized-view-streaming-ingestion-mtls-alter)
Per visualizzare i dettagli degli schemi esterni, esegui query sulla vista di sistema SVV\$1EXTERNAL\$1SCHEMAS. Per ulteriori informazioni, consulta [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md).
## Sintassi
```
ALTER EXTERNAL SCHEMA schema_name
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'asm-secret-arn' ]
[ URI 'Kafka bootstrap URL' ]
```
Se disponi di uno schema esterno esistente che utilizzi per l’importazione in streaming e desideri implementare mTLS per l’autenticazione, puoi eseguire un comando come il seguente, che specifica l’autenticazione mTLS e l’ARN del certificato ACM in ACM.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
AUTHENTICATION_ARN 'arn:aws:acm:us-east-1:444455556666:certificate/certificate_ID';
```
In alternativa puoi modificare l’autenticazione mTLS, con riferimento all’ARN del segreto in Secrets Manager.
```
ALTER EXTERNAL SCHEMA schema_name
AUTHENTICATION mtls
SECRET_ARN 'arn:aws:secretsmanager:us-east-1:012345678910:secret:myMTLSSecret';
```
L’esempio seguente mostra come modificare l’URI per ALTER EXTERNAL SCHEMA:
```
ALTER EXTERNAL SCHEMA schema_name
URI 'lkc-ghidef-67890.centralus.azure.glb.confluent.cloud:9092';
```
L’esempio seguente mostra come modificare il ruolo IAM per ALTER EXTERNAL SCHEMA:
```
ALTER EXTERNAL SCHEMA schema_name
IAM_ROLE 'arn:aws:iam::012345678901:role/testrole';
```
## Parameters
IAM\$1ROLE [predefinito \$1 'SESSION' \$1 'arn:aws:iam: :< account-id>:role/ ']AWS
Utilizza la parola chiave `default` per fare in modo che Amazon Redshift usi il ruolo IAM impostato come predefinito.
Utilizzare `'SESSION'` se ci si connette al cluster Amazon Redshift utilizzando un'identità federata e si accede alle tabelle dallo schema esterno creato con questo comando.
Per ulteriori informazioni, consulta [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION
Il tipo di autenticazione definito per l'importazione di dati in streaming. L’importazione in streaming con i tipi di autenticazione funziona con Apache Kafka, Confluent Cloud e Streaming gestito da Amazon per Apache Kafka. Per ulteriori informazioni, consulta [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
AUTHENTICATION\$1ARN
L'ARN del AWS Certificate Manager certificato utilizzato da Amazon Redshift per l'autenticazione mtls con Apache Kafka, Confluent Cloud o Amazon Managed Streaming for Apache Kafka (Amazon MSK). L’ARN è disponibile nella console ACM quando scegli il certificato emesso.
SECRET\$1ARN
L'Amazon Resource Name (ARN) di un segreto supportato creato utilizzando. Gestione dei segreti AWS Per informazioni su come creare e recuperare un ARN per un segreto, consulta [Gestione dei segreti con Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida per l’utente di Gestione dei segreti AWS * e [Recupero del nome della risorsa Amazon (ARN) del segreto in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
URI
L’URL di bootstrap del cluster Apache Kafka, Confluent Cloud o Streaming gestito da Amazon per Apache Kafka (Amazon MSK). L'endpoint deve essere raggiungibile (instradabile) dal cluster Amazon Redshift. Per ulteriori informazioni, consulta [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
# ALTER EXTERNAL VIEW
Utilizza il comando ALTER EXTERNAL VIEW per aggiornare la vista esterna. A seconda dei parametri utilizzati, possono essere interessati anche altri motori SQL, come Amazon Athena e Amazon EMR Spark, che possono fare riferimento a questa vista. Per ulteriori informazioni sulle viste del Catalogo dati, consulta [Viste del AWS Glue Data Catalog](https://docs.aws.amazon.com/redshift/latest/dg/data-catalog-views-overview.html).
## Sintassi
```
ALTER EXTERNAL VIEW schema_name.view_name
{catalog_name.schema_name.view_name | awsdatacatalog.dbname.view_name | external_schema_name.view_name}
[FORCE] { AS (query_definition) | REMOVE DEFINITION }
```
## Parameters
*schema\$1name.view\$1name*
Lo schema allegato al AWS Glue database, seguito dal nome della vista.
catalog\$1name.schema\$1name.view\$1name \$1 awsdatacatalog.dbname.view\$1name \$1 external\$1schema\$1name.view\$1name
La notazione dello schema da usare per la modifica della vista. È possibile specificare di utilizzare il AWS Glue Data Catalog, un database Glue creato dall'utente o uno schema esterno creato dall'utente. Per ulteriori informazioni, consulta [CREATE DATABASE](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html) e [CREATE EXTERNAL SCHEMA](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_EXTERNAL_SCHEMA.html).
FORCE
Indica se AWS Lake Formation aggiornare la definizione della vista anche se gli oggetti a cui si fa riferimento nella tabella non sono coerenti con altri motori SQL. Se Lake Formation esegue l'aggiornamento, la vista viene considerata obsoleta per gli altri motori SQL fino a quando non vengono aggiornati.
*AS query\$1definition*
La definizione della query SQL che Amazon Redshift esegue per alterare la vista.
REMOVE DEFINITION
Indica se rilasciare e ricreare le viste. Le viste devono essere rilasciate e ricreate per contrassegnarle come `PROTECTED`.
## Esempi
L'esempio seguente modifica una vista del catalogo dati denominata sample\$1schema.glue\$1data\$1catalog\$1view.
```
ALTER EXTERNAL VIEW sample_schema.glue_data_catalog_view
FORCE
REMOVE DEFINITION
```
# ALTER FUNCTION
Rinomina una funzione o cambia il proprietario. Sono richiesti sia il nome della funzione che i tipi di dati. Solo il proprietario o un utente con privilegi avanzati può rinominare una funzione. Solo un utente con privilegi avanzati può cambiare il proprietario di una funzione.
## Sintassi
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
RENAME TO new_name
```
```
ALTER FUNCTION function_name ( { [ py_arg_name py_arg_data_type | sql_arg_data_type } [ , ... ] ] )
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*function\$1name*
Il nome della funzione da modificare. Specifica il nome della funzione nel percorso di ricerca corrente oppure utilizza il formato `schema_name.function_name` per usare uno schema specifico.
*py\$1arg\$1name py\$1arg\$1data\$1type \$1 sql\$1arg\$1data\$1type*
Opzionale. Un elenco dei nomi e dei tipi di dati degli argomenti di input per la funzione definita dall’utente Python o un elenco dei tipi di dati degli argomenti di input per la funzione SQL definita dall’utente.
*new\$1name*
Un nuovo nome per la funzione definita dall’utente.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Un nuovo proprietario per la funzione definita dall’utente.
## Esempi
L’esempio seguente cambia il nome di una funzione da `first_quarter_revenue` in `quarterly_revenue`.
```
ALTER FUNCTION first_quarter_revenue(bigint, numeric, int)
RENAME TO quarterly_revenue;
```
L’esempio seguente cambia il proprietario della funzione `quarterly_revenue` in `etl_user`.
```
ALTER FUNCTION quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER GROUP
Cambia un gruppo di utenti. Usa questo comando per aggiungere utenti al gruppo, rimuovere utenti dal gruppo o rinominare il gruppo.
## Sintassi
```
ALTER GROUP group_name
{
ADD USER username [, ... ] |
DROP USER username [, ... ] |
RENAME TO new_name
}
```
## Parameters
*group\$1name*
Nome del gruppo di utenti da modificare.
ADD
Aggiunge un utente a un gruppo di utenti.
DROP
Rimuove un utente da un gruppo di utenti.
*username*
Nome dell'utente da aggiungere al gruppo o rimuovere dal gruppo.
RENAME TO
Rinomina il gruppo utente. I nomi di gruppo che iniziano con due caratteri di sottolineatura sono riservati all'uso interno di Amazon Redshift. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
*new\$1name*
Nuovo nome del gruppo di utenti.
## Esempi
L'esempio seguente aggiunge un utente denominato DWUSER al gruppo ADMIN\$1GROUP.
```
ALTER GROUP admin_group
ADD USER dwuser;
```
L'esempio seguente rinomina il gruppo ADMIN\$1GROUP in ADMINISTRATORS.
```
ALTER GROUP admin_group
RENAME TO administrators;
```
L'esempio seguente aggiunge due utenti al gruppo ADMIN\$1GROUP.
```
ALTER GROUP admin_group
ADD USER u1, u2;
```
L'esempio seguente elimina due utenti dal gruppo ADMIN\$1GROUP.
```
ALTER GROUP admin_group
DROP USER u1, u2;
```
# ALTER IDENTITY PROVIDER
Modifica un provider di identità per assegnare nuovi parametri e valori. Quando si esegue questo comando, tutti i valori dei parametri impostati in precedenza vengono eliminati prima dell'assegnazione dei nuovi valori. Solo un utente con privilegi avanzati può modificare un provider di identità.
## Sintassi
```
ALTER IDENTITY PROVIDER identity_provider_name
[PARAMETERS parameter_string]
[NAMESPACE namespace]
[IAM_ROLE iam_role]
[AUTO_CREATE_ROLES
[ TRUE [ { INCLUDE | EXCLUDE } GROUPS LIKE filter_pattern] |
FALSE
]
[DISABLE | ENABLE]
```
## Parameters
*identity\$1provider\$1name*
Il nome del nuovo provider di identità. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
*parameter\$1string*
Stringa contenente un oggetto JSON formattato correttamente che contiene i parametri e i valori richiesti per il provider di identità specifico.
*spazio dei nomi*
Il namespace dell’organizzazione.
*iam\$1role*
Il ruolo IAM che fornisce le autorizzazioni per la connessione a Centro identità IAM. Questo parametro è applicabile solo quando il tipo di provider di identità è. AWSIDC
*auto\$1create\$1roles*
Attiva o disattiva la funzionalità di creazione automatica del ruolo. Se il valore è TRUE, Amazon Redshift abilita la funzionalità di creazione automatica del ruolo. Se il valore è FALSE, Amazon Redshift disabilita la funzionalità di creazione automatica del ruolo. Se il valore di questo parametro non è specificato, Amazon Redshift determina il valore utilizzando la seguente logica:
+ Se `AUTO_CREATE_ROLES` viene fornito ma il valore non è specificato, il valore viene impostato su TRUE.
+ Se `AUTO_CREATE_ROLES` non viene fornito e il provider di identità sì AWSIDC, il valore è impostato su FALSE.
+ Se `AUTO_CREATE_ROLES` non viene fornito e il provider di identità è Azure, il valore viene impostato su TRUE.
Per includere i gruppi, specifica `INCLUDE`. L’impostazione predefinita è vuota, il che significa che devi includere tutti i gruppi se `AUTO_CREATE_ROLES` è attivo.
Per escludere i gruppi, specifica `EXCLUDE`. L’impostazione predefinita è vuota, il che significa che non devi escludere alcun gruppo se `AUTO_CREATE_ROLES` è attivo.
*filter\$1pattern*
Un’espressione di caratteri UTF-8 valida con il modello da associare ai nomi dei gruppi. L'opzione LIKE esegue una corrispondenza con distinzione tra maiuscole e minuscole e supporta i seguenti metacaratteri che corrispondono ai modelli:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_ALTER_IDENTITY_PROVIDER.html)
Se il *filter\$1pattern* non contiene metacaratteri, allora il modello rappresenta solo la stringa stessa; in questo caso LIKE agisce come l'operatore di uguaglianza.
*filter\$1pattern* supporta i seguenti caratteri:
+ Caratteri alfabetici maiuscoli e minuscoli (A-Z e a-z)
+ Numeri (0-9)
+ I seguenti caratteri speciali:
```
_ % ^ * + ? { } , $
```
*DISABLE o ENABLE*
Attiva o disattiva un provider di identità. L’impostazione predefinita è ENABLE.
## Esempi
Nell'esempio seguente viene modificato un provider di identità denominato *oauth\$1standard*. Si applica in particolare a quando Microsoft Azure AD è il provider di identità.
```
ALTER IDENTITY PROVIDER oauth_standard
PARAMETERS '{"issuer":"https://sts.windows.net/2sdfdsf-d475-420d-b5ac-667adad7c702/",
"client_id":"87f4aa26-78b7-410e-bf29-57b39929ef9a",
"client_secret":"BUAH~ewrqewrqwerUUY^%tHe1oNZShoiU7",
"audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift"]
}'
```
L’esempio seguente mostra come impostare il namespace del provider di identità. Ciò può essere applicato a Microsoft Azure AD, se segue un’istruzione come nell’esempio precedente, o a un altro provider di identità. Può essere applicato anche al caso in cui connetti un cluster con provisioning Amazon Redshift esistente o un gruppo di lavoro Amazon Redshift serverless a Centro identità IAM, se disponi di una connessione configurata tramite un’applicazione gestita.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
NAMESPACE 'MYCO';
```
L’esempio seguente imposta il ruolo IAM e funziona nel caso d’uso per configurare l’integrazione di Redshift con Centro identità IAM.
```
ALTER IDENTITY PROVIDER "my-redshift-idc-application"
IAM_ROLE 'arn:aws:iam::123456789012:role/myadministratorrole';
```
Per ulteriori informazioni sulla configurazione di una connessione a Centro identità IAM di Redshift, consulta [Connessione di Redshift a Centro identità IAM per offrire agli utenti un’esperienza di single sign-on](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
**Disabilitazione di un provider di identità**
L’istruzione di esempio seguente mostra come disabilitare un provider di identità. Quando è disabilitato, gli utenti federati del provider di identità non possono accedere al cluster finché non viene nuovamente abilitato.
```
ALTER IDENTITY PROVIDER "redshift-idc-app" DISABLE;
```
# ALTER MASKING POLICY
Modifica una politica di mascheramento dinamico dei dati esistente. Per ulteriori informazioni sul mascheramento dinamico dei dati, consulta [Mascheramento dinamico dei dati](t_ddm.md).
Una politica di mascheramento può essere modificata da utenti con privilegi avanzati e da utenti o ruoli che dispongono del ruolo sys:secadmin.
## Sintassi
```
ALTER MASKING POLICY
{ policy_name | database_name.policy_name }
USING (masking_expression);
```
## Parameters
*nome\$1policy*
Nome della policy di mascheramento. Deve essere il nome di una politica di mascheramento già esistente nel database.
database\$1name
Il nome del database da cui viene creata la policy. Il database può essere il database connesso o un database che supporta le autorizzazioni federate di Amazon Redshift.
*masking\$1expression*
Espressione SQL utilizzata per trasformare le colonne di destinazione. Può essere scritta utilizzando funzioni di manipolazione dei dati, come le funzioni di manipolazione delle stringhe, o in combinazione con funzioni definite dall'utente scritte in SQL, Python o con AWS Lambda.
L'espressione deve corrispondere alle colonne di input e ai tipi di dati dell'espressione originale. Ad esempio, se le colonne di input della politica di mascheramento originale fossero `sample_1 FLOAT` e `sample_2 VARCHAR(10)`, non sarebbe possibile modificare la politica di mascheramento per prendere una terza colonna o fare in modo che la politica assuma un valore FLOAT e un valore BOOLEAN. Se si utilizza una costante come espressione di mascheramento, è necessario convertirla in modo esplicito su un tipo che corrisponda al tipo di input.
È necessario disporre dell'autorizzazione USAGE per tutte le funzioni definite dall'utente utilizzate nell'espressione di mascheramento.
Per l'utilizzo di ALTER MASKING POLICY su Amazon Redshift Federated Permissions Catalog, [consulta Gestire il controllo degli accessi con le autorizzazioni federate di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ALTER MATERIALIZED VIEW
Modifica gli attributi di una vista materializzata.
## Sintassi
```
ALTER MATERIALIZED VIEW mv_name
{
AUTO REFRESH { YES | NO }
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [FOR DATASHARES]
};
```
## Parameters
*mv\$1name*
Il nome della vista materializzata da modificare.
AUTO REFRESH \$1 YES \$1 NO \$1
Una clausola che attiva o disattiva l'aggiornamento automatico di una vista materializzata. Per informazioni sull'aggiornamento automatico delle viste materializzate, consultare [Aggiornamento di una vista materializzata](materialized-view-refresh.md).
ALTER DISTSTYLE ALL
Una clausola che modifica lo stile di distribuzione esistente di una relazione e lo imposta su `ALL`. Considera i seguenti aspetti:
+ ALTER DISTSTYLE, ALTER SORTKEY e VACUUM non possono essere eseguiti contemporaneamente per la stessa relazione.
+ Se VACUUM è attualmente in esecuzione, l'esecuzione di ALTER DISTSTYLE ALL restituisce un errore.
+ Se ALTER DISTSTYLE ALL è in esecuzione, il vacuum di background non viene avviato per una relazione.
+ Il comando ALTER DISTSTYLE ALL non è supportato per le relazioni con chiavi di ordinamento interlacciate e tabelle temporanee.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l’ottimizzazione automatica della tabella.
Per ulteriori informazioni su DISTSTYLE ALL, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE EVEN
Una clausola che modifica lo stile di distribuzione esistente di una relazione e lo imposta su `EVEN`. Considera i seguenti aspetti:
+ ALTER DISTSYTLE, ALTER SORTKEY e VACUUM non possono essere eseguiti contemporaneamente per la stessa relazione.
+ Se VACUUM è attualmente in esecuzione, l'esecuzione di ALTER DISTSTYLE EVEN restituisce un errore.
+ Se ALTER DISTSTYLE EVEN è in esecuzione, il vacuum di background non viene avviato per una relazione.
+ Il comando ALTER DISTSTYLE EVEN non è supportato per le relazioni con chiavi di ordinamento interlacciate e tabelle temporanee.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l’ottimizzazione automatica della tabella.
Per ulteriori informazioni su DISTSTYLE EVEN, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTKEY *column\$1name* o ALTER DISTSTYLE KEY DISTKEY *column\$1name*
Una clausola che modifica la colonna utilizzata come chiave di distribuzione di una relazione. Considera i seguenti aspetti:
+ VACUUM e ALTER DISTKEY non possono essere eseguiti contemporaneamente per la stessa relazione.
+ Se VACUUM è già in esecuzione, ALTER DISTKEY restituisce un errore.
+ Se ALTER DISTKEY è in esecuzione, il vacuum di background non viene avviato per una relazione.
+ Se ALTER DISTKEY è in esecuzione, il vacuum in primo piano restituisce un errore.
+ Puoi eseguire solo un comando ALTER DISTKEY per una relazione alla volta.
+ Il comando ALTER DISTKEY non è supportato per le relazioni con chiavi di ordinamento interlacciate.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l’ottimizzazione automatica della tabella.
Quando si specifica DISTSTYLE KEY, i dati vengono distribuiti dai valori nella colonna DISTKEY. Per ulteriori informazioni su DISTSTYLE, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER DISTSTYLE AUTO
Una clausola che modifica lo stile di distribuzione esistente di una relazione su AUTO.
Quando modifichi uno stile di distribuzione su AUTO, lo stile di distribuzione della relazione viene impostato come segue:
+ Una piccola relazione con DISTSTYLE ALL viene convertita in AUTO(ALL).
+ Una piccola relazione con DISTSTYLE EVEN viene convertita in AUTO(ALL).
+ Una piccola relazione con DISTSTYLE KEY viene convertita in AUTO(ALL).
+ Una relazione grande con DISTSTYLE ALL viene convertita in AUTO(EVEN).
+ Una relazione grande con DISTSTYLE EVEN viene convertita in AUTO(EVEN).
+ Una relazione grande con DISTSTYLE KEY viene convertita in AUTO(KEY) e DISTKEY viene conservato. In questo caso Amazon Redshift non apporta modifiche alla relazione.
Se Amazon Redshift determina che un nuovo stile o una nuova chiave di distribuzione migliorerà le prestazioni delle query, Amazon Redshift potrebbe modificare lo stile o la chiave di distribuzione della relazione in futuro. Ad esempio, Amazon Redshift potrebbe convertire una relazione con DISTSTYLE di AUTO(KEY) in AUTO(EVEN) o viceversa. Per ulteriori informazioni sul comportamento in caso di modifica delle chiavi di distribuzione, tra cui la ridistribuzione dei dati e i blocchi, consulta [Suggerimenti di Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Per ulteriori informazioni su DISTSTYLE AUTO, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Per visualizzare lo stile di distribuzione di una relazione, esegui query sulla vista del catalogo di sistema SVV\$1TABLE\$1INFO. Per ulteriori informazioni, consulta [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Per visualizzare i suggerimenti di Amazon Redshift Advisor per le relazioni, esegui query sulla vista del catalogo di sistema SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Per ulteriori informazioni, consulta [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Per visualizzare le azioni intraprese da Amazon Redshift, eseguire una query sulla vista del catalogo di sistema SVL\$1AUTO\$1WORKER\$1ACTION. Per ulteriori informazioni, consulta [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Una clausola che modifica o aggiunge la chiave di ordinamento utilizzata per una relazione. ALTER SORTKEY non è supportato per le tabelle temporanee.
Quando si modifica una chiave di ordinamento, la codifica di compressione delle colonne nella chiave di ordinamento nuova o originale può cambiare. Se nessuna codifica è definita esplicitamente per la relazione, Amazon Redshift assegna automaticamente le codifiche di compressione come segue:
+ Le colonne definite come chiavi di ordinamento vengono assegnate alla compressione RAW.
+ Le colonne definite come tipi di dati BOOLEAN, REAL o DOUBLE PRECISION vengono assegnate alla compressione RAW.
+ Alle colonne definite come SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP o TIMESTAMPTZ viene assegnata la compressione. AZ64
+ Le colonne definite come CHAR o VARCHAR sono assegnate alla compressione LZO.
Considera i seguenti aspetti:
+ Puoi definire un massimo di 400 colonne per una chiave di ordinamento per relazione.
+ È possibile modificare una chiave di ordinamento interlacciata in una chiave di ordinamento composta o nessuna chiave di ordinamento. È possibile modificare una chiave di ordinamento interlacciata in una chiave di ordinamento composta o nessuna chiave di ordinamento.
+ Se la chiave di ordinamento è stata precedentemente definita come AUTO, la relazione non è più un candidato per l’ottimizzazione automatica della tabella.
+ Amazon Redshift consiglia di utilizzare la codifica RAW (senza compressione) per le colonne definite come chiavi di ordinamento. Quando si modifica una colonna per sceglierla come chiave di ordinamento, la compressione della colonna viene modificata in compressione RAW (senza compressione). Ciò può aumentare la quantità di archiviazione richiesta dalla relazione. L’aumento delle dimensioni della relazione dipende dalla definizione specifica della relazione e dal contenuto della relazione. Per ulteriori informazioni sulla compressione, consulta [Codifiche di compressione](c_Compression_encodings.md).
Quando i dati vengono caricati in una relazione, seguono l’ordine della chiave di ordinamento. Quando si modifica la chiave di ordinamento, Amazon Redshift riordina i dati. Per ulteriori informazioni su SORTKEY, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
ALTER SORTKEY AUTO
Una clausola che modifica o aggiunge la chiave di ordinamento della relazione di destinazione ad AUTO. ALTER SORTKEY AUTO non è supportato per le tabelle temporanee.
Quando modifichi una chiave di ordinamento e la imposti su AUTO, Amazon Redshift conserva la chiave di ordinamento esistente della relazione.
Se Amazon Redshift determina che una nuova chiave di ordinamento migliorerà le prestazioni delle query, Amazon Redshift potrebbe modificare la chiave di ordinamento della relazione in futuro.
Per ulteriori informazioni su SORTKEY AUTO, consulta [CREATE MATERIALIZED VIEW](materialized-view-create-sql-command.md).
Per visualizzare la chiave di ordinamento di una relazione, esegui query sulla vista del catalogo di sistema SVV\$1TABLE\$1INFO. Per ulteriori informazioni, consulta [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Per visualizzare i suggerimenti di Amazon Redshift Advisor per le relazioni, esegui query sulla vista del catalogo di sistema SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Per ulteriori informazioni, consulta [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Per visualizzare le azioni intraprese da Amazon Redshift, eseguire una query sulla vista del catalogo di sistema SVL\$1AUTO\$1WORKER\$1ACTION. Per ulteriori informazioni, consulta [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Una clausola che rimuove la chiave di ordinamento della tabella di relazione.
Se la chiave di ordinamento è stata precedentemente definita come AUTO, la relazione non è più un candidato per l’ottimizzazione automatica della tabella.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Una clausola che attiva o disattiva la sicurezza a livello di riga per una relazione.
Quando per una relazione è attivata la protezione a livello di riga, è possibile leggere solo le righe al livello di riga a cui la policy di sicurezza consente l'accesso. Quando non ci sono policy che consentono l'accesso alla relazione, non è possibile visualizzare alcuna riga dalla relazione. Solo gli utenti con privilegi avanzati e gli utenti o i ruoli che hanno il ruolo `sys:secadmin` possono impostare la clausola ROW LEVEL SECURITY. Per ulteriori informazioni, consulta [Sicurezza a livello di riga](t_rls.md).
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Una clausola che consente di scegliere il tipo di congiunzione della policy di sicurezza a livello di riga per una relazione. Quando a una relazione sono associate più policy di sicurezza a livello di riga, è possibile combinare le policy con la clausola AND oppure OR. Per impostazione predefinita, Amazon Redshift combina le policy RLS con la clausola AND. Gli utenti con privilegi avanzati, gli utenti o i ruoli che hanno il ruolo `sys:secadmin` possono utilizzare questa clausola per definire il tipo di combinazione della policy di sicurezza a livello di riga per una relazione. Per ulteriori informazioni, consulta [Combinazione di più policy per utente](t_rls_combine_policies.md).
+ FOR DATASHARES
Una clausola che determina se è possibile accedere a una relazione protetta da RLS in un'unità di condivisione dati. Per impostazione predefinita, non è possibile accedere a una relazione protetta da RLS in un'unità di condivisione dati. Il comando ALTER MATERIALIZED VIEW ROW LEVEL SECURITY eseguito con questa clausola influisce solo sulla proprietà di accessibilità dell'unità di condivisione dati della relazione. La proprietà ROW LEVEL SECURITY non viene modificata.
Se rendi accessibile una relazione protetta da RLS nelle unità di condivisione dati, la relazione non dispone di una sicurezza a livello di riga nel database con unità di condivisione dati sul lato consumer. La relazione mantiene la proprietà RLS sul lato producer.
## Esempi
Nell'esempio seguente la vista materializzata `tickets_mv` viene abilitata perché possa essere aggiornata automaticamente.
```
ALTER MATERIALIZED VIEW tickets_mv AUTO REFRESH YES
```
# Esempi di DISTSTYLE e SORTKEY per ALTER MATERIALIZED VIEW
Gli esempi in questo argomento mostrano come eseguire modifiche a DISTSTYLE e SORTKEY utilizzando ALTER MATERIALIZED VIEW.
Le seguenti query di esempio mostrano come modificare una colonna DISTSTYLE KEY DISTKEY utilizzando una tabella base di esempio:
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER diststyle KEY distkey inv_warehouse_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER distkey inv_item_sk;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
Modifica una vista materializzata in DISTSTYLE ALL:
```
CREATE TABLE base_inventory(
inv_date_sk int4 NOT NULL,
inv_item_sk int4 NOT NULL,
inv_warehouse_sk int4 NOT NULL,
inv_quantity_on_hand int4
);
INSERT INTO base_inventory VALUES(1,1,1,1);
CREATE materialized VIEW inventory diststyle even AS SELECT * FROM base_inventory;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
ALTER MATERIALIZED VIEW inventory ALTER diststyle ALL;
SELECT "table", diststyle FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
I comandi seguenti mostrano esempi di ALTER MATERIALIZED VIEW SORTKEY utilizzando una tabella base di esempio:
```
CREATE TABLE base_inventory (c0 int, c1 int);
INSERT INTO base_inventory VALUES(1,1);
CREATE materialized VIEW inventory interleaved sortkey(c0, c1) AS SELECT * FROM base_inventory;
SELECT "table", sortkey1 FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0, c1);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey NONE;
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
ALTER materialized VIEW inventory ALTER sortkey(c0);
SELECT "table", diststyle, sortkey_num FROM svv_table_info WHERE "table" = 'inventory';
DROP TABLE base_inventory CASCADE;
```
# ALTER RLS POLICY
Modifica di una policy di sicurezza a livello di riga esistente su una tabella.
Una policy può essere modificata da un utente con privilegi avanzati e da utenti o ruoli che dispongono del ruolo `sys:secadmin`.
## Sintassi
```
ALTER RLS POLICY
{ policy_name | database_name.policy_name }
USING ( using_predicate_exp );
```
## Parameters
*nome\$1policy*
Il nome della policy .
database\$1name
Il nome del database da cui viene creata la politica. Il database può essere il database connesso o un database che supporta le autorizzazioni federate di Amazon Redshift.
USING (* using\$1predicate\$1exp *)
Specifica un filtro applicato alla clausola WHERE della query. Amazon Redshift applica un predicato di policy prima dei predicati utente a livello di query. Ad esempio, **current\$1user = ‘joe’ and price > 10** limita Joe a visualizzare solo i record con un prezzo superiore a 10 USD.
L'espressione ha accesso alle variabili dichiarate nella clausola WITH dell'istruzione CREATE RLS POLICY utilizzata per creare la policy con il nome "nome\$1policy".
Per l'utilizzo di ALTER RLS POLICY su Amazon Redshift Federated Permissions Catalog, [consulta Gestire il controllo degli accessi con le autorizzazioni federate di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Esempi
L'esempio seguente modifica una policy RLS.
```
-- First create an RLS policy that limits access to rows where catgroup is 'concerts'.
CREATE RLS POLICY policy_concerts
WITH (catgroup VARCHAR(10))
USING (catgroup = 'concerts');
-- Then, alter the RLS policy to only show rows where catgroup is 'piano concerts'.
ALTER RLS POLICY policy_concerts
USING (catgroup = 'piano concerts');
```
# ALTER ROLE
Rinomina un ruolo o cambia il proprietario. Per un elenco di ruoli Amazon Redshift definiti dal sistema, consulta [Ruoli definiti dal sistema di Amazon Redshift](r_roles-default.md).
## Autorizzazioni richieste
Di seguito sono riportate le autorizzazioni richieste per ALTER ROLE:
+ Superuser
+ Utenti con le autorizzazioni ALTER ROLE
## Sintassi
```
ALTER ROLE role [ WITH ]
{ { RENAME TO role } | { OWNER TO user_name } }[, ...]
[ EXTERNALID TO external_id ]
```
## Parameters
*ruolo*
Il nome del ruolo da modificare.
RENAME TO
Un nuovo nome per il ruolo.
OWNER TO *user\$1name*
Un nuovo proprietario per il ruolo.
EXTERNALID TO *external\$1id*
Un nuovo ID esterno per il ruolo, associato a un provider di identità. Per ulteriori informazioni, consulta [Native identity provider (IdP) federation for Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html) (Federazione di provider di identità nativi (IdP) per Amazon Redshift).
## Esempi
L'esempio seguente cambia il nome di un ruolo da `sample_role1` a `sample_role2`.
```
ALTER ROLE sample_role1 RENAME TO sample_role2;
```
L'esempio seguente cambia il proprietario del ruolo.
```
ALTER ROLE sample_role1 WITH OWNER TO user1
```
La sintassi di ALTER ROLE è simile ad ALTER PROCEDURE di seguito.
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
L'esempio seguente cambia il proprietario di una procedura in `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
Nell'esempio seguente viene aggiornato un ruolo `sample_role1` con un nuovo ID esterno associato a un provider di identità.
```
ALTER ROLE sample_role1 EXTERNALID TO "XYZ456";
```
# ALTER PROCEDURE
Rinomina una procedura o cambia il proprietario. Sono richiesti sia il nome della procedura che i tipi di dati o la firma. Una procedura può essere rinominata solo dal proprietario o da un utente con privilegi avanzati. Solo un utente con privilegi avanzati può cambiare il proprietario di una procedura.
## Sintassi
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
RENAME TO new_name
```
```
ALTER PROCEDURE sp_name [ ( [ [ argname ] [ argmode ] argtype [, ...] ] ) ]
OWNER TO { new_owner | CURRENT_USER | SESSION_USER }
```
## Parameters
*sp\$1name*
Il nome della procedura da cambiare. Specifica solo il nome della procedura nel percorso di ricerca corrente oppure utilizza il formato `schema_name.sp_procedure_name` per utilizzare uno schema specifico.
*[argname] [argmode] argtype*
Elenco di nomi di argomento, modalità di argomento e tipi di dati. Sono richiesti solo i tipi di dati di input, utilizzati per individuare la procedura archiviata. In alternativa, puoi fornire la firma completa utilizzata per creare la procedura che include i parametri di input e output con le relative modalità.
*new\$1name*
Nuovo nome per la procedura archiviata.
*new\$1owner* \$1 CURRENT\$1USER \$1 SESSION\$1USER
Nuovo proprietario della procedura archiviata.
## Esempi
L'esempio seguente cambia il nome di una procedura da `first_quarter_revenue` a `quarterly_revenue`.
```
ALTER PROCEDURE first_quarter_revenue(volume INOUT bigint, at_price IN numeric,
result OUT int) RENAME TO quarterly_revenue;
```
Questo esempio è uguale al seguente.
```
ALTER PROCEDURE first_quarter_revenue(bigint, numeric) RENAME TO quarterly_revenue;
```
L'esempio seguente cambia il proprietario di una procedura in `etl_user`.
```
ALTER PROCEDURE quarterly_revenue(bigint, numeric) OWNER TO etl_user;
```
# ALTER SCHEMA
Cambia la definizione di uno schema esistente. Usa questo comando per rinominare uno schema o modificare il proprietario di uno schema. Ad esempio, rinomina uno schema esistente per conservare una copia di backup di tale schema quando pianifichi di creare una nuova versione dello schema. Per ulteriori informazioni sugli schemi, consultare [CREATE SCHEMA](r_CREATE_SCHEMA.md).
Per visualizzare le quote dello schema configurate, consultare [SVV\$1SCHEMA\$1QUOTA\$1STATE](r_SVV_SCHEMA_QUOTA_STATE.md).
Per visualizzare i record in cui le quote dello schema sono state superate, consultare [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md).
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per ALTER SCHEMA:
+ Superuser
+ Utente con il privilegio ALTER SCHEMA
+ Proprietario dello schema
Quando si modifica il nome di uno schema, tenere presente che gli oggetti che utilizzano il vecchio nome, come le procedure archiviate o le viste materializzate, devono essere aggiornati per utilizzare il nuovo nome.
## Sintassi
```
ALTER SCHEMA schema_name
{
RENAME TO new_name |
OWNER TO new_owner |
QUOTA { quota [MB | GB | TB] | UNLIMITED }
}
```
## Parameters
*schema\$1name*
Il nome dello schema del database da modificare.
RENAME TO
Clausola che rinomina lo schema.
*new\$1name*
Il nuovo nome dello schema. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
OWNER TO
Clausola che modifica il proprietario dello schema.
*new\$1owner*
Il nuovo proprietario dello schema.
QUOTA
La quantità massima di spazio su disco che lo schema specificato può utilizzare. Questo spazio è la dimensione collettiva di tutte le tabelle nello schema specificato. Amazon Redshift converte il valore selezionato in megabyte. Il gigabyte è l'unità di misura predefinita quando non si specifica un valore.
Per ulteriori informazioni sulla configurazione delle quote dello schema, consultare [CREATE SCHEMA](r_CREATE_SCHEMA.md).
## Esempi
L'esempio seguente rinomina lo schema SALES in US\$1SALES.
```
alter schema sales
rename to us_sales;
```
L'esempio seguente concede la proprietà dello schema US\$1SALES all'utente DWUSER.
```
alter schema us_sales
owner to dwuser;
```
Nell'esempio seguente la quota viene modificata a 300 GB e viene rimossa.
```
alter schema us_sales QUOTA 300 GB;
alter schema us_sales QUOTA UNLIMITED;
```
# ALTER SYSTEM
Modifica un'opzione di configurazione a livello di sistema per il cluster Amazon Redshift o il gruppo di lavoro Redshift Serverless.
## Privilegi richiesti
Uno dei seguenti tipi di utente può eseguire il comando ALTER SYSTEM:
+ Superuser
+ Utente amministratore
## Sintassi
```
ALTER SYSTEM SET system-level-configuration = {true| t | on | false | f | off}
```
## Parameters
*system-level-configuration*
Una configurazione a livello di sistema. Valori validi: `data_catalog_auto_mount` e `metadata_security`.
\$1vero\$1 t \$1 attivo \$1 falso \$1 f \$1 disattivato\$1
Un valore per attivare o disattivare la configurazione a livello di sistema. Un `true`, `t` oppure `on` indica di attivare la configurazione. Un `false`, `f` oppure `off` indica di disattivare la configurazione.
## Note per l'utilizzo
Per un cluster con provisioning, le modifiche apportate a `data_catalog_auto_mount` diventano effettive al successivo riavvio del cluster. Per ulteriori informazioni, consulta [Riavvio di un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-clusters-console.html#reboot-cluster) nella *Guida alla gestione di Amazon Redshift*.
Per un gruppo di lavoro serverless, le modifiche apportate a `data_catalog_auto_mount` non diventano immediatamente effettive.
## Esempi
L'esempio seguente attiva il montaggio automatico di AWS Glue Data Catalog.
```
ALTER SYSTEM SET data_catalog_auto_mount = true;
```
L'esempio seguente attiva la sicurezza dei metadati.
```
ALTER SYSTEM SET metadata_security = true;
```
### Impostazione di un namespace di identità predefinito
Questo esempio è specifico per l’utilizzo di un provider di identità. Puoi integrare Redshift con IAM Identity Center e un provider di identità per centralizzare la gestione delle identità per Redshift e altri servizi. AWS
L’esempio seguente mostra come impostare il namespace di identità predefinito per il sistema. Se effettui questa operazione successivamente, semplifichi l’esecuzione delle istruzioni GRANT e CREATE perché non devi includere il namespace come prefisso per ogni identità.
```
ALTER SYSTEM SET default_identity_namespace = 'MYCO';
```
Dopo avere eseguito il comando, puoi utilizzare istruzioni come le seguenti:
```
GRANT SELECT ON TABLE mytable TO alice;
GRANT UPDATE ON TABLE mytable TO salesrole;
CREATE USER bob password 'md50c983d1a624280812631c5389e60d48c';
```
L’effetto dell’impostazione del namespace di identità predefinito è che ogni identità non lo richiede come prefisso. In questo esempio, `alice` viene sostituito da `MYCO:alice`. Ciò accade con qualsiasi identità inclusa. Per ulteriori informazioni sull’utilizzo di un provider di identità con Redshift, consulta [Connessione di Redshift a Centro identità IAM per offrire agli utenti un’esperienza di single sign-on](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-idp-connect.html).
Per ulteriori informazioni sulle impostazioni relative alla configurazione di Redshift con Centro identità IAM, consulta [SET](r_SET.md) e [ALTER IDENTITY PROVIDER](r_ALTER_IDENTITY_PROVIDER.md).
# ALTER TABLE
Questo comando modifica la definizione di una tabella del database Amazon Redshift o la tabella esterna di Amazon Redshift Spectrum. Questo comando aggiorna i valori e le proprietà impostati da [CREATE TABLE](r_CREATE_TABLE_NEW.md) o [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Puoi utilizzare ALTER TABLE in una vista per la sicurezza a livello di riga (RLS).
Non è possibile eseguire ALTER TABLE su una tabella esterna all'interno di un blocco di transazione (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
ALTER TABLE blocca le operazioni di lettura e scrittura della tabella fino al completamento della transazione che contiene l'operazione ALTER TABLE, a meno che nella documentazione non sia specificamente indicato che è possibile eseguire query sui dati o eseguire altre operazioni sulla tabella durante la modifica.
## Privilegi richiesti
L'utente che modifica una tabella deve disporre del privilegio appropriato affinché il comando venga eseguito correttamente. A seconda del comando ALTER TABLE, è richiesto uno dei seguenti privilegi.
+ Superuser
+ Utenti con il privilegio ALTER TABLE
+ Il proprietario della tabella con il privilegio USAGE sullo schema
## Sintassi
```
ALTER TABLE table_name
{
ADD table_constraint
| DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
| OWNER TO new_owner
| RENAME TO new_name
| RENAME COLUMN column_name TO new_name
| ALTER COLUMN column_name TYPE updated_varchar_data_type_size
| ALTER COLUMN column_name ENCODE new_encode_type
| ALTER COLUMN column_name ENCODE encode_type,
| ALTER COLUMN column_name ENCODE encode_type, .....;
| ALTER DISTKEY column_name
| ALTER DISTSTYLE ALL
| ALTER DISTSTYLE EVEN
| ALTER DISTSTYLE KEY DISTKEY column_name
| ALTER DISTSTYLE AUTO
| ALTER [COMPOUND] SORTKEY ( column_name [,...] )
| ALTER SORTKEY AUTO
| ALTER SORTKEY NONE
| ALTER ENCODE AUTO
| ADD [ COLUMN ] column_name column_type
[ DEFAULT default_expr ]
[ ENCODE encoding ]
[ NOT NULL | NULL ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ] |
| DROP [ COLUMN ] column_name [ RESTRICT | CASCADE ]
| ROW LEVEL SECURITY { ON | OFF } [ CONJUNCTION TYPE { AND | OR } ] [ FOR DATASHARES ]
| MASKING { ON | OFF } FOR DATASHARES }
where table_constraint is:
[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] )
| PRIMARY KEY ( column_name [, ... ] )
| FOREIGN KEY (column_name [, ... ] )
REFERENCES reftable [ ( refcolumn ) ]}
The following options apply only to external tables:
SET LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
| SET FILE FORMAT format |
| SET TABLE PROPERTIES ('property_name'='property_value')
| PARTITION ( partition_column=partition_value [, ...] )
SET LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
| ADD [IF NOT EXISTS]
PARTITION ( partition_column=partition_value [, ...] ) LOCATION { 's3://bucket/folder' |'s3://bucket/manifest_file' }
[, ... ]
| DROP PARTITION ( partition_column=partition_value [, ...] )
```
Per ridurre il tempo necessario per eseguire il comando ALTER TABLE, è possibile combinare alcune clausole del comando ALTER TABLE.
Amazon Redshift supporta le seguenti combinazioni delle clausole ALTER TABLE:
```
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTKEY column_Id;
ALTER TABLE tablename ALTER DISTKEY column_Id, ALTER SORTKEY (column_list);
ALTER TABLE tablename ALTER SORTKEY (column_list), ALTER DISTSTYLE ALL;
ALTER TABLE tablename ALTER DISTSTYLE ALL, ALTER SORTKEY (column_list);
```
## Parameters
*table\$1name*
Nome della tabella da modificare. Specifica solo il nome della tabella o utilizzare il formato *schema\$1name.table\$1name* per utilizzare uno schema specifico. Le tabelle esterne devono essere qualificate da un nome di schema esterno. Inoltre puoi specificare un nome di vista se utilizzi l'istruzione ALTER TABLE per rinominare una vista o cambiare il proprietario. La lunghezza massima per il nome della tabella è 127 byte; i nomi più lunghi vengono troncati a 127 byte. Puoi utilizzare caratteri multibyte UTF-8 fino a un massimo di quattro byte. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
ADD *table\$1constraint*
Clausola che aggiunge il vincolo specificato alla tabella. Per le descrizioni dei valori validi di *table\$1constraint*, vedi [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Non puoi aggiungere un vincolo della chiave primaria a una colonna nullable. Se la colonna è stata originariamente creata con il vincolo NOT NULL, puoi aggiungere il vincolo della chiave primaria.
DROP CONSTRAINT *constraint\$1name*
Clausola che rimuove il vincolo denominato dalla tabella. Per rimuovere un vincolo, specifica il nome del vincolo e non il tipo di vincolo. Per visualizzare i nomi dei vincoli di tabella, esegui la seguente query.
```
select constraint_name, constraint_type
from information_schema.table_constraints;
```
RESTRICT
Clausola che rimuove solo il vincolo specificato. RESTRICT è un'opzione per DROP CONSTRAINT. RESTRICT non può essere usata con CASCADE.
CASCADE
Clausola che rimuove il vincolo specificato e tutto quello che dipende da quel vincolo. CASCADE è un'opzione per DROP CONSTRAINT. CASCADE non può essere usata con RESTRICT.
OWNER TO *new\$1owner*
Clausola che modifica il proprietario della tabella (o vista) sul valore *new\$1owner*.
RENAME TO *new\$1name*
Clausola che rinomina una tabella (o una vista) sul valore specificato in *new\$1name*. La lunghezza massima per il nome della tabella è 127 byte; i nomi più lunghi vengono troncati a 127 byte.
Non è possibile rinominare una tabella permanente con un nome che inizia con "\$1". Un nome di tabella che inizia con "\$1" indica una tabella temporanea.
Non puoi rinominare una tabella esterna.
ALTER COLUMN *column\$1name* TYPE *updated\$1varchar\$1data\$1type\$1size*
Una clausola che modifica le dimensioni di una colonna definita come un tipo di dati VARCHAR. Questa clausola supporta solo la modifica della dimensione di un tipo di dati VARCHAR. Considera i seguenti limiti:
+ Non è possibile modificare una colonna con le codifiche di compressione BYTEDICT, RUNLENGTH o K. TEXT255 TEXT32
+ Non è possibile ridurre le dimensioni al di sotto delle dimensioni massime dei dati esistenti.
+ Non puoi alterare le colonne con valori predefiniti.
+ Non puoi alterare le colonne con UNIQUE, PRIMARY KEY o FOREIGN KEY.
+ Non è possibile modificare le colonne all'interno di un blocco di transazione (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
ALTER COLUMN *column\$1name* ENCODE *new\$1encode\$1type*
Una clausola che modifica la codifica di compressione di una colonna. Se si specifica la codifica di compressione per una colonna, la tabella non è più impostata su ENCODE AUTO. Per informazioni sulla codifica della compressione, consultare [Compressione delle colonne per ridurre la dimensione dei dati archiviati](t_Compressing_data_on_disk.md).
Quando si modifica la codifica di compressione per una colonna, la tabella rimane disponibile per l'esecuzione di query.
Considera i seguenti limiti:
+ Non è possibile modificare una colonna con la stessa codifica definita per la colonna.
+ Non è possibile modificare la codifica per una colonna in una tabella con un sortkey interlacciato.
ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, ALTER COLUMN *column\$1name* ENCODE *encode\$1type*, .....;
Una clausola che modifica la codifica di compressione di più colonne in un singolo comando. Per informazioni sulla codifica della compressione, consultare [Compressione delle colonne per ridurre la dimensione dei dati archiviati](t_Compressing_data_on_disk.md).
Quando si modifica la codifica di compressione per una colonna, la tabella rimane disponibile per l'esecuzione di query.
Considera i seguenti limiti:
+ Non è possibile modificare più volte una colonna con lo stesso tipo di codifica o con un tipo di codifica diverso in un singolo comando.
+ Non è possibile modificare una colonna con la stessa codifica definita per la colonna.
+ Non è possibile modificare la codifica per una colonna in una tabella con un sortkey interlacciato.
ALTER DISTSTYLE ALL
Una clausola che modifica lo stile di distribuzione esistente di una tabella in `ALL`. Considera i seguenti aspetti:
+ ALTER DISTSTYLE, ALTER SORTKEY e VACUUM non possono essere eseguiti contemporaneamente sulla stessa tabella.
+ Se VACUUM è attualmente in esecuzione, l'esecuzione di ALTER DISTSTYLE ALL restituisce un errore.
+ Se ALTER DISTSTYLE è in esecuzione, il vacuum di background non viene avviato su una tabella.
+ Il comando ALTER DISTSTYLE ALL non è supportato per le tabelle con chiavi di ordinamento interlacciato e tabelle temporanee.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l'ottimizzazione automatica della tabella.
Per ulteriori informazioni su DISTSTYLE ALL, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE EVEN
Una clausola che modifica lo stile di distribuzione esistente di una tabella in `EVEN`. Considera i seguenti aspetti:
+ ALTER DISTSYTLE, ALTER SORTKEY e VACUUM non possono essere eseguiti contemporaneamente sulla stessa tabella.
+ Se VACUUM è attualmente in esecuzione, l'esecuzione di ALTER DISTSTYLE EVEN restituisce un errore.
+ Se ALTER DISTSTYLE EVEN è in esecuzione, il vacuum di background non viene avviato su una tabella.
+ Il comando ALTER DISTSTYLE EVEN non è supportato per le tabelle con chiavi di ordinamento interlacciato e tabelle temporanee.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l'ottimizzazione automatica della tabella.
Per ulteriori informazioni su DISTSTYLE ALL EVEN, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTKEY *column\$1name* o ALTER DISTSTYLE KEY DISTKEY *column\$1name*
Una clausola che modifica la colonna utilizzata come chiave di distribuzione di una tabella. Considera i seguenti aspetti:
+ VACUUM e ALTER DISTKEY non possono essere eseguiti contestualmente sulla stessa tabella.
+ Se VACUUM è già in esecuzione, ALTER DISTKEY restituisce un errore.
+ Se ALTER DISTKEY è in esecuzione, il vacuum di background non viene avviato su una tabella.
+ Se ALTER DISTKEY è in esecuzione, il vacuum in primo piano restituisce un errore.
+ Su una tabella, è possibile eseguire solo un comando ALTER DISTKEY alla volta.
+ Il comando ALTER DISTKEY non è supportato sulle tabelle con chiavi di ordinamento interlacciato.
+ Se lo stile di distribuzione è stato precedentemente definito come AUTO, la tabella non è più un candidato per l'ottimizzazione automatica della tabella.
Quando si specifica DISTSTYLE KEY, i dati vengono distribuiti dai valori nella colonna DISTKEY. Per ulteriori informazioni su DISTSTYLE, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER DISTSTYLE AUTO
Una clausola che modifica lo stile di distribuzione esistente di una tabella in AUTO.
Quando si modifica uno stile di distribuzione su AUTO, lo stile di distribuzione della tabella viene impostato come segue:
+ Una piccola tabella con DISTSTYLE ALL è convertita in AUTO(ALL).
+ Una piccola tabella con DISTSTYLE EVEN è convertita in AUTO(ALL).
+ Una piccola tabella con DISTSTYLE KEY è convertita in AUTO(ALL).
+ Una tabella grande con DISTSTYLE ALL è convertita in AUTO(ALL).
+ Una tabella grande con DISTSTYLE EVEN è convertita in AUTO(ALL).
+ Una tabella grande con DISTSTYLE KEY viene convertita in AUTO(KEY) e il DISTKEY viene conservato In questo caso, Amazon Redshift non apporta modifiche alla tabella.
Se Amazon Redshift determina che un nuovo stile o chiave di distribuzione migliorerà le prestazioni delle query, Amazon Redshift potrebbe modificare lo stile o la chiave di distribuzione della tabella in futuro. Ad esempio, Amazon Redshift potrebbe convertire una tabella con un DISTSTYLE di AUTO(KEY) in AUTO(EVEN) o viceversa. Per ulteriori informazioni sul comportamento in caso di modifica delle chiavi di distribuzione, tra cui la ridistribuzione dei dati e i blocchi, consulta i [suggerimenti di Amazon Redshift Advisor](https://docs.aws.amazon.com/redshift/latest/dg/advisor-recommendations.html#alter-diststyle-distkey-recommendation).
Per ulteriori informazioni su DISTSTYLE AUTO, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Per visualizzare lo stile di distribuzione di una tabella, eseguire una query sulla vista del catalogo di sistema SVV\$1TABLE\$1INFO. Per ulteriori informazioni, consulta [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Per visualizzare i suggerimenti di Amazon Redshift Advisor per le tabelle, eseguire una query sulla vista del catalogo di sistema SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Per ulteriori informazioni, consulta [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Per visualizzare le azioni intraprese da Amazon Redshift, eseguire una query sulla vista del catalogo di sistema SVL\$1AUTO\$1WORKER\$1ACTION. Per ulteriori informazioni, consulta [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER [COMPOUND] SORTKEY ( *column\$1name* [,...] )
Una clausola che modifica o aggiunge la chiave di ordinamento utilizzata per una tabella. ALTER SORTKEY non è supportato per le tabelle temporanee.
Quando si modifica una chiave di ordinamento, la codifica di compressione delle colonne nella chiave di ordinamento nuova o originale può cambiare. Se nessuna codifica è definita esplicitamente per la tabella, allora Amazon Redshift assegna automaticamente le codifiche di compressione come segue:
+ Le colonne definite come chiavi di ordinamento vengono assegnate alla compressione RAW.
+ Le colonne definite come tipi di dati BOOLEAN, REAL o DOUBLE PRECISION vengono assegnate alla compressione RAW.
+ Alle colonne definite come SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP o TIMESTAMPTZ viene assegnata la compressione. AZ64
+ Le colonne definite come CHAR o VARCHAR sono assegnate alla compressione LZO.
Considera i seguenti aspetti:
+ È possibile definire un massimo di 400 colonne per una chiave di ordinamento per tabella.
+ È possibile modificare una chiave di ordinamento interlacciata in una chiave di ordinamento composta o nessuna chiave di ordinamento. È possibile modificare una chiave di ordinamento interlacciata in una chiave di ordinamento composta o nessuna chiave di ordinamento.
+ Se la chiave di ordinamento è stata precedentemente definita come AUTO, la tabella non è più un candidato per l'ottimizzazione automatica della tabella.
+ Amazon Redshift consiglia di utilizzare la codifica RAW (senza compressione) per le colonne definite come chiavi di ordinamento. Quando si modifica una colonna per sceglierla come chiave di ordinamento, la compressione della colonna viene modificata in compressione RAW (senza compressione). Ciò può aumentare la quantità di archiviazione richiesta dalla tabella. L'aumento delle dimensioni della tabella dipende dalla definizione specifica della tabella e dal contenuto della tabella. Per ulteriori informazioni su questi componenti, consultare . [Codifiche di compressione](c_Compression_encodings.md)
Quando i dati vengono caricati in una tabella seguono l'ordine della chiave di ordinamento. Quando si modifica la chiave di ordinamento, Amazon Redshift riordina i dati. Per ulteriori informazioni su SORTKEY, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
ALTER SORTKEY AUTO
Una clausola che modifica o aggiunge la chiave di ordinamento della tabella di destinazione ad AUTO. ALTER SORTKEY AUTO non è supportato per le tabelle temporanee.
Quando si modifica una chiave di ordinamento in AUTO, Amazon Redshift conserva la chiave di ordinamento esistente della tabella.
Se Amazon Redshift determina che una nuova chiave di ordinamento migliorerà le prestazioni delle query, Amazon Redshift potrebbe modificare la chiave di ordinamento della tabella in futuro.
Per ulteriori informazioni su SORTKEY AUTO, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Per visualizzare la chiave di ordinamento di una tabella, eseguire una query sulla vista del catalogo di sistema SVV\$1TABLE\$1INFO. Per ulteriori informazioni, consulta [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Per visualizzare i suggerimenti di Amazon Redshift Advisor per le tabelle, eseguire una query sulla vista del catalogo di sistema SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. Per ulteriori informazioni, consulta [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md). Per visualizzare le azioni intraprese da Amazon Redshift, eseguire una query sulla vista del catalogo di sistema SVL\$1AUTO\$1WORKER\$1ACTION. Per ulteriori informazioni, consulta [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md).
ALTER SORTKEY NONE
Una clausola che rimuove la chiave di ordinamento della tabella di destinazione.
Se la chiave di ordinamento è stata precedentemente definita come AUTO, la tabella non è più un candidato per l'ottimizzazione automatica della tabella.
ALTER ENCODE AUTO
Una clausola che modifica il tipo di codifica delle colonne della tabella di destinazione in AUTO. Quando si modifica la codifica in AUTO, Amazon Redshift conserva il tipo di codifica esistente delle colonne nella tabella. Quindi, se Amazon Redshift determina che un nuovo tipo di codifica può migliorare le prestazioni delle query, Amazon Redshift può modificare il tipo di codifica delle colonne della tabella.
Se si modifica una o più colonne per specificare una codifica, Amazon Redshift non regola più automaticamente la codifica per tutte le colonne della tabella. Le colonne mantengono le impostazioni di codifica correnti.
Le seguenti azioni non influiscono sull'impostazione ENCODE AUTO per la tabella:
+ Ridenominazione della tabella.
+ Modifica dell'impostazione DISTSTYLE o SORTKEY per la tabella.
+ Aggiunta o eliminazione di una colonna con un'impostazione ENCODE.
+ Utilizzo dell'opzione COMPUPDATE del comando COPY. Per ulteriori informazioni, consulta [Operazioni di caricamento dati](copy-parameters-data-load.md).
Per visualizzare la codifica di una tabella, eseguire una query sulla vista del catalogo di sistema SVV\$1TABLE\$1INFO. Per ulteriori informazioni, consulta [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md).
RENAME COLUMN *column\$1name* TO *new\$1name*
Clausola che rinomina una colonna sul valore specificato in *new\$1name*. La lunghezza massima per il nome della colonna è 127 byte; i nomi più lunghi vengono troncati a 127 byte. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
ADD [ COLUMN ] *column\$1name*
Clausola che aggiunge una colonna con il nome specificato alla tabella. Puoi aggiungere una sola colonna in ogni istruzione ALTER TABLE.
Non puoi aggiungere una colonna che sia la chiave di distribuzione (DISTKEY) o una chiave di ordinamento (SORTKEY) della tabella.
Non puoi utilizzare un comando ALTER TABLE ADD COLUMN per modificare i seguenti attributi di tabella e colonna:
+ UNIQUE
+ PRIMARY KEY
+ REFERENCES (chiave esterna)
+ IDENTITY o GENERATED BY DEFAULT AS IDENTITY
La lunghezza massima per il nome della colonna è 127 byte; i nomi più lunghi vengono troncati a 127 byte. Il numero massimo di colonne che puoi definire in una singola tabella è 1.600.
Le seguenti restrizioni si applicano quando si aggiunge una colonna a una tabella esterna:
+ Non puoi aggiungere una colonna a una tabella esterna con i vincoli di colonna DEFAULT, ENCODE, NOT NULL o NULL.
+ Non puoi aggiungere colonne a una tabella esterna definita utilizzando il formato file AVRO.
+ Se le pseudocolonne sono abilitate, il numero massimo di colonne che è possibile definire in una singola tabella esterna è 1.598. Se le pseudocolonne non sono abilitate, il numero massimo di colonne che puoi definire in una singola tabella è 1.600.
Per ulteriori informazioni, consulta [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
*column\$1type*
Tipo dei dati della colonna da aggiungere. Per le colonne CHAR e VARCHAR, puoi utilizzare la parola chiave MAX invece di dichiarare una lunghezza massima. MAX imposta la lunghezza massima a 4.096 byte per CHAR o a 65.535 byte per VARCHAR. La dimensione massima di un oggetto di tipo GEOMETRY è di 1.048.447 byte.
Per informazioni sui tipi di dati supportati da Amazon Redshift, consultare [Tipi di dati](c_Supported_data_types.md).
DEFAULT *default\$1expr*
Clausola che assegna un valore di dati predefinito per la colonna. Il tipo di dati di *default\$1expr* deve corrispondere al tipo di dati della colonna. Il valore DEFAULT deve essere un'espressione senza variabili. Le sottoquery, i riferimenti incrociati ad altre colonne della tabella corrente e le funzioni definite dall'utente non sono consentiti.
*default\$1expr* è utilizzato in qualsiasi operazione INSERT che non specifica un valore per la colonna. Se non viene specificato alcun valore predefinito, il valore predefinito per la colonna è null.
Se un'operazione COPY incontra un campo nullo su una colonna che ha un valore DEFAULT e un vincolo NOT NULL, il comando COPY inserisce il valore di *default\$1expr*.
DEFAULT non è supportato per le tabelle esterne.
ENCODE *encoding*
La codifica della compressione per una colonna. Per impostazione predefinita, Amazon Redshift gestisce automaticamente la codifica di compressione per tutte le colonne di una tabella se non si specifica la codifica di compressione per qualsiasi colonna della tabella o se si specifica l'opzione ENCODE AUTO per la tabella.
Se si specifica la codifica di compressione per qualsiasi colonna della tabella o se non si specifica l'opzione ENCODE AUTO per la tabella, Amazon Redshift assegna automaticamente la codifica di compressione alle colonne per le quali non si specifica la codifica di compressione come segue:
+ Per impostazione predefinita, tutte le colonne nelle tabelle temporanee vengono assegnate alla compressione RAW.
+ Le colonne definite come chiavi di ordinamento vengono assegnate alla compressione RAW.
+ Alle colonne definite come tipi di dati BOOLEAN, REAL, DOUBLE PRECISION, GEOMETRY o GEOGRAPHY viene assegnata la compressione di tipo RAW.
+ Alle colonne definite come SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIME, TIMETZ, TIMESTAMP o TIMESTAMPTZ viene assegnata la compressione. AZ64
+ Le colonne definite come CHAR, VARCHAR o VARBYTE sono assegnate alla compressione LZO.
Se non vuoi che una colonna venga compressa, specifica esplicitamente la codifica RAW.
Sono supportate le seguenti [compression encodings](c_Compression_encodings.md#compression-encoding-list):
+ AZ64
+ BYTEDICT
+ DELTA
+ DELTA32K
+ LZO
+ MOSTLY8
+ MOSTLY16
+ MOSTLY32
+ RAW (nessuna compressione)
+ RUNLENGTH
+ TEXT255
+ TEXT32K
+ ZSTD
ENCODE non è supportato per le tabelle esterne.
NOT NULL \$1 NULL
NOT NULL specifica che la colonna non può contenere valori null. NULL, il valore predefinito, specifica che la colonna accetta valori nulli.
NOT NULL e NULL non sono supportati per tabelle esterne.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Una clausola che specifica se la stringa di ricerca o il confronto per la colonna fa distinzione o meno tra maiuscole e minuscole. Il valore di default corrisponde alla stessa configurazione corrente della distinzione tra maiuscole e minuscole del database.
Per informazioni sul confronto di database, utilizzare il comando seguente:
```
SELECT db_collation();
db_collation
----------------
case_sensitive
(1 row)
```
CASE\$1SENSITIVE e CS sono intercambiabili e producono gli stessi risultati. Allo stesso modo CASE\$1INSENSITIVE e CI sono intercambiabili e producono gli stessi risultati.
DROP [ COLUMN ] *column\$1name*
Il nome della colonna da eliminare dalla tabella.
Non puoi rimuovere l'ultima colonna di una tabella. Una tabella deve avere almeno una colonna.
Non puoi rimuovere una colonna che sia la chiave di distribuzione (DISTKEY) o una chiave di ordinamento (SORTKEY) della tabella. Il comportamento predefinito per DROP COLUMN è RESTRICT se la colonna contiene oggetti dipendenti, ad esempio una vista, una chiave primaria, una chiave esterna o una restrizione UNIQUE.
Le seguenti restrizioni si applicano quando si rimuove una colonna da una tabella esterna:
+ Non puoi rimuovere una colonna da una tabella esterna se la colonna viene utilizzata come partizione.
+ Non puoi rimuovere una colonna da una tabella esterna definita utilizzando il formato file AVRO.
+ RESTRICT e CASCADE vengono ignorati per le tabelle esterne.
+ Non è possibile eliminare le colonne della tabella delle policy a cui viene fatto riferimento all'interno della definizione della policy a meno che non si elimini o si scolleghi la policy. Ciò vale anche quando viene specificata l'opzione CASCADE. È possibile eliminare altre colonne nella tabella delle policy.
Per ulteriori informazioni, consulta [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md).
RESTRICT
Quando viene utilizzato con DROP COLUMN, RESTRICT indica che la colonna da rimuovere non è stata rimossa, in questi casi:
+ Se una vista definita fa riferimento alla colonna che si vuole eliminare
+ Se una chiave esterna fa riferimento alla colonna
+ Se la colonna fa parte di una chiave multiparte
RESTRICT non può essere usata con CASCADE.
RESTRICT e CASCADE vengono ignorati per le tabelle esterne.
CASCADE
Se utilizzato con DROP COLUMN, rimuove la colonna specificata e tutto ciò che dipende da tale colonna. CASCADE non può essere usata con RESTRICT.
RESTRICT e CASCADE vengono ignorati per le tabelle esterne.
Le seguenti opzioni si applicano solo alle tabelle esterne.
SET LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*' \$1
Il percorso della cartella Amazon S3 che contiene i file di dati o un file manifest che contiene un elenco di percorsi di oggetti Amazon S3. I bucket devono trovarsi nella stessa regione AWS del cluster Amazon Redshift. Per AWS un [Limitazioni di Amazon Redshift Spectrum](c-spectrum-considerations.md) elenco delle regioni supportate, vedere. Per ulteriori informazioni sull'uso di un file manifest, vedi LOCATION nel riferimento CREATE EXTERNAL TABLE [Parameters](r_CREATE_EXTERNAL_TABLE.md#r_CREATE_EXTERNAL_TABLE-parameters).
SET FILE FORMAT *format*
Il formato dei file di dati esterni.
I formati validi sono:
+ AVRO
+ PARQUET
+ RCFILE
+ SEQUENCEFILE
+ TEXTFILE
SET TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*')
Clausola che imposta la definizione della tabella delle proprietà della tabella per una tabella esterna.
Le proprietà della tabella rispettano la distinzione tra maiuscole e minuscole.
'numRows'='*row\$1count*'
Proprietà che imposta il valore numRows per la definizione della tabella. Per aggiornare in modo esplicito le statistiche di una tabella esterna, imposta la proprietà numRows in modo da indicare le dimensioni della tabella. Amazon Redshift non analizza le tabelle esterne per generare le statistiche delle tabelle che l'ottimizzatore di query utilizza per generare un piano di query. Se le statistiche della tabella non sono impostate per una tabella esterna, Amazon Redshift genera un piano di esecuzione della query. Il piano si basa sul presupposto che le tabelle esterne sono le tabelle più grandi e che quelle locali sono le più piccole.
'skip.header.line.count'='*line\$1count*'
Proprietà che imposta il numero di righe da saltare all'inizio di ogni file sorgente.
PARTITION ( *partition\$1column*=*partition\$1value* [, ...] SET LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1
Clausola che imposta una nuova posizione per una o più colonne di partizione.
ADD [ IF NOT EXISTS ] PARTITION ( *partition\$1column*=*partition\$1value* [, ...] ) LOCATION \$1 's3://*bucket*/*folder*' \$1 's3://*bucket*/*manifest\$1file*' \$1 [, ... ]
Una clausola che aggiunge una o più partizioni. È possibile specificare più clausole PARTITION utilizzando una singola istruzione ALTER TABLE … ADD.
Se si utilizza il AWS Glue catalogo, è possibile aggiungere fino a 100 partizioni utilizzando una singola istruzione ALTER TABLE.
La clausola IF NOT EXISTS indica che se la partizione specificata esiste già, il comando non deve apportare modifiche. Indica inoltre che il comando deve restituire un messaggio che la partizione esiste, anziché terminare con un errore. Questa clausola è utile durante lo scripting, quindi lo script non fallisce se ALTER TABLE tenta di aggiungere una partizione già esistente.
DROP PARTITION (*partition\$1column*=*partition\$1value* [, ...] )
Clausola che rimuove la partizione specificata. La rimozione di una partizione altera solo i metadati della tabella esterna. I dati su Amazon S3 non sono interessati.
ROW LEVEL SECURITY \$1 ON \$1 OFF \$1 [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ] [ FOR DATASHARES ]
Una clausola che attiva o disattiva la sicurezza a livello di riga per una relazione.
Quando per una relazione è attivata la protezione a livello di riga, è possibile leggere solo le righe al livello di riga a cui la policy di sicurezza consente l'accesso. Quando non ci sono policy che consentono l'accesso alla relazione, non è possibile visualizzare alcuna riga dalla relazione. Solo gli utenti con privilegi avanzati e gli utenti o i ruoli che hanno il ruolo `sys:secadmin` possono impostare la clausola ROW LEVEL SECURITY. Per ulteriori informazioni, consulta [Sicurezza a livello di riga](t_rls.md). Questa istruzione è supportata sul database connesso o su un database con autorizzazioni federate di Amazon Redshift. La clausola FOR DATASHARES non è supportata su un database con autorizzazioni federate Amazon Redshift.
+ [ CONJUNCTION TYPE \$1 AND \$1 OR \$1 ]
Una clausola che consente di scegliere il tipo di congiunzione della policy di sicurezza a livello di riga per una relazione. Quando a una relazione sono associate più policy di sicurezza a livello di riga, è possibile combinare le policy con la clausola AND oppure OR. Per impostazione predefinita, Amazon Redshift combina le policy RLS con la clausola AND. Gli utenti con privilegi avanzati, gli utenti o i ruoli che hanno il ruolo `sys:secadmin` possono utilizzare questa clausola per definire il tipo di combinazione della policy di sicurezza a livello di riga per una relazione. Per ulteriori informazioni, consulta [Combinazione di più policy per utente](t_rls_combine_policies.md).
+ FOR DATASHARES
Una clausola che determina se è possibile accedere a una relazione protetta da RLS in un'unità di condivisione dati. Per impostazione predefinita, non è possibile accedere a una relazione protetta da RLS in un'unità di condivisione dati. Il comando ALTER TABLE ROW LEVEL SECURITY eseguito con questa clausola influisce solo sulla proprietà di accessibilità dell'unità di condivisione dati della relazione. La proprietà ROW LEVEL SECURITY non viene modificata.
Se rendi accessibile una relazione protetta da RLS nelle unità di condivisione dati, la relazione non dispone di una sicurezza a livello di riga nel database con unità di condivisione dati sul lato consumer. La relazione mantiene la proprietà RLS sul lato producer.
MASKING \$1 ON \$1 OFF \$1 FOR DATASHARES
Una clausola che determina se è possibile accedere a una relazione protetta da DDM in un’unità di condivisione dati. Per impostazione predefinita, non è possibile accedere a una relazione protetta da DDM in un’unità di condivisione dati. Se rendi accessibile una relazione protetta da DDM nelle unità di condivisione dati, la relazione non dispone di una sicurezza a livello di riga nel database con unità di condivisione dati sul lato consumer. La relazione mantiene la proprietà di mascheramento sul lato producer. Solo gli utenti con privilegi avanzati e gli utenti o i ruoli che hanno il ruolo `sys:secadmin` possono impostare la clausola MASKING FOR DATASHARES. Per ulteriori informazioni, consulta [Mascheramento dinamico dei dati](t_ddm.md).
## Esempi
Per esempi che mostrano come utilizzare il comando ALTER TABLE, consultare quanto segue.
+ [Esempi di ALTER TABLE](r_ALTER_TABLE_examples_basic.md)
+ [Esempi per alterare la tabella esterna](r_ALTER_TABLE_external-table.md)
+ [Esempi di ALTER TABLE ADD e DROP COLUMN](r_ALTER_TABLE_COL_ex-add-drop.md)
# Esempi di ALTER TABLE
I seguenti esempi dimostrano l'utilizzo di base del comando ALTER TABLE.
## Ridenominazione di una tabella o una vista
Il seguente comando rinomina la tabella USERS in USERS\$1BKUP:
```
alter table users
rename to users_bkup;
```
Puoi anche usare questo tipo di comando per rinominare una vista.
## Modifica del proprietario di una tabella o di una vista
Il seguente comando modifica il proprietario della tabella VENUE nell'utente DWUSER:
```
alter table venue
owner to dwuser;
```
I seguenti comandi creano una vista, quindi cambiano il suo proprietario:
```
create view vdate as select * from date;
alter table vdate owner to vuser;
```
## Ridenominazione di una colonna
Il seguente comando rinomina la colonna VENUESEATS della tabella VENUE in VENUESIZE:
```
alter table venue
rename column venueseats to venuesize;
```
## Rimozione del vincolo di una tabella
Per eliminare un vincolo di tabella, ad esempio una chiave primaria, una chiave esterna o un vincolo univoco, individua innanzitutto il nome interno del vincolo. Poi specifica il nome del vincolo nel comando ALTER TABLE. L'esempio seguente trova i vincoli per la tabella CATEGORY, quindi rimuove la chiave primaria con il nome `category_pkey`.
```
select constraint_name, constraint_type
from information_schema.table_constraints
where constraint_schema ='public'
and table_name = 'category';
constraint_name | constraint_type
----------------+----------------
category_pkey | PRIMARY KEY
alter table category
drop constraint category_pkey;
```
## Modificare una colonna VARCHAR
Per preservare lo storage, è possibile definire una tabella inizialmente con colonne VARCHAR con la dimensione minima necessaria per i requisiti di dati attuali. Successivamente, per utilizzare stringhe più lunghe, è possibile modificare la tabella per aumentare le dimensioni della colonna.
L'esempio seguente aumenta le dimensioni della colonna EVENTNAME in VARCHAR(300).
```
alter table event alter column eventname type varchar(300);
```
## Modificare una colonna VARBYTE
Per preservare l’archiviazione, puoi definire una tabella inizialmente con colonne VARBYTE con la dimensione minima necessaria per i requisiti di dati attuali. Successivamente, per utilizzare stringhe più lunghe, è possibile modificare la tabella per aumentare le dimensioni della colonna.
L’esempio seguente aumenta le dimensioni della colonna EVENTNAME in VARBYTE(300).
```
alter table event alter column eventname type varbyte(300);
```
## Modifica della codifica di compressione per una colonna
È possibile modificare la codifica di compressione di una colonna. Di seguito è riportata una serie di esempi che dimostrano questo approccio. La definizione di tabella per questi esempi è come segue.
```
create table t1(c0 int encode lzo, c1 bigint encode zstd, c2 varchar(16) encode lzo, c3 varchar(32) encode zstd);
```
L'istruzione seguente modifica la codifica di compressione per la colonna c0 dalla codifica LZO alla codifica. AZ64
```
alter table t1 alter column c0 encode az64;
```
L'istruzione seguente modifica la codifica di compressione per la colonna c1 dalla codifica Zstandard alla codifica. AZ64
```
alter table t1 alter column c1 encode az64;
```
La seguente istruzione modifica la codifica di compressione per la colonna c2 dalla codifica LZO alla codifica Byte-Dictionary.
```
alter table t1 alter column c2 encode bytedict;
```
La seguente istruzione modifica la codifica di compressione per la colonna c3 dalla codifica Zstandard alla codifica Runlength.
```
alter table t1 alter column c3 encode runlength;
```
## Modificare una colonna DISTSTYLE KEY DISTKEY
I seguenti esempi mostrano come modificare DISTSTYLE e DISTKEY di una tabella.
Crea una tabella con stile di distribuzione EVEN. La vista SVV\$1TABLE\$1INFO mostra che DISTSTYLE è EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Modificare la tabella DISTKEY in `inv_warehouse_sk`. La vista SVV\$1TABLE\$1INFO mostra la colonna `inv_warehouse_sk` come chiave di distribuzione risultante.
```
alter table inventory alter diststyle key distkey inv_warehouse_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_warehouse_sk)
```
Modificare la tabella DISTKEY in `inv_item_sk`. La vista SVV\$1TABLE\$1INFO mostra la colonna `inv_item_sk` come chiave di distribuzione risultante.
```
alter table inventory alter distkey inv_item_sk;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+-----------------------
inventory | KEY(inv_item_sk)
```
## Modificare una tabella in DISTSTYLE ALL
Gli esempi seguenti mostrano come modificare una tabella in DISTSTYLE ALL.
Crea una tabella con stile di distribuzione EVEN. La vista SVV\$1TABLE\$1INFO mostra che DISTSTYLE è EVEN.
```
create table inventory(
inv_date_sk int4 not null ,
inv_item_sk int4 not null ,
inv_warehouse_sk int4 not null ,
inv_quantity_on_hand int4
) diststyle even;
Insert into inventory values(1,1,1,1);
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | EVEN
```
Modificare la tabella DISTSTYLE su ALL. La vista SVV\$1TABLE\$1INFO mostra il DISTSYTLE modificato.
```
alter table inventory alter diststyle all;
select "table", "diststyle" from svv_table_info;
table | diststyle
-----------+----------------
inventory | ALL
```
## Modifica una tabella SORTKEY
È possibile modificare una tabella per avere una chiave di ordinamento composta o nessuna chiave di ordinamento.
Nella seguente definizione della tabella, tabella `t1` è definita con una chiave di ordinamento interlacciata.
```
create table t1 (c0 int, c1 int) interleaved sortkey(c0, c1);
```
Il comando seguente modifica la tabella da una chiave di ordinamento interlacciata a una chiave di ordinamento composta.
```
alter table t1 alter sortkey(c0, c1);
```
Il comando seguente modifica la tabella per rimuovere la chiave di ordinamento interlacciata.
```
alter table t1 alter sortkey none;
```
Nella seguente definizione della tabella, tabella `t1` è definita con una colonna `c0` come chiave di ordinamento.
```
create table t1 (c0 int, c1 int) sortkey(c0);
```
Il comando seguente modifica la tabella `t1` in una chiave di ordinamento composta.
```
alter table t1 alter sortkey(c0, c1);
```
## Modifica di una tabella in ENCODE AUTO
L'esempio seguente mostra come modificare una tabella in ENCODE AUTO.
La definizione di tabella per questo esempio è come segue. `c0`La colonna è definita con il tipo di codifica e la colonna `c1` è definita con il tipo di AZ64 codifica LZO.
```
create table t1(c0 int encode AZ64, c1 varchar encode LZO);
```
Per questa tabella, l'istruzione seguente modifica la codifica in AUTO.
```
alter table t1 alter encode auto;
```
L'esempio seguente mostra come modificare una tabella per rimuovere l'impostazione ENCODE AUTO.
La definizione di tabella per questo esempio è come segue. Le colonne della tabella sono definite senza codifica. In questo caso, la codifica predefinita è ENCODE AUTO.
```
create table t2(c0 int, c1 varchar);
```
Per questa tabella, la seguente istruzione modifica la codifica della colonna c0 in LZO. La codifica della tabella non è più impostata su ENCODE AUTO.
```
alter table t2 alter column c0 encode lzo;;
```
## Modifica del controllo della sicurezza a livello di riga
Il seguente comando disattiva RLS per la tabella:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY OFF;
```
Il seguente comando disattiva RLS (sicurezza a livello di riga) per la tabella:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
```
Il seguente comando attiva RLS per la tabella e la rende accessibile nell'unità di condivisione dati:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES OFF;
```
Il seguente comando attiva RLS per la tabella e la rende inaccessibile nell'unità di condivisione dati:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON;
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY FOR DATASHARES ON;
```
Il seguente comando attiva RLS e imposta il tipo di combinazione RLS su OR per la tabella:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE OR;
```
Il seguente comando attiva RLS e imposta il tipo di combinazione RLS su AND per la tabella:
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON CONJUNCTION TYPE AND;
```
# Esempi per alterare la tabella esterna
I seguenti esempi utilizzano un bucket Amazon S3 situato nella regione Stati Uniti orientali (Virginia settentrionale) (`us-east-1`) Regione AWS e le tabelle di esempio create in [Esempi](r_CREATE_EXTERNAL_TABLE_examples.md) CREATE TABLE. Per ulteriori informazioni su come utilizzare le partizioni con tabelle esterne, consulta [Partizionamento delle tabelle esterne di Redshift Spectrum](c-spectrum-external-tables.md#c-spectrum-external-tables-partitioning).
L'esempio seguente imposta la proprietà della tabella numRows per la tabella esterna SPECTRUM.SALES su 170.000 righe.
```
alter table spectrum.sales
set table properties ('numRows'='170000');
```
L'esempio seguente modifica la posizione della tabella esterna SPECTRUM.SALES.
```
alter table spectrum.sales
set location 's3://redshift-downloads/tickit/spectrum/sales/';
```
L'esempio seguente modifica il formato della tabella esterna SPECTRUM.SALES in Parquet.
```
alter table spectrum.sales
set file format parquet;
```
L'esempio seguente aggiunge una partizione per la tabella SPECTRUM.SALES\$1PART.
```
alter table spectrum.sales_part
add if not exists partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/';
```
L'esempio seguente aggiunge tre partizioni per la tabella SPECTRUM.SALES\$1PART.
```
alter table spectrum.sales_part add if not exists
partition(saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/'
partition(saledate='2008-02-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/'
partition(saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
```
L'esempio seguente altera SPECTRUM.SALES\$1PART per eliminare la partizione con `saledate='2008-01-01''`.
```
alter table spectrum.sales_part
drop partition(saledate='2008-01-01');
```
L'esempio seguente imposta un nuovo percorso Amazon S3 per la partizione con `saledate='2008-01-01'`.
```
alter table spectrum.sales_part
partition(saledate='2008-01-01')
set location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01-01/';
```
L'esempio seguente cambia il nome di `sales_date` in `transaction_date`.
```
alter table spectrum.sales rename column sales_date to transaction_date;
```
Il seguente esempio imposta la mappatura della colonna sulla mappatura in base alla posizione per una tabella esterna che utilizza il formato ORC (optimized row columnar).
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='position');
```
Il seguente esempio imposta la mappatura della colonna sulla mappatura del nome per una tabella esterna che utilizza il formato ORC (optimized row columnar).
```
alter table spectrum.orc_example
set table properties('orc.schema.resolution'='name');
```
# Esempi di ALTER TABLE ADD e DROP COLUMN
I seguenti esempi mostrano come usare ALTER TABLE per aggiungere e rimuovere una colonna di base e anche come eliminare una colonna con un oggetto dipendente.
## ADD e DROP di una colonna di base
L'esempio seguente aggiunge una colonna autonoma FEEDBACK\$1SCORE alla tabella USERS. Questa colonna contiene semplicemente uninteger e il valore predefinito per questa colonna è NULL (nessun punteggio di feedback).
Per prima cosa, esegui una query sulla tabella di catalogo PG\$1TABLE\$1DEF per visualizzare lo schema della tabella USERS:
```
column | type | encoding | distkey | sortkey
--------------+------------------------+----------+---------+--------
userid | integer | delta | true | 1
username | character(8) | lzo | false | 0
firstname | character varying(30) | text32k | false | 0
lastname | character varying(30) | text32k | false | 0
city | character varying(30) | text32k | false | 0
state | character(2) | bytedict | false | 0
email | character varying(100) | lzo | false | 0
phone | character(14) | lzo | false | 0
likesports | boolean | none | false | 0
liketheatre | boolean | none | false | 0
likeconcerts | boolean | none | false | 0
likejazz | boolean | none | false | 0
likeclassical | boolean | none | false | 0
likeopera | boolean | none | false | 0
likerock | boolean | none | false | 0
likevegas | boolean | none | false | 0
likebroadway | boolean | none | false | 0
likemusicals | boolean | none | false | 0
```
Ora aggiungi la colonna feedback\$1score:
```
alter table users
add column feedback_score int
default NULL;
```
Seleziona la colonna FEEDBACK\$1SCORE da USERS per verificare che sia stata aggiunta:
```
select feedback_score from users limit 5;
feedback_score
----------------
NULL
NULL
NULL
NULL
NULL
```
Rimuovi la colonna per ripristinare la DDL originale:
```
alter table users drop column feedback_score;
```
## Eliminazione di una colonna con un oggetto dipendente
Nell'esempio seguente viene rimossa una colonna che ha un oggetto dipendente. Di conseguenza, anche l'oggetto dipendente viene rimosso.
Per iniziare, aggiungi nuovamente la colonna FEEDBACK\$1SCORE alla tabella USERS:
```
alter table users
add column feedback_score int
default NULL;
```
Quindi, crea una vista dalla tabella USERS chiamata USERS\$1VIEW:
```
create view users_view as select * from users;
```
Ora prova a rimuovere la colonna FEEDBACK\$1SCORE dalla tabella USERS. Questa istruzione DROP utilizza il comportamento predefinito (RESTRICT):
```
alter table users drop column feedback_score;
```
Amazon Redshift visualizza un messaggio di errore indicante che la colonna non può essere rimossa perché un altro oggetto dipende da essa.
Prova a rimuovere nuovamente la colonna FEEDBACK\$1SCORE, questa volta specificando CASCADE per eliminare tutti gli oggetti dipendenti:
```
alter table users
drop column feedback_score cascade;
```
# ALTER TABLE APPEND
Aggiunge le righe a una tabella di destinazione spostando i dati da una tabella di origine esistente. I dati nella tabella di origine vengono spostati nelle colonne corrispondenti della tabella di destinazione. L'ordine delle colonne non ha importanza. Dopo che i dati sono stati aggiunti alla tabella di destinazione, la tabella di origine è vuota. ALTER TABLE APPEND è in genere molto più veloce di un'operazione [CREATE TABLE AS](r_CREATE_TABLE_AS.md) o [INSERT](r_INSERT_30.md) INTO simile in quanto i dati vengono spostati, non duplicati.
**Nota**
ALTER TABLE APPEND sposta i blocchi di dati tra la tabella di origine e la tabella di destinazione. Per migliorare le prestazioni, ALTER TABLE APPEND non compatta lo storage come parte dell'operazione di aggiunta. Di conseguenza, l'utilizzo della memoria aumenta temporaneamente. Per recuperare lo spazio, esegui un'operazione [VACUUM](r_VACUUM_command.md).
Le colonne con lo stesso nome devono avere anche attributi di colonna identici. Se la tabella di origine o la tabella di destinazione contiene colonne che non esistono nell'altra tabella, utilizza i parametri IGNOREEXTRA o FILLTARGET per specificare la modalità di gestione delle colonne aggiuntive.
Non puoi aggiungere una colonna di identità. Se entrambe le tabelle includono una colonna di identità, il comando non riesce. Se solo una tabella ha una colonna di identità, includi il parametro FILLTARGET o IGNOREEXTRA. Per ulteriori informazioni, consulta [Note per l'utilizzo di ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
Puoi aggiungere una colonna GENERATED BY DEFAULT AS IDENTITY. Puoi aggiornare colonne definite come GENERATED BY DEFAULT AS IDENTITY con i valori forniti. Per ulteriori informazioni, consulta [Note per l'utilizzo di ALTER TABLE APPEND](#r_ALTER_TABLE_APPEND_usage).
La tabella di destinazione deve essere una tabella permanente. Tuttavia, l'origine può essere una tabella permanente o una vista materializzata configurata per l'importazione di dati in streaming. Entrambe le tabelle devono utilizzare lo stesso stile di distribuzione e la stessa chiave di distribuzione, se ne è stata definita una. Se gli oggetti sono ordinati, entrambi gli oggetti devono utilizzare lo stesso stile di ordinamento e definire le stesse colonne come chiavi di ordinamento.
Un comando ALTER TABLE APPEND automaticamente esegue il commit al completamento dell'operazione. Non è possibile eseguire il rollback. Non è possibile eseguire ALTER TABLE APPEND all'interno di un blocco di transazioni (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
## Privilegi richiesti
A seconda del comando ALTER TABLE APPEND, è richiesto uno dei seguenti privilegi:
+ Superuser
+ Utenti con il privilegio di sistema ALTER TABLE
+ Utenti con privilegi DELETE e SELECT sulla tabella di origine e privilegi INSERT sulla tabella di destinazione
## Sintassi
```
ALTER TABLE target_table_name APPEND FROM [ source_table_name | source_materialized_view_name ]
[ IGNOREEXTRA | FILLTARGET ]
```
L'aggiunta da una vista materializzata funziona solo nel caso in cui la vista materializzata sia configurata per [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md).
## Parameters
*target\$1table\$1name*
Il nome della tabella a cui vengono aggiunte le righe. Specifica solo il nome della tabella o utilizzare il formato *schema\$1name.table\$1name* per utilizzare uno schema specifico. La tabella di destinazione deve essere una tabella permanente esistente.
FROM *source\$1table\$1name*
Il nome della tabella che fornisce le righe da aggiungere. Specifica solo il nome della tabella o utilizzare il formato *schema\$1name.table\$1name* per utilizzare uno schema specifico. La tabella di origine deve essere una tabella permanente esistente.
FROM *source\$1materialized\$1view\$1name*
Il nome di una vista materializzata che fornisce le righe da aggiungere. L'aggiunta da una vista materializzata funziona solo nel caso in cui la vista materializzata sia configurata per [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md). La vista materializzata di origine deve esistere già.
IGNOREEXTRA
Parola chiave che specifica che se la tabella di origine include colonne che non sono presenti nella tabella di destinazione, i dati nelle colonne aggiuntive devono essere eliminati. Non puoi usare IGNOREEXTRA con FILLTARGET.
FILLTARGET
Parola chiave che specifica che se la tabella di origine include colonne che non sono presenti nella tabella di origine, le colonne devono contenere il valore di colonna [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) se definito, altrimenti NULL. Non puoi usare IGNOREEXTRA con FILLTARGET.
## Note per l'utilizzo di ALTER TABLE APPEND
+ ALTER TABLE APPEND sposta solo colonne identiche dalla tabella di origine alla tabella di destinazione. L'ordine delle colonne non ha importanza.
+ Se la tabella di origine o le tabelle di destinazione contengono colonne aggiuntive, utilizza FILLTARGET o IGNOREEXTRA in base alle seguenti regole:
+ Se la tabella di origine contiene colonne che non esistono nella tabella di destinazione, includi IGNOREEXTRA. Il comando ignora le colonne aggiuntive nella tabella di origine.
+ Se la tabella di destinazione contiene colonne che non esistono nella tabella di origine, includi FILLTARGET. Il comando inserisce nelle colonne aggiuntive della tabella di destinazione il valore di colonna predefinito o il valore IDENTITY se definito, altrimenti NULL.
+ Se sia la tabella di origine che la tabella di destinazione contengono colonne aggiuntive, il comando non riesce. Non puoi usare entrambi FILLTARGET e IGNOREEXTRA.
+ Se una colonna con lo stesso nome ma attributi diversi esiste in entrambe le tabelle, il comando non riesce. Le colonne con nome simile devono avere i seguenti attributi in comune:
+ Tipo di dati
+ Dimensione colonna
+ Codifica di compressione
+ Non null
+ Stile di ordinamento
+ Colonne con chiave di ordinamento
+ Stile di distribuzione
+ Colonne con chiave di distribuzione
+ Non puoi aggiungere una colonna di identità. Se sia la tabella di origine che la tabella di destinazione hanno colonne di identità, il comando non riesce. Se solo la tabella di origine ha una colonna di identità, includi il parametro IGNOREEXTRA in modo che la colonna di identità venga ignorata. Se solo la tabella di destinazione ha una colonna Identity, includi il parametro FILLTARGET in modo che la colonna di identità venga compilata in base alla clausola IDENTITY definita per la tabella. Per ulteriori informazioni, consulta [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default).
+ Puoi aggiungere una colonna di identità predefinita con l'istruzione ALTER TABLE APPEND. Per ulteriori informazioni, consulta [CREATE TABLE](r_CREATE_TABLE_NEW.md).
+ Le operazioni ALTER TABLE APPEND mantengono blocchi esclusivi quando vengono eseguite sulle viste materializzate in streaming di Amazon Redshift connesse a uno dei seguenti elementi:
+ Un flusso di dati Amazon Kinesis
+ Un argomento Streaming gestito da Amazon per Apache Kafka
+ Un flusso esterno supportato, ad esempio un argomento Confluent Cloud Kafka
Per ulteriori informazioni, consulta [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md).
## Esempi di ALTER TABLE APPEND
Supponiamo che la tua organizzazione mantenga una tabella, SALES\$1MONTHLY, per acquisire le transazioni di vendita correnti. Vuoi spostare i dati dalla tabella delle transazioni alla tabella SALES, ogni mese.
Puoi utilizzare i seguenti comandi INSERT INTO e TRUNCATE per eseguire l'operazione.
```
insert into sales (select * from sales_monthly);
truncate sales_monthly;
```
Tuttavia, puoi eseguire la stessa operazione in modo molto più efficiente utilizzando il comando ALTER TABLE APPEND.
Innanzitutto, eseguire una query sulla tabella del catalogo di sistema [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md) per verificare che entrambe le tabelle abbiano le stesse colonne con attributi di colonna identici.
```
select trim(tablename) as table, "column", trim(type) as type,
encoding, distkey, sortkey, "notnull"
from pg_table_def where tablename like 'sales%';
table | column | type | encoding | distkey | sortkey | notnull
-----------+------------+-----------------------------+----------+---------+---------+--------
sales | salesid | integer | lzo | false | 0 | true
sales | listid | integer | none | true | 1 | true
sales | sellerid | integer | none | false | 2 | true
sales | buyerid | integer | lzo | false | 0 | true
sales | eventid | integer | mostly16 | false | 0 | true
sales | dateid | smallint | lzo | false | 0 | true
sales | qtysold | smallint | mostly8 | false | 0 | true
sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false
sales | commission | numeric(8,2) | delta32k | false | 0 | false
sales | saletime | timestamp without time zone | lzo | false | 0 | false
salesmonth | salesid | integer | lzo | false | 0 | true
salesmonth | listid | integer | none | true | 1 | true
salesmonth | sellerid | integer | none | false | 2 | true
salesmonth | buyerid | integer | lzo | false | 0 | true
salesmonth | eventid | integer | mostly16 | false | 0 | true
salesmonth | dateid | smallint | lzo | false | 0 | true
salesmonth | qtysold | smallint | mostly8 | false | 0 | true
salesmonth | pricepaid | numeric(8,2) | delta32k | false | 0 | false
salesmonth | commission | numeric(8,2) | delta32k | false | 0 | false
salesmonth | saletime | timestamp without time zone | lzo | false | 0 | false
```
Quindi, guarda le dimensioni di ogni tabella.
```
select count(*) from sales_monthly;
count
-------
2000
(1 row)
select count(*) from sales;
count
-------
412,214
(1 row)
```
Ora esegui il seguente comando ALTER TABLE APPEND.
```
alter table sales append from sales_monthly;
```
Guarda di nuovo le dimensioni di ogni tabella. La tabella SALES\$1MONTHLY ora ha 0 righe e la tabella SALES è cresciuta di 2000 righe.
```
select count(*) from sales_monthly;
count
-------
0
(1 row)
select count(*) from sales;
count
-------
414214
(1 row)
```
Se la tabella di origine ha più colonne della tabella di destinazione, specifica il parametro IGNOREEXTRA. L'esempio seguente utilizza il parametro IGNOREEXTRA per ignorare le colonne aggiuntive nella tabella SALES\$1LISTING quando si accede alla tabella SALES.
```
alter table sales append from sales_listing ignoreextra;
```
Se la tabella di destinazione ha più colonne della tabella di origine, specifica il parametro FILLTARGET. L'esempio seguente utilizza il parametro FILLTARGET per popolare le colonne nella tabella SALES\$1REPORT che non esistono nella tabella SALES\$1MONTH.
```
alter table sales_report append from sales_month filltarget;
```
L'esempio seguente mostra un esempio di come utilizzare ALTER TABLE APPEND con una vista materializzata come origine.
```
ALTER TABLE target_tbl APPEND FROM my_streaming_materialized_view;
```
I nomi delle tabelle e delle viste materializzate in questo esempio sono esempi. L'aggiunta da una vista materializzata funziona solo nel caso in cui la vista materializzata sia configurata per [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md). Sposta tutti i record della vista materializzata di origine in una tabella di destinazione con lo stesso schema della vista materializzata e lascia intatta la vista materializzata. Si tratta dello stesso comportamento di quando l'origine dei dati è una tabella.
# MODIFICA MODELLO
Modifica la definizione di un modello esistente. Utilizzate questo comando per rinominare un modello, modificare il proprietario di un modello, aggiungere o rimuovere parametri dalla definizione del modello o impostare i valori dei parametri.
## Privilegi richiesti
Per modificare un modello, è necessario disporre di una delle seguenti opzioni:
+ Privilegi di superutente
+ Privilegio ALTER TEMPLATE e privilegio USAGE sullo schema contenente il modello
## Sintassi
```
ALTER TEMPLATE [database_name.][schema_name.]template_name
{
RENAME TO new_name
| OWNER TO new_owner
| ADD parameter [AS] [value]
| DROP parameter
| SET parameter TO value1 [, parameter2 TO value2 , ...]
};
```
## Parameters
*database\$1name*
(Facoltativo) Il nome del database in cui viene creato il modello. Se non viene specificato, viene utilizzato il database corrente.
*schema\$1name*
(Facoltativo) Il nome dello schema in cui viene creato il modello. Se non viene specificato, il modello viene cercato nel percorso di ricerca corrente.
*nome\$1modello*
Il nome del modello da modificare.
RENAME TO
Una clausola che rinomina il modello.
*new\$1name*
Il nuovo nome del modello. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
OWNER TO
Una clausola che modifica il proprietario del modello.
*new\$1owner*
Il nuovo proprietario del modello.
*PARAMETRO* ADD [AS] [*valore*]
Aggiunge un nuovo parametro al modello.
+ Per i parametri relativi solo alle parole chiave (come CSV o GZIP), specifica solo il nome del parametro.
+ Per i parametri che richiedono valori, specificate il nome del parametro seguito dal valore. Facoltativamente, puoi includere AS tra il parametro e il valore.
*Parametro DROP*
Rimuove il parametro specificato dal modello. Non è possibile eliminare più parametri con un solo comando DROP.
*IMPOSTA *il parametro* SU *value1* [, *parameter2 SU value2*,...]*
Aggiorna i valori dei parametri del modello esistenti. Utilizzalo solo per i parametri che hanno già dei valori. È possibile aggiornare più parametri con un unico comando.
## Esempi
L'esempio seguente rinomina il modello test\$1template in demo\$1template.
```
ALTER TEMPLATE test_template
RENAME TO demo_template;
```
L'esempio seguente assegna la proprietà dello schema demo\$1template all'utente bob.
```
ALTER TEMPLATE demo_template
OWNER TO bob;
```
L'esempio seguente aggiunge un parametro `CSV` al template demo\$1template
```
ALTER TEMPLATE demo_template
ADD CSV;
```
L'esempio seguente aggiunge un parametro `TIMEFORMAT 'auto'` al modello demo\$1template
```
ALTER TEMPLATE demo_template
ADD TIMEFORMAT 'auto';
```
L'esempio seguente elimina il parametro `ENCRYPTED` dal modello demo\$1template
```
ALTER TEMPLATE demo_template
DROP ENCRYPTED;
```
L'esempio seguente imposta il `DELIMITER` parametro su `'|'` e il `TIMEFORMAT` parametro su: `'epochsecs'`
```
ALTER TEMPLATE demo_template
SET DELIMITER TO '|', TIMEFORMAT TO 'epochsecs';
```
# ALTER USER
Cambia un utente del database.
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per ALTER USER:
+ Superuser
+ Utenti con il privilegio ALTER USER
+ Utente attuale che desidera modificare la propria password
## Sintassi
```
ALTER USER username [ WITH ] option [, ... ]
where option is
CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| SYSLOG ACCESS { RESTRICTED | UNRESTRICTED }
| PASSWORD { 'password' | 'md5hash' | 'sha256hash' | DISABLE }
[ VALID UNTIL 'expiration_date' ]
| RENAME TO new_name |
| CONNECTION LIMIT { limit | UNLIMITED }
| SESSION TIMEOUT limit | RESET SESSION TIMEOUT
| SET parameter { TO | = } { value | DEFAULT }
| RESET parameter
| EXTERNALID external_id
```
## Parameters
*username*
Nome dell'utente.
WITH
Parola chiave facoltativa.
CREATEDB \$1 NOCREATEDB
L'opzione CREATEDB consente all'utente di creare nuovi database. NOCREATEDB è il valore predefinito.
CREATEUSER \$1 NOCREATEUSER
L'opzione CREATEUSER crea un utente con privilegi avanzati con tutti i privilegi del database, incluso CREATE USER. L'impostazione predefinita è NOCREATEUSER. Per ulteriori informazioni, consulta [Utenti con privilegi avanzati](r_superusers.md).
SYSLOG ACCESS \$1 RESTRICTED \$1 UNRESTRICTED \$1
Una clausola che specifica il livello di accesso che l'utente ha per tabelle e viste di sistema di Amazon Redshift.
Gli utenti normali che dispongono dell’autorizzazione SYSLOG ACCESS RESTRICTED possono visualizzare solo le righe generate da tale utente nelle tabelle e nelle viste di sistema visibili all’utente. Il valore predefinito è RESTRICTED.
Gli utenti con privilegi normali che dispongono dell’autorizzazione SYSLOG ACCESS UNRESTRICTED possono visualizzare tutte le righe nelle tabelle e nelle viste di sistema visibili all’utente, incluse quelle generate da un altro utente. UNRESTRICTED non fornisce un accesso regolare all'utente alle tabelle visibili agli utenti con privilegi avanzati. Solo gli utenti con privilegi avanzati possono vedere le tabelle visibili agli utenti con privilegi avanzati.
Concedere all'utente un accesso illimitato alle tabelle di sistema offre all'utente la visibilità dei dati generati da altri utenti. Ad esempio, STL\$1QUERY e STL\$1QUERYTEXT contengono il testo completo delle istruzioni INSERT, UPDATE e DELETE, che potrebbero contenere dati sensibili generati dall'utente.
Tutte le righe in SVV\$1TRANSACTIONS sono visibili per tutti gli utenti.
Per ulteriori informazioni, consulta [Visibilità dei dati nelle tabelle e nelle viste di sistema](cm_chap_system-tables.md#c_visibility-of-data).
PASSWORD \$1 '*password*' \$1 '*md5hash*' \$1 '*sha256hash*' \$1 DISABLE \$1
Imposta la password dell'utente.
Per impostazione predefinita, gli utenti possono modificare le proprie password, a meno che la password non sia disabilitata. Per disabilitare la password di un utente, specifica DISABLE. Quando la password di un utente è disabilitata, la password viene eliminata dal sistema e l'utente può accedere solo utilizzando credenziali utente temporanee AWS Identity and Access Management (IAM). Per ulteriori informazioni, consultare [Utilizzo dell'autenticazione IAM per generare credenziali utente di database](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html). Solo un utente con privilegi avanzati può abilitare o disabilitare le password. Non puoi disabilitare la password di un utente con privilegi avanzati. Per abilitare una password, esegui ALTER USER e specifica una password.
Per i dettagli sull'utilizzo del parametro PASSWORD, consultare [CREA UTENTE](r_CREATE_USER.md).
VALID UNTIL '*expiration\$1date*'
Specifica che la password ha una data di scadenza. Usa il valore `'infinity'` per evitare di avere una data di scadenza. Il tipo di dati valido per questo parametro è il timestamp.
Solo gli utenti con privilegi avanzati possono utilizzare questo parametro.
RENAME TO
Rinomina l'utente.
*new\$1name*
Nuovo nome dell'utente. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
Quando rinomini un utente, devi anche reimpostarne la password. La password reimpostata non deve necessariamente essere diversa dalla password precedente. Il nome utente viene utilizzato come parte della crittografia della password, quindi quando un utente viene rinominato, la password viene cancellata. L'utente non sarà in grado di accedere fino a quando la password viene ripristinata. Ad esempio:
```
alter user newuser password 'EXAMPLENewPassword11';
```
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
Numero massimo di connessioni di database che l'utente può aprire contemporaneamente. Il limite non viene applicato per gli utente con privilegi avanzati. Utilizza la parola chiave UNLIMITED per consentire il numero massimo di connessioni simultanee. È possibile che venga applicato anche un limite al numero di connessioni per ciascun database. Per ulteriori informazioni, consulta [CREATE DATABASE](r_CREATE_DATABASE.md). Il valore predefinito è UNLIMITED. Per visualizzare le connessioni correnti, eseguire una query sulla vista di sistema [STV\$1SESSIONS](r_STV_SESSIONS.md).
Se si applicano entrambi i limiti di connessione utente e database, deve essere disponibile uno slot di connessione inutilizzato che rientra in entrambi i limiti quando un utente tenta di connettersi.
TIMEOUT SESSIONE *limite* \$1 REIMPOSTARE IL TIMEOUT DELLA SESSIONE
Il tempo massimo (in secondi) in cui una sessione rimane inattiva o inutilizzata. L'intervallo è compreso tra 60 secondi (un minuto) e 1.728.000 secondi (20 giorni). Se per l'utente non è impostato alcun timeout di sessione, verrà applicata l'impostazione del cluster. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
Quando si imposta il timeout della sessione, viene applicato solo alle nuove sessioni.
Per visualizzare informazioni sulle sessioni utente attive, tra cui l'ora di inizio, il nome utente e il timeout della sessione, eseguire una query sulla vista di sistema [STV\$1SESSIONS](r_STV_SESSIONS.md). Per visualizzare le informazioni sulla cronologia delle sessioni utente, eseguire una query sulla vista [STL\$1SESSIONS](r_STL_SESSIONS.md). Per recuperare informazioni sugli utenti del database, inclusi i valori di timeout della sessione, eseguire una query sulla vista [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md).
SET
Imposta un parametro di configurazione su un nuovo valore predefinito per tutte le sessioni eseguite dall'utente specificato.
RESET
Reimposta un parametro di configurazione sul valore predefinito originale per l'utente specificato.
*parameter*
Nome del parametro da impostare o reimpostare.
*value*
Nuovo valore del parametro.
DEFAULT
Imposta il parametro di configurazione sul valore predefinito per tutte le sessioni eseguite dall'utente specificato.
EXTERNALID *external\$1id*
L'identificativo dell'utente, associato a un provider di identità. L'utente deve avere la password disabilitata. Per ulteriori informazioni, consulta [Native identity provider (IdP) federation for Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-native-idp.html) (Federazione di provider di identità nativi (IdP) per Amazon Redshift).
## Note per l'utilizzo
+ **Tentativo di modificare rdsdb**: non puoi modificare l'utente denominato `rdsdb`.
+ **Creazione di una password sconosciuta**: quando si utilizza l'autenticazione AWS Identity and Access Management (IAM) per creare le credenziali utente del database, è possibile creare un superutente in grado di accedere solo utilizzando credenziali temporanee. Non puoi disabilitare la password di un superutente, ma puoi creare una password sconosciuta utilizzando una stringa hash generata casualmente. MD5
```
alter user iam_superuser password 'md51234567890123456780123456789012';
```
+ **Impostazione di search\$1path**: quando imposti il parametro [search\$1path](r_search_path.md) con il comando ALTER USER, la modifica diventa effettiva all'accesso successivo dell'utente specificato. Se si desidera modificare il valore di search\$1path per l'utente e la sessione correnti, utilizzare un comando SET.
+ **Impostazione del fuso orario**: quando utilizzi SET TIMEZONE con il comando ALTER USER, la modifica diventa effettiva all'accesso successivo dell'utente specificato.
+ **Utilizzo del mascheramento dinamico dei dati e delle policy di sicurezza a livello di riga**: quando il cluster o lo spazio dei nomi serverless di cui è stato effettuato il provisioning prevede il mascheramento dinamico dei dati o policy di sicurezza a livello di riga, i seguenti comandi sono bloccati per gli utenti normali:
```
ALTER SET enable_case_sensitive_super_attribute/enable_case_sensitive_identifier/downcase_delimited_identifier
```
Solo gli utenti con privilegi avanzati e gli utenti con il privilegio ALTER USER possono impostare queste opzioni di configurazione. Per ulteriori informazioni sulla sicurezza a livello di riga. consulta [Sicurezza a livello di riga](t_rls.md). Per informazioni sul mascheramento dinamico dei dati, consulta [Mascheramento dinamico dei dati](t_ddm.md).
## Esempi
L'esempio seguente concede all'utente ADMIN il privilegio di creare database:
```
alter user admin createdb;
```
L'esempio seguente imposta la password dell'utente ADMIN su `adminPass9` e imposta una data e un'ora di scadenza per la password:
```
alter user admin password 'adminPass9'
valid until '2017-12-31 23:59';
```
L'esempio seguente rinomina l'utente il gruppo ADMIN in SYSADMIN:
```
alter user admin rename to sysadmin;
```
Nell'esempio seguente il timeout della sessione di inattività per un utente viene aggiornato a 300 secondi.
```
ALTER USER dbuser SESSION TIMEOUT 300;
```
Reimposta il timeout della sessione di inattività dell'utente. Quando si reimposta, viene applicata l'impostazione del cluster. Per eseguire questo comando, è necessario essere un utente con privilegi avanzati del database. Per ulteriori informazioni, consulta [Quote e limiti in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
```
ALTER USER dbuser RESET SESSION TIMEOUT;
```
Nell'esempio seguente viene aggiornato l'ID esterno di un utente denominato `bob`. Lo spazio dei nomi è `myco_aad`. Se lo spazio dei nomi non è associato a un provider di identità registrato, si verifica un errore.
```
ALTER USER myco_aad:bob EXTERNALID "ABC123" PASSWORD DISABLE;
```
L'esempio seguente imposta il fuso orario per tutte le sessioni eseguite da un utente di database specifico. Modifica il fuso orario per le sessioni successive e non per quella corrente.
```
ALTER USER odie SET TIMEZONE TO 'Europe/Zurich';
```
Nell’esempio seguente viene impostato il numero massimo di connessioni al database che l’utente `bob` è autorizzato a tenere aperte.
```
ALTER USER bob CONNECTION LIMIT 10;
```
# ANALYZE
Aggiorna le statistiche della tabella per l'utilizzo da parte del pianificatore di query.
## Privilegi richiesti
Di seguito sono riportati i privilegi necessari per ANALYZE:
+ Superuser
+ Utenti con il privilegio ANALYZE
+ Proprietario della relazione
+ Proprietario del database con cui è condivisa la tabella
## Sintassi
```
ANALYZE [ VERBOSE ]
[ [ table_name [ ( column_name [, ...] ) ] ]
[ PREDICATE COLUMNS | ALL COLUMNS ]
```
## Parameters
VERBOSE
Clausola che restituisce i messaggi di informazione sull'avanzamento relativi all'operazione ANALYZE. Questa opzione è utile quando non si specifica una tabella.
*table\$1name*
Puoi analizzare tabelle specifiche, incluse le tabelle temporanee. Puoi qualificare la tabella con il nome dello schema. Puoi specificare facoltativamente un table\$1name per analizzare una singola tabella. Non puoi specificare più di un *table\$1name* con una singola istruzione ANALYZE *table\$1name*. Se non si specifichi un valore *nome\$1tabella*, saranno analizzate tutte le tabelle nel database correntemente connesso, comprese le tabelle persistenti nel catalogo di sistema. Amazon Redshift salta l'analisi di una tabella se la percentuale di righe che sono state modificate dall'ultima analisi è inferiore alla soglia di analisi. Per ulteriori informazioni, consulta [Soglia di analisi](#r_ANALYZE-threshold).
Non è necessario analizzare le tabelle di sistema di Amazon Redshift (tabelle STL e STV).
*column\$1name*
Se specifichi un *table\$1name*, puoi anche specificare una o più colonne nella tabella (come un elenco separato da colonne tra parentesi). Se viene specificato un elenco di colonne, vengono analizzate solo le colonne elencate.
PREDICATE COLUMNS \$1 ALL COLUMNS
Clausole che indicano se ANALYZE deve includere solo le colonne di predicato. Specifica PREDICATE COLUMNS per analizzare solo le colonne che sono state utilizzate come predicati nelle query precedenti o sono probabili candidati da utilizzare come predicati. Specifica ALL COLUMNS per analizzare tutte le colonne. Il valore predefinito è ALL COLUMNS.
Una colonna è inclusa nel set di colonne dei predicati se una delle seguenti condizioni è vera:
+ La colonna è stata utilizzata in una query come parte di un filtro, condizione di join o clausola group by.
+ La colonna è una chiave di distribuzione.
+ La colonna fa parte di una chiave di ordinamento.
Se nessuna colonna è contrassegnata come colonne di predicato, ad esempio perché la tabella non è stata ancora sottoposta a query, tutte le colonne vengono analizzate anche quando viene specificato PREDICATE COLUMNS. Quando ciò accade, Amazon Redshift potrebbe rispondere con un messaggio del tipo No predicate columns found for "». *table-name* Analisi di tutte le colonne. Per ulteriori informazioni sulle colonne di predicato, consultare [Analisi delle tabelle](t_Analyzing_tables.md).
## Note per l'utilizzo
Amazon Redshift esegue automaticamente ANALYZE sulle tabelle create con i seguenti comandi:
+ CREATE TABLE AS
+ CREATE TEMP TABLE AS
+ SELECT INTO
Non puoi analizzare una tabella esterna.
Non è necessario eseguire il comando ANALYZE su queste tabelle quando vengono create per la prima volta. Se le modifichi, devi analizzarle come fai per le altre tabelle.
### Soglia di analisi
Per ridurre i tempi di elaborazione e migliorare le prestazioni generali del sistema, Amazon Redshift salta ANALYZE per una tabella se la percentuale di righe che sono state modificate dall'ultima esecuzione del comando ANALYZE è inferiore alla soglia di analisi specificata dal parametro [analyze\$1threshold\$1percent](r_analyze_threshold_percent.md). Per impostazione predefinita, `analyze_threshold_percent` è 10. Per cambiare `analyze_threshold_percent` per la sessione corrente, emettere il comando [SET](r_SET.md). L'esempio seguente cambia `analyze_threshold_percent` sul 20 percento.
```
set analyze_threshold_percent to 20;
```
Per analizzare le tabelle quando è stato modificato solo un piccolo numero di righe, imposta `analyze_threshold_percent` su un numero arbitrariamente piccolo. Ad esempio, se imposti `analyze_threshold_percent` su 0.01, una tabella con 100.000.000 di righe non viene ignorata se sono state modificate almeno 10.000 righe.
```
set analyze_threshold_percent to 0.01;
```
Se ANALYZE salta una tabella perché non soddisfa la soglia di analisi, Amazon Redshift restituisce il seguente messaggio.
```
ANALYZE SKIP
```
Per analizzare tutte le tabelle anche se non sono state modificate righe, imposta `analyze_threshold_percent` su 0.
Per visualizzare i risultati delle operazioni ANALYZE, eseguire una query della tabella di sistema [STL\$1ANALYZE](r_STL_ANALYZE.md).
Per ulteriori informazioni sull'analisi delle tabelle, consultare [Analisi delle tabelle](t_Analyzing_tables.md).
## Esempi
Analizza tutte le tabelle nel database TICKIT e restituisci le informazioni sull'avanzamento.
```
analyze verbose;
```
Analizza solo la tabella LISTING.
```
analyze listing;
```
Analizza le colonne VENUEID e VENUENAME nella tabella VENUE.
```
analyze venue(venueid, venuename);
```
Analizza solo le colonne di predicato della tabella VENUE.
```
analyze venue predicate columns;
```
# ANALYZE COMPRESSION
Esegue l'analisi della compressione e produce un rapporto con la codifica di compressione suggerita per le tabelle analizzate. Per ogni colonna, il report include una stima della potenziale riduzione dello spazio su disco rispetto alla codifica RAW.
## Sintassi
```
ANALYZE COMPRESSION
[ [ table_name ]
[ ( column_name [, ...] ) ] ]
[COMPROWS numrows]
```
## Parameters
*table\$1name*
Puoi analizzare la compressione di tabelle specifiche, incluse le tabelle temporanee. Puoi qualificare la tabella con il nome dello schema. Puoi specificare facoltativamente un *table\$1name* per analizzare una singola tabella. Se non specifichi un valore *table\$1name*, vengono analizzate tutte le tabelle nel database attualmente connesso. Non puoi specificare più di un *table\$1name* con una singola istruzione ANALYZE COMPRESSION.
*column\$1name*
Se specifichi un *table\$1name*, puoi anche specificare una o più colonne nella tabella (come un elenco separato da colonne tra parentesi).
COMPROWS
Numero di righe da utilizzare come dimensione del campione per l'analisi della compressione. L'analisi viene eseguita su righe da ciascuna sezione di dati. Ad esempio, se specifichi COMPROWS 1000000 (1.000.000) e il sistema contiene 4 sezioni totali, vengono lette e analizzate non più di 250.000 righe per sezione. Se COMPROWS non è specificato, la dimensione del campione è impostata su 100.000 per sezione. I valori di COMPROWS inferiori al valore predefinito di 100.000 righe per sezione vengono automaticamente aggiornati al valore predefinito. Tuttavia, l'analisi della compressione non produce raccomandazioni se la quantità di dati nella tabella è insufficiente per produrre un campione significativo. Se il numero COMPROWS è maggiore del numero di righe nella tabella, il comando ANALYZE COMPRESSION procede comunque ed esegue l'analisi della compressione su tutte le righe disponibili. L’utilizzo di COMPROWS genera un errore se non è specificata una tabella.
*numrows*
Numero di righe da utilizzare come dimensione del campione per l'analisi della compressione. L'intervallo accettato per *numrows* è un numero compreso tra 1000 e 1000000000 (1.000.000.000).
## Note per l'utilizzo
ANALYZE COMPRESSION acquisisce un blocco di tabella esclusivo che impedisce letture e scritture simultanee nella tabella. Esegui il comando ANALYZE COMPRESSION solo quando la tabella è inattiva.
Esegui ANALYZE COMPRESSION per ottenere consigli per schemi di codifica delle colonne, basati su un campione dei contenuti della tabella. ANALYZE COMPRESSION è uno strumento di consulenza e non modifica le codifiche delle colonne della tabella. La codifica suggerita può essere applicata ricreando la tabella o creando una nuova tabella con lo stesso schema. Ricreare una tabella non compressa con schemi di codifica appropriati può ridurre significativamente il footprint su disco. Questo approccio consente di risparmiare spazio su disco e migliora le prestazioni delle query per i carichi di lavoro associati all'I/O.
ANALYZE COMPRESSION salta la fase di analisi effettiva e restituisce direttamente il tipo di codifica originale su qualsiasi colonna designata come SORTKEY. Lo fa perché le scansioni con limiti di intervallo potrebbero funzionare male quando le colonne SORTKEY sono molto più compresse di altre colonne.
## Esempi
L'esempio seguente mostra la codifica e la riduzione percentuale stimata per le colonne solo nella tabella LISTING:
```
analyze compression listing;
Table | Column | Encoding | Est_reduction_pct
---------+----------------+----------+-------------------
listing | listid | az64 | 40.96
listing | sellerid | az64 | 46.92
listing | eventid | az64 | 53.37
listing | dateid | raw | 0.00
listing | numtickets | az64 | 65.66
listing | priceperticket | az64 | 72.94
listing | totalprice | az64 | 68.05
listing | listtime | az64 | 49.74
```
L'esempio seguente analizza le colonne QTYSOLD, COMMISSION e SALETIME nella tabella SALES.
```
analyze compression sales(qtysold, commission, saletime);
Table | Column | Encoding | Est_reduction_pct
-------+------------+----------+-------------------
sales | salesid | N/A | 0.00
sales | listid | N/A | 0.00
sales | sellerid | N/A | 0.00
sales | buyerid | N/A | 0.00
sales | eventid | N/A | 0.00
sales | dateid | N/A | 0.00
sales | qtysold | az64 | 83.06
sales | pricepaid | N/A | 0.00
sales | commission | az64 | 71.85
sales | saletime | az64 | 49.63
```
# ATTACH MASKING POLICY
Collega una policy di mascheramento dinamico dei dati esistente a una colonna. Per ulteriori informazioni sul mascheramento dinamico dei dati, consulta [Mascheramento dinamico dei dati](t_ddm.md).
Una policy di mascheramento può essere collegata da utenti con privilegi avanzati e da utenti o ruoli che dispongono del ruolo sys:secadmin.
## Sintassi
```
ATTACH MASKING POLICY
{
policy_name ON relation_name
| database_name.policy_name ON database_name.schema_name.relation_name
}
( { output_column_names | output_path } )
[ USING ( { input_column_names | input_path } ) ]
TO { user_name | ROLE role_name | PUBLIC }
[ PRIORITY priority ];
```
## Parameters
*nome\$1policy*
Nome della policy di mascheramento da collegare.
database\$1name
Il nome del database in cui vengono create la politica e la relazione. La politica e la relazione devono trovarsi sullo stesso database. Il database può essere il database connesso o un database che supporta le autorizzazioni federate di Amazon Redshift.
schema\$1name
Il nome dello schema a cui appartiene la relazione.
*relation\$1name*
Il nome della relazione a cui collegare la politica di mascheramento.
*output\$1column\$1names*
INmi delle colonne a cui verrà applicata la policy di mascheramento.
*output\$1paths*
Il percorso completo dell'oggetto SUPER a cui viene applicata la politica di mascheramento, incluso il nome della colonna. Ad esempio, per una relazione con una colonna di tipo SUPER denominata `person`, *output\$1path* può essere `person.name.first_name`.
*input\$1column\$1names*
Nomi delle colonne che la policy di mascheramento utilizzerà come input. Questo parametro è facoltativo. Se non specificato, la politica di mascheramento utilizza come input *output\$1column\$1names*.
*input\$1paths*
Il percorso completo dell'oggetto SUPER che la politica di mascheramento utilizza come input. Questo parametro è facoltativo. Se non specificato, la politica di mascheramento utilizza come input *output\$1path*.
*user\$1name*
Nome dell'utente a cui verrà collegata la policy di mascheramento. Non è possibile collegare due politiche alla stessa combinazione di utente e colonna oppure ruolo e colonna. È possibile collegare una policy a un utente e un'altra policy al ruolo dell'utente. In questo caso, si applica la policy con la priorità più alta.
È possibile impostare solo uno tra user\$1name, role\$1name e PUBLIC in un singolo comando ATTACH MASKING POLICY.
*role\$1name*
Nome del ruolo a cui verrà collegata la policy di mascheramento. Non è possibile allegare due politiche alla stessa column/role coppia. È possibile collegare una policy a un utente e un'altra policy al ruolo dell'utente. In questo caso, si applica la policy con la priorità più alta.
È possibile impostare solo uno tra user\$1name, role\$1name e PUBLIC in un singolo comando ATTACH MASKING POLICY.
*PUBLIC*
Collega la policy di mascheramento a tutti gli utenti che accedono alla tabella. Affinché vengano applicate, è necessario assegnare alle altre politiche di mascheramento allegate a specifiche column/user o column/role coppie una priorità maggiore rispetto alla politica PUBLIC.
È possibile impostare solo uno tra user\$1name, role\$1name e PUBLIC in un singolo comando ATTACH MASKING POLICY.
*priority*
La priorità della policy di mascheramento. Quando si applicano più policy di mascheramento alla query di un determinato utente, si applica la policy con la massima priorità.
Non è possibile collegare due politiche diverse alla stessa colonna con la medesima priorità, anche se sono collegate a utenti o ruoli diversi. È possibile collegare la stessa politica più volte allo stesso set di tabella, colonna di output, colonna di input e parametri di priorità, purché l'utente o il ruolo a cui si riferisce la politica ogni volta sia diverso.
Non è possibile applicare una policy a una colonna con la stessa priorità di un'altra policy associato a quella colonna, anche se si tratta di ruoli diversi. Questo campo è facoltativo. Se non si specifica una priorità, per impostazione predefinita la policy di mascheramento prevede l'associazione con una priorità pari a 0.
Per l'utilizzo di ATTACH MASKING POLICY su Amazon Redshift Federated Permissions Catalog, [consulta Gestire il controllo degli accessi con le autorizzazioni federate di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
# ATTACH RLS POLICY
Collegamento di una policy di sicurezza a livello di riga su una tabella a uno o più utenti o ruoli.
Una policy può essere collegata da superuser e utenti o ruoli che dispongono del ruolo `sys:secadmin`.
## Sintassi
```
ATTACH RLS POLICY
{
policy_name ON [TABLE] table_name [, ...]
| database_name.policy_name ON [TABLE] database_name.schema_name.table_name [, ...]
}
TO { user_name | ROLE role_name | PUBLIC } [, ...]
```
## Parameters
*nome\$1policy*
Il nome della policy .
database\$1name
Il nome del database in cui vengono create la politica e la relazione. La politica e la relazione devono trovarsi sullo stesso database. Il database può essere il database connesso o un database che supporta le autorizzazioni federate di Amazon Redshift.
schema\$1name
Il nome dello schema a cui appartiene la relazione.
table\$1name
La relazione a cui è collegata la policy di sicurezza a livello di riga.
TO \$1 *nome\$1utente* \$1 ROLE *nome\$1ruolo* \$1 PUBLIC\$1 [, ...]
Specifica se la policy è collegata a uno o più utenti o ruoli specificati.
Per l'utilizzo di ATTACH RLS POLICY su Amazon Redshift Federated Permissions Catalog, [consulta Gestire il controllo degli accessi con le autorizzazioni federate di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/federated-permissions-managing-access.html).
## Note per l'utilizzo
Quando lavori con l'istruzione ATTACH RLS POLICY, tieni presente quanto segue:
+ La tabella che viene collegata deve contenere tutte le colonne elencate nella clausola WITH dell'istruzione di creazione della policy.
+ Amazon Redshift RLS non supporta il collegamento di policy RLS ai seguenti oggetti:
+ Tabelle
+ Visualizzazioni
+ Viste con associazione tardiva
+ Viste materializzate
+ Amazon Redshift RLS non supporta il collegamento di policy RLS ai seguenti oggetti:
+ Tabelle del catalogo
+ Relazioni tra database
+ Tabelle esterna
+ Tabelle temporanee
+ Tabelle di ricerca delle policy
+ Tabelle di base di viste materializzate
+ Le policy RLS collegate a utenti con privilegi avanzati o utenti con l’autorizzazione `sys:secadmin` vengono ignorate.
## Esempi
Nell’esempio seguente una policy RLS viene collegata alla tabella e alle combinazioni di ruoli specificate. La policy RLS si applica a tutti gli utenti con il ruolo `analyst` o `dbadmin` quando accedono alla tabella tickit\$1category\$1redshift.
```
ATTACH RLS POLICY policy_concerts ON tickit_category_redshift TO ROLE analyst, ROLE dbadmin;
```
# BEGIN
Inizia una transazione. Sinonimo di START TRANSACTION.
Una transazione è una singola unità logica di lavoro composta da uno o più comandi. In generale, tutti i comandi in una transazione vengono eseguiti in uno snapshot del database la cui ora di inizio è determinata dal valore impostato per il parametro di configurazione del sistema `transaction_snapshot_begin`.
Per impostazione predefinita, le singole operazioni Amazon Redshift (query, istruzioni DDL, caricamenti) vengono sottoposte automaticamente al commit nel database. Se vuoi sospendere il commit per un'operazione fino al completamento del lavoro successivo, è necessario aprire una transazione con l'istruzione BEGIN, quindi eseguire i comandi richiesti e chiudere la transazione con un'istruzione [COMMIT](r_COMMIT.md) o [END](r_END.md). Se necessario, è possibile utilizzare un'istruzione [ROLLBACK](r_ROLLBACK.md) per interrompere una transazione in corso. Un'eccezione a questo comportamento è costituita dal comando [TRUNCATE](r_TRUNCATE.md) che esegue il commit della transazione in cui viene eseguito e non può essere sottoposto al rollback.
## Sintassi
```
BEGIN [ WORK | TRANSACTION ] [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
START TRANSACTION [ ISOLATION LEVEL option ] [ READ WRITE | READ ONLY ]
Where option is
SERIALIZABLE
| READ UNCOMMITTED
| READ COMMITTED
| REPEATABLE READ
Note: READ UNCOMMITTED, READ COMMITTED, and REPEATABLE READ have no
operational impact and map to SERIALIZABLE in Amazon Redshift. You can see database isolation levels on your cluster
by querying the stv_db_isolation_level table.
```
## Parameters
WORK
Parola chiave facoltativa.
TRANSACTION
Parola chiave facoltativa; WORK e TRANSACTION sono sinonimi.
ISOLATION LEVEL SERIALIZABLE
L'isolamento serializzabile è supportato per impostazione predefinita, quindi il comportamento della transazione è lo stesso indipendentemente dal fatto che questa sintassi sia inclusa nell'istruzione. Per ulteriori informazioni, consulta [Gestione delle operazioni di scrittura simultanee](c_Concurrent_writes.md). Non sono supportate altri livelli di isolamento.
Lo standard SQL definisce quattro livelli di isolamento della transazione per impedire *letture modificate* (in cui una transazione legge i dati scritti da una transazione concorrente non impegnata), *letture non ripetibili* (in cui una transazione rilegge i dati letti in precedenza e trova che i dati sono stati modificati da un'altra transazione che ha eseguito il commit dalla lettura iniziale) e *letture fantasma* (in cui una transazione esegue nuovamente una query, restituisce un set di righe che soddisfa una condizione di ricerca e poi trova che il set di righe è cambiato a causa di un'altra transazione recentemente sottoposta al commit):
+ Lettura non sottoposta al commit: sono possibili letture modificate, letture non ripetibili e letture fantasma.
+ Lettura sottoposta al commit: sono possibili letture non ripetibili e letture fantasma.
+ Lettura ripetibile: sono possibili letture fantasma.
+ Serializzabile: impedisce letture modificate, letture non ripetibili e letture fantasma.
Sebbene sia possibile utilizzare uno qualsiasi dei quattro livelli di isolamento della transazione, Amazon Redshift elabora tutti i livelli di isolamento come serializzabili.
READ WRITE
Fornisce le autorizzazioni di lettura e scrittura alla transazione.
READ ONLY
Fornisce solo le autorizzazioni di lettura alla transazione.
## Esempi
L'esempio seguente avvia un blocco di transazione serializzabile:
```
begin;
```
L'esempio seguente avvia il blocco di transazione con un livello di isolamento serializzabile e le autorizzazioni di lettura e scrittura:
```
begin read write;
```
# CALL
Esegue una procedura archiviata. Il comando CALL deve includere il nome della procedura e i valori dell'argomento di input. Per chiamare una procedura archiviata, utilizza l'istruzione CALL.
**Nota**
CALL non può fare parte di alcuna query normale.
## Sintassi
```
CALL sp_name ( [ argument ] [, ...] )
```
## Parameters
*sp\$1name*
Il nome della procedura da eseguire.
*argument*
Il valore dell'argomento di input. Questo parametro può essere anche un nome di funzione, ad esempio `pg_last_query_id()`. Non puoi utilizzare le query come argomenti CALL.
## Note per l'utilizzo
Le procedure archiviate di Amazon Redshift supportano le chiamate nidificate e ricorsive, come descritto di seguito. Inoltre, assicurati che il supporto del tuo autista sia up-to-date descritto di seguito.
**Topics**
+ [Chiamate nidificate](#r_CALL_procedure-nested-calls)
+ [Supporto driver](#r_CALL_procedure-driver-support)
### Chiamate nidificate
Le procedure archiviate di Amazon Redshift supportano le chiamate nidificate e ricorsive. Il numero massimo consentito di livelli di nidificazione è 16. Le chiamate nidificate possono incapsulare la logica di business in procedure più piccole, condivisibili da più intermediari.
Se chiami una procedura nidificata che dispone di parametri di output, la procedura interna deve definire argomenti INOUT. In questo caso, la procedura interna viene trasmessa a una variabile non costante. Gli argomenti OUT non sono consentiti. Questo comportamento si verifica in quanto una variabile è necessaria per mantenere l'output di una chiamata interna.
La relazione tra procedure interne ed esterne è registrata nella colonna `from_sp_call` di [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md).
L'esempio seguente mostra la trasmissione di variabili a una chiamata di procedura nidificata tramite argomenti INOUT.
```
CREATE OR REPLACE PROCEDURE inner_proc(INOUT a int, b int, INOUT c int) LANGUAGE plpgsql
AS $$
BEGIN
a := b * a;
c := b * c;
END;
$$;
CREATE OR REPLACE PROCEDURE outer_proc(multiplier int) LANGUAGE plpgsql
AS $$
DECLARE
x int := 3;
y int := 4;
BEGIN
DROP TABLE IF EXISTS test_tbl;
CREATE TEMP TABLE test_tbl(a int, b varchar(256));
CALL inner_proc(x, multiplier, y);
insert into test_tbl values (x, y::varchar);
END;
$$;
CALL outer_proc(5);
SELECT * from test_tbl;
a | b
----+----
15 | 20
(1 row)
```
### Supporto driver
È consigliabile aggiornare i driver Java Database Connectivity (JDBC) e Open Database Connectivity (ODBC) alla versione più recente che dispone del supporto per le procedure archiviate di Amazon Redshift.
Se lo strumento del tuo client utilizza le operazioni API che trasmettono al server tramite l'istruzione CALL, devi essere in grado di utilizzare il driver esistente. Se esistenti, i parametri di output vengono restituiti come insieme di risultati di una riga.
Le versioni più recenti dei driver JDBC e ODBC di Amazon Redshift dispongono del supporto dei metadati per il rilevamento delle procedure archiviate. oltre che del supporto `CallableStatement` per le applicazioni Java personalizzate. Per ulteriori informazioni sui driver, consulta [Connessione a un cluster Amazon Redshift tramite gli strumenti del client SQL](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-to-cluster.html) nella *Guida alla gestione di Amazon Redshift*.
Gli esempi seguenti mostrano come utilizzare operazioni API diverse del driver JDBC per le chiamate delle procedure archiviate.
```
void statement_example(Connection conn) throws SQLException {
statement.execute("CALL sp_statement_example(1)");
}
void prepared_statement_example(Connection conn) throws SQLException {
String sql = "CALL sp_prepared_statement_example(42, 84)";
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.execute();
}
void callable_statement_example(Connection conn) throws SQLException {
CallableStatement cstmt = conn.prepareCall("CALL sp_create_out_in(?,?)");
cstmt.registerOutParameter(1, java.sql.Types.INTEGER);
cstmt.setInt(2, 42);
cstmt.executeQuery();
Integer out_value = cstmt.getInt(1);
}
```
## Esempi
L'esempio seguente chiama il nome della procedura `test_spl`.
```
call test_sp1(3,'book');
INFO: Table "tmp_tbl" does not exist and will be skipped
INFO: min_val = 3, f2 = book
```
L'esempio seguente chiama il nome della procedura `test_spl2`.
```
call test_sp2(2,'2019');
f2 | column2
---------------------+---------
2019+2019+2019+2019 | 2
(1 row)
```
# CANCEL
Annulla una query del database attualmente in esecuzione.
Il comando CANCEL richiede l’ID processo o l’ID sessione della query in esecuzione e visualizza un messaggio di conferma per verificare che la query sia stata annullata.
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per CANCEL:
+ Utente con privilegi avanzati che annulla la propria query
+ Utente con privilegi avanzati che annulla la query di un utente
+ Utenti con il privilegio CANCEL che annulla la query di un utente
+ Utente che annulla la propria query
## Sintassi
```
CANCEL process_id [ 'message' ]
```
## Parameters
*process\$1id*
Per annullare una query in esecuzione in un cluster Amazon Redshift, utilizza `pid` (ID processo) di [STV\$1RECENTS](r_STV_RECENTS.md) corrispondente alla query da annullare.
Per annullare una query in esecuzione in un gruppo di lavoro Amazon Redshift serverless, utilizza `session_id` di [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) corrispondente alla query da annullare.
'*message*'
Messaggio di conferma facoltativo che viene visualizzato al termine dell'annullamento della query. Se non si specifica un messaggio, Amazon Redshift visualizza il messaggio predefinito come verifica. È necessario racchiudere il messaggio tra virgolette singole.
## Note per l'utilizzo
Non puoi annullare una query specificando un *ID query*. Devi specificare l’*ID processo* (PID) o l’*ID sessione* della query. Puoi annullare solo le query attualmente eseguite dall'utente. Gli utenti con privilegi avanzati possono annullare tutte le query.
Se le query in più sessioni contengono blocchi sulla stessa tabella, è possibile utilizzare la funzione [PG\$1TERMINATE\$1BACKEND](PG_TERMINATE_BACKEND.md) per terminare una delle sessioni. Questa operazione forza qualsiasi transazione attualmente in esecuzione nella sessione terminata al fine di rilasciare tutti i blocchi ed eseguire il rollback della transazione. Per visualizzare i blocchi correnti, eseguire una query sulla tabella di sistema [STV\$1LOCKS](r_STV_LOCKS.md).
Seguendo determinati eventi interni, Amazon Redshift può riavviare una sessione attiva e assegnare un nuovo PID. Se il PID è cambiato, è possibile che venga ricevuto il seguente messaggio di errore:
```
Session does not exist. The session PID might have changed. Check the stl_restarted_sessions system table for details.
```
Per trovare il nuovo PID, eseguire una query sulla tabella di sistema [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md) e filtrare la colonna `oldpid`.
```
select oldpid, newpid from stl_restarted_sessions where oldpid = 1234;
```
## Esempi
Per annullare una query attualmente in esecuzione in un cluster Amazon Redshift, recupera prima l’ID processo della query da annullare. Per determinare il processo IDs per tutte le query attualmente in esecuzione, digitate il seguente comando:
```
select pid, starttime, duration,
trim(user_name) as user,
trim (query) as querytxt
from stv_recents
where status = 'Running';
pid | starttime | duration | user | querytxt
-----+----------------------------+----------+----------+-----------------
802 | 2008-10-14 09:19:03.550885 | 132 | dwuser | select
venuename from venue where venuestate='FL', where venuecity not in
('Miami' , 'Orlando');
834 | 2008-10-14 08:33:49.473585 | 1250414 | dwuser | select *
from listing;
964 | 2008-10-14 08:30:43.290527 | 326179 | dwuser | select
sellerid from sales where qtysold in (8, 10);
```
Controlla il testo della query per determinare quale ID processo (PID) corrisponde alla query che vuoi annullare.
Digita il seguente comando per utilizzare PID 802 per annullare quella query:
```
cancel 802;
```
La sessione in cui è stata eseguita la query visualizza il seguente messaggio:
```
ERROR: Query (168) cancelled on user's request
```
dove `168` è l'ID query (non l'ID processo utilizzato per annullare la query).
In alternativa, puoi specificare un messaggio di conferma personalizzato da visualizzare al posto del messaggio predefinito. Per specificare un messaggio personalizzato, includi il messaggio tra virgolette singole alla fine del comando CANCEL:
```
cancel 802 'Long-running query';
```
La sessione in cui è stata eseguita la query visualizza il seguente messaggio:
```
ERROR: Long-running query
```
# CLOSE
(Facoltativo) Chiude tutte le risorse libere associate a un cursore aperto. [COMMIT](r_COMMIT.md), [END](r_END.md) e [ROLLBACK](r_ROLLBACK.md) chiudono automaticamente il cursore, quindi non è necessario usare il comando CLOSE per chiudere esplicitamente il cursore.
Per ulteriori informazioni, consultare [DECLARE](declare.md), [FETCH](fetch.md).
## Sintassi
```
CLOSE cursor
```
## Parameters
*cursor*
Nome del cursore da chiudere.
## Esempio di CLOSE
I seguenti comandi chiudono il cursore ed eseguono un commit che termina la transazione:
```
close movie_cursor;
commit;
```
# COMMENT
Crea o modifica un commento su un oggetto di database.
## Sintassi
```
COMMENT ON
{
TABLE object_name |
COLUMN object_name.column_name |
CONSTRAINT constraint_name ON table_name |
DATABASE object_name |
VIEW object_name
}
IS 'text' | NULL
```
## Parameters
*object\$1name*
Nome dell'oggetto del database che viene commentato. Puoi aggiungere un commento ai seguenti oggetti:
+ TABLE
+ COLUMN (prende anche un *column\$1name*).
+ CONSTRAINT (prende anche un *constraint\$1name* e un *table\$1name*).
+ DATABASE
+ VIEW
+ SCHEMA
IS '*text*' \$1 NULL
Il testo del commento che si desidera aggiungere o sostituire per l'oggetto specificato. La stringa *text* ha un tipo di dati TEXT. Racchiudi il commento tra virgolette singole. Impostare il valore su NULL per rimuovere il testo del commento.
*column\$1name*
Nome della colonna che viene commentata. Parametro di COLUMN. Segue una tabella specificata in `object_name`.
*constraint\$1name*
Nome del vincolo che viene commentato. Parametro di CONSTRAINT.
*table\$1name*
Nome della tabella contenente il vincolo. Parametro di CONSTRAINT.
## Note per l'utilizzo
Per aggiungere o aggiornare un commento, si deve essere un superuser o il proprietario di un oggetto di database.
I commenti sui database possono essere applicati solo al database corrente. Viene visualizzato un messaggio di avviso se tenti di commentare un database diverso. Lo stesso avviso viene visualizzato per i commenti su database che non esistono.
I commenti su tabelle esterne, colonne esterne e colonne di viste con associazione tardiva non sono supportati.
## Esempi
Nell'esempio seguente viene aggiunto un commento alla tabella SALES.
```
COMMENT ON TABLE sales IS 'This table stores tickets sales data';
```
Nell'esempio seguente viene visualizzato il commento nella tabella SALES.
```
select obj_description('public.sales'::regclass);
obj_description
-------------------------------------
This table stores tickets sales data
```
Nell'esempio seguente viene rimosso un commento dalla tabella SALES.
```
COMMENT ON TABLE sales IS NULL;
```
Nell'esempio seguente viene aggiunto un commento alla colonna EVENTID della tabella SALES.
```
COMMENT ON COLUMN sales.eventid IS 'Foreign-key reference to the EVENT table.';
```
Nell'esempio seguente viene visualizzato un commento nella colonna EVENTID (colonna numero 5) della tabella SALES.
```
select col_description( 'public.sales'::regclass, 5::integer );
col_description
-----------------------------------------
Foreign-key reference to the EVENT table.
```
Nell'esempio seguente viene aggiunto un commento descrittivo alla tabella EVENT.
```
comment on table event is 'Contains listings of individual events.';
```
Per visualizzare i commenti, eseguire una query sul catalogo di sistema PG\$1DESCRIPTION. L'esempio seguente restituisce la descrizione per la tabella EVENT.
```
select * from pg_catalog.pg_description
where objoid =
(select oid from pg_class where relname = 'event'
and relnamespace =
(select oid from pg_catalog.pg_namespace where nspname = 'public') );
objoid | classoid | objsubid | description
-------+----------+----------+----------------------------------------
116658 | 1259 | 0 | Contains listings of individual events.
```
# COMMIT
Esegue il commit della transazione corrente nel database. Questo comando rende permanenti gli aggiornamenti del database dalla transazione.
## Sintassi
```
COMMIT [ WORK | TRANSACTION ]
```
## Parameters
WORK
Parola chiave facoltativa. Questa parola chiave non è supportata all'interno di una procedura archiviata.
TRANSACTION
Parola chiave facoltativa. WORK e TRANSACTION sono sinonimi. Nessuno dei due è supportato all'interno d una procedura archiviata.
Per informazioni su come utilizzare COMMIT all'interno di una procedura archiviata, consultare [Gestione delle transazioni](stored-procedure-transaction-management.md).
## Esempi
Ciascuno degli esempi seguenti esegue il commit della transazione corrente nel database:
```
commit;
```
```
commit work;
```
```
commit transaction;
```
# COPY
| |
| --- |
| La crittografia lato client per i comandi COPY e UNLOAD non sarà più disponibile per i nuovi clienti a partire dal 30 aprile 2025. Se hai utilizzato la crittografia lato client con i comandi COPY e UNLOAD nei 12 mesi precedenti il 30 aprile 2025, puoi continuare a utilizzare la crittografia lato client con COPY o UNLOAD fino al 30 aprile 2026. Dopo il 30 aprile 2026 non potrai utilizzare la crittografia lato client per i comandi COPY e UNLOAD. Consigliamo di passare alla crittografia lato server per COPY e UNLOAD il prima possibile. Se utilizzi già la crittografia lato server per COPY e UNLOAD, non cambia nulla e puoi continuare a utilizzarla senza modificare le query. Per ulteriori informazioni sulla crittografia per COPY e UNLOAD, consulta il parametro ENCRYPTED di seguito. |
Carica i dati in una tabella dai file di dati o da una tabella Amazon DynamoDB. I file possono trovarsi in un bucket Amazon Simple Storage Service (Amazon S3), un cluster Amazon EMR o un host remoto che accede tramite una connessione Secure Shell (SSH).
**Nota**
Le tabelle esterne di Amazon Redshift Spectrum sono di sola lettura. Non è possibile eseguire il comando COPY per una tabella esterna.
Il comando COPY aggiunge i nuovi dati di input come righe aggiuntive nella tabella.
La dimensione massima di una singola riga di input da qualsiasi origine è pari a 4 MB.
**Topics**
+ [Autorizzazioni richieste](#r_COPY-permissions)
+ [Sintassi di COPY](#r_COPY-syntax)
+ [Parametri obbligatori](#r_COPY-syntax-required-parameters)
+ [Parametri facoltativi](#r_COPY-syntax-overview-optional-parameters)
+ [Note sull'utilizzo e risorse aggiuntive per il comando COPY](#r_COPY-using-the-copy-command)
+ [Esempi di comando COPY](#r_COPY-using-the-copy-command-examples)
+ [COPY JOB](r_COPY-JOB.md)
+ [COPIA con TEMPLATE](r_COPY-WITH-TEMPLATE.md)
+ [Documentazione di riferimento dei parametri di COPY](r_COPY-parameters.md)
+ [Note per l'utilizzo](r_COPY_usage_notes.md)
+ [Esempi di COPY](r_COPY_command_examples.md)
## Autorizzazioni richieste
Per utilizzare il comando COPY, è necessario disporre del privilegio [INSERT](r_GRANT.md#grant-insert) per la tabella Amazon Redshift.
## Sintassi di COPY
```
COPY table-name
[ column-list ]
FROM data_source
authorization
[ [ FORMAT ] [ AS ] data_format ]
[ parameter [ argument ] [, ... ] ]
```
È possibile eseguire un'operazione COPY con soli tre parametri: un nome di tabella, un'origine dati e l'autorizzazione per accedere ai dati.
Amazon Redshift estende la funzionalità del comando COPY per consentirti di caricare i dati in diversi formati di dati da diverse origini dati, controllare l'accesso per caricare i dati, gestire le trasformazioni di dati e gestire l'operazione di caricamento.
Le seguenti sezioni presentano i parametri obbligatori del comando COPY e raggruppano i parametri opzionali per funzione. Gli argomenti successivi descrivono ogni parametro e spiegano come interagiscono le diverse opzioni. Puoi anche andare direttamente alla descrizione di un parametro utilizzando un elenco alfabetico di parametri.
## Parametri obbligatori
Il comando COPY necessita di tre elementi:
+ [Table Name](#r_COPY-syntax-overview-table-name)
+ [Data Source](#r_COPY-syntax-overview-data-source)
+ [Authorization](#r_COPY-syntax-overview-credentials)
Il comando COPY più semplice utilizza il seguente formato.
```
COPY table-name
FROM data-source
authorization;
```
L'esempio seguente crea una tabella chiamata CATDEMO, poi carica la tabella con dati campione da un file di dati in Amazon S3 chiamato `category_pipe.txt`.
```
create table catdemo(catid smallint, catgroup varchar(10), catname varchar(10), catdesc varchar(50));
```
Nell'esempio seguente, l'origine dati per il comando COPY è un file di dati chiamato `category_pipe.txt` nella cartella `tickit` di un bucket Amazon S3 chiamato `redshift-downloads`. Il comando COPY è autorizzato ad accedere al bucket Amazon S3 tramite un ruolo AWS Identity and Access Management (IAM). Se il cluster possiede un ruolo IAM esistente per accedere ad Amazon S3 collegato, è possibile sostituire l'Amazon Resource Name (ARN) del ruolo nel comando COPY successivo ed eseguirlo.
```
copy catdemo
from 's3://redshift-downloads/tickit/category_pipe.txt'
iam_role 'arn:aws:iam:::role/'
region 'us-east-1';
```
Per istruzioni complete su come utilizzare i comandi COPY per caricare dati di esempio, incluse istruzioni per caricare dati da altre AWS regioni, consulta [Load Sample Data from Amazon S3 nella Amazon](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-create-sample-db.html) Redshift Getting Started Guide.
*table-name*
Il nome della tabella di destinazione per il comando COPY. La tabella deve esistere già nel database. La tabella può essere temporanea o persistente. Il comando COPY aggiunge i nuovi dati di input a tutte le righe esistenti nella tabella.
FROM *data-source*
La posizione dei dati di origine da caricare nella tabella di destinazione. È possibile specificare un file manifest con alcune origini dati.
Di solito, il repository dei dati più utilizzato è un bucket Amazon S3. È possibile anche caricare da file di dati ubicati in un cluster Amazon EMR, un'istanza Amazon EC2 o un host remoto a cui il cluster può accedere utilizzando una connessione SSH oppure è possibile caricare direttamente da una tabella DynamoDB.
+ [COPY da Amazon S3](copy-parameters-data-source-s3.md)
+ [COPY da Amazon EMR](copy-parameters-data-source-emr.md)
+ [COPY da host remoto (SSH)](copy-parameters-data-source-ssh.md)
+ [COPY da Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
Autorizzazione
Una clausola che indica il metodo utilizzato dal cluster per l'autenticazione e l'autorizzazione all'accesso ad altre risorse. AWS Il comando COPY richiede l'autorizzazione per accedere ai dati in un'altra AWS risorsa, tra cui Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. È possibile fornire tale autorizzazione referenziando il ruolo IAM collegato al cluster o fornendo l'ID chiave di accesso e la chiave di accesso segreta per un utente IAM.
+ [Parametri di autorizzazione](copy-parameters-authorization.md)
+ [Controllo degli accessi basato sui ruoli](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Controllo degli accessi basato su chiave](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
## Parametri facoltativi
È possibile specificare facoltativamente il modo in cui COPY mappa i dati dei campi in colonne nella tabella di destinazione, definire gli attributi dei dati di origine per consentire al comando COPY di leggere correttamente e analizzare i dati di origine e gestire le operazioni che il comando COPY deve eseguire durante il processo di caricamento.
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ [Parametri del formato dei dati](#r_COPY-syntax-overview-data-format)
+ [Parametri di conversione dei dati](#r_COPY-syntax-overview-data-conversion)
+ [Operazioni di caricamento dati](#r_COPY-syntax-overview-data-load)
### Mappatura di colonne
Per impostazione predefinita, COPY inserisce i valori dei campi nelle colonne della tabella di destinazione nello stesso ordine in cui i campi si presentano nei file di dati. Se l'ordine predefinito delle colonne non funziona, puoi specificare un elenco di colonne o utilizzare JSONPath espressioni per mappare i campi dei dati di origine alle colonne di destinazione.
+ [Column List](copy-parameters-column-mapping.md#copy-column-list)
+ [JSONPaths File](copy-parameters-column-mapping.md#copy-column-mapping-jsonpaths)
### Parametri del formato dei dati
È possibile caricare dati da file di testo in formato larghezza fissa, delimitato da caratteri, valori separati da virgole (CSV) o JSON o da file Avro.
Per impostazione predefinita, il comando COPY prevede che i dati di origine siano in file di testo UTF-8 delimitati da caratteri. Il delimitatore predefinito è una barra verticale ( \$1 ). Se i dati di origine sono in un altro formato, utilizza i seguenti parametri per specificare il formato dei dati.
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [PARQUET](copy-parameters-data-format.md#copy-parquet)
+ [ORC](copy-parameters-data-format.md#copy-orc)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
### Parametri di conversione dei dati
Mentre carica la tabella, COPY tenta di convertire in modo implicito le stringhe nei dati di origine nel tipo di dati della colonna di destinazione. Se hai necessità di specificare una conversione diversa dal comportamento predefinito o se la conversione predefinita dà luogo a errori, è possibile gestire le conversioni dei dati specificando i seguenti parametri.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
### Operazioni di caricamento dati
Gestisce il comportamento predefinito dell'operazione di caricamento per la risoluzione dei problemi o per ridurre i tempi di caricamento specificando i seguenti parametri.
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
## Note sull'utilizzo e risorse aggiuntive per il comando COPY
Per ulteriori informazioni su come utilizzare il comando COPY, consultare i seguenti argomenti:
+ [Note per l'utilizzo](r_COPY_usage_notes.md)
+ [Tutorial: Caricamento dei dati da Amazon S3](tutorial-loading-data.md)
+ [Best practice di Amazon Redshift per il caricamento di dati](c_loading-data-best-practices.md)
+ [Caricamento delle tabelle con il comando COPY](t_Loading_tables_with_the_COPY_command.md)
+ [Caricamento di dati da Amazon S3](t_Loading-data-from-S3.md)
+ [Caricamento di dati da Amazon EMR](loading-data-from-emr.md)
+ [Caricamento di dati da host remoti](loading-data-from-remote-hosts.md)
+ [Caricamento di dati da una tabella Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
+ [Risoluzione di problemi di caricamento dei dati](t_Troubleshooting_load_errors.md)
## Esempi di comando COPY
Per altri esempi che mostrano come eseguire COPY da varie origini, in formati diversi e con diverse opzioni di COPY, consulta [Esempi di COPY](r_COPY_command_examples.md).
# COPY JOB
Per ulteriori informazioni sull’utilizzo di questo comando, consulta [Creare un’integrazione di eventi S3 per copiare automaticamente i file dai bucket Amazon S3](loading-data-copy-job.md).
Gestisce i comandi COPY per il caricamento dei dati in una tabella. Il comando COPY JOB è un'estensione del comando COPY e automatizza il caricamento dei dati dai bucket Amazon S3. Quando crei un processo COPY, Amazon Redshift rileva quando vengono creati nuovi file Amazon S3 in un percorso specificato e li carica automaticamente senza il tuo intervento. Gli stessi parametri utilizzati nel comando COPY originale vengono utilizzati durante il caricamento dei dati. Amazon Redshift tiene traccia dei file caricati (in base al nome di file) per verificare che vengano caricati una sola volta.
**Nota**
Per informazioni sul comando COPY, inclusi utilizzo, parametri e autorizzazioni, consulta [COPY](r_COPY.md).
## Autorizzazione richiesta
Per utilizzare il comando COPY JOB, devi disporre di una delle seguenti autorizzazioni oltre a tutte le autorizzazioni necessarie per usare COPY:
+ Superuser
+ Tutte le seguenti:
+ L’autorizzazione con ambito CREATE, ALTER o DROP pertinente per COPY JOBS nel database per cui desideri eseguire il comando COPY.
+ Autorizzazione USAGE per lo schema per cui si desidera eseguire il comando COPY o l’autorizzazione con ambito USAGE per gli schemi del database per cui si desidera eseguire il comando COPY.
+ Autorizzazione INSERT per la tabella per cui desideri eseguire il comando COPY o autorizzazione con ambito INSERT per le tabelle dello schema o del database per cui desideri eseguire il comando COPY.
Il ruolo IAM specificato con il comando COPY deve disporre dell'autorizzazione per accedere ai dati da caricare. Per ulteriori informazioni, consulta [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
## Sintassi
Crea un processo di copia. I parametri del comando COPY vengono salvati con il processo di copia.
Non puoi eseguire il comando COPY JOB CREATE nell’ambito di un blocco di transazioni.
```
COPY copy-command JOB CREATE job-name
[AUTO ON | OFF]
```
Modifica la configurazione di un processo di copia.
```
COPY JOB ALTER job-name
[AUTO ON | OFF]
```
Esegui un processo di copia. Vengono utilizzati i parametri del comando COPY memorizzati.
```
COPY JOB RUN job-name
```
Elenca tutti i processi di copia.
```
COPY JOB LIST
```
Mostra i dettagli di un processo di copia.
```
COPY JOB SHOW job-name
```
Elimina un processo di copia.
Non puoi eseguire il comando COPY JOB DROP nell’ambito di un blocco di transazioni.
```
COPY JOB DROP job-name
```
## Parameters
*copy-command*
Un comando COPY che carica i dati da Amazon S3 ad Amazon Redshift. La clausola contiene i parametri COPY che definiscono il bucket Amazon S3, la tabella di destinazione, il ruolo IAM e altri parametri utilizzati durante il caricamento dei dati. Sono supportati tutti i parametri del comando COPY per il caricamento di dati Amazon S3 con le seguenti eccezioni:
+ COPY JOB non importa file preesistenti nella cartella a cui fa riferimento il comando COPY. Vengono importati solo i file creati dopo il timestamp di creazione di COPY JOB.
+ Non è possibile specificare un comando COPY con le opzioni MAXERROR o IGNOREALLERRORS.
+ Non è possibile specificare un file manifesto. COPY JOB richiede una posizione Amazon S3 designata per monitorare i file appena creati.
+ Non è possibile specificare un comando COPY con tipi di autorizzazione come le chiavi Access e Secret. Sono supportati solo i comandi COPY che utilizzano il parametro `IAM_ROLE` per l'autorizzazione. Per ulteriori informazioni, consulta [Parametri di autorizzazione](copy-parameters-authorization.md).
+ Il comando COPY JOB non supporta il ruolo IAM predefinito associato al cluster. Devi specificare il `IAM_ROLE` nel comando COPY.
Per ulteriori informazioni, consulta [COPY da Amazon S3](copy-parameters-data-source-s3.md).
*job-name*
Nome del processo utilizzato per fare riferimento al processo COPY. Il nome *job-name* non può contenere un trattino (‐).
[AUTO ON \$1 OFF]
Clausola che indica se i dati Amazon S3 vengono caricati automaticamente nelle tabelle Amazon Redshift.
+ Se è selezionato `ON`, Amazon Redshift monitora il percorso Amazon S3 di origine per individuare i file appena creati e, se ne trova, viene eseguito un comando COPY con i parametri COPY nella definizione del processo. Questa è l’impostazione predefinita.
+ Se è selezionato `OFF`, Amazon Redshift non esegue automaticamente il comando COPY JOB.
## Note per l'utilizzo
Le opzioni del comando COPY vengono convalidate solo in fase di esecuzione. Ad esempio, un `IAM_ROLE` e un'origine dati Amazon S3 non validi generano errori di runtime all'avvio del processo COPY JOB.
Se il cluster è in pausa, i processi COPY JOB non vengono eseguiti.
Per eseguire query sui file di comando COPY caricati e per gli errori di caricamento, consulta [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md), [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md), [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md). Per ulteriori informazioni, consulta [Verifica del caricamento corretto dei dati](verifying-that-data-loaded-correctly.md).
I COPY JOBS non sono supportati sui database zero-ETL poiché funzionano in modalità di sola lettura.
## Esempi
L'esempio seguente mostra la creazione di un processo COPY JOB per il caricamento di dati da un bucket Amazon S3.
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
JOB CREATE my_copy_job_name
AUTO ON;
```
# COPIA con TEMPLATE
È possibile utilizzare i modelli Redshift con comandi COPY per semplificare la sintassi dei comandi e garantire la coerenza tra le operazioni di caricamento dei dati. Invece di specificare ripetutamente gli stessi parametri di formattazione, li definisci una volta in un modello e fai riferimento al modello nei comandi COPY. Quando utilizzate un modello, il comando COPY combina i parametri del modello con tutti i parametri specificati direttamente nel comando. Se lo stesso parametro appare sia nel modello che nel comando, il parametro del comando ha la precedenza. Per ulteriori informazioni, consulta [CREARE UN MODELLO](r_CREATE_TEMPLATE.md).
I modelli per il comando COPY possono essere creati con:
+ [Parametri del formato dei dati](copy-parameters-data-format.md)
+ [Parametri di compressione dei file](copy-parameters-file-compression.md)
+ [Parametri di conversione dei dati](copy-parameters-data-conversion.md)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
Per un elenco completo dei parametri supportati, vedere [COPY](r_COPY.md) comando.
## Autorizzazione richiesta
Per utilizzare un modello in un comando COPY, è necessario disporre di:
+ Tutte le autorizzazioni necessarie per eseguire il comando COPY (vedi[Autorizzazioni richieste](r_COPY.md#r_COPY-permissions))
+ Una delle seguenti autorizzazioni del modello:
+ Privilegi di superutente
+ Privilegio USAGE sul modello e privilegio USAGE sullo schema contenente il modello
## Sintassi
```
COPY target_table FROM 's3://...'
authorization
[ option, ...]
USING TEMPLATE [database_name.][schema_name.]template_name;
```
## Parameters
*database\$1name*
(Facoltativo) Il nome del database in cui esiste il modello. Se non specificato, viene utilizzato il database corrente.
*schema\$1name*
(Facoltativo) Il nome dello schema in cui esiste il modello. Se non viene specificato, il modello viene cercato nel percorso di ricerca corrente.
*nome\$1modello*
Il nome del modello da usare in COPY.
## Note per l'utilizzo
+ I parametri specifici del comando (origine, destinazione, autorizzazione) devono ancora essere specificati nel comando COPY.
+ I modelli non possono contenere le specifiche dei file manifest per i comandi COPY.
## Esempi
Gli esempi seguenti mostrano come creare un modello e utilizzarlo nei comandi COPY:
```
CREATE TEMPLATE public.test_template FOR COPY AS
CSV DELIMITER '|' IGNOREHEADER 1 MAXERROR 100;
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
USING TEMPLATE public.test_template;
```
Quando un parametro esiste sia nel modello che nel comando, il parametro del comando ha la precedenza. In questo esempio, se il modello `public.test_template` contiene `DELIMITER '|'` ma il comando COPY lo specifica`DELIMITER ','`, verrà utilizzato il delimitatore di virgola (`,`) del comando anziché il delimitatore pipe () del modello. `|`
```
COPY public.target_table
FROM 's3://amzn-s3-demo-bucket/staging-folder'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyLoadRoleName'
DELIMITER ','
USING TEMPLATE public.test_template;
```
# Documentazione di riferimento dei parametri di COPY
COPY dispone di molti parametri che possono essere utilizzati in molte situazioni. Tuttavia, non tutti i parametri sono supportati in ogni situazione. Ad esempio, per il caricamento da file ORC o PARQUET esiste un numero limitato di parametri supportati. Per ulteriori informazioni, consulta [COPY da formati di dati a colonna](copy-usage_notes-copy-from-columnar.md).
**Topics**
+ [Origini dati](copy-parameters-data-source.md)
+ [Parametri di autorizzazione](copy-parameters-authorization.md)
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ [Parametri del formato dei dati](copy-parameters-data-format.md)
+ [Parametri di compressione dei file](copy-parameters-file-compression.md)
+ [Parametri di conversione dei dati](copy-parameters-data-conversion.md)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
+ [Elenco alfabetico dei parametri](r_COPY-alphabetical-parm-list.md)
# Origini dati
È possibile caricare i dati da file di testo in un bucket Amazon S3, in un cluster Amazon EMR o in un host remoto a cui il cluster può accedere utilizzando una connessione SSH. È possibile caricare i dati anche direttamente da una tabella DynamoDB.
La dimensione massima di una singola riga di input da qualsiasi origine è pari a 4 MB.
Per esportare i dati da una tabella a un set di file in un Amazon S3, utilizzare il comando [UNLOAD](r_UNLOAD.md).
**Topics**
+ [COPY da Amazon S3](copy-parameters-data-source-s3.md)
+ [COPY da Amazon EMR](copy-parameters-data-source-emr.md)
+ [COPY da host remoto (SSH)](copy-parameters-data-source-ssh.md)
+ [COPY da Amazon DynamoDB](copy-parameters-data-source-dynamodb.md)
# COPY da Amazon S3
Per caricare dati da file ubicati in uno o più bucket S3, utilizzare la clausola FROM per indicare il modo in cui COPY individua i file in Amazon S3. È possibile fornire il percorso dell'oggetto ai file di dati come parte della clausola FROM, oppure è possibile fornire la posizione di un file manifest che contiene un elenco di percorsi dell'oggetto Amazon S3. COPY da Amazon S3 utilizza una connessione HTTPS. Assicurati che gli intervalli IP S3 siano aggiunti all'elenco di indirizzi consentiti. Per ulteriori informazioni sugli intervalli IP S3 richiesti, consulta [Isolamento di rete](https://docs.aws.amazon.com//redshift/latest/mgmt/security-network-isolation.html#network-isolation).
**Importante**
Se i bucket Amazon S3 che contengono i file di dati non risiedono nella stessa AWS regione del cluster, devi utilizzare il [REGION](#copy-region) parametro per specificare la regione in cui si trovano i dati.
**Topics**
+ [Sintassi](#copy-parameters-data-source-s3-syntax)
+ [Esempi](#copy-parameters-data-source-s3-examples)
+ [Parametri facoltativi](#copy-parameters-data-source-s3-optional-parms)
+ [Parametri non supportati](#copy-parameters-data-source-s3-unsupported-parms)
## Sintassi
```
FROM { 's3://objectpath' | 's3://manifest_file' }
authorization
| MANIFEST
| ENCRYPTED
| REGION [AS] 'aws-region'
| optional-parameters
```
## Esempi
Nell'esempio seguente viene utilizzato un percorso oggetto per caricare dati da Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/customer'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Nell'esempio seguente viene utilizzato un file manifest per caricare dati da Amazon S3.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
manifest;
```
### Parameters
FROM
L'origine dei dati da caricare. Per ulteriori informazioni sulla codifica del file Amazon S3, consultare [Parametri di conversione dei dati](copy-parameters-data-conversion.md).
's3://*copy\$1from\$1s3\$1objectpath*'
Specifica il percorso degli oggetti Amazon S3 che contengono i dati, ad esempio `'s3://amzn-s3-demo-bucket/custdata.txt'`. Il parametro *s3://copy\$1from\$1s3\$1objectpath* può fare riferimento a un singolo file o a un insieme di oggetti o cartelle che hanno lo stesso prefisso della chiave. Ad esempio, il nome `custdata.txt` è un prefisso della chiave che si riferisce a un certo numero di file fisici: `custdata.txt`,`custdata.txt.1`, `custdata.txt.2`, `custdata.txt.bak` e così via. Il prefisso della chiave può anche fare riferimento a un certo numero di cartelle. Ad esempio `'s3://amzn-s3-demo-bucket/custfolder'` fa riferimento alle cartelle `custfolder`, `custfolder_1`, `custfolder_2` e così via. Se un prefisso della chiave fa riferimento a più cartelle, vengono caricati tutti i file in esse contenuti. Se un prefisso della chiave corrisponde sia a un file sia a una cartella, come `custfolder.log`, COPY tenta di caricare anche il file. Se un prefisso della chiave può causare il tentativo da parte di COPY di caricare i file indesiderati, utilizzare un file manifest. Per ulteriori informazioni, consultare [copy_from_s3_manifest_file](#copy-manifest-file).
Se il bucket S3 che contiene i file di dati non si trova nella stessa AWS regione del cluster, devi utilizzare il [REGION](#copy-region) parametro per specificare la regione in cui si trovano i dati.
Per ulteriori informazioni, consulta [Caricamento di dati da Amazon S3](t_Loading-data-from-S3.md).
's3://*copy\$1from\$1s3\$1manifest\$1file*'
Specifica la chiave oggetto Amazon S3 per un file manifest che elenca i file di dati da caricare. L'argomento *'s3://*copy\$1from\$1s3\$1manifest\$1file'** deve fare esplicito riferimento a un singolo file, ad esempio, `'s3://amzn-s3-demo-bucket/manifest.txt'`. Non può fare riferimento a un prefisso della chiave.
Il manifest è un file di testo in formato JSON che elenca l'URL di ciascun file che deve essere caricato da Amazon S3. L'URL include il nome del bucket e il percorso completo dell'oggetto per il file. I file specificati nel manifesto possono trovarsi in diversi bucket, ma tutti i bucket devono trovarsi nella stessa AWS regione del cluster Amazon Redshift. Se un file viene elencato due volte, viene caricato due volte. L'esempio seguente mostra il JSON per un manifest che carica tre file.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket1/custdata.2","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket2/custdata.1","mandatory":false}
]
}
```
I caratteri delle virgolette doppie sono obbligatori e devono essere virgolette semplici (0x22), non oblique o "intelligenti". Ogni accesso al manifest può facoltativamente includere un flag `mandatory`. Se `mandatory` è impostato come `true`, COPY termina se non trova il file per quella voce; altrimenti COPY continuerà. Il valore predefinito per `mandatory` è `false`.
Quando si carica da file di dati in formato ORC o Parquet, è necessario un campo `meta`, come mostrato nell'esempio seguente.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
Il file manifesto non deve essere crittografato o compresso, anche se sono specificate le opzioni ENCRYPTED, GZIP, LZOP o ZSTD. BZIP2 COPY restituisce un errore se il file manifest specificato non viene trovato o non viene formato correttamente.
Se si utilizza un file manifest, il parametro MANIFEST deve essere specificato con il comando COPY. Se il parametro MANIFEST non è specificato, COPY presuppone che il file specificato con FROM sia un file di dati.
Per ulteriori informazioni, consulta [Caricamento di dati da Amazon S3](t_Loading-data-from-S3.md).
*authorization*
Il comando COPY necessita dell'autorizzazione per accedere ai dati in un'altra risorsa AWS , incluso in Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. È possibile fornire tale autorizzazione facendo riferimento a un ruolo AWS Identity and Access Management (IAM) collegato al cluster (controllo degli accessi basato sui ruoli) o fornendo le credenziali di accesso per un utente (controllo degli accessi basato su chiavi). Per una maggiore sicurezza e flessibilità, consigliamo di utilizzare il controllo degli accessi basato sui ruoli IAM. Per ulteriori informazioni, consulta [Parametri di autorizzazione](copy-parameters-authorization.md).
MANIFEST
Specifica che un manifest viene utilizzato per identificare i file di dati da caricare da Amazon S3. Se si utilizza il parametro MANIFEST, COPY carica i dati dai file elencati nel manifesto a cui fa riferimento *'s3://copy\$1from\$1s3\$1manifest\$1file'*. Se il file manifest non viene trovato o non è formato correttamente, COPY non va a buon fine. Per ulteriori informazioni, consulta [Utilizzo di un manifest per specificare i fili di dati](loading-data-files-using-manifest.md).
ENCRYPTED
Una clausola che specifica che i file di input su Amazon S3 sono crittografati utilizzando la crittografia lato client con chiavi simmetriche gestite dal cliente. Per ulteriori informazioni, consulta [Caricamento di file di dati crittografati da Amazon S3](c_loading-encrypted-files.md). Non specificare ENCRYPTED se i file di input sono crittati utilizzando la crittografia lato server di Amazon S3 (SSE-KMS o SSE-S3). COPY legge automaticamente i file crittati lato server.
Se specifichi il parametro ENCRYPTED, devi anche specificare il parametro [MASTER_SYMMETRIC_KEY](#copy-master-symmetric-key) o includere il valore **master\$1symmetric\$1key** nella stringa [Utilizzo del parametro CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Se i file crittografati sono in formato compresso, aggiungi il parametro GZIP, LZOP o ZSTD. BZIP2
I file e JSONPaths i file manifesto non devono essere crittografati, anche se è specificata l'opzione ENCRYPTED.
MASTER\$1SYMMETRIC\$1KEY '*root\$1key*'
La chiave master simmetrica era utilizzata per crittografare i file di dati su Amazon S3. Se è specificato MASTER\$1SYMMETRIC\$1KEY, è necessario specificare anche il parametro [ENCRYPTED](#copy-encrypted). MASTER\$1SYMMETRIC\$1KEY non può essere utilizzato con il parametro CREDENTIALS. Per ulteriori informazioni, consulta [Caricamento di file di dati crittografati da Amazon S3](c_loading-encrypted-files.md).
Se i file crittografati sono in formato compresso, aggiungete il parametro GZIP, LZOP o BZIP2 ZSTD.
REGION [AS] '*aws-region*'
Speciifica la AWS regione in cui si trovano i dati di origine. REGION è obbligatorio per COPY da un bucket Amazon S3 o una tabella DynamoDB quando la risorsa AWS che contiene i dati non si trova nella stessa regione del cluster Amazon Redshift.
Il valore per *aws\$1region* deve corrispondere a una regione elencata nella tabella [Regioni ed endpoint di Amazon Redshift](https://docs.aws.amazon.com/general/latest/gr/rande.html#redshift_region).
Se viene specificato il parametro REGION, tutte le risorse, compresi un file manifest o più bucket Amazon S3 devono trovarsi nella regione specificata.
Il trasferimento di dati tra regioni comporta costi aggiuntivi a carico del bucket Amazon S3 o della tabella DynamoDB che contiene i dati. Per ulteriori informazioni sui prezzi, consulta **Data Transfer OUT da Amazon S3 a un'altra AWS regione nella** pagina dei prezzi di [Amazon S3](https://aws.amazon.com/s3/pricing/) **e Data Transfer** OUT nella pagina dei prezzi di Amazon [DynamoDB](https://aws.amazon.com/dynamodb/pricing/).
Per impostazione predefinita, COPY presuppone che i dati si trovino nella stessa regione del cluster Amazon Redshift.
## Parametri facoltativi
Facoltativamente è possibile specificare i seguenti parametri con COPY da Amazon S3:
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ [Parametri del formato dei dati](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Parametri di conversione dei dati](copy-parameters-data-conversion.md)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
## Parametri non supportati
Non è possibile utilizzare i seguenti parametri con COPY da Amazon S3:
+ SSH
+ READRATIO
# COPY da Amazon EMR
È possibile utilizzare il comando COPY per caricare dati in parallelo da un cluster Amazon EMR configurato per scrivere file di testo nel Hadoop Distributed File System (HDFS) del cluster sotto forma di file a larghezza fissa, delimitati da caratteri, CSV, formattati JSON o Avro.
**Topics**
+ [Sintassi](#copy-parameters-data-source-emr-syntax)
+ [Esempio](#copy-parameters-data-source-emr-example)
+ [Parameters](#copy-parameters-data-source-emr-parameters)
+ [Parametri supportati](#copy-parameters-data-source-emr-optional-parms)
+ [Parametri non supportati](#copy-parameters-data-source-emr-unsupported-parms)
## Sintassi
```
FROM 'emr://emr_cluster_id/hdfs_filepath'
authorization
[ optional_parameters ]
```
## Esempio
Nell'esempio seguente i dati vengono caricati da un cluster Amazon EMR.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Parameters
FROM
L'origine dei dati da caricare.
'emr://*emr\$1cluster\$1id*/*hdfs\$1file\$1path*'
L'identificatore univoco per il cluster Amazon EMR e il percorso del file HDFS che fa riferimento ai file di dati per il comando COPY. I nomi dei file di dati HDFS non devono contenere i caratteri jolly asterisco (\$1) e punto interrogativo (?).
Il cluster Amazon EMR deve continuare a funzionare fino al completamento dell'operazione COPY. Se uno qualsiasi dei file di dati HDFS viene modificato o cancellato prima del completamento dell'operazione COPY, si potrebbero ottenere risultati imprevisti o l'operazione COPY potrebbe fallire.
È possibile utilizzare i caratteri jolly asterisco (\$1) e punto interrogativo (?) come parte dell'argomento *hdfs\$1file\$1path* del nome file. Ad esempio `'emr://j-SAMPLE2B500FC/myoutput/part*'` identifica i file `part-0000`, `part-0001` e così via. Se il percorso del file non contiene caratteri jolly, viene trattato come una stringa letterale. Se specifichi solo il nome di una cartella, COPY tenta di caricare tutti i file nella cartella.
Se utilizzi caratteri jolly o solo il nome della cartella, verifica che non vengano caricati file indesiderati. Ad esempio, alcuni processi potrebbero scrivere un file di log nella cartella di output.
Per ulteriori informazioni, consulta [Caricamento di dati da Amazon EMR](loading-data-from-emr.md).
*authorization*
Il comando COPY necessita dell'autorizzazione per accedere ai dati in un'altra risorsa AWS , incluso in Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. Puoi fornire tale autorizzazione facendo riferimento a un ruolo AWS Identity and Access Management (IAM) collegato al cluster (controllo degli accessi basato sui ruoli) o fornendo le credenziali di accesso per un utente (controllo degli accessi basato su chiavi). Per una maggiore sicurezza e flessibilità, consigliamo di utilizzare il controllo degli accessi basato sui ruoli IAM. Per ulteriori informazioni, consulta [Parametri di autorizzazione](copy-parameters-authorization.md).
## Parametri supportati
Facoltativamente è possibile specificare i seguenti parametri con COPY da Amazon EMR:
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ [Parametri del formato dei dati](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Parametri di conversione dei dati](copy-parameters-data-conversion.md)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
## Parametri non supportati
Non è possibile utilizzare i seguenti parametri con COPY da Amazon EMR:
+ ENCRYPTED
+ MANIFEST
+ REGION
+ READRATIO
+ SSH
# COPY da host remoto (SSH)
È possibile utilizzare il comando COPY per caricare dati in parallelo da uno o più host remoti, quali istanze Amazon Elastic Compute Cloud (Amazon EC2) o altri computer. COPY si connette agli host remoti utilizzando Secure Shell (SSH) ed esegue comandi sugli host remoti per generare output di testo. L'host remoto può essere un'istanza EC2 Linux o un altro computer Unix o Linux configurato per accettare connessioni SSH. Amazon Redshift può connettersi a più host e può aprire più connessioni SSH per ogni host. Amazon Redshift invia un comando univoco attraverso ogni connessione per generare output di testo per l'output standard dell'host, che legge quindi come un file di testo.
Utilizzare la clausola FROM per specificare la chiave oggetto di Amazon S3 per il file manifest che fornisce le informazioni che COPY utilizza per aprire le connessioni SSH ed eseguire i comandi remoti.
**Topics**
+ [Sintassi](#copy-parameters-data-source-ssh-syntax)
+ [Esempi](#copy-parameters-data-source-ssh-examples)
+ [Parameters](#copy-parameters-data-source-ssh-parameters)
+ [Parametri facoltativi](#copy-parameters-data-source-ssh-optional-parms)
+ [Parametri non supportati](#copy-parameters-data-source-ssh-unsupported-parms)
**Importante**
Se il bucket S3 che contiene i file manifest non si trova nella stessa regione AWS del cluster, è necessario utilizzare il parametro REGION per specificare la regione in cui si trova il bucket.
## Sintassi
```
FROM 's3://'ssh_manifest_file' }
authorization
SSH
| optional-parameters
```
## Esempi
Nell'esempio seguente viene utilizzato un file manifest per caricare dati da un host remoto tramite SSH.
```
copy sales
from 's3://amzn-s3-demo-bucket/ssh_manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
ssh;
```
## Parameters
FROM
L'origine dei dati da caricare.
's3://*copy\$1from\$1ssh\$1manifest\$1file*'
Il comando COPY può connettersi a più host tramite SSH e può creare più connessioni SSH per ogni host. COPY esegue un comando attraverso ogni connessione host, quindi carica l'output dai comandi in parallelo nella tabella. L'argomento *s3://copy\$1from\$1ssh\$1manifest\$1file* specifica la chiave oggetto di Amazon S3 per il file manifest che fornisce le informazioni che COPY utilizza per aprire connessioni SSH ed eseguire i comandi remoti.
L'argomento *s3://copy\$1from\$1ssh\$1manifest\$1file* deve fare esplicito riferimento a un singolo file; non può essere un prefisso della chiave. Di seguito viene riportato un esempio:
```
's3://amzn-s3-demo-bucket/ssh_manifest.txt'
```
Il file manifest è un file di testo in formato JSON che Amazon Redshift utilizza per la connessione all'host. Il file manifesto specifica gli endpoint dell'host SSH e i comandi che verranno eseguiti sugli host per restituire i dati ad Amazon Redshift. Facoltativamente, puoi includere la chiave pubblica dell'host, il nome utente di login e un flag obbligatorio per ogni voce. L'esempio seguente mostra un file manifest che crea due connessioni SSH:
```
{
"entries": [
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""},
{"endpoint":"",
"command": "",
"mandatory":true,
"publickey": "",
"username": ""}
]
}
```
Il file manifest contiene un costrutto `"entries"` per ogni connessione SSH. È possibile avere più connessioni a un singolo host o più connessioni a più host. I caratteri delle doppie virgolette sono richiesti come mostrato, sia per i nomi dei campi sia per i valori. I caratteri delle virgolette devono essere virgolette semplici (0x22), non oblique o "intelligenti". L'unico valore che non necessita di caratteri di virgolette doppie è il valore booleano `true` o `false` per il campo `"mandatory"`.
Nella seguente lista sono descritti i campi del file manifest.
endpoint
L'indirizzo URL o l'indirizzo IP dell'host, ad esempio `"ec2-111-222-333.compute-1.amazonaws.com"` o `"198.51.100.0"`.
command
Il comando che deve essere eseguito dall'host per generare output di testo o binario in formato gzip, lzop, bzip2 o zstd. Il comando può essere qualsiasi comando che l'utente *"host\$1user\$1name"* è autorizzato a eseguire. Il comando può essere semplice come stampare un file o eseguire una query su un database o lanciare uno script. L'output (file di testo o file binario gzip, lzop o bzip2) deve essere in un formato che il comando COPY di Amazon Redshift possa importare. Per ulteriori informazioni, consulta [Preparazione dei dati di input](t_preparing-input-data.md).
publickey
(Facoltativo) La chiave pubblica dell'host. Se fornita, Amazon Redshift userà la chiave pubblica per identificare l'host. Se la chiave pubblica non viene fornita, Amazon Redshift non proverà a eseguire l'identificazione dell'host. Ad esempio, se la chiave pubblica dell'host remoto è `ssh-rsa AbcCbaxxx…Example root@amazon.com`, digita il seguente testo nel campo della chiave pubblica: `"AbcCbaxxx…Example"`
mandatory
(Facoltativo) Una clausola che indica se il comando COPY debba fallire se il tentativo di connessione fallisce. Il valore predefinito è `false`. Se Amazon Redshift non riesce a effettuare almeno una connessione, il comando COPY avrà esito negativo.
username
(Facoltativo) Il nome utente che verrà utilizzato per accedere al sistema host ed eseguire il comando remoto. Il nome di accesso dell'utente deve essere lo stesso usato per aggiungere la chiave pubblica del cluster Amazon Redshift al file delle chiavi autorizzate dell'host. Il nome utente predefinito è `redshift`.
Per ulteriori informazioni sulla creazione di un file manifest, consultare [Processo di caricamento dei dati](loading-data-from-remote-hosts.md#load-from-host-process).
Per utilizzare COPY da un host remoto, il parametro SSH deve essere specificato con il comando COPY. Se il parametro SSH non è specificato, COPY presuppone che il file specificato con FROM sia un file di dati e non va a buon fine.
Se si utilizza la compressione automatica, il comando COPY esegue due operazioni di lettura dati, il che significa che eseguirà il comando remoto due volte. La prima operazione di lettura consiste nel fornire un campione di dati per l'analisi della compressione e la seconda operazione di lettura carica effettivamente i dati. Se la doppia esecuzione del comando remoto potrebbe causare un problema, è necessario disattivare la compressione automatica. Per disattivare la compressione automatica, esegui il comando COPY con il parametro COMPUPDATE impostato su OFF. Per ulteriori informazioni, consulta [Caricamento di tabelle con compressione automatica](c_Loading_tables_auto_compress.md).
Per le procedure dettagliate sull'utilizzo di COPY da SSH, consultare [Caricamento di dati da host remoti](loading-data-from-remote-hosts.md).
*authorization*
Il comando COPY necessita dell'autorizzazione per accedere ai dati in un'altra risorsa AWS , incluso in Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. È possibile fornire tale autorizzazione facendo riferimento a un ruolo AWS Identity and Access Management (IAM) collegato al cluster (controllo degli accessi basato sui ruoli) o fornendo le credenziali di accesso per un utente (controllo degli accessi basato su chiavi). Per una maggiore sicurezza e flessibilità, consigliamo di utilizzare il controllo degli accessi basato sui ruoli IAM. Per ulteriori informazioni, consulta [Parametri di autorizzazione](copy-parameters-authorization.md).
SSH
Una clausola che specifica che i dati devono essere caricati da un host remoto utilizzando il protocollo SSH. Se specifichi SSH. devi anche fornire un file manifest usando l'argomento [s3://copy_from_ssh_manifest_file](#copy-ssh-manifest).
Se stai utilizzando SSH per effettuare la copia da un host utilizzando un indirizzo IP privato su un VPC remoto, il VPC deve avere il routing VPC avanzato abilitato. Per ulteriori informazioni sul routing VPC avanzato, consultare [Amazon Redshift Spectrum con il routing VPC avanzato](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
## Parametri facoltativi
Facoltativamente è possibile specificare i seguenti parametri con COPY da SSH:
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ [Parametri del formato dei dati](copy-parameters-data-format.md#copy-data-format-parameters)
+ [Parametri di conversione dei dati](copy-parameters-data-conversion.md)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
## Parametri non supportati
Non è possibile utilizzare i seguenti parametri con COPY da SSH:
+ ENCRYPTED
+ MANIFEST
+ READRATIO
# COPY da Amazon DynamoDB
Per caricare i dati da una tabella DynamoDB esistente, utilizza la clausola FROM per specificare il nome della tabella DynamoDB.
**Topics**
+ [Sintassi](#copy-parameters-data-source-dynamodb-syntax)
+ [Esempi](#copy-parameters-data-source-dynamodb-examples)
+ [Parametri facoltativi](#copy-parameters-data-source-dynamodb-optional-parms)
+ [Parametri non supportati](#copy-parameters-data-source-dynamodb-unsupported-parms)
**Importante**
Se la tabella DynamoDB non si trova nella stessa regione del cluster Amazon Redshift è necessario utilizzare il parametro REGION per specificare la regione in cui si trovano i dati.
## Sintassi
```
FROM 'dynamodb://table-name'
authorization
READRATIO ratio
| REGION [AS] 'aws_region'
| optional-parameters
```
## Esempi
Nell'esempio seguente i dati sono caricati da una tabella DynamoDB.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
### Parameters
FROM
L'origine dei dati da caricare.
'dynamodb://*table-name*'
Il nome della tabella DynamoDB che contiene i dati, ad esempio `'dynamodb://ProductCatalog'`. Per maggiori dettagli su come gli attributi DynamoDB siano mappati alle colonne Amazon Redshift, consultare [Caricamento di dati da una tabella Amazon DynamoDB](t_Loading-data-from-dynamodb.md).
Il nome di una tabella DynamoDB è univoco per AWS un account, identificato dalle AWS credenziali di accesso.
*authorization*
Il comando COPY necessita dell'autorizzazione per accedere ai dati in un'altra risorsa AWS , incluso in Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. È possibile fornire tale autorizzazione facendo riferimento a un ruolo AWS Identity and Access Management (IAM) collegato al cluster (controllo degli accessi basato sui ruoli) o fornendo le credenziali di accesso per un utente (controllo degli accessi basato su chiavi). Per una maggiore sicurezza e flessibilità, consigliamo di utilizzare il controllo degli accessi basato sui ruoli IAM. Per ulteriori informazioni, consulta [Parametri di autorizzazione](copy-parameters-authorization.md).
READRATIO [AS] *ratio*
La percentuale di throughput assegnato della tabella DynamoDB da utilizzare per il caricamento dei dati. READRATIO è necessario per COPY da DynamoDB. Non può essere utilizzato con COPY da Amazon S3. È consigliabile impostare la percentuale su un valore minore del throughput assegnato mediamente non utilizzato. I valori validi sono numeri interi compresi tra 1 e 200.
Impostando READRATIO su 100 o su un valore superiore si consente a Amazon Redshift di consumare l'intero throughput assegnato della tabella DynamoDB che degrada notevolmente le prestazioni delle operazioni di lettura simultanee rispetto alla stessa tabella durante la sessione di COPY. Il traffico della funzione di scrittura non viene modificato. I valori superiori a 100 possono risolvere problemi in scenari rari quando Amazon Redshift non è in grado di soddisfare il throughput assegnato della tabella. Se i dati vengono caricati da DynamoDB ad Amazon Redshift su base continuativa, considerare l'organizzazione delle tabelle DynamoDB come una serie temporale per separare il traffico in tempo reale dall'operazione COPY.
## Parametri facoltativi
Facoltativamente è possibile specificare i seguenti parametri con COPY da Amazon DynamoDB:
+ [Opzioni di mappatura di colonne](copy-parameters-column-mapping.md)
+ Sono supportati i seguenti parametri di conversione dei dati:
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [Operazioni di caricamento dati](copy-parameters-data-load.md)
## Parametri non supportati
Non è possibile utilizzare i seguenti parametri con COPY da DynamoDB:
+ Tutti i parametri del formato dei dati
+ ESCAPE
+ FILLRECORD
+ IGNOREBLANKLINES
+ IGNOREHEADER
+ NULL
+ REMOVEQUOTES
+ ACCEPTINVCHARS
+ MANIFEST
+ ENCRYPTED
# Parametri di autorizzazione
Il comando COPY richiede l'autorizzazione per accedere ai dati in un'altra AWS risorsa, tra cui Amazon S3, Amazon EMR, Amazon DynamoDB e Amazon EC2. Per concedere questa autorizzazione, è necessario fare riferimento a un [ruolo (IAM)AWS Identity and Access Management](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles.html) associato al cluster (*controllo degli accessi basato sul ruolo*). Puoi crittografare i dati di caricamento su Amazon S3.
I seguenti argomenti forniscono ulteriori dettagli ed esempi di opzioni di autenticazione:
+ [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions)
+ [Controllo degli accessi basato sui ruoli](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based)
+ [Controllo degli accessi basato su chiave](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based)
Utilizza una delle seguenti opzioni per fornire l'autorizzazione per il comando COPY:
+ Parametro [Utilizzo del parametro IAM\$1ROLE](#copy-iam-role)
+ Parametri di [Utilizzo dei parametri ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY](#copy-access-key-id)
+ [Utilizzo del parametro CREDENTIALS](#copy-credentials)Clausola
## Utilizzo del parametro IAM\$1ROLE
### IAM\$1ROLE
Utilizzare la parola chiave predefinita per fare in modo che Amazon Redshift utilizzi il ruolo IAM impostato come predefinito e associato al cluster quando viene eseguito il comando COPY.
L'Amazon Resource Name (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione. Se specifichi IAM\$1ROLE, non è possibile utilizzare ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY, SESSION\$1TOKEN o CREDENTIALS.
Di seguito è mostrata la sintassi del parametro IAM\$1ROLE.
```
IAM_ROLE { default | 'arn:aws:iam:::role/' }
```
Per ulteriori informazioni, consulta [Controllo degli accessi basato sui ruoli](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
## Utilizzo dei parametri ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY
### ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY
Questo metodo di autorizzazione non è raccomandato.
**Nota**
Invece di fornire le credenziali di accesso come testo in chiaro, consigliamo vivamente di utilizzare l'autenticazione basata sui ruoli specificando il parametro IAM\$1ROLE. Per ulteriori informazioni, consulta [Controllo degli accessi basato sui ruoli](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
### SESSION\$1TOKEN
Il token di sessione da utilizzare con le credenziali di accesso temporaneo. Quando è specificato SESSION\$1TOKEN, devi utilizzare anche ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY per fornire credenziali di chiave di accesso temporanee. Se specifichi SESSION\$1TOKEN, non è possibile utilizzare IAM\$1ROLE o CREDENTIALS. Per ulteriori informazioni, consultare [Credenziali di sicurezza temporanee](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials) nella Guida per l'utente di IAM.
**Nota**
Invece di creare credenziali di sicurezza temporanee, consigliamo vivamente di utilizzare l'autenticazione basata su ruoli. Quando si autorizza l'uso di un ruolo IAM, Amazon Redshift crea automaticamente credenziali utente temporanee per ogni sessione. Per ulteriori informazioni, consulta [Controllo degli accessi basato sui ruoli](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based).
Di seguito è riportata la sintassi del parametro SESSION\$1TOKEN con i parametri ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Se specifichi SESSION\$1TOKEN, non è possibile utilizzare CREDENTIALS o IAM\$1ROLE.
## Utilizzo del parametro CREDENTIALS
### CREDENTIALS
Una clausola che indica il metodo utilizzato dal cluster per accedere ad altre AWS risorse che contengono file di dati o file manifest. Non è possibile utilizzare il parametro CREDENTIALS con IAM\$1ROLE o ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY.
Di seguito è mostrata la sintassi del parametro CREDENTIALS.
```
[WITH] CREDENTIALS [AS] 'credentials-args'
```
**Nota**
Per una maggiore flessibilità, consigliamo di utilizzare il parametro [IAM\$1ROLE](#copy-iam-role-iam) invece del parametro CREDENTIALS.
Facoltativamente, se utilizzi il parametro [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted), la stringa *credentials-args* fornisce anche la chiave di crittografia.
La stringa *credentials-args* prevede la distinzione tra maiuscole e minuscole e non deve contenere spazi.
Le parole chiave WITH e AS sono opzionali e vengono ignorate.
È possibile specificare [role-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-role-based.phrase) o [key-based access control](copy-usage_notes-access-permissions.md#copy-usage_notes-access-key-based.phrase). In entrambi i casi, l'utente o il ruolo IAM deve disporre delle autorizzazioni necessarie per accedere alle risorse AWS specificate. Per ulteriori informazioni, consulta [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](copy-usage_notes-access-permissions.md#copy-usage_notes-iam-permissions).
**Nota**
Per salvaguardare le AWS credenziali e proteggere i dati sensibili, consigliamo vivamente di utilizzare il controllo degli accessi basato sui ruoli.
Per specificare il controllo degli accessi basato su ruoli, fornisci la stringa *credentials-args* nel seguente formato.
```
'aws_iam_role=arn:aws:iam:::role/'
```
Per utilizzare le credenziali del token temporanee, devi fornire l'ID chiave di accesso, la chiave di accesso segreta e il token temporanei. La stringa *credentials-args* è nel seguente formato.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Un comando COPY che utilizza il controllo degli accessi basato su ruoli con credenziali temporanee sarebbe simile all’istruzione di esempio seguente:
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;token='
```
Per ulteriori informazioni, consulta [Credenziali di sicurezza temporanee](copy-usage_notes-access-permissions.md#r_copy-temporary-security-credentials).
Se viene utilizzato il [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted) parametro, la stringa *credentials-args* ha il seguente formato, dove ** è il valore della chiave principale utilizzata per crittografare i file.
```
CREDENTIALS
';master_symmetric_key='
```
Un comando COPY che utilizza il controllo degli accessi basato su ruoli con una chiave di crittografia sarebbe simile al comando di esempio seguente:
```
COPY customer FROM 's3://amzn-s3-demo-bucket/mydata'
CREDENTIALS
'aws_iam_role=arn:aws:iam:::role/;master_symmetric_key='
```
# Opzioni di mappatura di colonne
Per impostazione predefinita, COPY inserisce i valori nelle colonne della tabella di destinazione nello stesso ordine in cui i campi vengono visualizzati nei file di dati. Se l'ordine predefinito delle colonne non funziona, puoi specificare un elenco di colonne o utilizzare JSONPath espressioni per mappare i campi di dati di origine alle colonne di destinazione.
+ [Column List](#copy-column-list)
+ [JSONPaths File](#copy-column-mapping-jsonpaths)
## Elenco di colonne
È possibile specificare un elenco separato da virgole di nomi di colonna per caricare i campi dati sorgente in specifiche colonne di destinazione. Le colonne possono essere in qualsiasi ordine nell'istruzione COPY, ma quando si caricano da flat file, come in un bucket Amazon S3, il loro ordine deve corrispondere all'ordine dei dati di origine.
Durante il caricamento da una tabella Amazon DynamoDB l'ordine non è importante. Il comando COPY fa corrispondere i nomi degli attributi negli elementi recuperati dalla tabella DynamoDB ai nomi di colonna nella tabella Amazon Redshift. Per ulteriori informazioni, consultare [Caricamento di dati da una tabella Amazon DynamoDB](t_Loading-data-from-dynamodb.md)
Il formato dell'elenco di colonne è il seguente.
```
COPY tablename (column1 [,column2, ...])
```
Se una colonna nella tabella di destinazione viene omessa dall'elenco delle colonne, COPY carica l'espressione [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) della colonna di destinazione.
Se la colonna di destinazione non ha un valore predefinito, COPY tenta di caricare NULL.
Se COPY tenta di assegnare NULL a una colonna definita come NOT NULL, il comando COPY non viene eseguito.
Se una colonna [IDENTITY](r_CREATE_TABLE_NEW.md#identity-clause) è inclusa nell'elenco di colonne, allora è necessario specificare anche [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids); se viene omessa una colonna IDENTITY, allora EXPLICIT\$1IDS non può essere specificato. Se non è specificato un elenco di colonne, il comando si comporta come se fosse specificato un elenco completo di colonne in ordine, con le colonne IDENTITY omesse se non era specificato anche EXPLICIT\$1IDS.
Se una colonna è definita con GENERATED BY DEFAULT AS IDENTITY, può esser copiata. i valori vengono generati o aggiornati con i valori forniti dall'utente. L'opzione EXPLICIT\$1IDS non è obbligatoria. COPY non aggiorna la filigrana ad elevata identità. Per ulteriori informazioni, consulta [GENERATED BY DEFAULT AS IDENTITY](r_CREATE_TABLE_NEW.md#identity-generated-bydefault-clause).
## JSONPaths file
Quando si carica da file di dati in formato JSON o Avro, COPY mappa automaticamente gli elementi dei dati nei dati di origine JSON o Avro alle colonne della tabella di destinazione. Lo fa associando i nomi dei campi nello schema Avro ai nomi delle colonne nella tabella di destinazione o nell'elenco delle colonne.
In alcuni casi, i nomi delle colonne e dei campi non corrispondono o è necessario mappare a livelli più profondi nella gerarchia dei dati. In questi casi, puoi utilizzare un JSONPaths file per mappare in modo esplicito gli elementi di dati JSON o Avro alle colonne.
Per ulteriori informazioni, consulta [JSONPaths file](copy-parameters-data-format.md#copy-json-jsonpaths).
# Parametri del formato dei dati
Per impostazione predefinita, il comando COPY prevede che i dati di origine siano testi UTF-8 delimitati da caratteri. Il delimitatore predefinito è una barra verticale ( \$1 ). Se i dati di origine sono in un altro formato, utilizza i seguenti parametri per specificare il formato dei dati:
+ [FORMAT](#copy-format)
+ [CSV](#copy-csv)
+ [DELIMITER](#copy-delimiter)
+ [FIXEDWIDTH](#copy-fixedwidth)
+ [SHAPEFILE](#copy-shapefile)
+ [AVRO](#copy-avro)
+ [JSON format for COPY](#copy-json)
+ [PARQUET](#copy-parquet)
+ [ORC](#copy-orc)
Oltre ai formati di dati standard, COPY supporta i seguenti formati di dati a colonna per COPY da Amazon S3:
+ [ORC](#copy-orc)
+ [PARQUET](#copy-parquet)
COPY dal formato a colonne è supportato con alcune restrizioni. Per ulteriori informazioni, consulta [COPY da formati di dati a colonna](copy-usage_notes-copy-from-columnar.md). Parametri del formato dei dati
FORMAT [AS]
(Facoltativo) Identifica le parole chiave del formato dei dati. Gli argomenti FORMAT sono descritti di seguito.
CSV [ QUOTE [AS] *'quote\$1character'* ]
Consente l'utilizzo del formato CSV nei dati di input. Per creare automaticamente sequenza di escape con i delimitatori, i caratteri di linea e i ritorni a capo, racchiudi il campo nel carattere specificato dal parametro QUOTE. Il carattere virgoletta di default è una virgoletta doppia ( " ). Quando si utilizza il carattere virgolette in un campo, eseguire l'escape del carattere aggiungendo altre virgolette. Ad esempio, se il carattere virgoletta è una virgoletta doppia, per inserire la stringa `A "quoted" word` il file di input deve includere la stringa `"A ""quoted"" word"`. Quando si utilizza il parametro CSV, il delimitatore predefinito è una virgola ( , ). È possibile specificare un delimitatore diverso utilizzando il parametro DELIMITER.
Quando un campo è racchiuso tra virgolette, lo spazio tra i delimitatori e i caratteri delle virgolette viene ignorato. Se il delimitatore è un carattere di spazio, ad esempio un carattere di tabulazione, il delimitatore non viene trattato come spazio.
Il CSV non può essere utilizzato con FIXEDWIDTH, REMOVEQUOTES o ESCAPE.
QUOTE [AS] *'quote\$1character'*
Opzionale. Specifica il carattere da utilizzare come carattere virgoletta quando si utilizza il parametro CSV. Il carattere predefinito è una doppia virgoletta ( " ). Se si utilizzi il parametro QUOTE per definire un carattere virgoletta diverso dalla doppia virgoletta, non è necessario creare una sequenza di escape con le virgolette doppie all'interno del campo. Il parametro QUOTE può essere utilizzato solo con il parametro CSV. La parola chiave AS è facoltativa.
DELIMITER [AS] ['*delimiter\$1char*']
Specifica i caratteri utilizzati per separare i campi del file di input, ad esempio un carattere pipe (`|`), una virgola (`,`), una tabulazione (`\t`) o più caratteri come `|~|`. Sono supportati i caratteri non stampabili. I caratteri possono anche essere rappresentati in ottale come unità di codice UTF-8. Per ottale, utilizza il formato '\$1ddd', dove 'd' è una cifra ottale (0 – 7). Il delimitatore predefinito è un carattere pipe (`|`) a meno che non venga utilizzato il parametro CSV, nel qual caso il delimitatore predefinito è una virgola (`,`). La parola chiave AS è facoltativa. DELIMITER non può essere utilizzato con FIXEDWIDTH.
FIXEDWIDTH '*fixedwidth\$1spec*'
Carica i dati da un file in cui ogni larghezza di colonna è fissa, invece di avere colonne separate da un delimitatore. La stringa *fixedwidth\$1spec* specifica l'etichetta e la larghezza della colonna definite dall'utente. L'etichetta della colonna può essere sia una stringa di testo sia un intero, a seconda di ciò che sceglie l'utente. L'etichetta della colonna non ha alcuna relazione con il nome della colonna. L'ordine delle label/width coppie deve corrispondere esattamente all'ordine delle colonne della tabella. FIXEDWIDTH non può essere utilizzato con CSV o DELIMITER. In Amazon Redshift, la lunghezza delle colonne CHAR e VARCHAR è espressa in byte, quindi assicurati che la larghezza della colonna specificata corrisponda alla lunghezza binaria dei caratteri multibyte durante la preparazione del file da caricare. Per ulteriori informazioni, consulta [Tipi di carattere](r_Character_types.md).
Di seguito viene mostrato il formato per *fixedwidth\$1spec*:
```
'colLabel1:colWidth1,colLabel:colWidth2, ...'
```
SHAPEFILE [ SIMPLIFY [AUTO] [*'tolleranza'*] ]
Consente l'utilizzo del formato SHAPEFILE nei dati di input. Per impostazione predefinita, la prima colonna dello shapefile è una colonna `GEOMETRY` o `IDENTITY`. Tutte le colonne successive seguono l'ordine specificato nello shapefile.
Non è possibile utilizzare SHAPEFILE con FIXEDWIDTH, REMOVEQUOTES o ESCAPE.
Per utilizzare oggetti `GEOGRAPHY` con `COPY FROM SHAPEFILE`, prima importa in un colonna `GEOMETRY`, quindi converti gli oggetti in oggetti `GEOGRAPHY`.
SIMPLIFY [*tolleranza*]
(Facoltativo) Semplifica tutte le geometrie durante il processo di ingestione utilizzando l' Ramer-Douglas-Peuckeralgoritmo e la tolleranza specificata.
SIMPLIFY AUTO [*tolleranza*]
(Facoltativo) Semplifica solo le geometrie più grandi della dimensione massima della geometria. Questa semplificazione utilizza l' Ramer-Douglas-Peuckeralgoritmo e la tolleranza calcolata automaticamente se questa non supera la tolleranza specificata. Questo algoritmo calcola la dimensione per memorizzare gli oggetti entro la tolleranza specificata. Il valore *tolleranza* è facoltativo.
Per esempi di caricamento di uno shapefile, consultare [Caricamento di uno shapefile in Amazon Redshift](r_COPY_command_examples.md#copy-example-spatial-copy-shapefile).
AVRO [AS] '*avro\$1option*'
Specifica che i dati sorgente sono in formato Avro.
Il formato Avro è supportato per COPY da questi servizi e protocolli:
+ Simple Storage Service (Amazon S3)
+ Amazon EMR
+ Host remoto (SSH)
Avro non è supportato per COPY da DynamoDB.
Avro è un protocollo di serializzazione dei dati. Un file sorgente Avro include uno schema che definisce la struttura dei dati. Il tipo di schema Avro deve essere `record`. COPY accetta file Avro creati usando il codec di default non compresso così come i codec di compressione `deflate` e `snappy`. Per ulteriori informazioni su Avro, consultare [Apache Avro](https://avro.apache.org/).
I valori validi per *avro\$1option* sono i seguenti:
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
Il valore predefinito è `'auto'`.
COPY mappa automaticamente gli elementi di dati nei dati di origine Avro alle colonne della tabella di destinazione. Lo fa associando i nomi dei campi nello schema Avro ai nomi delle colonne nella tabella di destinazione. La corrispondenza prevede una distinzione tra lettere maiuscole e minuscole per `'auto'` e non fa distinzione tra lettere maiuscole e minuscole per `'auto ignorecase'`.
I nomi delle colonne nelle tabelle Amazon Redshift sono sempre in minuscolo, quindi quando si utilizza l'opzione `'auto'`, anche i nomi dei campi corrispondenti devono essere in minuscolo. Se i nomi dei campi non sono tutti minuscoli, è possibile utilizzare l'opzione `'auto ignorecase'`. Con l'argomento `'auto'` di default, COPY riconosce solo il primo livello di campi, o *campi esterni*, nella struttura.
Per mappare esplicitamente i nomi delle colonne ai nomi dei campi Avro, è possibile utilizzare un [JSONPaths file](#copy-json-jsonpaths).
Per impostazione predefinita, COPY tenta di far corrispondere tutte le colonne della tabella di destinazione ai nomi dei campi Avro. Per caricare un sottoinsieme delle colonne, è possibile specificare facoltativamente un elenco di colonne. Se una colonna nella tabella di destinazione viene omessa dall'elenco delle colonne, COPY carica l'espressione [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) della colonna di destinazione. Se la colonna di destinazione non ha un valore di default, COPY prova a caricare NULL. Se una colonna è inclusa nell'elenco di colonne e COPY non trova un campo corrispondente nei dati Avro, COPY prova a caricare NULL nella colonna.
Se COPY tenta di assegnare NULL a una colonna definita come NOT NULL, il comando COPY non viene eseguito.
**Schema Avro**
Un file di dati sorgente Avro include uno schema che definisce la struttura dei dati. COPY legge lo schema che fa parte del file di dati sorgente Avro per mappare gli elementi di dati sulle colonne della tabella di destinazione. L'esempio seguente mostra uno schema Avro.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"}]
}
```
Lo schema Avro è definito utilizzando il formato JSON. L'oggetto JSON di livello superiore contiene tre coppie nome-valore con i nomi o le *chiavi*, `"name"`, `"type"` e `"fields"`.
Le chiavi `"fields"` si accoppiano con un array di oggetti che definiscono il nome e il tipo di dati di ogni campo nella struttura dei dati. Per impostazione predefinita, COPY fa corrispondere automaticamente i nomi dei campi ai nomi delle colonne. I nomi delle colonne sono sempre in minuscolo, quindi anche i nomi dei campi corrispondenti devono essere in minuscolo a meno che non si specifichi l'opzione `‘auto ignorecase’`. I nomi dei campi che non corrispondono al nome di una colonna vengono ignorati. L'ordine non ha importanza. Nell'esempio precedente COPY mappa i nomi delle colonne `id`, `guid`, `name` e `address`.
Con l'argomento predefinito `'auto'`, COPY fa corrispondere solo agli oggetti di primo livello alle colonne. Per eseguire la mappatura a livelli più profondi dello schema o se i nomi dei campi e i nomi delle colonne non corrispondono, utilizza un JSONPaths file per definire la mappatura. Per ulteriori informazioni, consulta [JSONPaths file](#copy-json-jsonpaths).
Se il valore associato a una chiave è un tipo di dati Avro complesso come byte, array, record, mappa o link, COPY carica il valore come stringa. Qui, la stringa è la rappresentazione JSON dei dati. COPY carica i tipi di dati enum Avro come stringhe, dove il contenuto è il nome del tipo. Per un esempio, consultare [COPY dal formato JSON](copy-usage_notes-copy-from-json.md).
La dimensione massima dell'intestazione del file Avro, che include lo schema e i metadati del file, è di 1 MB.
La dimensione massima di un singolo blocco dati Avro è di 4 MB. È diverso dalla dimensione massima della riga. Se si supera la dimensione massima di un singolo blocco dati Avro, anche se la dimensione della riga risultante è inferiore al limite di 4 MB, il comando COPY non viene eseguito.
Nel calcolo delle dimensioni delle righe, Amazon Redshift internamente conta due volte i caratteri pipe ( \$1 ). Se i dati immessi contengono un numero molto elevato di caratteri pipe, è possibile che la dimensione delle righe superi i 4 MB anche se il blocco di dati è inferiore a 4 MB.
JSON [AS] '*json\$1option*'
I dati sorgente sono in formato JSON.
Il formato JSON è supportato per COPY da questi servizi e protocolli:
+ Simple Storage Service (Amazon S3)
+ COPY da Amazon EMR
+ COPY da SSH
JSON non è supportato per COPY da DynamoDB.
I valori validi per *json\$1option* sono i seguenti:
+ `'auto'`
+ `'auto ignorecase'`
+ `'s3://jsonpaths_file'`
+ `'noshred'`
Il valore predefinito è `'auto'`. Amazon Redshift non divide gli attributi delle strutture JSON in più colonne durante il caricamento di un documento JSON.
Per impostazione predefinita, COPY tenta di far corrispondere tutte le colonne della tabella di destinazione alle chiavi dei nomi dei campi JSON. Per caricare un sottoinsieme delle colonne, è possibile specificare facoltativamente un elenco di colonne. Se le chiavi del nome del campo JSON non sono tutte in minuscolo, è possibile utilizzare l'opzione `'auto ignorecase'` o un [JSONPaths file](#copy-json-jsonpaths) per mappare esplicitamente i nomi delle colonne sulle chiavi dei nomi dei campi JSON.
Se una colonna nella tabella di destinazione viene omessa dall'elenco delle colonne, COPY carica l'espressione [DEFAULT](r_CREATE_TABLE_NEW.md#create-table-default) della colonna di destinazione. Se la colonna di destinazione non ha un valore di default, COPY prova a caricare NULL. Se una colonna è inclusa nell'elenco di colonne e COPY non trova un campo corrispondente nei dati JSON, COPY prova a caricare NULL nella colonna.
Se COPY tenta di assegnare NULL a una colonna definita come NOT NULL, il comando COPY non viene eseguito.
COPY mappa automaticamente gli elementi di dati nei dati di origine JSON alle colonne della tabella di destinazione. Lo fa associando *chiavi di oggetti*, o nomi, nelle coppie nome-valore di origine ai nomi delle colonne nella tabella di destinazione.
Fare riferimento ai seguenti dettagli su ogni valore *json\$1option*:
'auto'
Questa opzione fa distinzione tra lettere maiuscole e minuscole. I nomi delle colonne nelle tabelle Amazon Redshift sono sempre in minuscolo, quindi quando si utilizza l'opzione `'auto'`, anche i nomi dei campi JSON corrispondenti devono essere in minuscolo.
'auto ignorecase'
Con questa opzione, non si fa distinzione tra maiuscole e minuscole. I nomi delle colonne nelle tabelle Amazon Redshift sono sempre minuscoli. Pertanto, quando utilizzi l’opzione `'auto ignorecase'`, i nomi dei campi JSON corrispondenti possono essere minuscoli, maiuscoli o maiuscoli e minuscoli.
's3://*jsonpaths\$1file*'
Con questa opzione, COPY utilizza il JSONPaths file denominato per mappare gli elementi di dati nei dati di origine JSON alle colonne della tabella di destinazione. L'argomento *`s3://jsonpaths_file`* deve essere una chiave oggetto Amazon S3 che fa esplicito riferimento a un singolo file. Un esempio è `'s3://amzn-s3-demo-bucket/jsonpaths.txt`'. L'argomento non può essere un prefisso di chiave. Per ulteriori informazioni sull'utilizzo di un JSONPaths file, consulta[JSONPaths file](#copy-json-jsonpaths).
In alcuni casi, il file specificato da `jsonpaths_file` ha lo stesso prefisso del percorso specificato da `copy_from_s3_objectpath` per i file di dati. In tal caso, COPY legge il JSONPaths file come file di dati e restituisce errori. Ad esempio, supponiamo che i file di dati utilizzino il percorso dell'oggetto `s3://amzn-s3-demo-bucket/my_data.json` e che il JSONPaths file lo sia. `s3://amzn-s3-demo-bucket/my_data.jsonpaths` In questo caso, COPY prova a caricare `my_data.jsonpaths` come file di dati.
'noshred'
Con questa opzione, Amazon Redshift non divide gli attributi delle strutture JSON in più colonne durante il caricamento di un documento JSON.
## File di dati JSON
Il file di dati JSON contiene un insieme di oggetti o array. COPY carica ogni oggetto o array JSON in una riga della tabella di destinazione. Ogni oggetto o array corrispondente a una riga deve essere una struttura autonoma a livello di root, cioè non deve essere membro di un'altra struttura JSON.
Un *oggetto* JSON inizia e termina con delle parentesi ( \$1 \$1 ) e contiene un insieme non ordinato di coppie nome-valore. Ogni coppia nome e valore è separata da due punti e le coppie sono separate da virgole. Per impostazione predefinita, la *chiave oggetto*, o nome, nelle coppie nome-valore deve corrispondere al nome della colonna corrispondente nella tabella. I nomi delle colonne nelle tabelle Amazon Redshift sono sempre in minuscolo, quindi anche le chiavi dei nomi dei campi JSON corrispondenti devono essere in minuscolo. Se i nomi delle colonne e le chiavi JSON non corrispondono, utilizza un [JSONPaths file](#copy-json-jsonpaths) per mappare esplicitamente le colonne sulle chiavi.
L'ordine non ha importanza in un oggetto JSON. I nomi che non corrispondono al nome di una colonna vengono ignorati. Di seguito viene mostrata la struttura di un semplice oggetto JSON.
```
{
"column1": "value1",
"column2": value2,
"notacolumn" : "ignore this value"
}
```
Un *array* JSON inizia e termina con delle parentesi ( \$1 \$1 ) e contiene un insieme ordinato di valori separati da virgole. Se i file di dati utilizzano matrici, è necessario specificare un JSONPaths file per abbinare i valori alle colonne. Di seguito viene mostrata la struttura di un semplice array JSON.
```
["value1", value2]
```
Il JSON deve essere ben formato. Ad esempio, gli oggetti o gli array non possono essere separati da virgole o altri caratteri tranne lo spazio. Le stringhe devono essere racchiuse tra virgolette doppie. I caratteri virgolette devono essere virgolette semplici (0x22), non oblique o "intelligenti".
La dimensione massima di un singolo oggetto o array JSON, compresi parentesi graffe o quadre, è di 4 MB. È diverso dalla dimensione massima della riga. Se la dimensione massima di un singolo oggetto o array JSON viene superata, anche se la dimensione della riga risultante è inferiore al limite di 4 MB, il comando COPY non viene eseguito.
Nel calcolo delle dimensioni delle righe, Amazon Redshift internamente conta due volte i caratteri pipe ( \$1 ). Se i dati immessi contengono un numero molto elevato di caratteri pipe, è possibile che la dimensione delle righe superi i 4 MB anche se la dimensione dell'oggetto è inferiore a 4 MB.
COPY carica `\n` come carattere newline e carica `\t` come carattere di tabulazione. Per caricare una barra rovesciata, crea una sequenza di escape con una barra rovesciata ( `\\` ).
COPY cerca il sorgente JSON specificato per un oggetto o array JSON valido e ben strutturato. Se COPY rileva caratteri non vuoti prima di individuare una struttura JSON utilizzabile o tra oggetti o array JSON validi, COPY restituisce un errore per ogni istanza. Questi errori contano ai fini del conteggio MAXERROR. Quando il conteggio degli errori è uguale o superiore a MAXERROR, COPY fallisce.
Per ogni errore, Amazon Redshift registra una riga nella tabella di sistema STL\$1LOAD\$1ERRORS. La colonna LINE\$1NUMBER registra l'ultima riga dell'oggetto JSON che ha causato l'errore.
Se è specificato IGNOREHEADER, COPY ignora il numero di righe specificato nei dati JSON. I caratteri newline nei dati JSON sono sempre conteggiati per i calcoli IGNOREHEADER.
COPY carica le stringhe vuote come campi vuoti per impostazione predefinita. Se è specificato EMPTYASNULL, COPY carica le stringhe vuote per i campi CHAR e VARCHAR come NULL. Le stringhe vuote per altri tipi di dati, come ad esempio INT, vengono sempre caricate come NULL.
Con JSON non sono supportate le seguenti opzioni:
+ CSV
+ DELIMITER
+ ESCAPE
+ FILLRECORD
+ FIXEDWIDTH
+ IGNOREBLANKLINES
+ NULL AS
+ READRATIO
+ REMOVEQUOTES
Per ulteriori informazioni, consulta [COPY dal formato JSON](copy-usage_notes-copy-from-json.md). Per ulteriori informazioni sulle strutture dati JSON, visita il sito [http://www.json.org/](https://www.json.org/).
## JSONPaths file
Se si carica da dati di origine con formattazione JSON o Avro, per impostazione predefinita COPY mappa gli elementi di dati di primo livello nei dati di origine alle colonne della tabella di destinazione. Lo fa associando ogni nome, o chiave di oggetti, in una coppia nome-valore al nome di una colonna nella tabella di destinazione.
Se i nomi delle colonne e le chiavi degli oggetti non corrispondono o per eseguire il mapping a livelli più profondi nella gerarchia dei dati, puoi utilizzare un JSONPaths file per mappare in modo esplicito gli elementi di dati JSON o Avro alle colonne. Il JSONPaths file mappa gli elementi di dati JSON alle colonne facendo corrispondere l'ordine delle colonne nella tabella di destinazione o nell'elenco delle colonne.
Il JSONPaths file deve contenere solo un singolo oggetto JSON (non un array). L'oggetto JSON è una coppia nome-valore. La *chiave oggetto*, che è il nome nella coppia nome-valore, deve essere `"jsonpaths"`. *Il *valore* nella coppia nome-valore è una matrice di espressioni. JSONPath * Ogni JSONPath espressione fa riferimento a un singolo elemento nella gerarchia dei dati JSON o nello schema Avro, in modo analogo a come un' XPathespressione si riferisce agli elementi di un documento XML. Per ulteriori informazioni, consulta [JSONPath espressioni](#copy-json-jsonpath-expressions).
Per utilizzare un JSONPaths file, aggiungete la parola chiave JSON o AVRO al comando COPY. Specificate il nome del bucket S3 e il percorso dell'oggetto del JSONPaths file utilizzando il seguente formato.
```
COPY tablename
FROM 'data_source'
CREDENTIALS 'credentials-args'
FORMAT AS { AVRO | JSON } 's3://jsonpaths_file';
```
Il valore `s3://jsonpaths_file` deve essere una chiave oggetto di Amazon S3 che fa riferimento esplicitamente a singolo file, come `'s3://amzn-s3-demo-bucket/jsonpaths.txt'`. Non può essere un prefisso di chiave.
In alcuni casi, se il caricamento avviene da Amazon S3 il file specificato da `jsonpaths_file` ha lo stesso prefisso del percorso specificato da `copy_from_s3_objectpath` per i file di dati. In tal caso, COPY legge il JSONPaths file come file di dati e restituisce errori. Ad esempio, supponiamo che i file di dati utilizzino il percorso dell'oggetto `s3://amzn-s3-demo-bucket/my_data.json` e che il JSONPaths file lo sia. `s3://amzn-s3-demo-bucket/my_data.jsonpaths` In questo caso, COPY prova a caricare `my_data.jsonpaths` come file di dati.
Se il nome della chiave è una stringa diversa da `"jsonpaths"`, il comando COPY non restituisce un errore, ma ignora *jsonpaths\$1file* e usa invece l'argomento `'auto'`.
Se si verifica una delle seguenti situazioni, il comando COPY non va a buon fine:
+ Il JSON ha un formato errato.
+ C'è più di un oggetto JSON.
+ Tutti i caratteri tranne lo spazio esistono al di fuori dell'oggetto.
+ Un elemento array è una stringa vuota o non è una stringa.
MAXERROR non si applica al JSONPaths file.
Il JSONPaths file non deve essere crittografato, anche se l'[ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)opzione è specificata.
Per ulteriori informazioni, consulta [COPY dal formato JSON](copy-usage_notes-copy-from-json.md).
## JSONPath espressioni
Il JSONPaths file utilizza JSONPath espressioni per mappare i campi di dati alle colonne di destinazione. Ogni JSONPath espressione corrisponde a una colonna nella tabella di destinazione di Amazon Redshift. L'ordine degli elementi dell' JSONPath array deve corrispondere all'ordine delle colonne nella tabella di destinazione o nell'elenco delle colonne, se viene utilizzato un elenco di colonne.
I caratteri delle doppie virgolette sono richiesti come mostrato, sia per i nomi dei campi sia per i valori. I caratteri delle virgolette devono essere virgolette semplici (0x22), non oblique o "intelligenti".
Se un elemento dell'oggetto a cui fa riferimento un' JSONPath espressione non viene trovato nei dati JSON, COPY tenta di caricare un valore NULL. Se l'oggetto di riferimento ha un formato errato, COPY restituisce un errore di caricamento.
Se un elemento dell'array a cui fa riferimento un' JSONPath espressione non viene trovato nei dati JSON o Avro, COPY ha esito negativo e restituisce il seguente errore: `Invalid JSONPath format: Not an array or index out of range.` Rimuovi tutti gli elementi dell'array JSONPaths che non esistono nei dati di origine e verifica che gli array nei dati di origine siano ben formati.
Le JSONPath espressioni possono utilizzare la notazione tra parentesi o la notazione a punti, ma non è possibile combinare le notazioni. L'esempio seguente mostra le JSONPath espressioni che utilizzano la notazione tra parentesi.
```
{
"jsonpaths": [
"$['venuename']",
"$['venuecity']",
"$['venuestate']",
"$['venueseats']"
]
}
```
L'esempio seguente mostra le JSONPath espressioni che utilizzano la notazione a punti.
```
{
"jsonpaths": [
"$.venuename",
"$.venuecity",
"$.venuestate",
"$.venueseats"
]
}
```
Nel contesto della sintassi Amazon Redshift COPY, un' JSONPath espressione deve specificare il percorso esplicito di un singolo elemento del nome in una struttura dati gerarchica JSON o Avro. Amazon Redshift non supporta alcun JSONPath elemento, come caratteri jolly o espressioni di filtro, che potrebbe risolversi in un percorso ambiguo o in più elementi del nome.
Per ulteriori informazioni, consulta [COPY dal formato JSON](copy-usage_notes-copy-from-json.md).
## Utilizzo con Avro Data JSONPaths
L'esempio seguente mostra uno schema Avro con più livelli.
```
{
"name": "person",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "guid", "type": "string"},
{"name": "isActive", "type": "boolean"},
{"name": "age", "type": "int"},
{"name": "name", "type": "string"},
{"name": "address", "type": "string"},
{"name": "latitude", "type": "double"},
{"name": "longitude", "type": "double"},
{
"name": "tags",
"type": {
"type" : "array",
"name" : "inner_tags",
"items" : "string"
}
},
{
"name": "friends",
"type": {
"type" : "array",
"name" : "inner_friends",
"items" : {
"name" : "friends_record",
"type" : "record",
"fields" : [
{"name" : "id", "type" : "int"},
{"name" : "name", "type" : "string"}
]
}
}
},
{"name": "randomArrayItem", "type": "string"}
]
}
```
L'esempio seguente mostra un JSONPaths file che utilizza AvroPath espressioni per fare riferimento allo schema precedente.
```
{
"jsonpaths": [
"$.id",
"$.guid",
"$.address",
"$.friends[0].id"
]
}
```
L' JSONPaths esempio include i seguenti elementi:
jsonpath
Il nome dell'oggetto JSON che contiene le AvroPath espressioni.
[ … ]
Le parentesi racchiudono l'array JSON che contiene gli elementi del percorso.
\$1
Il segno del dollaro fa riferimento all'elemento root nello schema Avro, che è l'array `"fields"`.
"\$1.id",
La destinazione dell' AvroPath espressione. In questa istanza, la destinazione è l'elemento nell'array `"fields"` con il nome `"id"`. Le espressioni sono separate da virgole.
"\$1.friends[0].id"
Le parentesi indicano un indice di matrice. JSONPath le espressioni utilizzano l'indicizzazione a base zero, quindi questa espressione fa riferimento al primo elemento dell'array con il `"friends"` nome. `"id"`
La sintassi dello schema Avro richiede l'utilizzo di *campi interni* per definire la struttura dei tipi di dati record e array. I campi interni vengono ignorati dalle espressioni. AvroPath Per esempio, il campo `"friends"` definisce un array chiamato `"inner_friends"`, che a sua volta definisce un record chiamato `"friends_record"`. L' AvroPath espressione che fa riferimento al campo `"id"` può ignorare i campi aggiuntivi per fare riferimento direttamente al campo di destinazione. Le AvroPath espressioni seguenti fanno riferimento ai due campi che appartengono all'`"friends"`array.
```
"$.friends[0].id"
"$.friends[0].name"
```
## Parametri del formato dei dati a colonna
Oltre ai formati di dati standard, COPY supporta i seguenti formati di dati a colonna per COPY da Amazon S3: COPY dal formato a colonne è supportato con alcune restrizioni. Per ulteriori informazioni, consulta [COPY da formati di dati a colonna](copy-usage_notes-copy-from-columnar.md).
ORC
Carica i dati da un file che utilizza il formato di file ORC (Optimized Row Columnar).
PARQUET
Carica i dati da un file che utilizza il formato di file Parquet.
# Parametri di compressione dei file
È possibile caricare da file di dati compressi specificando i seguenti parametri. Parametri di compressione dei file
BZIP2
Un valore che specifica che il file o i file di input sono nel formato compresso bzip2 (file .bz2). L'operazione COPY legge ogni file compresso e decomprime i dati man mano che vengono caricati.
GZIP
Un valore che specifica che il file o i file di input sono nel formato compresso gzip (file .gz). L'operazione COPY legge ogni file compresso e decomprime i dati man mano che vengono caricati.
LZOP
Un valore che specifica che il file o i file di input sono nel formato compresso lzop (file .lzo). L'operazione COPY legge ogni file compresso e decomprime i dati man mano che vengono caricati.
COPY non supporta i file che vengono compressi usando l'opzione *--filter* di lzop.
ZSTD
Un valore che specifica che il file o i file di input sono nel formato compresso Zstandard (file .zst). L'operazione COPY legge ogni file compresso e decomprime i dati man mano che vengono caricati.
ZSTD è supportato solo con COPY da Amazon S3.
# Parametri di conversione dei dati
Mentre carica la tabella, COPY tenta di convertire in modo implicito le stringhe nei dati di origine nel tipo di dati della colonna di destinazione. Se hai necessità di specificare una conversione diversa dal comportamento predefinito o se la conversione predefinita dà luogo a errori, è possibile gestire le conversioni dei dati specificando i seguenti parametri. Per ulteriori informazioni sulla sintassi dei parametri, consulta [Sintassi di COPY](https://docs.aws.amazon.com/redshift/latest/dg/r_COPY.html#r_COPY-syntax).
+ [ACCEPTANYDATE](#copy-acceptanydate)
+ [ACCEPTINVCHARS](#copy-acceptinvchars)
+ [BLANKSASNULL](#copy-blanksasnull)
+ [DATEFORMAT](#copy-dateformat)
+ [EMPTYASNULL](#copy-emptyasnull)
+ [ENCODING](#copy-encoding)
+ [ESCAPE](#copy-escape)
+ [EXPLICIT_IDS](#copy-explicit-ids)
+ [FILLRECORD](#copy-fillrecord)
+ [IGNOREBLANKLINES](#copy-ignoreblanklines)
+ [IGNOREHEADER](#copy-ignoreheader)
+ [NULL AS](#copy-null-as)
+ [REMOVEQUOTES](#copy-removequotes)
+ [ROUNDEC](#copy-roundec)
+ [TIMEFORMAT](#copy-timeformat)
+ [TRIMBLANKS](#copy-trimblanks)
+ [TRUNCATECOLUMNS](#copy-truncatecolumns) Parametri di conversione dei dati
ACCEPTANYDATE
Consente il caricamento di qualsiasi formato di data, compresi i formati non validi come `00/00/00 00:00:00` senza generare un errore. Questo parametro è valido solo alle colonne TIMESTAMP e DATE. Utilizza sempre ACCEPTANYDATE con il parametro DATEFORMAT. Se il formato della data per i dati non corrisponde alla specifica DATEFORMAT, Amazon Redshift inserisce un valore NULL nel campo.
ACCEPTINVCHARS [AS] ['*replacement\$1char*']
Consente il caricamento di dati nelle colonne VARCHAR anche se i dati contengono caratteri UTF-8 non validi. Quando è specificato ACCEPTINVCHARS, COPY sostituisce ogni carattere UTF-8 non valido con una stringa di uguale lunghezza composta dal carattere specificato da *replacement\$1char*. Ad esempio, se il carattere sostitutivo è "`^`", un carattere a tre byte non valido verrà sostituito con "`^^^`".
Il carattere sostitutivo può essere qualsiasi carattere ASCII tranne NULL. Il valore predefinito è un punto interrogativo ( ? ). Per informazioni sui caratteri UTF-8 non validi, consultare [Errori di caricamento di caratteri multibyte](multi-byte-character-load-errors.md).
COPY restituisce il numero di righe che contenevano caratteri UTF-8 non validi e aggiunge una voce alla tabella di sistema [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) per ogni riga interessata, fino a un massimo di 100 righe per ogni porzione di nodo. Vengono sostituiti anche altri caratteri UTF-8 non validi, ma gli eventi di sostituzione non vengono registrati.
Se non è specificato ACCEPTINVCHARS, COPY restituisce un errore ogni volta che incontra un carattere UTF-8 non valido.
ACCEPTINVCHARS è valido solo per le colonne VARCHAR.
BLANKSASNULL
Carica come NULL i campi vuoti, composti solo da caratteri di spazio. Questa opzione è valide solo alle colonne CHAR e VARCHAR. I campi vuoti per altri tipi di dati, come ad esempio INT, vengono sempre caricati come NULL. Ad esempio, una stringa che contiene tre caratteri spazio in successione (e nessun altro carattere) viene caricata come NULL. Il comportamento predefinito, senza questa opzione, è di caricare i caratteri spazio così come sono.
DATEFORMAT [AS] \$1'*dateformat\$1string*' \$1 'auto' \$1
Se non è specificato nessun DATEFORMAT, il formato predefinito è `'YYYY-MM-DD'`. Ad esempio, un formato valido alternativo è `'MM-DD-YYYY'`.
Se il comando COPY non riconosce il formato dei valori di data e ora o se i valori di data e ora utilizzano formati diversi, utilizza l'argomento `'auto'` con il parametro DATEFORMAT o TIMEFORMAT. L'argomento `'auto'` riconosce diversi formati che non sono supportati quando si usa una stringa DATEFORMAT e TIMEFORMAT. La parola chiave `'auto'`' prevede una distinzione tra lettere maiuscole e minuscole. Per ulteriori informazioni, consulta [Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT](automatic-recognition.md).
Il formato della data può includere informazioni sull'ora (ore, minuti, secondi), ma tali informazioni vengono ignorate. La parola chiave AS è facoltativa. Per ulteriori informazioni, consulta [Stringhe DATEFORMAT e TIMEFORMATEsempio](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
EMPTYASNULL
Indica che Amazon Redshift dovrebbe caricare i campi vuoti CHAR e VARCHAR come NULL. I campi vuoti per altri tipi di dati, come ad esempio INT, vengono sempre caricati come NULL. I campi vuoti si hanno quando i dati contengono due delimitatori in successione senza caratteri tra i delimitatori. EMPTYASNULL e NULL AS '' (stringa vuota) producono lo stesso comportamento.
ENCODING [AS] *file\$1encoding*
Specifica il tipo di codifica dei dati di caricamento. Il comando COPY converte i dati dalla codifica specificata a UTF-8 durante il caricamento.
I valori validi per *file\$1encoding* sono i seguenti:
+ `UTF8`
+ `UTF16`
+ `UTF16LE`
+ `UTF16BE`
+ `ISO88591`
Il valore predefinito è `UTF8`.
I nomi dei file di origine devono utilizzare la codifica UTF-8.
I seguenti file devono utilizzare la codifica UTF-8, anche se per i dati di caricamento è specificata una codifica diversa:
+ File manifesto
+ JSONPaths file
Le stringhe di argomento con i seguenti parametri devono utilizzare UTF-8:
+ FIXEDWIDTH '*fixedwidth\$1spec*'
+ ACCEPTINVCHARS '*replacement\$1char*'
+ DATEFORMAT '*dateformat\$1string*'
+ TIMEFORMAT '*timeformat\$1string*'
+ NULL AS '*null\$1string*'
I file di dati a larghezza fissa devono utilizzare la codifica UTF-8. Le larghezze dei campi si basano sul numero di caratteri, non sul numero di byte.
Tutti i dati di caricamento devono utilizzare la codifica specificata. Se COPY incontra una codifica diversa, salta il file e restituisce un errore.
Se specifichi `UTF16`, i dati devono avere un BOM (byte order mark). Se sai se i dati UTF-16 sono little-endian (LE) o big-endian (BE), è possibile utilizzare `UTF16LE` o `UTF16BE` indipendentemente dalla presenza di un BOM.
Per utilizzare la codifica ISO-8859-1, specifica `ISO88591`. Per ulteriori informazioni, consulta [ISO/IEC 8859-1](https://en.wikipedia.org/wiki/ISO/IEC_8859-1) in *Wikipedia*.
ESCAPE
Quando si specifica questo parametro, il carattere di barra rovesciata (`\`) nei dati di input viene trattato come un carattere di escape. Il carattere che segue immediatamente il carattere di barra rovesciata viene caricato nella tabella come parte del valore corrente della colonna, anche se è un carattere che normalmente ha uno scopo particolare. Ad esempio, è possibile utilizzare questo parametro per creare una sequenza di escape con il carattere delimitatore, un punto interrogativo, un carattere newline incorporato o il carattere di escape stesso quando uno di questi caratteri è una parte lecita di un valore di colonna.
Se specifichi il parametro ESCAPE in combinazione con il parametro REMOVEQUOTES, è possibile creare una sequenza di escape e mantenere le virgolette (`'` o `"`) che altrimenti potrebbero essere rimosse. La stringa nulla predefinita, `\N`, funziona così com'è, ma è possibile anche creare una sequenza di escape nei dati di input come `\\N`. Finché non specifichi una stringa nulla alternativa con il parametro NULL AS, `\N` e `\\N` produrranno gli stessi risultati.
Non è possibile eseguire l'escape del carattere di controllo `0x00` (NUL) e questo carattere deve essere rimosso dai dati di input o convertito. Questo carattere viene trattato come un marcatore EOR (end of record), causando il troncamento del resto del record.
Non è possibile utilizzare il parametro ESCAPE per caricamenti FIXEDWIDTH e non è possibile specificare il carattere di escape stesso; il carattere di escape è sempre il carattere di barra rovesciata. Inoltre, devi assicurarti che i dati di input contengano il carattere di escape nei punti appropriati.
Di seguito sono riportati alcuni esempi di dati di input e i dati caricati risultanti quando viene specificato il parametro ESCAPE. Il risultato per la riga 4 presuppone che sia stato specificato anche il parametro REMOVEQUOTES. I dati di input sono costituiti da due campi delimitati da pipe:
```
1|The quick brown fox\[newline]
jumped over the lazy dog.
2| A\\B\\C
3| A \| B \| C
4| 'A Midsummer Night\'s Dream'
```
I dati caricati nella colonna 2 assomigliano a questi:
```
The quick brown fox
jumped over the lazy dog.
A\B\C
A|B|C
A Midsummer Night's Dream
```
L'applicazione del carattere di escape ai dati di input per un caricamento è responsabilità dell'utente. Un'eccezione a questo requisito è quando ricarichi dati che erano stati precedentemente scaricati con il parametro ESCAPE. In questo caso, i dati conterranno già i caratteri di escape necessari.
Il parametro ESCAPE non interpreta la notazione ottale, esadecimale, Unicode o altra sequenza di escape. Ad esempio, se i dati di origine contengono il valore di avanzamento della linea ottale (`\012`) e si prova a caricare questi dati con il parametro ESCAPE, Amazon Redshift carica il valore `012` nella tabella e non interpreta questo valore come un avanzamento di linea in una sequenza di escape.
Per inserire in una sequenza di escape i caratteri newline nei dati che provengono dalle piattaforme Microsoft Windows, potresti dover utilizzare due caratteri di escape: uno per il ritorno a capo e uno per l'avanzamento di linea. In alternativa, è possibile rimuovere il ritorno a capo prima di caricare il file (ad esempio, utilizzando l'utilità dos2unix).
EXPLICIT\$1IDS
Utilizza EXPLICIT\$1IDS con tabelle che hanno colonne IDENTITY se desideri sostituire i valori generati automaticamente con valori espliciti dai file di dati sorgente per le tabelle. Se il comando include un elenco di colonne, tale elenco deve includere le colonne IDENTITY per poter utilizzare questo parametro. Il formato dei dati per i valori di EXPLICIT\$1IDS deve corrispondere al formato IDENTITY specificato dalla definizione CREATE TABLE.
Quando esegui un comando COPY su una tabella con l'opzione EXPLICIT\$1IDS, Amazon Redshift non controlla più l'univocità delle colonne IDENTITY della tabella.
Se una colonna è definita con GENERATED BY DEFAULT AS IDENTITY, può esser copiata. i valori vengono generati o aggiornati con i valori forniti dall'utente. L'opzione EXPLICIT\$1IDS non è obbligatoria. COPY non aggiorna la filigrana ad elevata identità.
Per un esempio di comando COPY con EXPLICIT\$1IDS, consulta [Caricamento di VENUE con valori espliciti per una colonna IDENTITY](r_COPY_command_examples.md#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column).
FILLRECORD
Consente di caricare file di dati quando mancano colonne contigue alla fine di alcuni record. Le colonne mancanti vengono caricate come NULLs. Per i formati di testo e CSV, se la colonna mancante è una colonna VARCHAR, vengono caricate stringhe di lunghezza zero anziché. NULLs Per caricare colonne in VARCHAR NULLs da testo e CSV, specificate la parola chiave EMPTYASNULL. La sostituzione NULL funziona solo se la definizione della colonna lo consente. NULLs
Per esempio, se la definizione della tabella contiene quattro colonne CHAR che possono contenere dei null e un record contiene i valori `apple, orange, banana, mango`, il comando COPY può caricare e compilare un record che contiene solo i valori `apple, orange`. I valori CHAR mancanti saranno caricati come valori NULL.
IGNOREBLANKLINES
Ignora le righe vuote che contengono solo un avanzamento di linea in un file di dati e non tenta di caricarle.
IGNOREHEADER [ AS ] *number\$1rows*
Tratta il *number\$1rows* specificato come intestazione del file e non carica le righe. Usa IGNOREHEADER per saltare le intestazioni di tutti i file in un caricamento parallelo.
NULL AS '*null\$1string*'
Carica i campi che fanno corrispondere *null\$1string* a NULL, dove *null\$1string* può essere una stringa qualsiasi. Se i dati includono un terminatore null, chiamato anche NUL (UTF-8 0000) o zero binario (0x000), COPY lo tratta come qualsiasi altro carattere. Ad esempio, un record contenente '1' \$1\$1 NUL \$1\$1 '2' viene copiato come stringa di lunghezza da 3 byte. Se un campo contiene solo NUL, è possibile utilizzare NULL AS per sostituire il terminatore null con NULL specificando `'\0'` o `'\000'`, ad esempio `NULL AS '\0'` o `NULL AS '\000'`. Se un campo contiene una stringa che termina con NUL ed è specificato NULL AS, la stringa viene inserita con NUL alla fine. Non utilizzare '\$1n' (newline) per il valore *null\$1string*. Amazon Redshift riserva '\$1n' per l'utilizzo come delimitatore di linea. La *null\$1string* predefinita è `'\N`'.
Se tenti di caricare i nulli in una colonna definita come NON NULL, il comando COPY fallirà.
REMOVEQUOTES
Rimuove le virgolette intorno alle stringhe nei dati in entrata. Tutti i caratteri compresi tra le virgolette, inclusi i delimitatori, vengono mantenuti. Se una stringa ha una virgoletta iniziale singola o doppia ma non una virgoletta finale corrispondente, il comando COPY non carica quella riga e restituisce un errore. La seguente tabella mostra alcuni semplici esempi di stringhe che contengono virgolette e i valori caricati risultanti.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/copy-parameters-data-conversion.html)
ROUNDEC
Arrotonda i valori numerici quando la scala del valore di input è maggiore della scala della colonna. Per impostazione predefinita, COPY tronca i valori quando necessario per adattarli alla scala della colonna. Per esempio, se un valore di `20.259` viene caricato in una colonna DECIMAL(8,2), COPY tronca il valore a `20.25` per impostazione predefinita. Se è specificato ROUNDEC, COPY arrotonda il valore a `20.26`. Il comando INSERT arrotonda sempre i valori quando necessario per farli corrispondere alla scala della colonna, quindi un comando COPY con il parametro ROUNDEC si comporta come un comando INSERT.
TIMEFORMAT [AS] \$1'*timeformat\$1string*' \$1 'auto' \$1 'epochsecs' \$1 'epochmillisecs' \$1
Specifica il formato dell'ora. Se non è specificato alcun TIMEFORMAT, il formato predefinito è `YYYY-MM-DD HH:MI:SS` per le colonne TIMESTAMP o `YYYY-MM-DD HH:MI:SSOF` per le colonne TIMESTAMPTZ, dove `OF` è l'offset rispetto all'UTC (Tempo coordinato universale). Non è possibile includere uno specificatore di fuso orario in *timeformat\$1string*. Per caricare i dati TIMESTAMPTZ in un formato diverso da quello predefinito, specificare "auto"; per maggiori informazioni, consultare [Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT](automatic-recognition.md). Per maggiori informazioni su *timeformat\$1string*, consultare [Stringhe DATEFORMAT e TIMEFORMATEsempio](r_DATEFORMAT_and_TIMEFORMAT_strings.md).
L'argomento `'auto'` riconosce diversi formati che non sono supportati quando si usa una stringa DATEFORMAT e TIMEFORMAT. Se il comando COPY non riconosce il formato dei valori di data e ora o se i valori di data e ora utilizzano formati diversi uno dall'altro, utilizza l'argomento `'auto'` con il parametro DATEFORMAT o TIMEFORMAT. Per ulteriori informazioni, consulta [Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT](automatic-recognition.md).
Se i dati sorgente sono rappresentati come tempo dell'epoca, cioè il numero di secondi o millisecondi dal 1° gennaio 1970, 00:00:00 UTC, specifica `'epochsecs'` o `'epochmillisecs'`.
Le parole chiave `'auto'`, `'epochsecs'` e `'epochmillisecs'` prevedono una distinzione tra lettere maiuscole e minuscole.
La parola chiave AS è facoltativa.
TRIMBLANKS
Rimuove i caratteri di spazio finale da una stringa VARCHAR. Questo parametro è valido solo per le colonne con un tipo di dati VARCHAR.
TRUNCATECOLUMNS
Tronca i dati nelle colonne al numero appropriato di caratteri in modo che corrispondano alle specifiche della colonna. Si applica solo alle colonne con un tipo di dati VARCHAR o CHAR e alle righe di dimensioni fino a 4 MB.
# Operazioni di caricamento dati
Gestisce il comportamento predefinito dell'operazione di caricamento per la risoluzione dei problemi o per ridurre i tempi di caricamento specificando i seguenti parametri.
+ [COMPROWS](#copy-comprows)
+ [COMPUPDATE](#copy-compupdate)
+ [IGNOREALLERRORS](#copy-ignoreallerrors)
+ [MAXERROR](#copy-maxerror)
+ [NOLOAD](#copy-noload)
+ [STATUPDATE](#copy-statupdate) Parameters
COMPROWS *numrows*
Specifica il numero di righe da utilizzare come dimensione del campione per l'analisi della compressione. L'analisi viene eseguita su righe da ciascuna sezione di dati. Ad esempio, se specifichi `COMPROWS 1000000` (1,000,000) e il sistema contiene quattro sezioni totali, vengono lette e analizzate non più di 250.000 righe per ogni sezione.
Se COMPROWS non è specificato, la dimensione del campione è impostata su 100.000 per ogni sezione. I valori di COMPROWS inferiori al valore predefinito di 100.000 righe per ogni sezione vengono automaticamente aggiornati al valore predefinito. Tuttavia, la compressione automatica non verrà eseguita se la quantità di dati caricati è insufficiente per produrre un campione significativo.
Se il numero di COMPROWS è maggiore del numero di righe del file di input, il comando COPY continua ad eseguire l'analisi di compressione su tutte le righe disponibili. L'intervallo accettato per questo argomento è un numero compreso tra 1000 e 2147483647 (2.147.483.647).
COMPUPDATE [ PRESET \$1 \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Controlla se le codifiche di compressione vengono applicate automaticamente durante un COPY.
Quando COMPUPDATE è PRESET, il comando COPY sceglie la codifica di compressione per ogni colonna se la tabella di destinazione è vuota; anche se le colonne hanno già codifiche diverse da RAW. Le codifiche di colonna specificate attualmente possono essere sostituite. La codifica per ogni colonna si basa sul tipo di dati della colonna. Nessun dato viene campionato. Amazon Redshift assegna automaticamente la codifica della compressione come segue:
+ Le colonne definite come chiavi di ordinamento vengono assegnate alla compressione RAW.
+ Le colonne definite come tipi di dati BOOLEAN, REAL o DOUBLE PRECISION vengono assegnate alla compressione RAW.
+ Alle colonne definite come SMALLINT, INTEGER, BIGINT, DECIMAL, DATE, TIMESTAMP o TIMESTAMPTZ viene assegnata la compressione. AZ64
+ Le colonne definite come CHAR o VARCHAR sono assegnate alla compressione LZO.
Quando COMPUPDATE viene omesso, il comando COPY sceglie la codifica di compressione per ciascuna colonna solo se la tabella di destinazione è vuota e non è stata specificata una codifica (diversa da RAW) per nessuna colonna. La codifica per ciascuna colonna è determinata da Amazon Redshift. Nessun dato viene campionato.
Quando COMPUPDATE è impostato su ON (o TRUE) o COMPUPDATE viene specificato senza un'opzione, il comando COPY applica la compressione automatica se la tabella è vuota, anche se le colonne della tabella possiedono già codifiche diverse da RAW. Le codifiche di colonna specificate attualmente possono essere sostituite. La codifica di ciascuna colonna è basata su un'analisi dei dati campione. Per ulteriori informazioni, consulta [Caricamento di tabelle con compressione automatica](c_Loading_tables_auto_compress.md).
Con COMPUPDATE è impostato su OFF (o FALSE), la compressione automatica è disabilitata. Le codifiche di colonna non vengono modificate.
Per informazioni sulla tabella di sistema per analizzare la compressione, consultare [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md).
IGNOREALLERRORS
Puoi specificare questa opzione per ignorare tutti gli errori che si verificano durante l'operazione di caricamento.
Non è possibile specificare l'opzione IGNOREALLERRORS se si specifica l'opzione MAXERROR. Non è possibile specificare l'opzione IGNOREALLERRORS per i formati in colonna tra cui ORC e Parquet.
MAXERROR [AS] *error\$1count*
Se il caricamento restituisce il *error\$1count* numero di errori o superiore, il caricamento fallisce. Se il caricamento restituisce meno errori, continua e restituisce un messaggio INFO che indica il numero di righe che non è stato possibile caricare. Utilizza questo parametro per permettere la prosecuzione del caricamento quando alcune righe non vengono caricate nella tabella a causa di errori di formattazione o altre incongruenze nei dati.
Imposta questo valore su `0` o `1` se desideri che il caricamento fallisca non appena si verifica il primo errore. La parola chiave AS è facoltativa. Il valore predefinito per MAXERROR è `0` e il limite è `100000`.
Il numero effettivo di errori segnalati potrebbe essere maggiore del MAXERROR specificato a causa della natura parallela di Amazon Redshift. Se un nodo qualsiasi nel cluster Amazon Redshift rileva che MAXERROR è stato superato, ogni nodo riporta tutti gli errori incontrati.
NOLOAD
Controlla la validità del file di dati senza caricare effettivamente i dati. Utilizza il parametro NOLOAD per assicurarti che il file di dati venga caricato senza errori prima di eseguire il caricamento effettivo dei dati. Eseguire COPY con il parametro NOLOAD è molto più veloce che caricare i dati, perché analizza solo i file.
STATUPDATE [ \$1 ON \$1 TRUE \$1 \$1 \$1 OFF \$1 FALSE \$1 ]
Regola il calcolo automatico e l'aggiornamento delle statistiche dell'ottimizzatore al termine di un comando COPY che ha avuto successo. Per impostazione predefinita, se il parametro STATUPDATE non viene utilizzato, le statistiche vengono aggiornate automaticamente se la tabella è inizialmente vuota.
Ogni volta che l'inserimento di dati in una tabella non vuota modifica significativamente le dimensioni della tabella, consigliamo di aggiornare le statistiche eseguendo un comando [ANALYZE](r_ANALYZE.md) o utilizzando l'argomento STATUPDATE ON.
Con STATUPDATE ON (o TRUE), le statistiche vengono aggiornate automaticamente indipendentemente dal fatto che la tabella sia inizialmente vuota. Se si utilizza STATUPDATE, l'utente corrente deve essere il proprietario della tabella o un utente con privilegi avanzati. Se STATUPDATE non è specificato, è richiesta solo l'autorizzazione di INSERT.
Con STATUPDATE OFF (o FALSE), le statistiche non vengono mai aggiornate.
Per ulteriori informazioni, consultare [Analisi delle tabelle](t_Analyzing_tables.md).
# Elenco alfabetico dei parametri
Il seguente elenco fornisce i collegamenti a ogni descrizione del parametro del comando COPY, in ordine alfabetico.
+ [ACCEPTANYDATE](copy-parameters-data-conversion.md#copy-acceptanydate)
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars)
+ [ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id-access)
+ [AVRO](copy-parameters-data-format.md#copy-avro)
+ [BLANKSASNULL](copy-parameters-data-conversion.md#copy-blanksasnull)
+ [BZIP2](copy-parameters-file-compression.md#copy-bzip2)
+ [COMPROWS](copy-parameters-data-load.md#copy-comprows)
+ [COMPUPDATE](copy-parameters-data-load.md#copy-compupdate)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials-cred)
+ [CSV](copy-parameters-data-format.md#copy-csv)
+ [DATEFORMAT](copy-parameters-data-conversion.md#copy-dateformat)
+ [DELIMITER](copy-parameters-data-format.md#copy-delimiter)
+ [EMPTYASNULL](copy-parameters-data-conversion.md#copy-emptyasnull)
+ [ENCODING](copy-parameters-data-conversion.md#copy-encoding)
+ [ENCRYPTED](copy-parameters-data-source-s3.md#copy-encrypted)
+ [ESCAPE](copy-parameters-data-conversion.md#copy-escape)
+ [EXPLICIT_IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth)
+ [FORMAT](copy-parameters-data-format.md#copy-format)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [GZIP](copy-parameters-file-compression.md#copy-gzip)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role-iam)
+ [IGNOREALLERRORS](copy-parameters-data-load.md#copy-ignoreallerrors)
+ [IGNOREBLANKLINES](copy-parameters-data-conversion.md#copy-ignoreblanklines)
+ [IGNOREHEADER](copy-parameters-data-conversion.md#copy-ignoreheader)
+ [JSON format for COPY](copy-parameters-data-format.md#copy-json)
+ [LZOP](copy-parameters-file-compression.md#copy-lzop)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [MASTER_SYMMETRIC_KEY](copy-parameters-data-source-s3.md#copy-master-symmetric-key)
+ [MAXERROR](copy-parameters-data-load.md#copy-maxerror)
+ [NOLOAD](copy-parameters-data-load.md#copy-noload)
+ [NULL AS](copy-parameters-data-conversion.md#copy-null-as)
+ [READRATIO](copy-parameters-data-source-dynamodb.md#copy-readratio)
+ [REGION](copy-parameters-data-source-s3.md#copy-region)
+ [REMOVEQUOTES](copy-parameters-data-conversion.md#copy-removequotes)
+ [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec)
+ [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token)
+ [SHAPEFILE](copy-parameters-data-format.md#copy-shapefile)
+ [SSH](copy-parameters-data-source-ssh.md#copy-ssh)
+ [STATUPDATE](copy-parameters-data-load.md#copy-statupdate)
+ [TIMEFORMAT](copy-parameters-data-conversion.md#copy-timeformat)
+ [TRIMBLANKS](copy-parameters-data-conversion.md#copy-trimblanks)
+ [TRUNCATECOLUMNS](copy-parameters-data-conversion.md#copy-truncatecolumns)
+ [ZSTD](copy-parameters-file-compression.md#copy-zstd)
# Note per l'utilizzo
**Topics**
+ [AWS Autorizzazioni per accedere ad altre risorse](copy-usage_notes-access-permissions.md)
+ [Utilizzo di COPY con gli alias degli Access Point Amazon S3](copy-usage_notes-s3-access-point-alias.md)
+ [Caricamento di dati multibyte da Amazon S3](copy-usage_notes-multi-byte.md)
+ [Caricamento di una colonna definita come tipo dati GEOMETRY o GEOGRAPHY](copy-usage_notes-spatial-data.md)
+ [Caricamento del tipo di dati HLLSKETCH](copy-usage_notes-hll.md)
+ [Caricamento di una colonna definita come tipo dati VARBYTE](copy-usage-varbyte.md)
+ [Errori durante la lettura di più file](copy-usage_notes-multiple-files.md)
+ [COPY dal formato JSON](copy-usage_notes-copy-from-json.md)
+ [COPY da formati di dati a colonna](copy-usage_notes-copy-from-columnar.md)
+ [Stringhe DATEFORMAT e TIMEFORMAT](r_DATEFORMAT_and_TIMEFORMAT_strings.md)
+ [Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT](automatic-recognition.md)
# AWS Autorizzazioni per accedere ad altre risorse
Per spostare dati tra il cluster e un'altra AWS risorsa, come Amazon S3, Amazon DynamoDB, Amazon EMR o Amazon EC2, il cluster deve disporre dell'autorizzazione per accedere alla risorsa ed eseguire le azioni necessarie. Ad esempio, per caricare i dati da Amazon S3, COPY deve avere accesso LIST al bucket e accesso GET per gli oggetti del bucket. Per maggiori informazioni sulle autorizzazioni minime, consultare [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](#copy-usage_notes-iam-permissions).
Per ottenere l'autorizzazione per accedere alla risorsa, il cluster deve essere autenticato. È possibile scegliere uno dei seguenti metodi di autenticazione:
+ [Controllo degli accessi basato sui ruoli](#copy-usage_notes-access-role-based)— Per il controllo degli accessi basato sui ruoli, è necessario specificare un ruolo AWS Identity and Access Management (IAM) utilizzato dal cluster per l'autenticazione e l'autorizzazione. Per proteggere AWS le credenziali e i dati sensibili, consigliamo vivamente di utilizzare l'autenticazione basata sui ruoli.
+ [Controllo degli accessi basato su chiave](#copy-usage_notes-access-key-based)— Per il controllo degli accessi basato su chiavi, fornisci le credenziali di AWS accesso (ID della chiave di accesso e chiave di accesso segreta) per un utente come testo semplice.
## Controllo degli accessi basato sui ruoli
Con il controllo degli accessi basato su ruoli, il cluster assume in modo temporaneo e automatico un ruolo (IAM). Quindi, in base alle autorizzazioni concesse al ruolo, il cluster può accedere alle risorse AWS necessarie.
La creazione di un *ruolo* IAM è simile all'assegnazione delle autorizzazioni a un utente, in quanto è un'identità AWS con policy di autorizzazioni che determinano ciò che l'identità può e non può fare in AWS. Tuttavia, invece di essere associato univocamente a un utente, un ruolo può essere assunto da qualsiasi entità che ne abbia bisogno. Inoltre, a un ruolo non sono associate credenziali (password o chiavi di accesso). Al contrario, se un ruolo è associato a un cluster, le chiavi di accesso vengono create dinamicamente e fornite al cluster.
Ti consigliamo di utilizzare il controllo degli accessi basato sui ruoli perché offre un controllo più sicuro e dettagliato dell'accesso alle AWS risorse e ai dati sensibili degli utenti, oltre a salvaguardare le credenziali. AWS
L'autenticazione basata sui ruoli offre i seguenti vantaggi:
+ Puoi utilizzare strumenti IAM AWS standard per definire un ruolo IAM e associarlo a più cluster. Quando modifichi la policy di accesso a un ruolo, le modifiche vengono applicate automaticamente a tutti i cluster che utilizzano il ruolo.
+ Puoi definire policy IAM granulari che concedono autorizzazioni a cluster e utenti del database specifici per accedere a risorse e azioni specifiche. AWS
+ Il cluster ottiene le credenziali di sessione temporanee al momento dell'esecuzione e le aggiorna come necessario fino al completamento dell'operazione. Se utilizzi credenziali temporanee basate su chiavi, l'operazione fallisce se le credenziali temporanee scadono prima del completamento.
+ L'ID chiave di accesso e l'ID chiave di accesso segreta non vengono memorizzati o trasmessi nel codice SQL.
Per utilizzare il controllo degli accessi basato su ruoli, è necessario creare prima un ruolo IAM utilizzando il tipo di ruolo di servizio Amazon Redshift, quindi collegare il ruolo al cluster. Il ruolo deve avere, come minimo, le autorizzazioni elencate in [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](#copy-usage_notes-iam-permissions). Per i passaggi per creare un ruolo IAM e collegarlo al cluster, consulta la sezione [Autorizzazione di Amazon Redshift ad accedere ad AWS altri servizi per conto dell'utente](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) nella *Amazon Redshift* Management Guide.
È possibile aggiungere un ruolo a un cluster o visualizzare i ruoli associati a un cluster utilizzando la Console di gestione, la CLI o l'API di Amazon Redshift. Per ulteriori informazioni, consulta [Associazione di un ruolo IAM a un cluster](https://docs.aws.amazon.com/redshift/latest/mgmt/copy-unload-iam-role.html) nella *Guida alla gestione di Amazon Redshift*.
Quando crei un ruolo IAM, IAM restituisce un Amazon Resource Name (ARN) per il ruolo. Per specificare un ruolo IAM, fornisci al ruolo ARN il parametro [Utilizzo del parametro IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role) o il parametro [Utilizzo del parametro CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
Ad esempio, supponiamo che al cluster sia collegato il seguente ruolo.
```
"IamRoleArn": "arn:aws:iam::0123456789012:role/MyRedshiftRole"
```
Il seguente esempio di comando COPY utilizza il parametro IAM\$1ROLE con l'ARN dell'esempio precedente per l'autenticazione e l'accesso a Amazon S3.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Il seguente esempio di comando COPY utilizza il parametro CREDENTIALS per specificare il ruolo IAM.
```
copy customer from 's3://amzn-s3-demo-bucket/mydata'
credentials
'aws_iam_role=arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Inoltre, un utente con privilegi avanzati può concedere il privilegio ASSUMEROLE a utenti e gruppi di database per fornire l'accesso a un ruolo per le operazioni COPY. Per informazioni, consulta [GRANT](r_GRANT.md).
## Controllo degli accessi basato su chiave
Con il controllo degli accessi basato su chiavi, fornisci l'ID della chiave di accesso e la chiave di accesso segreta per un utente IAM autorizzato ad accedere alle AWS risorse che contengono i dati. Puoi utilizzare i parametri [Utilizzo dei parametri ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) insieme o il parametro [Utilizzo del parametro CREDENTIALS](copy-parameters-authorization.md#copy-credentials).
**Nota**
Consigliamo vivamente di utilizzare un ruolo IAM per l'autenticazione invece di fornire un ID chiave di accesso in chiaro e una chiave di accesso segreta. Se scegli il controllo degli accessi basato su chiavi, non utilizzare mai le credenziali del tuo AWS account (root). Creare sempre un utente IAM e fornire l'ID della chiave di accesso e la chiave di accesso segreta di quell'utente. Per la procedura per creare un utente IAM, consultare [Creazione di un utente IAM nell'account AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html).
Per eseguire l'autenticazione utilizzando ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY, sostituisci e ** con l'ID della chiave di accesso di un utente autorizzato ** e una chiave di accesso segreta completa, come illustrato di seguito.
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY '';
```
Per eseguire l'autenticazione utilizzando il parametro CREDENTIALS, sostituite ** e ** con l'ID della chiave di accesso di un utente autorizzato e una chiave di accesso segreta completa, come illustrato di seguito.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=';
```
L'utente IAM deve disporre, come minimo, delle autorizzazioni elencate in [Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY](#copy-usage_notes-iam-permissions).
### Credenziali di sicurezza temporanee
Se utilizzi il controllo degli accessi basato su chiave, è possibile limitare ulteriormente l'accesso ai dati degli utenti utilizzando le credenziali di sicurezza temporanee. L'autenticazione basata su ruoli utilizza automaticamente credenziali temporanee.
**Nota**
Consigliamo vivamente di utilizzare [role-based access control](#copy-usage_notes-access-role-based.phrase) invece di creare credenziali temporanee e fornire ID chiave di accesso e chiave di accesso segreta come testo in chiaro. Il controllo degli accessi basato sui ruoli utilizza automaticamente le credenziali temporanee.
Le credenziali di sicurezza temporanee offrono maggiore sicurezza perché hanno una durata breve e non possono essere riutilizzate dopo la loro scadenza. L'ID chiave di accesso e la chiave di accesso segreta generate con il token non possono essere utilizzate senza il token e un utente che ha queste credenziali di sicurezza temporanee può accedere alle risorse solo fino a quando le credenziali non scadono.
Per concedere agli utenti l'accesso temporaneo alle tue risorse, chiami le operazioni API AWS Security Token Service (AWS STS). Le operazioni AWS STS API restituiscono credenziali di sicurezza temporanee costituite da un token di sicurezza, un ID della chiave di accesso e una chiave di accesso segreta. Rilascia le credenziali di sicurezza temporanee agli utenti che necessitano di un accesso temporaneo alle risorse. Questi utenti possono essere utenti IAM esistenti o utenti non AWS . Per ulteriori informazioni sulla creazione delle credenziali di sicurezza temporanee, consultare [Utilizzo delle credenziali di sicurezza temporanee](https://docs.aws.amazon.com/STS/latest/UsingSTS/Welcome.html) nella Guida per l'utente di IAM.
È possibile utilizzare sia i parametri [Utilizzo dei parametri ACCESS\$1KEY\$1ID e SECRET\$1ACCESS\$1KEY](copy-parameters-authorization.md#copy-access-key-id) insieme con il parametro [SESSION\$1TOKEN](copy-parameters-authorization.md#copy-token) o il parametro [Utilizzo del parametro CREDENTIALS](copy-parameters-authorization.md#copy-credentials). È inoltre necessario fornire l'ID chiave di accesso e la chiave di accesso segreta forniti con il token.
Per eseguire l'autenticazione utilizzando ACCESS\$1KEY\$1ID, SECRET\$1ACCESS\$1KEY e SESSION\$1TOKEN, sostituisci e come mostrato di seguito. ** ** **
```
ACCESS_KEY_ID ''
SECRET_ACCESS_KEY ''
SESSION_TOKEN '';
```
Per autenticarti utilizzando CREDENTIALS, includi `session_token=` nella stringa delle credenziali come mostrato di seguito.
```
CREDENTIALS
'aws_access_key_id=;aws_secret_access_key=;session_token=';
```
L'esempio seguente mostra un comando COPY con credenziali di sicurezza temporanee.
```
copy table-name
from 's3://objectpath'
access_key_id ''
secret_access_key ''
session_token '';
```
L'esempio seguente carica la tabella LISTING con credenziali temporanee e crittografia dei file.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
access_key_id ''
secret_access_key ''
session_token ''
master_symmetric_key ''
encrypted;
```
L'esempio seguente carica la tabella LISTING utilizzando il parametro CREDENTIALS con credenziali temporanee e crittografia dei file.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
credentials
'aws_access_key_id=;aws_secret_access_key=;session_token=;master_symmetric_key='
encrypted;
```
**Importante**
Le credenziali di sicurezza temporanee devono essere valide per l'intera durata dell'operazione COPY o UNLOAD. Se le credenziali di sicurezza temporanee scadono durante l'operazione, il comando fallisce e la transazione viene annullata. Ad esempio, se le credenziali di sicurezza temporanee scadono dopo 15 minuti e l'operazione COPY richiede un'ora, l'operazione COPY fallisce prima del completamento. Se utilizzi l'accesso basato su ruoli, le credenziali di sicurezza temporanee vengono aggiornate automaticamente fino al completamento dell'operazione.
## Autorizzazioni IAM per COPY, UNLOAD e CREATE LIBRARY
L'utente o il ruolo IAM a cui fa riferimento il parametro CREDENTIALS deve avere, come minimo, le seguenti autorizzazioni:
+ Per COPY da Amazon S3, l'autorizzazione per il LIST del bucket Amazon S3 e il GET degli oggetti Amazon S3 che vengono caricati e il file manifest, se viene utilizzato.
+ Per la COPIA da Amazon S3, Amazon EMR e host remoti (SSH) con dati in formato JSON, autorizzazione a ELENCARE e OTTENERE il file su JSONPaths Amazon S3, se ne viene utilizzato uno.
+ Per COPY da DynamoDB, l'autorizzazione a SCAN e DESCRIBE sulla tabella DynamoDB che viene caricata.
+ Per COPY da un cluster Amazon EMR, l'autorizzazione per l'operazione `ListInstances` sul cluster Amazon EMR.
+ Per UNLOAD su Amazon S3, le autorizzazioni GET, LIST e PUT per il bucket Amazon S3 in cui i file di dati vengono scaricati.
+ Per CREATE LIBRARY da Amazon S3, l'autorizzazione per il LIST del bucket Amazon S3 e il GET degli oggetti Amazon S3 importati.
**Nota**
Se si riceve il messaggio di errore `S3ServiceException: Access Denied`, quando si esegue un comando COPY, UNLOAD o CREATE LIBRARY, il cluster non ha le autorizzazioni di accesso appropriate per Amazon S3.
È possibile gestire le autorizzazioni IAM assegnando una policy IAM a un ruolo IAM collegato al cluster, all'utente o al gruppo a cui appartiene l'utente. Ad esempio, la policy gestita da `AmazonS3ReadOnlyAccess` concede le autorizzazioni LIST e GET alle risorse Amazon S3. Per ulteriori informazioni sulle policy IAM, consultare [Utilizzo delle policy IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html) nella *Guida per l'utente di IAM*.
# Utilizzo di COPY con gli alias degli Access Point Amazon S3
Utilizzo di COPY con gli alias degli Access Point Amazon S3 Per ulteriori informazioni, consulta [Utilizzo di un alias in stile bucket per il punto di accesso](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points-alias.html) nella *Guida utente di Amazon Simple Storage Service*.
# Caricamento di dati multibyte da Amazon S3
Se i dati includono caratteri multibyte non ASCII (ad esempio caratteri cinesi o cirillici), è necessario caricare i dati nelle colonne VARCHAR. Il tipo di dati VARCHAR supporta caratteri UTF-8 a quattro byte, ma il tipo di dati CHAR accetta solo caratteri ASCII a byte singolo. Non è possibile caricare caratteri a cinque byte o più lunghi nelle tabelle Amazon Redshift. Per ulteriori informazioni, consulta [Caratteri multibyte](c_Supported_data_types.md#c_Supported_data_types-multi-byte-characters).
# Caricamento di una colonna definita come tipo dati GEOMETRY o GEOGRAPHY
È possibile eseguire COPY su colonne `GEOMETRY` o `GEOGRAPHY` dai dati in un file di testo delimitato da caratteri, ad esempio un file CSV. I dati devono essere nella forma esadecimale del noto formato binario (WKB o EWKB) o del noto formato di testo (WKT o EWKT) e rientrare nella dimensione massima di una singola riga di ingresso al comando COPY. Per ulteriori informazioni, consulta [COPY](r_COPY.md).
Per informazioni su come caricare da uno shapefile, consulta.[Caricamento di uno shapefile in Amazon Redshift](spatial-copy-shapefile.md).
Per ulteriori informazioni sui tipi di dati `GEOMETRY` o `GEOGRAPHY`, consultare [Query su dati spaziali in Amazon Redshift](geospatial-overview.md).
# Caricamento del tipo di dati HLLSKETCH
È possibile copiare gli schizzi HLL solo nel formato sparso o denso supportato da Amazon Redshift. Per utilizzare il comando COPY sugli HyperLogLog schizzi, usa il formato Base64 per schizzi densi e il formato JSON per schizzi sparsi. HyperLogLog HyperLogLog Per ulteriori informazioni, consulta [HyperLogLog funzioni](hyperloglog-functions.md).
Nell'esempio seguente vengono importati dati da un file CSV in una tabella utilizzando CREATE TABLE e COPY. Innanzitutto, l'esempio crea la tabella `t1` utilizzando CREATE TABLE.
```
CREATE TABLE t1 (sketch hllsketch, a bigint);
```
Quindi utilizza COPY per importare i dati da un file CSV nella tabella `t1`.
```
COPY t1 FROM s3://amzn-s3-demo-bucket/unload/' IAM_ROLE 'arn:aws:iam::0123456789012:role/MyRedshiftRole' NULL AS 'null' CSV;
```
# Caricamento di una colonna definita come tipo dati VARBYTE
È possibile caricare dati da un file in formato CSV, Parquet e ORC. Se si sceglie il formato CSV, i dati vengono caricati da un file nella rappresentazione esadecimale dei dati VARBYTE. Non è possibile caricare i dati VARBYTE con l'opzione `FIXEDWIDTH`. Le opzioni `ADDQUOTES` o `REMOVEQUOTES` di COPY non sono supportate. Una colonna VARBYTE non può essere utilizzata come colonna di partizione.
# Errori durante la lettura di più file
Il comando COPY è atomico e transazionale. In altre parole, anche quando il comando COPY legge i dati da più file, l'intero processo viene trattato come una singola transazione. Se COPY rileva un errore nella lettura di un file, riprova automaticamente fino a quando il processo scade (vedere [statement\$1timeout](r_statement_timeout.md)) o se i dati non possono essere scaricati da Amazon S3 per un periodo di tempo prolungato (tra 15 e 30 minuti), assicurandosi che ogni file venga caricato una sola volta. Se il comando COPY fallisce, l'intera transazione viene interrotta e tutte le modifiche vengono annullate. Per ulteriori informazioni sulla gestione degli errori di caricamento, vedi [Risoluzione di problemi di caricamento dei dati](t_Troubleshooting_load_errors.md).
Una volta avviato un comando COPY con successo, non fallisce se la sessione termina, ad esempio quando il client si disconnette. Tuttavia, se il comando COPY si trova all'interno di un blocco di transazioni BEGIN … END che non viene completato perché la sessione termina, l'intera transazione, compreso il comando COPY, viene annullata. Per ulteriori informazioni sulle transazioni, consultare [BEGIN](r_BEGIN.md).
# COPY dal formato JSON
La struttura dei dati JSON è costituita da una serie di oggetti o array. Un *oggetto* JSON inizia e termina con delle parentesi e contiene un insieme non ordinato di coppie nome-valore. Ogni nome e valore sono separati da due punti e le coppie sono separate da virgole. Il nome è una stringa tra doppie virgolette. I caratteri virgoletta devono essere virgolette semplici (0x22), non oblique o "smart".
Un *array* JSON inizia e termina con delle parentesi e contiene un insieme ordinato di valori separati da virgole. Un valore può essere una stringa tra doppie virgolette, un numero, un booleano vero o falso, nullo, un oggetto JSON o un array.
Gli oggetti e gli array JSON possono essere annidati, consentendo una struttura gerarchica dei dati. L'esempio seguente mostra una struttura di dati JSON con due oggetti validi.
```
{
"id": 1006410,
"title": "Amazon Redshift Database Developer Guide"
}
{
"id": 100540,
"name": "Amazon Simple Storage Service User Guide"
}
```
Di seguito sono riportati gli stessi dati di due array JSON.
```
[
1006410,
"Amazon Redshift Database Developer Guide"
]
[
100540,
"Amazon Simple Storage Service User Guide"
]
```
## Opzioni COPY per JSON
È possibile specificare le seguenti opzioni quando si utilizza COPY con i dati in formato JSON:
+ `'auto' `: COPY carica automaticamente i campi dal file JSON.
+ `'auto ignorecase'`: COPY carica automaticamente i campi dal file JSON ignorando la distinzione tra maiuscole e minuscole per i nomi dei campi.
+ `s3://jsonpaths_file`— COPY utilizza un JSONPaths file per analizzare i dati di origine JSON. Un *JSONPaths file* è un file di testo che contiene un singolo oggetto JSON con il nome `"jsonpaths"` associato a una serie di espressioni. JSONPath Se il nome è una stringa diversa da`"jsonpaths"`, COPY utilizza l'`'auto'`argomento anziché il JSONPaths file.
Per esempi che mostrano come caricare dati utilizzando `'auto'``'auto ignorecase'`, o un JSONPaths file e utilizzando oggetti o array JSON, consulta. [Esempi di copia da JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json)
## JSONPath opzione
Nella sintassi Amazon Redshift COPY, un' JSONPath espressione specifica il percorso esplicito di un singolo elemento del nome in una struttura dati gerarchica JSON, utilizzando la notazione tra parentesi o la notazione a punti. Amazon Redshift non supporta alcun JSONPath elemento, come caratteri jolly o espressioni di filtro, che potrebbe risolversi in un percorso ambiguo o in più elementi del nome. Di conseguenza, Amazon Redshift non è in grado di analizzare strutture di dati complesse e a più livelli.
Di seguito è riportato un esempio di JSONPaths file con JSONPath espressioni che utilizzano la notazione tra parentesi. Il simbolo del dollaro (\$1) rappresenta la struttura a livello di root.
```
{
"jsonpaths": [
"$['id']",
"$['store']['book']['title']",
"$['location'][0]"
]
}
```
Nell'esempio precedente, `$['location'][0]` fa riferimento al primo elemento di un array. JSON utilizza un'indicizzazione dell'array basata su zero. Gli indici degli array devono essere numeri interi positivi (maggiori o uguali a zero).
L'esempio seguente mostra il JSONPaths file precedente utilizzando la notazione a punti.
```
{
"jsonpaths": [
"$.id",
"$.store.book.title",
"$.location[0]"
]
}
```
Non è possibile mischiare la notazione a parentesi e a punti nell'array `jsonpaths`. Le parentesi possono essere utilizzate sia nella notazione a parentesi sia nella notazione a punti per fare riferimento a un elemento dell'array.
Quando si utilizza la notazione a punti, le JSONPath espressioni non possono contenere i seguenti caratteri:
+ Virgolette singole diritte ( ' )
+ Periodo o punto ( . )
+ Parentesi ( [ ] ) salvo se utilizzate per fare riferimento a un elemento dell'array
Se il valore nella coppia nome-valore a cui fa riferimento un' JSONPath espressione è un oggetto o una matrice, l'intero oggetto o matrice viene caricato come stringa, comprese le parentesi o le parentesi. Ad esempio, si supponga che i dati JSON contengano il seguente oggetto.
```
{
"id": 0,
"guid": "84512477-fa49-456b-b407-581d0d851c3c",
"isActive": true,
"tags": [
"nisi",
"culpa",
"ad",
"amet",
"voluptate",
"reprehenderit",
"veniam"
],
"friends": [
{
"id": 0,
"name": "Martha Rivera"
},
{
"id": 1,
"name": "Renaldo"
}
]
}
```
L' JSONPath espressione restituisce `$['tags']` quindi il seguente valore.
```
"["nisi","culpa","ad","amet","voluptate","reprehenderit","veniam"]"
```
L' JSONPath espressione restituisce `$['friends'][1]` quindi il seguente valore.
```
"{"id": 1,"name": "Renaldo"}"
```
Ogni JSONPath espressione nell'`jsonpaths`array corrisponde a una colonna nella tabella di destinazione di Amazon Redshift. L'ordine degli elementi dell'array `jsonpaths` deve corrispondere all'ordine delle colonne della tabella di destinazione o, se viene utilizzato un elenco di colonne, di quest'ultimo.
Per esempi che mostrano come caricare dati utilizzando l'`'auto'`argomento o un JSONPaths file e utilizzando oggetti o array JSON, consulta. [Esempi di copia da JSON](r_COPY_command_examples.md#r_COPY_command_examples-copy-from-json)
Per informazioni su come copiare più file JSON, consultare [Utilizzo di un manifest per specificare i fili di dati](loading-data-files-using-manifest.md).
## Caratteri escape in JSON
COPY carica `\n` come carattere newline e carica `\t` come carattere di tabulazione. Per caricare una barra rovesciata, crea una sequenza di escape con una barra rovesciata ( `\\` ).
Ad esempio, supponiamo di avere la seguente struttura JSON in un file denominato `escape.json` nel bucket `s3://amzn-s3-demo-bucket/json/`.
```
{
"backslash": "This is a backslash: \\",
"newline": "This sentence\n is on two lines.",
"tab": "This sentence \t contains a tab."
}
```
Esegui i seguenti comandi per creare la tabella ESCAPES e caricare il JSON.
```
create table escapes (backslash varchar(25), newline varchar(35), tab varchar(35));
copy escapes from 's3://amzn-s3-demo-bucket/json/escape.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as json 'auto';
```
Eseguire una query sulla tabella ESCAPES per visualizzare i risultati.
```
select * from escapes;
backslash | newline | tab
------------------------+-------------------+----------------------------------
This is a backslash: \ | This sentence | This sentence contains a tab.
: is on two lines.
(1 row)
```
## Perdita di precisione numerica
Potrebbe verificarsi una perdita di precisione quando carichi numeri da file di dati in formato JSON in una colonna definita come tipo di dati numerico. Alcuni valori float non sono rappresentati con esattezza nei sistemi informatici. Di conseguenza, i dati copiati da un file JSON potrebbero non essere arrotondati come previsto. Per evitare una perdita di precisione, consigliamo di utilizzare una delle seguenti alternative:
+ Rappresentare il numero come stringa racchiudendo il valore in caratteri di doppia virgoletta.
+ Utilizza [ROUNDEC](copy-parameters-data-conversion.md#copy-roundec) per arrotondare il numero invece di troncarlo.
+ Invece di utilizzare file JSON o Avro, utilizza file di testo CSV, delimitati da caratteri o a larghezza fissa.
# COPY da formati di dati a colonna
COPY può caricare i dati da Amazon S3 nei seguenti formati di colonna:
+ ORC
+ Parquet
Per esempi di utilizzo di COPY con formati di dati colonnari, consulta [Esempi di COPY](r_COPY_command_examples.md).
COPY supporta i dati formattati a colonna con le seguenti restrizioni:
+ Il bucket Amazon S3 deve trovarsi nella stessa AWS regione del database Amazon Redshift.
+ Per accedere ai dati Amazon S3 tramite un endpoint VPC, configurare l'accesso utilizzando le policy e i ruoli IAM come descritto in [Utilizzo di Amazon Redshift Spectrum con il routing VPC avanzato](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html) nella *Guida alla gestione di Amazon Redshift*.
+ COPY non applica automaticamente le codifiche di compressione.
+ Sono supportati solo i seguenti parametri COPY:
+ [ACCEPTINVCHARS](copy-parameters-data-conversion.md#copy-acceptinvchars) durante la copia da un file ORC o Parquet.
+ [FILLRECORD](copy-parameters-data-conversion.md#copy-fillrecord)
+ [FROM](copy-parameters-data-source-s3.md#copy-parameters-from)
+ [IAM\$1ROLE](copy-parameters-authorization.md#copy-iam-role)
+ [CREDENTIALS](copy-parameters-authorization.md#copy-credentials)
+ [STATUPDATE ](copy-parameters-data-load.md#copy-statupdate)
+ [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest)
+ [EXPLICIT\$1IDS](copy-parameters-data-conversion.md#copy-explicit-ids)
+ Se COPY rileva un errore durante il caricamento, il comando fallisce. ACCEPTANYDATE e MAXERROR non sono supportati per i tipi di dati colonnari..
+ I messaggi di errore vengono inviati al client SQL. Alcuni errori vengono registrati in STL\$1LOAD\$1ERRORS e STL\$1ERROR.
+ COPY inserisce i valori nelle colonne della tabella di destinazione nello stesso ordine in cui si presentano le colonne nei file di dati a colonna. Il numero di colonne nella tabella di destinazione e il numero di colonne nel file di dati devono corrispondere.
+ Se il file specificato per l'operazione COPY include una delle seguenti estensioni, decomprimiamo i dati senza la necessità di aggiungere alcun parametro:
+ `.gz`
+ `.snappy`
+ `.bz2`
+ Il COPY dai formati di file Parquet e ORC utilizza Redshift Spectrum e l'accesso al bucket. Per utilizzare COPY per questi formati, assicurati che non vi siano policy IAM che blocchino l'uso di Amazon S3 presigned. URLs I URLs prefirmati generati da Amazon Redshift sono validi per 1 ora, in modo che Amazon Redshift abbia abbastanza tempo per caricare tutti i file dal bucket Amazon S3. Viene generato un URL prefirmato univoco per ogni file scansionato da COPY da formati di dati a colonna. Per le policy di bucket che includono un’azione `s3:signatureAge`, assicurati di impostare il valore su almeno 3.600.000 millisecondi. Per ulteriori informazioni, consultare [Utilizzo di Amazon Redshift Spectrum con il routing VPC avanzato](https://docs.aws.amazon.com/redshift/latest/mgmt/spectrum-enhanced-vpc.html).
+ Il parametro REGION non è supportato con COPY da formati di dati a colonna. Anche se il bucket Amazon S3 e il database si trovano nello stesso database, è possibile che si verifichi un errore Regione AWS, ad esempio, l'argomento REGION non è supportato per COPY basato su PARQUET.
+ COPY da formati a colonna ora supporta il dimensionamento simultaneo. Per abilitare il dimensionamento simultaneo, consulta [Configurazione delle code di dimensionamento simultaneo.](https://docs.aws.amazon.com/redshift/latest/dg/concurrency-scaling.html#concurrency-scaling-queues)
# Stringhe DATEFORMAT e TIMEFORMAT
Il comando COPY utilizza le opzioni DATEFORMAT e TIMEFORMAT per analizzare i valori di data e ora nei dati di origine. DATEFORMAT e TIMEFORMAT sono stringhe formattate che devono corrispondere al formato dei valori di data e ora dei dati di origine. Ad esempio, un comando COPY che carica i dati di origine con il valore della data `Jan-01-1999` deve includere la seguente stringa DATEFORMAT:
```
COPY ...
DATEFORMAT AS 'MON-DD-YYYY'
```
Per ulteriori informazioni sulla gestione delle conversioni dei dati COPY, consulta [Parametri di conversione dei dati](https://docs.aws.amazon.com/redshift/latest/dg/copy-parameters-data-conversion.html).
Le stringhe DATEFORMAT e TIMEFORMAT possono contenere separatori datetime (come "`-`", "`/`" o "`:`") e i formati datepart e timepart nella tabella seguente.
**Nota**
Se non è possibile abbinare il formato dei valori di data e ora con i seguenti datepart e timepart o se i valori di data e ora utilizzano formati diversi tra di loro, utilizza l'argomento `'auto'` con il parametro DATEFORMAT o TIMEFORMAT. L'argomento `'auto'` riconosce diversi formati che non sono supportati quando si utilizza una stringa DATEFORMAT o TIMEFORMAT. Per ulteriori informazioni, consulta [Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT](automatic-recognition.md).
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
Il formato di data predefinito è. YYYY-MM-DD Il formato di timestamp predefinito senza fuso orario (TIMESTAMP) è HH:MI:SS. YYYY-MM-DD Il formato predefinito del timestamp con fuso orario (TIMESTAMPTZ) è HH:MI:SSOF, dove OF è YYYY-MM-DD l'offset dall'UTC (ad esempio, - 8:00. Non è possibile includere un identificatore di fuso orario (TZ, tz o OF) in timeformat\$1string. Il campo secondi (SS) supporta anche secondi frazionari di dettaglio fino a un livello di microsecondi. Per caricare i dati TIMESTAMPTZ in un formato diverso da quello predefinito, specificare "auto".
Di seguito sono riportati alcuni esempi di date o ore che è possibile trovare nei dati di origine e le relative stringhe DATEFORMAT o TIMEFORMAT.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_DATEFORMAT_and_TIMEFORMAT_strings.html)
## Esempio
Per un esempio di utilizzo di TIMEFORMAT, consulta [Caricamento di un Timestamp o di un Datestamp](r_COPY_command_examples.md#r_COPY_command_examples-load-a-time-datestamp).
# Utilizzo del riconoscimento automatico con DATEFORMAT e TIMEFORMAT
Se si specifica `'auto'` come argomento per il parametro DATEFORMAT o TIMEFORMAT, Amazon Redshift riconoscerà e convertirà automaticamente il formato data o ora nei dati di origine. Di seguito viene riportato un esempio.
```
copy favoritemovies from 'dynamodb://ProductCatalog'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
dateformat 'auto';
```
Se usato con l'argomento `'auto'` per DATEFORMAT e TIMEFORMAT, COPY riconosce e converte i formati di data e ora elencati nella tabella in [Stringhe DATEFORMAT e TIMEFORMATEsempio](r_DATEFORMAT_and_TIMEFORMAT_strings.md). Inoltre, l'argomento `'auto'` riconosce i seguenti formati che non sono supportati quando si usa una stringa DATEFORMAT e TIMEFORMAT.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/automatic-recognition.html)
Il riconoscimento automatico non supporta epochsecs ed epochmillisecs.
Per verificare se un valore di data o di timestamp viene convertito automaticamente, utilizza una funzione CAST per tentare di convertire la stringa in un valore di data o timestamp. Ad esempio, i seguenti comandi verificano il valore del timestamp `'J2345678 04:05:06.789'`:
```
create table formattest (test char(21));
insert into formattest values('J2345678 04:05:06.789');
select test, cast(test as timestamp) as timestamp, cast(test as date) as date from formattest;
test | timestamp | date
----------------------+---------------------+------------
J2345678 04:05:06.789 1710-02-23 04:05:06 1710-02-23
```
Se i dati sorgente di una colonna DATE includono informazioni sull'ora, la componente temporale viene troncata. Se i dati sorgente di una colonna TIMESTAMP omettono informazioni sull'ora, per la componente dell'ora viene utilizzato 00:00:00.
# Esempi di COPY
**Nota**
Questi esempi contengono interruzioni di riga per una migliore leggibilità. Non includere interruzioni di riga o spazi nella stringa *credentials-args*.
**Topics**
+ [Caricamento di FAVORITEMOVIES da una tabella DynamoDB](#r_COPY_command_examples-load-favoritemovies-from-an-amazon-dynamodb-table)
+ [Caricamento di LISTING da un bucket Amazon S3](#r_COPY_command_examples-load-listing-from-an-amazon-s3-bucket)
+ [Caricamento di LISTING da un cluster Amazon EMR](#copy-command-examples-emr)
+ [Example: COPY from Amazon S3 using a manifest](#copy-command-examples-manifest)
+ [Caricamento di LISTING da un file delimitato da pipe (Delimitatore predefinito)](#r_COPY_command_examples-load-listing-from-a-pipe-delimited-file-default-delimiter)
+ [Caricamento di LISTING utilizzando i dati a colonna nel formato Parquet](#r_COPY_command_examples-load-listing-from-parquet)
+ [Caricamento di LISTING utilizzando i dati a colonna nel formato ORC](#r_COPY_command_examples-load-listing-from-orc)
+ [Caricamento di EVENT con le opzioni](#r_COPY_command_examples-load-event-with-options)
+ [Caricamento di VENUE da un file di dati a larghezza fissa](#r_COPY_command_examples-load-venue-from-a-fixed-width-data-file)
+ [Caricamento di CATEGORY da un file CSV](#load-from-csv)
+ [Caricamento di VENUE con valori espliciti per una colonna IDENTITY](#r_COPY_command_examples-load-venue-with-explicit-values-for-an-identity-column)
+ [Caricamento di TIME da un file GZIP delimitato da pipe](#r_COPY_command_examples-load-time-from-a-pipe-delimited-gzip-file)
+ [Caricamento di un Timestamp o di un Datestamp](#r_COPY_command_examples-load-a-time-datestamp)
+ [Caricamento dei dati da un file con valori predefiniti](#r_COPY_command_examples-load-data-from-a-file-with-default-values)
+ [Dati COPY con l'opzione ESCAPE](#r_COPY_command_examples-copy-data-with-the-escape-option)
+ [Esempi di copia da JSON](#r_COPY_command_examples-copy-from-json)
+ [Esempi di copia da Avro](#r_COPY_command_examples-copy-from-avro)
+ [Preparazione dei file per COPY con l'opzione ESCAPE](#r_COPY_preparing_data)
+ [Caricamento di uno shapefile in Amazon Redshift](#copy-example-spatial-copy-shapefile)
+ [Comando COPY con l'opzione NOLOAD](#r_COPY_command_examples-load-noload-option)
+ [Comando COPY con un delimitatore multibyte e l’opzione ENCODING](#r_COPY_command_examples-load-encoding-multibyte-delimiter-option)
## Caricamento di FAVORITEMOVIES da una tabella DynamoDB
AWS SDKs *Includono un semplice esempio di creazione di una tabella DynamoDB chiamata Movies.* (Per questo esempio, consultare [Nozioni di base su DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/GettingStarted.html).) Nell'esempio seguente la tabella MOVIES di Amazon Redshift viene caricata con i dati della tabella DynamoDB. La tabella di Amazon Redshift deve esistere già nel database.
```
copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
readratio 50;
```
## Caricamento di LISTING da un bucket Amazon S3
L'esempio seguente carica LISTING da un bucket Amazon S3. Il comando COPY carica tutti i file contenuti nella cartella `/data/listing/`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listing/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Caricamento di LISTING da un cluster Amazon EMR
L'esempio seguente carica la tabella SALES con i dati delimitati da schede da file compressi lzop in un cluster Amazon EMR. COPY carica ogni file nella cartella `myoutput/` che inizia con `part-`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;
```
L'esempio seguente carica la tabella SALES con i dati con dati formattati in JSON in un cluster Amazon EMR. COPY carica ogni file nella cartella `myoutput/json/`.
```
copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';
```
## Utilizzo di un manifest per specificare i fili di dati
È possibile utilizzare un manifest per assicurarsi che il comando COPY carichi tutti i file richiesti, e solo i file richiesti, da Amazon S3. È anche possibile utilizzare un manifest quando è necessario caricare più file da bucket o file diversi che non condividono lo stesso prefisso.
Ad esempio, supponi di dover caricare i seguenti tre file: `custdata1.txt`, `custdata2.txt` e `custdata3.txt`. È possibile usare il seguente comando per caricare tutti i file in `amzn-s3-demo-bucket` che iniziano con `custdata` specificando un prefisso:
```
copy category
from 's3://amzn-s3-demo-bucket/custdata'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
Se solo due dei file esistono a causa di un errore, COPY carica solo questi due file e terminerà con successo, con un caricamento di dati che risulterà incompleto. Se il bucket contiene anche un file indesiderato che utilizza lo stesso prefisso, come ad esempio un file chiamato `custdata.backup`, COPY carica anche quel file, caricando così dati indesiderati.
Per assicurarsi che tutti i file richiesti siano caricati e per evitare che vengano caricati file indesiderati, è possibile utilizzare un file manifest. Il manifest è un file di testo con formattazione JSON che elenca i file che devono essere elaborati dal comando COPY. Ad esempio, il seguente manifest carica i tre file nell'esempio precedente.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket/custdata.1",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.2",
"mandatory":true
},
{
"url":"s3://amzn-s3-demo-bucket/custdata.3",
"mandatory":true
}
]
}
```
Il flag opzionale `mandatory` indica se COPY deve terminare se il file non esiste. Il valore predefinito è `false`. Indipendentemente da eventuali impostazioni obbligatorie, COPY termina se non vengono trovati file. In questo esempio, COPY restituisce un errore se uno qualsiasi dei file non viene trovato. I file indesiderati che potrebbero essere stati raccolti se hai specificato solo un prefisso della chiave, come `custdata.backup`, vengono ignorati, perché non sono sul manifest.
Quando si carica da file di dati in formato ORC o Parquet, è necessario un campo `meta`, come mostrato nell'esempio seguente.
```
{
"entries":[
{
"url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
},
{
"url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
"mandatory":true,
"meta":{
"content_length":99
}
}
]
}
```
L'esempio seguente utilizza un manifest denominato `cust.manifest`.
```
copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;
```
È possibile utilizzare un manifest per caricare file da diversi bucket o file che non condividono lo stesso prefisso. L'esempio seguente mostra il JSON per caricare dati con file i cui nomi iniziano con uno stamp di data.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
{"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
]
}
```
Il manifesto può elencare i file che si trovano in bucket diversi, purché i bucket si trovino nella stessa AWS regione del cluster.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
{"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
]
}
```
## Caricamento di LISTING da un file delimitato da pipe (Delimitatore predefinito)
L'esempio seguente è un caso molto semplice in cui non sono specificate opzioni e il file di input contiene il delimitatore predefinito, un carattere pipe ("\$1").
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';
```
## Caricamento di LISTING utilizzando i dati a colonna nel formato Parquet
Il seguente esempio carica i dati da una cartella su Amazon S3 chiamata parquet.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/parquet/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;
```
## Caricamento di LISTING utilizzando i dati a colonna nel formato ORC
Il seguente esempio carica i dati da una cartella su Amazon S3 chiamata `orc`.
```
copy listing
from 's3://amzn-s3-demo-bucket/data/listings/orc/'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;
```
## Caricamento di EVENT con le opzioni
Il seguente esempio carica i dati delimitati da pipe nella tabella EVENT e applica le seguenti regole:
+ Se si utilizzano coppie di virgolette per circondare una qualsiasi stringa di caratteri, vengono rimosse.
+ Sia le stringhe vuote sia quelle che contengono spazi vuoti vengono caricate come valori NULL.
+ Il caricamento non riesce se vengono restituiti più di 5 errori.
+ I valori di timestamp devono essere conformi al formato specificato; ad esempio, un timestamp valido è `2008-09-26 05:43:12`.
```
copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
## Caricamento di VENUE da un file di dati a larghezza fissa
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';
```
L'esempio precedente assume un file di dati formattato nello stesso modo dei dati campione mostrati. Nel seguente esempio, gli spazi fungono da placeholder in modo che tutte le colonne abbiano la stessa larghezza indicata nelle specifiche:
```
1 Toyota Park Bridgeview IL0
2 Columbus Crew Stadium Columbus OH0
3 RFK Stadium Washington DC0
4 CommunityAmerica BallparkKansas City KS0
5 Gillette Stadium Foxborough MA68756
```
## Caricamento di CATEGORY da un file CSV
Supponi di voler caricare CATEGORY con i valori indicati nella tabella seguente.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_COPY_command_examples.html)
L'esempio seguente mostra il contenuto di un file di testo con i valori dei campi separati da virgole.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts
```
Se carichi il file utilizzando il parametro DELIMITER per specificare l'input delimitato da virgole, il comando COPY non riesce perché alcuni campi di input contengono virgole. È possibile evitare questo problema utilizzando il parametro CSV e racchiudendo i campi che contengono virgole tra virgolette. Se il carattere virgolette viene visualizzato all'interno di una stringa tra virgolette, è necessario eseguirne l'escape raddoppiando le virgolette. Il carattere di virgoletta di default è una virgoletta doppia, quindi è necessario eseguire l'escape di ogni virgoletta doppia con una virgoletta doppia aggiuntiva. Il nuovo file di input è simile a questo.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"
```
Supponendo che il nome del file sia `category_csv.txt`, è possibile caricare il file utilizzando il seguente comando COPY:
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv;
```
In alternativa, per evitare di dover creare una sequenza di escape per le doppie virgolette nell'input, è possibile specificare un carattere virgolette diverso utilizzando il parametro QUOTE AS. Per esempio, la seguente versione di `category_csv.txt` utilizza "`%`" come carattere virgolette.
```
12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%
```
Il seguente comando COPY utilizza QUOTE AS per caricare `category_csv.txt`:
```
copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
csv quote as '%';
```
## Caricamento di VENUE con valori espliciti per una colonna IDENTITY
L'esempio seguente presuppone che quando è stata creata la tabella VENUE almeno una colonna (come la colonna `venueid`) sia stata specificata come colonna IDENTITY. Questo comando sostituisce il comportamento di IDENTITY predefinito dei valori autogeneranti per una colonna IDENTITY e carica invece i valori espliciti dal file venue.txt. Amazon Redshift non verifica se i valori IDENTITY duplicati vengono caricati nella tabella quando utilizza l'opzione EXLICIT\$1IDS.
```
copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;
```
## Caricamento di TIME da un file GZIP delimitato da pipe
L'esempio seguente carica la tabella TIME da un file GZIP delimitato dal pipe:
```
copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';
```
## Caricamento di un Timestamp o di un Datestamp
L'esempio seguente carica i dati con un timestamp formattato.
**Nota**
Il TIMEFORMAT di `HH:MI:SS` può anche supportare i secondi frazionari oltre il `SS` a un livello di dettaglio di microsecondi. Il file `time.txt` utilizzato in questo esempio contiene una riga `2009-01-12 14:15:57.119568`.
```
copy timestamp1
from 's3://amzn-s3-demo-bucket/data/time.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';
```
Il risultato di questa copia è il seguente:
```
select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)
```
## Caricamento dei dati da un file con valori predefiniti
L'esempio seguente usa una variazione della tabella VENUE nel database TICKIT. Considera una tabella VENUE\$1NEW definita con la seguente dichiarazione:
```
create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Considera un file di dati venue\$1noseats.txt che non contiene valori per la colonna VENUESEATS, come mostrato nell'esempio seguente:
```
1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|
```
La seguente dichiarazione COPY caricherà la tabella dal file e applicherà il valore DEFAULT ("1000") alla colonna omessa:
```
copy venue_new(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Ora visualizza la tabella caricata:
```
select * from venue_new order by venueid;
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 1000
2 | Columbus Crew Stadium | Columbus | OH | 1000
3 | RFK Stadium | Washington | DC | 1000
4 | CommunityAmerica Ballpark | Kansas City | KS | 1000
5 | Gillette Stadium | Foxborough | MA | 1000
6 | New York Giants Stadium | East Rutherford | NJ | 1000
7 | BMO Field | Toronto | ON | 1000
8 | The Home Depot Center | Carson | CA | 1000
9 | Dick's Sporting Goods Park | Commerce City | CO | 1000
10 | Pizza Hut Park | Frisco | TX | 1000
(10 rows)
```
Per l'esempio seguente, oltre a supporre che nel file non siano inclusi dati VENUESEATS, supponi anche che non siano inclusi dati VENUENAME:
```
1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|
```
Usando la stessa definizione della tabella, la seguente dichiarazione COPY non riesce perché non è stato specificato alcun valore DEFAULT per VENUENAME, il quale è una colonna NOT NULL:
```
copy venue(venueid, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
Considera ora una variazione della tabella VENUE che utilizza una colonna IDENTITY:
```
create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');
```
Come per l'esempio precedente, supponi che la colonna VENUESEATS non abbia valori corrispondenti nel file sorgente. La seguente dichiarazione COPY carica correttamente la tabella, inclusi i valori dei dati IDENTITY predefiniti, invece di generare tali valori autonomamente:
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Questa dichiarazione non riesce perché non include la colonna IDENTITY (VENUEID è assente dall'elenco delle colonne) ma include un parametro EXPLICIT\$1IDS:
```
copy venue(venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;
```
Questa dichiarazione non riesce perché non include un parametro EXPLICIT\$1IDS:
```
copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';
```
## Dati COPY con l'opzione ESCAPE
L'esempio seguente mostra come caricare i caratteri che corrispondono al carattere del delimitatore (in questo caso, il carattere pipe). Nel file di input, assicurati che tutti i caratteri pipe (\$1) che desideri caricare siano resi una sequenza di escape con il carattere di barra rovesciata (\$1). Quindi carica il file con il parametro ESCAPE.
```
$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser
create table redshiftinfo(infoid int,tableinfo varchar(50));
copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' escape;
select * from redshiftinfo order by 1;
infoid | tableinfo
-------+--------------------
1 | public|event|dwuser
2 | public|sales|dwuser
(2 rows)
```
Senza il parametro ESCAPE, questo comando COPY fallisce con un errore `Extra column(s) found`.
**Importante**
Se carichi i dati utilizzando un COPY con il parametro ESCAPE, è necessario specificare anche il parametro ESCAPE con il comando UNLOAD per generare il file di output reciproco. Allo stesso modo, se utilizzi UNLOAD usando il parametro ESCAPE, è necessario usare ESCAPE quando effettui un COPY sugli stessi dati.
## Esempi di copia da JSON
Negli esempi seguenti, carica la tabella CATEGORY con i seguenti dati.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Caricamento da dati JSON utilizzando l'opzione "auto".](#copy-from-json-examples-using-auto)
+ [Caricamento da dati JSON utilizzando l'opzione 'auto ignorecase'](#copy-from-json-examples-using-auto-ignorecase)
+ [Carica dati da JSON utilizzando un file JSONPaths](#copy-from-json-examples-using-jsonpaths)
+ [Caricamento da array JSON utilizzando un file JSONPaths](#copy-from-json-examples-using-jsonpaths-arrays)
### Caricamento da dati JSON utilizzando l'opzione "auto".
Per caricare dai dati JSON utilizzando l'opzione `'auto'`, i dati JSON devono essere costituiti da un set di oggetti. I nomi delle chiavi devono corrispondere ai nomi delle colonne, ma l'ordine non ha importanza. Di seguito viene mostrato il contenuto di un file denominato `category_object_auto.json`.
```
{
"catdesc": "Major League Baseball",
"catid": 1,
"catgroup": "Sports",
"catname": "MLB"
}
{
"catgroup": "Sports",
"catid": 2,
"catname": "NHL",
"catdesc": "National Hockey League"
}
{
"catid": 3,
"catname": "NFL",
"catgroup": "Sports",
"catdesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"catid": 4,
"catgroup": "Sports",
"catname": "NBA",
"catdesc": "National Basketball Association"
}
{
"catid": 5,
"catgroup": "Shows",
"catname": "Musicals",
"catdesc": "All symphony, concerto, and choir concerts"
}
```
Per caricare dal file dati JSON nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto';
```
### Caricamento da dati JSON utilizzando l'opzione 'auto ignorecase'
Per caricare dai dati JSON utilizzando l'opzione `'auto ignorecase'`, i dati JSON devono essere costituiti da un set di oggetti. Il formato maiuscolo/minuscolo dei nomi delle chiavi non deve corrispondere ai nomi delle colonne e l'ordine non ha importanza. Di seguito viene mostrato il contenuto di un file denominato `category_object_auto-ignorecase.json`.
```
{
"CatDesc": "Major League Baseball",
"CatID": 1,
"CatGroup": "Sports",
"CatName": "MLB"
}
{
"CatGroup": "Sports",
"CatID": 2,
"CatName": "NHL",
"CatDesc": "National Hockey League"
}
{
"CatID": 3,
"CatName": "NFL",
"CatGroup": "Sports",
"CatDesc": "National Football League"
}
{
"bogus": "Bogus Sports LLC",
"CatID": 4,
"CatGroup": "Sports",
"CatName": "NBA",
"CatDesc": "National Basketball Association"
}
{
"CatID": 5,
"CatGroup": "Shows",
"CatName": "Musicals",
"CatDesc": "All symphony, concerto, and choir concerts"
}
```
Per caricare dal file dati JSON nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 'auto ignorecase';
```
### Carica dati da JSON utilizzando un file JSONPaths
Se gli oggetti dati JSON non corrispondono direttamente ai nomi delle colonne, puoi utilizzare un JSONPaths file per mappare gli elementi JSON alle colonne. L'ordine non ha importanza nei dati di origine JSON, ma l'ordine delle espressioni di JSONPaths file deve corrispondere all'ordine delle colonne. Supponi di avere il seguente file di dati, denominato `category_object_paths.json`.
```
{
"one": 1,
"two": "Sports",
"three": "MLB",
"four": "Major League Baseball"
}
{
"three": "NHL",
"four": "National Hockey League",
"one": 2,
"two": "Sports"
}
{
"two": "Sports",
"three": "NFL",
"one": 3,
"four": "National Football League"
}
{
"one": 4,
"two": "Sports",
"three": "NBA",
"four": "National Basketball Association"
}
{
"one": 6,
"two": "Shows",
"three": "Musicals",
"four": "All symphony, concerto, and choir concerts"
}
```
Il JSONPaths file seguente, denominato`category_jsonpath.json`, mappa i dati di origine alle colonne della tabella.
```
{
"jsonpaths": [
"$['one']",
"$['two']",
"$['three']",
"$['four']"
]
}
```
Per caricare dal file dati JSON nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';
```
### Caricamento da array JSON utilizzando un file JSONPaths
Per caricare dati JSON costituiti da un set di array, è necessario utilizzare un JSONPaths file per mappare gli elementi dell'array alle colonne. Supponi di avere il seguente file di dati, denominato `category_array_data.json`.
```
[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]
```
Il JSONPaths file seguente, denominato`category_array_jsonpath.json`, mappa i dati di origine alle colonne della tabella.
```
{
"jsonpaths": [
"$[0]",
"$[1]",
"$[2]",
"$[3]"
]
}
```
Per caricare dal file dati JSON nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';
```
## Esempi di copia da Avro
Negli esempi seguenti, carica la tabella CATEGORY con i seguenti dati.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/redshift/latest/dg/r_COPY_command_examples.html)
**Topics**
+ [Caricamento dai dati Avro utilizzando l'opzione "auto".](#copy-from-avro-examples-using-auto)
+ [Caricamento da dati Avro utilizzando l'opzione 'auto ignorecase'](#copy-from-avro-examples-using-auto-ignorecase)
+ [Carica dati da Avro utilizzando un JSONPaths file](#copy-from-avro-examples-using-avropaths)
### Caricamento dai dati Avro utilizzando l'opzione "auto".
Per caricare dai dati Avro usando l'argomento `'auto'`, i nomi dei campi nello schema Avro devono corrispondere ai nomi delle colonne. Quando si utilizza l'argomento `'auto'`, l'ordine non ha importanza. Di seguito viene mostrato lo schema per un file denominato `category_auto.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "catid", "type": "int"},
{"name": "catdesc", "type": "string"},
{"name": "catname", "type": "string"},
{"name": "catgroup", "type": "string"},
}
```
I dati in un file Avro sono in formato binario, quindi non sono leggibili dall'utente. Di seguito viene mostrata una rappresentazione JSON dei dati nel file `category_auto.avro`.
```
{
"catid": 1,
"catdesc": "Major League Baseball",
"catname": "MLB",
"catgroup": "Sports"
}
{
"catid": 2,
"catdesc": "National Hockey League",
"catname": "NHL",
"catgroup": "Sports"
}
{
"catid": 3,
"catdesc": "National Basketball Association",
"catname": "NBA",
"catgroup": "Sports"
}
{
"catid": 4,
"catdesc": "All symphony, concerto, and choir concerts",
"catname": "Classical",
"catgroup": "Concerts"
}
```
Per caricare dal file di dati Avro nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';
```
### Caricamento da dati Avro utilizzando l'opzione 'auto ignorecase'
Per caricare dai dati Avro con l'argomento `'auto ignorecase'`, il formato maiuscolo/minuscolo dei nomi dei campi nello schema Avro non deve corrispondere al formato dei nomi delle colonne. Quando si utilizza l'argomento `'auto ignorecase'`, l'ordine non ha importanza. Di seguito viene mostrato lo schema per un file denominato `category_auto-ignorecase.avro`.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "CatID", "type": "int"},
{"name": "CatDesc", "type": "string"},
{"name": "CatName", "type": "string"},
{"name": "CatGroup", "type": "string"},
}
```
I dati in un file Avro sono in formato binario, quindi non sono leggibili dall'utente. Di seguito viene mostrata una rappresentazione JSON dei dati nel file `category_auto-ignorecase.avro`.
```
{
"CatID": 1,
"CatDesc": "Major League Baseball",
"CatName": "MLB",
"CatGroup": "Sports"
}
{
"CatID": 2,
"CatDesc": "National Hockey League",
"CatName": "NHL",
"CatGroup": "Sports"
}
{
"CatID": 3,
"CatDesc": "National Basketball Association",
"CatName": "NBA",
"CatGroup": "Sports"
}
{
"CatID": 4,
"CatDesc": "All symphony, concerto, and choir concerts",
"CatName": "Classical",
"CatGroup": "Concerts"
}
```
Per caricare dal file di dati Avro nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';
```
### Carica dati da Avro utilizzando un JSONPaths file
Se i nomi dei campi nello schema Avro non corrispondono direttamente ai nomi delle colonne, puoi utilizzare un JSONPaths file per mappare gli elementi dello schema alle colonne. L'ordine delle espressioni del JSONPaths file deve corrispondere all'ordine delle colonne.
Supponi di avere un file di dati chiamato `category_paths.avro` che contenga gli stessi dati dell'esempio precedente, ma con lo schema seguente.
```
{
"name": "category",
"type": "record",
"fields": [
{"name": "id", "type": "int"},
{"name": "desc", "type": "string"},
{"name": "name", "type": "string"},
{"name": "group", "type": "string"},
{"name": "region", "type": "string"}
]
}
```
Il JSONPaths file seguente, denominato`category_path.avropath`, mappa i dati di origine alle colonne della tabella.
```
{
"jsonpaths": [
"$['id']",
"$['group']",
"$['name']",
"$['desc']"
]
}
```
Per caricare dal file di dati Avro nell'esempio precedente, emettere il seguente comando COPY.
```
copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';
```
## Preparazione dei file per COPY con l'opzione ESCAPE
L'esempio seguente descrive come preparare i dati per eseguire un "escape" dei caratteri newline prima di importarli in una tabella Amazon Redshift usando il comando COPY con il parametro ESCAPE. Senza preparare i dati per delimitare i caratteri newline, Amazon Redshift restituisce errori di caricamento quando si esegue il comando COPY, perché il carattere newline è normalmente usato come separatore di record.
Ad esempio, si consideri un file o una colonna in una tabella esterna che si desidera copiare in una tabella Amazon Redshift. Se il file o la colonna ha del contenuto formattato in XML o dati simili, è necessario assicurarsi che tutti i caratteri newline (\$1n) che fanno parte del contenuto siano inseriti in una sequenza di escape con il carattere di barra rovesciata (\$1).
Un file o una tabella che contiene caratteri newline incorporati è che fornisce un modello relativamente facile da associare. Ogni carattere newline incorporato molto probabilmente segue sempre un carattere `>` con potenzialmente alcuni caratteri di spazio (`' '` o tabulazione) in mezzo, come è possibile vedere nel seguente esempio di un file di testo denominato `nlTest1.txt`.
```
$ cat nlTest1.txt
|1000
|2000
```
Con l'esempio seguente, è possibile eseguire un'utilità di elaborazione del testo per pre-elaborare il file sorgente e inserire caratteri di escape, se necessario. (Il carattere `|` deve essere usato come delimitatore per separare i dati delle colonne quando viene copiato in una tabella Amazon Redshift).
```
$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt
```
Allo stesso modo, è possibile utilizzare Perl per eseguire un'operazione simile:
```
cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt
```
Per facilitare il caricamento dei dati dal file `nlTest2.txt` in Amazon Redshift, è stata creata una tabella a due colonne in Amazon Redshift. La prima colonna c1, è una colonna di caratteri che ha il contenuto in formato XML dal file `nlTest2.txt`. La seconda colonna c2 contiene i valori interi caricati dallo stesso file.
Dopo aver eseguito il comando `sed`, è possibile caricare correttamente i dati dal file `nlTest2.txt` in una tabella Amazon Redshift utilizzando il parametro ESCAPE.
**Nota**
Quando includi il parametro ESCAPE al comando COPY, crea una sequenza di escape con un certo numero di caratteri speciali che includono il carattere di barra rovesciata (incluso newline).
```
copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
escape
delimiter as '|';
select * from t2 order by 2;
c1 | c2
-------------+------
| 1000
| 2000
(2 rows)
```
In modo analogo è possibile preparare i file di dati esportati da database esterni. Ad esempio, con un database Oracle, è possibile utilizzare la funzione REPLACE su ogni colonna interessata in una tabella che si desideri copiare in Amazon Redshift.
```
SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml
```
Inoltre, molti strumenti di esportazione, estrazione, trasformazione e caricamento di database (ETL) che elaborano regolarmente grandi quantità di dati forniscono opzioni per specificare i caratteri di escape e i delimitatori.
## Caricamento di uno shapefile in Amazon Redshift
Negli esempi seguenti viene illustrato come caricare uno shapefile Esri mediante COPY. Per ulteriori informazioni sul caricamento di shapefile, consultare [Caricamento di uno shapefile in Amazon Redshift](spatial-copy-shapefile.md).
### Caricamento di uno shapefile
I passaggi seguenti mostrano come importare OpenStreetMap dati da Amazon S3 utilizzando il comando COPY. Questo esempio presuppone che l'archivio degli shapefile in Norvegia dal [sito di download di Geofabrik sia stato](https://download.geofabrik.de/europe.html) caricato in un bucket Amazon S3 privato nella tua regione. AWS I file `.shp`, `.shx` e `.dbf` devono condividere lo stesso prefisso Amazon S3 e lo stesso nome file.
#### Importazione dei dati senza semplificazione
I seguenti comandi creano tabelle e importano dati che possono adattarsi alle dimensioni massime della geometria senza alcuna semplificazione. Aprire il `gis_osm_natural_free_1.shp` nel software GIS preferito e ispezionare le colonne di questo livello. Per impostazione predefinita, le colonne IDENTITY o GEOMETRY sono le prime. Quando una colonna GEOMETRY è prima, è possibile creare la tabella come illustrato di seguito.
```
CREATE TABLE norway_natural (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Quando invece è la colonna IDENTITY a essere prima, è possibile creare la tabella come illustrato di seguito.
```
CREATE TABLE norway_natural_with_id (
fid INT IDENTITY(1,1),
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Ora è possibile importare i dati usando COPY.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully
```
In alternativa, è possibile importare i dati come illustrato di seguito.
```
COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.
```
#### Importazione dei dati con semplificazione
I seguenti comandi creano tabelle e provano a importare i dati che possono adattarsi alle dimensioni massime della geometria senza alcuna semplificazione. Ispezionare lo shapefile `gis_osm_water_a_free_1.shp` e creare la tabella appropriata come illustrato di seguito.
```
CREATE TABLE norway_water (
wkb_geometry GEOMETRY,
osm_id BIGINT,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Quando viene eseguito il comando COPY, viene generato un errore.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR: Load into table 'norway_water' failed. Check 'stl_load_errors' system table for details.
```
L'esecuzione della query su `STL_LOAD_ERRORS` ,ostra che la geometria è troppo grande.
```
SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
line_number | btrim | btrim
-------------+--------------+-----------------------------------------------------------------------
1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447
```
Per superare questo problema, viene aggiunto il parametro `SIMPLIFY AUTO` al comando COPY per semplificare le geometrie.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.
```
Per visualizzare le righe e le geometrie semplificate, eseguire una query su `SVL_SPATIAL_SIMPLIFY`.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
L'uso di di SIMPLIFY AUTO *tolleranza max* con una tolleranza inferiore a quella calcolata automaticamente probabilmente restituisce un errore di importazione. In questo caso, utilizzare MAXERROR per ignorare gli errori.
```
COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO: Load into table 'norway_water' completed, 1 record(s) could not be loaded. Check 'stl_load_errors' system table for details.
```
Eseguire di nuovo la query su `SVL_SPATIAL_SIMPLIFY` per identificare il record che COPY non è riuscito a caricare.
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
29 | 1184704 | 1.1e-05 | 1513736 | f | 0 | 0
29 | 1664115 | 1.1e-05 | 1233456 | t | 794432 | 1.1e-05
```
In questo esempio, il primo record non è riuscito a adattarsi, quindi la colonna `simplified` riporta false. Il secondo record è stato caricato entro la tolleranza specificata. Tuttavia, la dimensione finale è maggiore rispetto all'utilizzo della tolleranza calcolata automaticamente senza specificare la tolleranza massima.
### Caricamento da uno shapefile compresso
Il comando COPY di Amazon Redshift supporta l'importazione di dati da uno shapefile compresso. Tutti i componenti shapefile devono avere lo stesso prefisso Amazon S3 e lo stesso suffisso di compressione. Ad esempio, si supponga di voler caricare i dati dell'esempio precedente. In questo caso, i file `gis_osm_water_a_free_1.shp.gz`, `gis_osm_water_a_free_1.dbf.gz` e `gis_osm_water_a_free_1.shx.gz` devono condividere la stessa directory Amazon S3. Il comando COPY richiede l'opzione GZIP e la clausola FROM deve specificare il file compresso corretto, come illustrato di seguito.
```
COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.
```
### Caricamento di dati in una tabella con un ordine di colonna diverso
Se hai una tabella che non dispone di `GEOMETRY` come prima colonna, è possibile mappare le colonne alla tabella di destinazione. Ad esempio, creare una tabella con `osm_id` specificato come prima colonna.
```
CREATE TABLE norway_natural_order (
osm_id BIGINT,
wkb_geometry GEOMETRY,
code INT,
fclass VARCHAR,
name VARCHAR);
```
Quindi importare uno shapefile utilizzando la mappatura delle colonne.
```
COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name)
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.
```
### Caricamento di dati in una tabella con una colonna geografica
Se hai una tabella con una colonna `GEOGRAPHY`, prima importa in una colonna `GEOMETRY` e quindi converti gli oggetti in oggetti `GEOGRAPHY`. Ad esempio, dopo aver copiato lo shapefile in una colonna `GEOMETRY`, modifica la tabella per aggiungere una colonna del tipo di dati `GEOGRAPHY`.
```
ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;
```
Quindi converti le geometrie in aree geografiche.
```
UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;
```
Facoltativamente, è possibile eliminare la colonna `GEOMETRY`.
```
ALTER TABLE norway_natural DROP COLUMN wkb_geometry;
```
## Comando COPY con l'opzione NOLOAD
Per convalidare i file di dati prima di caricare effettivamente i dati, utilizza l'opzione NOLOAD con il comando COPY. Amazon Redshift analizza il file di input e visualizza gli eventuali errori che si verificano. L'esempio seguente utilizza l'opzione NOLOAD e nessuna riga viene effettivamente caricata nella tabella.
```
COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv'
DELIMITER ';'
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';
Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.
```
## Comando COPY con un delimitatore multibyte e l’opzione ENCODING
L'esempio seguente viene caricato LATIN1 da un file Amazon S3 che contiene dati multibyte. Il comando COPY specifica il delimitatore nel formato ottale `\302\246\303\254` per separare i campi nel file di input codificato come ISO-8859-1. Per specificare lo stesso delimitatore in UTF-8, indica `DELIMITER '¦ì'`.
```
COPY latin1
FROM 's3://amzn-s3-demo-bucket/multibyte/myfile'
IAM_ROLE 'arn:aws:iam::123456789012:role/myRedshiftRole'
DELIMITER '\302\246\303\254'
ENCODING ISO88591
```
# CREATE DATABASE
Crea un nuovo database.
Per creare un database, devi essere un utente con privilegi avanzati o disporre del privilegio CREATEDB. Per creare un database associato a un’integrazione Zero-ETL, devi essere un utente con privilegi avanzati o disporre di entrambi i privilegi CREATEDB e CREATEUSER.
Non è possibile eseguire CREATE DATABASE all'interno di un blocco di transazione (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
## Sintassi
```
CREATE DATABASE database_name
[ { [
FROM INTEGRATION ''[ DATABASE '' ]
[ SET ]
[ ACCEPTINVCHARS [=] { TRUE | FALSE }]
[ QUERY_ALL_STATES [=] { TRUE | FALSE }]
[ REFRESH_INTERVAL ]
[ TRUNCATECOLUMNS [=] { TRUE | FALSE } ]
[ HISTORY_MODE [=] {TRUE | FALSE} ]
]
[ WITH ]
[ OWNER [=] db_owner ]
[ CONNECTION LIMIT { limit | UNLIMITED } ]
[ COLLATE { CASE_SENSITIVE | CS | CASE_INSENSITIVE | CI } ]
[ ISOLATION LEVEL { SNAPSHOT | SERIALIZABLE } ]
}
| { FROM { { ARN '' } { WITH DATA CATALOG SCHEMA '' | WITH NO DATA CATALOG SCHEMA } } }
| { IAM_ROLE {default | 'SESSION' | 'arn:aws:iam:::role/' } }
| { [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid }
]
```
## Parameters
*database\$1name*
Nome del nuovo database. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
FROM INTEGRATION '' [ DATABASE '' ]
Specifica se creare il database utilizzando un identificatore di integrazione Zero-ETL. Puoi recuperare il formato `integration_id` dalla vista di sistema SVV\$1INTEGRATION. Per le integrazioni Zero-ETL di Aurora PostgreSQL, devi inoltre specificare il nome `source_database`, che può essere recuperato anche da SVV\$1INTEGRATION.
Per vedere un esempio, consulta [Crea database per ricevere i risultati delle integrazioni Zero-ETL](#r_CREATE_DATABASE-integration). Per ulteriori informazioni sulla creazione di database con integrazioni Zero-ETL, consulta [Creazione di database di destinazione in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.creating-db.html) nella *Guida alla gestione di Amazon Redshift*.
SET
Parola chiave facoltativa.
ACCEPTINVCHARS [=] \$1 TRUE \$1 FALSE \$1
La clausola ACCEPTINVCHARS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando per il tipo di dati VARCHAR vengono rilevati caratteri non validi. Quando vengono rilevati caratteri non validi, il carattere non valido viene sostituito con un carattere `?` predefinito.
QUERY\$1ALL\$1STATES [=] \$1 TRUE \$1 FALSE \$1
La clausola QUERY\$1ALL\$1STATES imposta se è possibile eseguire query sulle tabelle di integrazione Zero-ETL in tutti gli stati (`Synced`, `Failed`, `ResyncRequired` e `ResyncInitiated`). Per impostazione predefinita puoi eseguire query su una tabella di integrazione Zero-ETL solo nello stato `Synced`.
REFRESH\$1INTERVAL
La clausola REFRESH\$1INTERVAL imposta l’intervallo di tempo approssimativo, in secondi, per aggiornare i dati dall’origine zero-ETL al database di destinazione. Il valore può essere impostato su un numero compreso tra 0 e 432.000 secondi (5 giorni) per le integrazioni Zero-ETL il cui tipo di origine è Aurora MySQL, Aurora PostgreSQL o RDS per MySQL. Per le integrazioni Zero-ETL di Amazon DynamoDB, il valore può essere impostato su un numero compreso tra 900 e 432.000 secondi (15 minuti – 5 giorni). L’impostazione predefinita di `interval` è zero (0) secondi per le integrazioni Zero-ETL il cui tipo di origine è Aurora MySQL, Aurora PostgreSQL o RDS per MySQL. Per le integrazioni Zero-ETL di Amazon DynamoDB, l’impostazione predefinita di `interval` è 900 secondi (15 minuti).
TRUNCATECOLUMNS [=] \$1TRUE \$1 FALSE\$1
La clausola TRUNCATECOLUMNS imposta se le tabelle di integrazione Zero-ETL continuano con l’importazione quando i valori per gli attributi della colonna VARCHAR o della colonna SUPER superano il limite. Quando è `TRUE`, i valori vengono troncati per adattarsi alla colonna e i valori degli attributi JSON in overflow vengono troncati per adattarsi alla colonna SUPER.
HISTORY\$1MODE [=] \$1TRUE \$1 FALSE\$1
Una clausola che specifica se Amazon Redshift imposterà la modalità cronologia per tutte le nuove tabelle nel database specificato. Questa opzione è applicabile solo ai database creati per l’integrazione Zero-ETL.
La clausola HISTORY\$1MODE può essere impostata su `TRUE` o `FALSE`. Il valore predefinito è `FALSE`. Per informazioni su HISTORY\$1MODE, consulta [Modalità cronologia](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-history-mode.html) nella *Guida alla gestione di Amazon Redshift*.
WITH
Parola chiave facoltativa.
OWNER [=] db\$1owner
Specifica il nome utente del proprietario del database.
CONNECTION LIMIT \$1 *limit* \$1 UNLIMITED \$1
Numero massimo di connessioni di database che gli utenti possono aprire contemporaneamente. Il limite non viene applicato per gli utente con privilegi avanzati. Utilizza la parola chiave UNLIMITED per consentire il numero massimo di connessioni simultanee. È possibile che venga applicato anche un limite al numero di connessioni per ciascun utente. Per ulteriori informazioni, consultare [CREA UTENTE](r_CREATE_USER.md). Il valore predefinito è UNLIMITED. Per visualizzare le connessioni correnti, eseguire una query sulla vista di sistema [STV\$1SESSIONS](r_STV_SESSIONS.md).
Se si applicano entrambi i limiti di connessione utente e database, deve essere disponibile uno slot di connessione inutilizzato che rientra in entrambi i limiti quando un utente tenta di connettersi.
COLLATE \$1 CASE\$1SENSITIVE \$1 CS \$1 CASE\$1INSENSITIVE \$1 CI \$1
Una clausola che specifica se la ricerca o il confronto di stringhe fa distinzione tra maiuscole e minuscole o meno. L’impostazione predefinita fa distinzione tra maiuscole e minuscole.
COLLATE non è supportato quando si crea un database da un’unità di condivisione dati.
CASE\$1SENSITIVE e CS sono intercambiabili e producono gli stessi risultati. Allo stesso modo CASE\$1INSENSITIVE e CI sono intercambiabili e producono gli stessi risultati.
ISOLATION LEVEL \$1 SNAPSHOT \$1 SERIALIZABLE \$1
Una clausola che specifica il livello di isolamento utilizzato quando vengono eseguite query su un database. Per ulteriori informazioni sui livello di isolamento, consulta [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
+ Isolamento SNAPSHOT: fornisce un livello di isolamento con protezione contro i conflitti di aggiornamento ed eliminazione. Questa è l’impostazione predefinita per un database creato in un cluster con provisioning o un namespace serverless.
+ Isolamento SERIALIZABLE: fornisce la serializzabilità completa per le transazioni simultanee.
FROM ARN ''
L'ARN del AWS Glue database da utilizzare per creare il database.
\$1 WITH DATA CATALOG SCHEMA '' \$1 WITH NO DATA CATALOG SCHEMA \$1
Questo parametro è applicabile solo se il comando CREATE DATABASE utilizza anche il parametro FROM ARN.
Specifica se creare il database utilizzando uno schema per agevolare l'accesso agli oggetti da AWS Glue Data Catalog.
IAM\$1ROLE \$1default \$1 'SESSION' \$1 'arn:aws:iam: :role/ '\$1 ** **
Questo parametro è applicabile solo se il comando CREATE DATABASE utilizza anche il parametro FROM ARN.
Se specifichi un ruolo IAM associato al cluster quando esegui il comando CREATE DATABASE, Amazon Redshift utilizzerà le credenziali del ruolo quando esegui le query sul database.
Specificare la parola chiave `default` significa utilizzare il ruolo IAM impostato come predefinito e associato al cluster.
Utilizzare `'SESSION'` se ci si connette al cluster Amazon Redshift utilizzando un'identità federata e si accede alle tabelle dallo schema esterno creato con questo comando. Per ulteriori informazioni, consulta l'argomento relativo a [Utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html), che illustra come configurare l'identità federata.
L'Amazon Resource Name (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione. Come minimo, il ruolo IAM deve disporre dell'autorizzazione per eseguire un'operazione LIST sul bucket Amazon S3 a cui accedere e un'operazione GET sugli oggetti Amazon S3 contenuti nel bucket. Per ulteriori informazioni sull'utilizzo di IAM\$1ROLE durante la creazione di un database utilizzando AWS Glue Data Catalog per le condivisioni di dati, consulta [Lavorare con le condivisioni di dati gestite da Lake Formation come consumatore](https://docs.aws.amazon.com/redshift/latest/dg/lake-formation-getting-started-consumer.html).
Quanto segue mostra la sintassi per la stringa di parametro IAM\$1ROLE per un singolo ARN.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
È possibile concatenare i ruoli in modo che il cluster possa presumere un altro ruolo IAM, possibilmente appartenente a un altro account. Puoi concatenare fino a 10 ruoli. Per ulteriori informazioni, consulta [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Per collegare a questo ruolo IAM una policy di autorizzazioni IAM simile alla seguente.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Per la procedura per creare un ruolo IAM da utilizzare con la query federata, consultare [Creazione di un segreto e di un ruolo IAM per l'utilizzo di query federate](federated-create-secret-iam-role.md).
Non includere spazi nell'elenco dei ruoli concatenati.
Quanto segue mostra la sintassi per concatenare tre ruoli.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
## Sintassi per l'uso di CREATE DATABASE con una unità di condivisione dati
La sintassi seguente descrive il comando CREATE DATABASE utilizzato per creare database da un datashare per condividere dati all'interno dello stesso account. AWS
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF [ ACCOUNT account_id ] NAMESPACE namespace_guid
```
La sintassi seguente descrive il comando CREATE DATABASE utilizzato per creare database da un datashare per la condivisione di dati tra account. AWS
```
CREATE DATABASE database_name
[ [ WITH PERMISSIONS ] FROM DATASHARE datashare_name OF ACCOUNT account_id NAMESPACE namespace_guid
```
### Parametri per l'uso di CREATE DATABASE con una unità di condivisione dati
FROM DATASHARE
Una parola chiave che indica dove si trova l'unità di condivisione dati.
*datashare\$1name*
Il nome dell'unità di condivisione dati in cui viene creato il database consumer.
WITH PERMISSIONS
Specifica che il database creato dall'unità di condivisione dati richiede autorizzazioni a livello di oggetto per accedere ai singoli oggetti del database. Senza questa clausola, gli utenti o i ruoli a cui è stata concessa l'autorizzazione USAGE sul database hanno automaticamente accesso a tutti gli oggetti del database.
NAMESPACE *namespace\$1guid*
Un valore che specifica lo spazio dei nomi del produttore a cui appartiene l'unità di condivisione dati.
ACCOUNT *account\$1id*
Un valore che specifica lo spazio dei nomi del produttore a cui appartiene l'unità di condivisione dati.
## Note di utilizzo per CREATE DATABASE per la condivisione di dati
In qualità di superutente del database, quando utilizzi CREATE DATABASE per creare database da datashare all'interno dell' AWS account, specifica l'opzione NAMESPACE. L'opzione ACCOUNT è facoltativa. Quando si utilizza CREATE DATABASE per creare database da unità di condivisione dati tra account AWS , è necessario specificare le opzioni ACCOUNT e NAMESPACE dal producer.
È possibile creare un solo database consumer per un'unità unità di condivisione dati in un cluster consumer. Non è possibile creare più database consumer che si riferiscono alla stessa unità di condivisione dati.
## CREA DATABASE da AWS Glue Data Catalog
Per creare un database utilizzando un ARN di AWS Glue database, specifica l'ARN nel comando CREATE DATABASE.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA;
```
Facoltativamente, puoi anche fornire un valore nel parametro IAM\$1ROLE. Per ulteriori informazioni sui parametri e sui valori accettati, consulta [Parametri](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_DATABASE.html#r_CREATE_DATABASE-parameters).
Di seguito sono riportati esempi che dimostrano come creare un database da un ARN utilizzando un ruolo IAM.
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE
```
```
CREATE DATABASE sampledb FROM ARN WITH NO DATA CATALOG SCHEMA IAM_ROLE default;
```
È inoltre possibile creare un database utilizzando uno SCHEMA DEL CATALOGO DATI.
```
CREATE DATABASE sampledb FROM ARN WITH DATA CATALOG SCHEMA IAM_ROLE default;
```
## Crea database per ricevere i risultati delle integrazioni Zero-ETL
Per creare un database utilizzando un’identità di integrazione Zero-ETL, specifica il valore `integration_id` nel comando CREATE DATABASE.
```
CREATE DATABASE destination_db_name FROM INTEGRATION 'integration_id';
```
Ad esempio, recupera innanzitutto gli ID di integrazione da SVV\$1INTEGRATION.
```
SELECT integration_id FROM SVV_INTEGRATION;
```
Quindi utilizza uno degli ID di integrazione recuperati per creare il database che riceve le integrazioni Zero-ETL.
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111';
```
Quando è necessario il database di origine delle integrazioni Zero-ETL, ad esempio, specifica:
```
CREATE DATABASE sampledb FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' DATABASE sourcedb;
```
Puoi inoltre impostare un intervallo di aggiornamento per il database. Ad esempio, per impostare l’intervallo di aggiornamento su 7.200 secondi per i dati provenienti da una fonte di integrazione Zero-ETL:
```
CREATE DATABASE myacct_mysql FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET REFRESH_INTERVAL 7200;
```
Esegui la query sulla vista del catalogo SVV\$1INTEGRATION per informazioni su un’integrazione Zero-ETL, ad esempio integration\$1id, target\$1database, source, refresh\$1interval e altro.
```
SELECT * FROM svv_integration;
```
L’esempio seguente crea un database a partire da un’integrazione con la modalità cronologia attiva.
```
CREATE DATABASE sample_integration_db FROM INTEGRATION 'a1b2c3d4-5678-90ab-cdef-EXAMPLE11111' SET HISTORY_MODE = true;
```
## Limiti di CREATE DATABASE
Amazon Redshift applica i seguenti limiti per i database:
+ Massimo 60 database definiti dall'utente per cluster.
+ Massimo 127 byte per un nome del database.
+ Il nome di un database non può essere una parola riservata.
## Confronto di database
Il confronto è un insieme di regole che definisce il modo in cui il motore di database confronta e ordina i dati di tipo carattere in SQL. Il confronto senza distinzione tra maiuscole e minuscole è il tipo di confronto più utilizzato. Amazon Redshift utilizza il confronto senza distinzione tra maiuscole e minuscole per facilitare la migrazione da altri sistemi di data warehouse. Con il supporto nativo del confronto senza distinzione tra maiuscole e minuscole, Amazon Redshift continua a utilizzare importanti metodi di regolazione o ottimizzazione, come le chiavi di distribuzione, le chiavi di ordinamento o la scansione con intervallo limitato.
La clausola COLLATE specifica il confronto di default per tutte le colonne CHAR e VARCHAR nel database. Se è specificato CASE\$1INSENSITIVE, tutte le colonne CHAR o VARCHAR utilizzano confronto senza distinzione tra maiuscole e minuscole Per informazioni sul confronto, consultare [Sequenze di regole di confronto](c_collation_sequences.md).
I dati inseriti o importati nelle colonne senza distinzione tra maiuscole e minuscole manterranno il loro formato maiuscole/minuscole originale. Ma tutte le operazioni di stringa basate su confronto, inclusi l'ordinamento e il raggruppamento, non fanno distinzione tra maiuscole e minuscole. Anche le operazioni di corrispondenza dei modelli come predicati LIKE, SIMILAR TO e funzioni di espressione regolare non fanno distinzione tra maiuscole e minuscole.
Le seguenti operazioni SQL supportano la semantica di confronto applicabile:
+ Operatori di confronto: =, <>, <, <=, >, >=.
+ Operatore LIKE
+ Clausola ORDER BY
+ Clausole GROUP BY
+ Funzioni di aggregazione che utilizzano il confronto di stringhe, come MIN e MAX e LISTAGG
+ Funzioni finestra, ad esempio clausole PARTITION BY e clausole ORDER BY
+ Funzioni scalari greatest() e least(), STRPOS(), REGEXP\$1COUNT(), REGEXP\$1REPLACE(), REGEXP\$1INSTR(), REGEXP\$1SUBSTR()
+ Clausola separata
+ UNION, INTERSECT ed EXCEPT
+ IN LIST
Per le query esterne, incluse le query federate di Amazon Redshift Spectrum e Aurora PostgreSQL, il confronto della colonna VARCHAR o CHAR è uguale al confronto corrente a livello di database.
Nell'esempio seguente viene eseguita una query su una tabella Amazon Redshift Spectrum:
```
SELECT ci_varchar FROM spectrum.test_collation
WHERE ci_varchar = 'AMAZON';
ci_varchar
----------
amazon
Amazon
AMAZON
AmaZon
(4 rows)
```
Per informazioni su come creare le tabelle mediante il confronto di database, consultare [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Per ulteriori informazioni sulla funzione COLLATE, consultare [Funzione COLLATE](r_COLLATE.md).
### Limitazioni del confronto di database
Di seguito sono elencate le limitazioni nell'utilizzo del confronto di database in Amazon Redshift:
+ Tutte le tabelle o le viste di sistema, incluse le tabelle dei cataloghi PG e le tabelle di sistema di Amazon Redshift, fanno distinzione tra maiuscole e minuscole.
+ Quando il database consumer e il database producer hanno regole di confronto diverse a livello di database, Amazon Redshift non supporta query tra database e tra cluster.
+ Amazon Redshift non supporta il confronto senza distinzione tra maiuscole e minuscole nella query sul solo nodo principale.
Nell'esempio seguente viene mostrata una query senza distinzione tra maiuscole e minuscole non supportata e l'errore restituito da Amazon Redshift:
```
SELECT collate(usename, 'case_insensitive') FROM pg_user;
ERROR: Case insensitive collation is not supported in leader node only query.
```
+ Amazon Redshift non supporta l'interazione tra le colonne con distinzione o senza distinzione tra maiuscole e minuscole, ad esempio operazioni di confronto, funzione, join o set.
Negli esempi seguenti vengono mostrati gli errori restituiti quando interagiscono colonne con distinzione e senza distinzione tra maiuscole e minuscole:
```
CREATE TABLE test
(ci_col varchar(10) COLLATE case_insensitive,
cs_col varchar(10) COLLATE case_sensitive,
cint int,
cbigint bigint);
```
```
SELECT ci_col = cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT concat(ci_col, cs_col) FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT ci_col FROM test UNION SELECT cs_col FROM test;
ERROR: Query with different collations is not supported yet.
```
```
SELECT * FROM test a, test b WHERE a.ci_col = b.cs_col;
ERROR: Query with different collations is not supported yet.
```
```
Select Coalesce(ci_col, cs_col) from test;
ERROR: Query with different collations is not supported yet.
```
```
Select case when cint > 0 then ci_col else cs_col end from test;
ERROR: Query with different collations is not supported yet.
```
Per far funzionare queste query, utilizzare la funzione COLLATE per convertire il confronto di una colonna in modo che corrisponda all'altra. Per ulteriori informazioni, consulta [Funzione COLLATE](r_COLLATE.md).
## Esempi
**Creazione di un database**
Nell'esempio seguente viene creato un database denominato TICKIT e ne viene assegnata la proprietà all'utente DWUSER:
```
create database tickit
with owner dwuser;
```
Per visualizzare i dettagli sui database, eseguire una query sulla tabella di catalogo PG\$1DATABASE\$1INFO.
```
select datname, datdba, datconnlimit
from pg_database_info
where datdba > 1;
datname | datdba | datconnlimit
-------------+--------+-------------
admin | 100 | UNLIMITED
reports | 100 | 100
tickit | 100 | 100
```
L'esempio seguente crea un database denominato **sampledb** con livello di isolamento SNAPSHOT.
```
CREATE DATABASE sampledb ISOLATION LEVEL SNAPSHOT;
```
Nell'esempio seguente viene creato il database sales\$1db dall'unità di condivisione dati salesshare.
```
CREATE DATABASE sales_db FROM DATASHARE salesshare OF NAMESPACE '13b8833d-17c6-4f16-8fe4-1a018f5ed00d';
```
### Esempi di confronto di database
**Creazione di un database senza distinzione tra maiuscole e minuscole**
Nell'esempio seguente viene creato il database `sampledb`, la tabella `T1` e sono inseriti i dati nella tabella `T1`.
```
create database sampledb collate case_insensitive;
```
Esegui la connessione al nuovo database che hai appena creato usando il client SQL. Se usi l'Editor di query Amazon Redshift v2, scegli `sampledb` in **Editor**. Se usi RSQL, esegui un comando come il seguente.
```
\connect sampledb;
```
```
CREATE TABLE T1 (
col1 Varchar(20) distkey sortkey
);
```
```
INSERT INTO T1 VALUES ('bob'), ('john'), ('Mary'), ('JOHN'), ('Bob');
```
Quindi la query trova i risultati con `John`.
```
SELECT * FROM T1 WHERE col1 = 'John';
col1
------
john
JOHN
(2 row)
```
**Ordinamento senza distinzione tra maiuscole e minuscole**
Nell'esempio seguente è mostrato l'ordinamento senza distinzione tra maiuscole e minuscole con la tabella T1. L’ordinamento di *Bob* e *bob* o *John* e *john* non è deterministico perché sono uguali nella colonna senza distinzione tra maiuscole e minuscole.
```
SELECT * FROM T1 ORDER BY 1;
col1
------
bob
Bob
JOHN
john
Mary
(5 rows)
```
Analogamente, nell'esempio seguente è mostrato l'ordinamento senza distinzione tra maiuscole e minuscole con la clausola GROUP BY. *Bob* e *bob* sono uguali e appartengono allo stesso gruppo. È non deterministico ciò che si presenta nel risultato.
```
SELECT col1, count(*) FROM T1 GROUP BY 1;
col1 | count
-----+------
Mary | 1
bob | 2
JOHN | 2
(3 rows)
```
**Esecuzione di query con una funzione finestra su colonne senza distinzione tra maiuscole e minuscole**
Nell'esempio seguente viene eseguita una query su una funzione finestra senza distinzione tra maiuscole e minuscole.
```
SELECT col1, rank() over (ORDER BY col1) FROM T1;
col1 | rank
-----+------
bob | 1
Bob | 1
john | 3
JOHN | 3
Mary | 5
(5 rows)
```
**Esecuzione di query con la parola chiave DISTINCT**
Nell'esempio seguente viene eseguita una query sulla tabella `T1` con la parola chiave DISTINCT.
```
SELECT DISTINCT col1 FROM T1;
col1
------
bob
Mary
john
(3 rows)
```
**Esecuzione di query con la clausola UNION**
Nell'esempio seguente sono mostrati i risultati dell'UNION delle tabelle `T1` e `T2`.
```
CREATE TABLE T2 AS SELECT * FROM T1;
```
```
SELECT col1 FROM T1 UNION SELECT col1 FROM T2;
col1
------
john
bob
Mary
(3 rows)
```
# CREARE DATASHARE
Crea una nuova unità di condivisione dati nel database corrente. Il proprietario di questa unità di condivisione dati è l'emittente del comando CREATE DATASHARE.
Amazon Redshift associa ogni unità di condivisione dati a un unico database Amazon Redshift. È possibile aggiungere oggetti all'unità di condivisione dati solo da quel database associato. È possibile creare più unità di condivisione dati sullo stesso database Amazon Redshift.
Per informazioni sulle unità di condivisione dati, consultare [Condivisione dei dati in Amazon Redshift](datashare-overview.md).
Per visualizzare informazioni sulle unità di condivisione dati, utilizzare [SHOW DATASHARES](r_SHOW_DATASHARES.md).
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per CREATE DATASHARE:
+ Superuser
+ Utenti con il privilegio CREATE DATASHARE
+ Proprietario del database
## Sintassi
```
CREATE DATASHARE datashare_name
[[SET] PUBLICACCESSIBLE [=] TRUE | FALSE ];
```
## Parameters
*datashare\$1name*
Il nome dell'unità di condivisione dati. Il nome dell'unità di condivisione dati deve essere univoco nello spazio dei nomi del cluster.
[[SET] PUBLICACCESSIBLE]
Una clausola che specifica se una unità di condivisione dati può essere condivisa nei cluster accessibili pubblicamente.
Il valore predefinito per `SET PUBLICACCESSIBLE` è `FALSE`.
## Note per l’utilizzo
Per impostazione predefinita, il proprietario dell'unità di condivisione dati possiede solo la condivisione e non gli oggetti all'interno della condivisione.
Solo gli utenti con privilegi avanzati e il proprietario del database possono utilizzare CREATE DATASHARE e delegare i privilegi ALTER ad altri utenti o gruppi.
## Esempi
Nell'esempio seguente viene creata l'unità di condivisione dati `salesshare`.
```
CREATE DATASHARE salesshare;
```
Nell'esempio seguente viene creata l'unità di condivisione dati `demoshare` gestita da AWS Data Exchange .
```
CREATE DATASHARE demoshare SET PUBLICACCESSIBLE TRUE, MANAGEDBY ADX;
```
# CREATE EXTERNAL FUNCTION
Crea una funzione scalare definita dall'utente (UDF) basata su Amazon AWS Lambda Redshift. Per ulteriori informazioni sulle funzioni Lambda definite dall'utente, consultare [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md).
## Privilegi richiesti
Di seguito sono riportati i privilegi necessari per CREATE EXTERNAL FUNCTION:
+ Superuser
+ Utenti con il privilegio CREATE [ OR REPLACE ] EXTERNAL FUNCTION
## Sintassi
```
CREATE [ OR REPLACE ] EXTERNAL FUNCTION external_fn_name ( [data_type] [, ...] )
RETURNS data_type
{ VOLATILE | STABLE }
LAMBDA 'lambda_fn_name'
IAM_ROLE { default | ‘arn:aws:iam:::role/’
RETRY_TIMEOUT milliseconds
MAX_BATCH_ROWS count
MAX_BATCH_SIZE size [ KB | MB ];
```
## Parameters
OR REPLACE
Una clausola che specifica che se una funzione con stesso nome e tipi di dati degli argomenti di input o *firma* è già esistente, la funzione esistente viene sostituita. Puoi sostituire una funzione solo con una nuova funzione che definisce un set identico di tipi di dati. Devi essere un utente con privilegi avanzati per sostituire una funzione.
Se definisci una funzione con lo stesso nome di una funzione esistente ma con una firma diversa, viene creata una nuova funzione. In altre parole, il nome della funzione è sottoposto a overload. Per ulteriori informazioni, consulta [Overload dei nomi delle funzioni](udf-naming-udfs.md#udf-naming-overloading-function-names).
*external\$1fn\$1name*
Il nome della funzione esterna. Se si specifica un nome schema (come myschema.myfunction), la funzione viene creata utilizzando lo schema specificato. Altrimenti, la funzione viene creata nello schema corrente. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
Consigliamo di assegnare un prefisso `f_` ai nomi di tutte le funzioni definite dall'utente. Amazon Redshift riserva il prefisso `f_` per i nomi delle funzioni definite dall'utente. Utilizzando il prefisso `f_`, è possibile assicurarsi che il nome della funzione non sia in conflitto con i nomi delle funzioni SQL predefinite di Amazon Redshift correnti e future. Per ulteriori informazioni, consulta [Prevenzione dei conflitti di denominazione delle funzioni definite dall'utente](udf-naming-udfs.md).
*data\$1type*
Il tipo di dati per gli argomenti di input. Per ulteriori informazioni, consultare [Python scalare UDFs](udf-creating-a-scalar-udf.md) e [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md).
RETURNS *data\$1type*
Il tipo di dati del valore restituito dalla funzione. Il tipo di dati RETURNS può essere qualsiasi tipo di dati standard Amazon Redshift. Per ulteriori informazioni, consultare [Python scalare UDFs](udf-creating-a-scalar-udf.md) e [Lambda scalare UDFs](udf-creating-a-lambda-sql-udf.md).
VOLATILE \$1 STABILE
Informa l'ottimizzatore di query circa la volatilità della funzione.
Per ottenere la migliore ottimizzazione, etichettare la funzione con la categoria di volatilità più rigida valida. In ordine di rigidità, a partire dalla meno rigida, le categorie di volatilità sono le seguenti:
+ VOLATILE
+ STABLE
VOLATILE
Dati gli stessi argomenti, la funzione può restituire risultati diversi su chiamate successive, anche per le righe in una singola istruzione. L'ottimizzatore di query non può fare alcuna ipotesi sul comportamento di una funzione volatile. Una query che utilizza una funzione volatile deve rivalutare la funzione per ogni input.
STABLE
Dati gli stessi argomenti, la funzione è garantita per restituire gli stessi risultati nelle chiamate successive elaborate all'interno di una singola istruzione. La funzione può restituire risultati diversi se richiamati in istruzioni diverse. Questa categoria consente all'ottimizzatore di ridurre il numero di volte in cui la funzione viene chiamata all'interno di una singola istruzione.
Nota che se la severità scelta non è valida per la funzione, c'è il rischio che l'ottimizzatore salti alcune chiamate in base a questa severità. Ciò può comportare un set di risultati errato.
La clausola IMMUTABLE non è attualmente supportata per Lambda. UDFs
LAMBDA *'lambda\$1fn\$1name'*
Il nome della funzione richiamata da Amazon Redshift.
Per i passaggi per creare una AWS Lambda funzione, consulta [Creare una funzione Lambda con la console nella Guida](https://docs.aws.amazon.com/lambda/latest/dg/getting-started-create-function.html) per gli *AWS Lambda sviluppatori*.
Per informazioni sulle autorizzazioni richieste per la funzione Lambda, consultare [Autorizzazioni AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-permissions.html) nella *Guida per gli sviluppatori di AWS Lambda *.
IAM\$1ROLE \$1default \$1 'arn:aws:iam: :role/ '****
Utilizzare la parola chiave predefinita per fare in modo che Amazon Redshift utilizzi il ruolo IAM impostato come predefinito e associato al cluster quando viene eseguito il comando CREATE EXTERNAL FUNCTION.
L'Amazon Resource Name (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione. Il comando CREATE EXTERNAL FUNCTION è autorizzato per il richiamo delle funzioni Lambda tramite questo ruolo IAM. Se il cluster possiede un ruolo IAM esistente con autorizzazioni per richiamare funzioni Lambda collegate, è possibile sostituire l'ARN del ruolo. Per ulteriori informazioni, consulta [Configurazione del parametro di autorizzazione per Lambda UDFs](udf-creating-a-lambda-sql-udf.md#udf-lambda-authorization).
Di seguito è mostrata la sintassi del parametro IAM\$1ROLE.
```
IAM_ROLE 'arn:aws:iam::aws-account-id:role/role-name'
```
RETRY\$1TIMEOUT *millisecondi*
La quantità di tempo totale, espressa in millisecondi, utilizzata da Amazon Redshift per i ritardi nei backoff dei tentativi.
Invece di riprovare immediatamente per eventuali query non riuscite, Amazon Redshift esegue i backoff e attende un certo periodo di tempo tra i tentativi. Quindi Amazon Redshift riprova la richiesta di eseguire nuovamente la query non riuscita fino a quando la somma di tutti i ritardi è uguale o superiore al valore RETRY\$1TIMEOUT specificato. Il valore di default è 20.000 millisecondi.
Quando viene richiamata una funzione Lambda, Amazon Redshift prova a eseguire nuovamente le query che ricevono errori come `TooManyRequestsException`, `EC2ThrottledException` e `ServiceException`.
È possibile impostare il parametro RETRY\$1TIMEOUT su 0 millisecondi per evitare nuovi tentativi per una funzione Lambda definita dall'utente.
MAX\$1BATCH\$1ROWS *count*
Numero massimo di righe che Amazon Redshift invia in una singola richiesta batch per una singola chiamata lambda.
Il valore minimo per questo parametro è 1. Il valore massimo è INT\$1MAX o 2.147.483.647.
Questo parametro è facoltativo. Il valore predefinito è INT\$1MAX o 2.147.483.647.
MAX\$1BATCH\$1SIZE *size* [ KB \$1 MB ]
La dimensione massima del payload di dati che Amazon Redshift invia in una singola richiesta batch per una singola chiamata lambda.
Il valore minimo per questo parametro è 1 KB. Il valore massimo è 5 MB.
Il valore predefinito di questo parametro è 5 MB.
KB e MB sono facoltativi. Se non si imposta l'unità di misura, Amazon Redshift utilizza per impostazione predefinita KB.
## Note per l'utilizzo
Considera quanto segue quando crei UDFs Lambda:
+ L'ordine delle chiamate alla funzione Lambda sugli argomenti di input non è fisso o garantito. Può variare tra le istanze di esecuzione delle query, a seconda della configurazione del cluster.
+ Non è garantito che le funzioni vengano applicate a ciascun argomento di input una sola volta. L'interazione tra Amazon Redshift e AWS Lambda potrebbe portare a chiamate ripetitive con gli stessi input.
## Esempi
Di seguito sono riportati alcuni esempi di utilizzo delle funzioni scalari definite dall'utente Lambda (). UDFs
### Esempio di funzione Lambda definita dall'utente scalare che utilizza una funzione Lambda Node.js
L'esempio seguente crea una funzione esterna denominata `exfunc_sum` che utilizza due numeri interi come argomenti di input. Questa funzione restituisce la somma come output intero. Il nome della funzione Lambda da chiamare è `lambda_sum`. La lingua utilizzata per questa funzione Lambda è Node.js 12.x. Assicurarsi di specificare il ruolo IAM. L'esempio utilizza `'arn:aws:iam::123456789012:user/johndoe'` come ruolo IAM.
```
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT)
RETURNS INT
VOLATILE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
La funzione Lambda accetta il payload della richiesta ed esegue l'iterazione su ogni riga. Tutti i valori di una singola riga vengono aggiunti per calcolare la somma per quella riga, che viene salvata nell'array di risposte. Il numero di righe nell'array dei risultati è simile al numero di righe ricevute nel payload della richiesta.
Perché sia riconosciuto dalla funzione esterna, il payload della risposta JSON deve avere i dati di risultato nel campo 'results'. Il campo argomenti nella richiesta inviata alla funzione Lambda contiene il payload dei dati. In caso di richiesta batch, è possibile avere più righe nel payload dei dati. La seguente funzione Lambda itera su tutte le righe nel payload dei dati della richiesta. Inoltre, itera individualmente su tutti i valori all'interno di una singola riga.
```
exports.handler = async (event) => {
// The 'arguments' field in the request sent to the Lambda function contains the data payload.
var t1 = event['arguments'];
// 'len(t1)' represents the number of rows in the request payload.
// The number of results in the response payload should be the same as the number of rows received.
const resp = new Array(t1.length);
// Iterating over all the rows in the request payload.
for (const [i, x] of t1.entries())
{
var sum = 0;
// Iterating over all the values in a single row.
for (const y of x) {
sum = sum + y;
}
resp[i] = sum;
}
// The 'results' field should contain the results of the lambda call.
const response = {
results: resp
};
return JSON.stringify(response);
};
```
Nell'esempio seguente viene chiamata la funzione esterna con valori letterali.
```
select exfunc_sum(1,2);
exfunc_sum
------------
3
(1 row)
```
Nell'esempio seguente viene creata una tabella denominata t\$1sum con due colonne, c1 e c2, del tipo di dati intero e vengono inserite due righe di dati. Quindi la funzione esterna viene chiamata passando i nomi delle colonne di questa tabella. Le due righe della tabella vengono inviate in una richiesta batch nel payload della richiesta come un singolo richiamo Lambda.
```
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
exfunc_sum
---------------
9
13
(2 rows)
```
### Esempio di funzione Lambda definita dall'utente scalare che utilizza l'attributo RETRY\$1TIMEOUT
Nella sezione seguente, puoi trovare un esempio di come utilizzare l'attributo RETRY\$1TIMEOUT in Lambda. UDFs
AWS Lambda le funzioni hanno limiti di concorrenza che è possibile impostare per ciascuna funzione. Per ulteriori informazioni sui limiti di concorrenza, consulta [Gestire la concorrenza per una funzione Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html) nella *Guida per gli AWS Lambda sviluppatori* e il post [Managing AWS Lambda Function Concurrency](https://aws.amazon.com/blogs/compute/managing-aws-lambda-function-concurrency) sul blog di Compute. AWS
Quando il numero di richieste servite da una funzione Lambda definita dall'utente supera i limiti di simultaneità, le nuove richieste ricevono l'errore `TooManyRequestsException`. La funzione Lambda definita dall'utente riprova su questo errore fino a quando la somma di tutti i ritardi tra le richieste inviate alla funzione Lambda è uguale o superiore al valore RETRY\$1TIMEOUT impostato. Il valore di default di RETRY\$1TIMEOUT è 20.000 millisecondi.
L'esempio seguente crea una funzione Lambda denominata `exfunc_sleep_3`. Questa funzione prende in carico il payload della richiesta, itera su ogni riga e converte l'input in maiuscolo. Quindi si interrompe per 3 secondi e restituisce il risultato. Il linguaggio utilizzato per questa funzione Lambda è Python 3.8.
Il numero di righe nell'array dei risultati è simile al numero di righe ricevute nel payload della richiesta. Perché sia riconosciuto dalla funzione esterna, il payload della risposta JSON deve avere i dati di risultato nel campo `results`. Il campo `arguments` nella richiesta inviata alla funzione Lambda contiene il payload dei dati. In caso di richiesta batch, è possibile avere più righe nel payload dei dati.
Il limite di simultaneità per questa funzione è impostato specificatamente su 1 nella simultaneità riservata per dimostrare l'utilizzo dell'attributo RETRY\$1TIMEOUT. Quando l'attributo è impostato su 1, la funzione Lambda può servire solo una richiesta alla volta.
```
import json
import time
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
# Iterating over all the values in a single row.
for j, y in enumerate(x):
resp[i] = y.upper()
time.sleep(3)
ret = dict()
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
Di seguito, due esempi aggiuntivi illustrano l'attributo RETRY\$1TIMEOUT. Ognuno di essi richiama una singola funzione Lambda definita dall'utente. Durante il richiamo della funzione Lambda, ogni esempio esegue la stessa query SQL per richiamare la funzione Lambda da due sessioni di database simultanee contemporaneamente. Quando la prima query che richiama la funzione Lambda definita dall'utente viene servita dalla funzione, la seconda query riceve l'errore `TooManyRequestsException`. Questo risultato si verifica perché si imposta in modo specifico la simultaneità riservata nella funzione definita dall'utente su 1. Per informazioni su come configurare la simultaneità riservata per le funzioni Lambda, consultare [Configurazione della simultaneità riservata](https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html#configuration-concurrency-reservedconfiguration-concurrency-reserved).
Nel primo esempio che segue, l'attributo RETRY\$1TIMEOUT per la funzione Lambda definita dall'utente viene impostato su 0 millisecondi. Se la richiesta Lambda riceve una qualsiasi eccezione dalla funzione Lambda, Amazon Redshift non esegue alcun nuovo tentativo. Questo risultato si verifica perché l'attributo RETRY\$1TIMEOUT è impostato su 0.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 0;
```
Con RETRY\$1TIMEOUT impostato su 0, è possibile eseguire le seguenti due query da sessioni di database separate e visualizzare risultati diversi.
La prima query SQL che utilizza la funzione Lambda definita dall'utente viene eseguita correttamente.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
La seconda query, eseguita contemporaneamente da una sessione di database separata, riceve l'errore `TooManyRequestsException`.
```
select exfunc_upper('Varchar');
ERROR: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
DETAIL:
-----------------------------------------------
error: Rate Exceeded.; Exception: TooManyRequestsException; ShouldRetry: 1
code: 32103
context:query: 0
location: exfunc_client.cpp:102
process: padbmaster [pid=26384]
-----------------------------------------------
```
Nel primo esempio che segue, l'attributo RETRY\$1TIMEOUT per la funzione Lambda definita dall'utente viene impostato su 3.000 millisecondi. Anche se la seconda query viene eseguita contemporaneamente, la funzione Lambda definita dall'utente tenta di nuovo fino a quando il ritardo totale è di 3.000 millisecondi. Pertanto, entrambe le query vengono eseguite correttamente.
```
CREATE OR REPLACE EXTERNAL FUNCTION exfunc_upper(varchar)
RETURNS varchar
VOLATILE
LAMBDA 'exfunc_sleep_3'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'
RETRY_TIMEOUT 3000;
```
Con RETRY\$1TIMEOUT impostato su 3.000 millisecondi, è possibile eseguire le seguenti due query da sessioni di database separate e visualizzare gli stessi risultati.
La prima query SQL che esegue la funzione Lambda definita dall'utente viene eseguita correttamente.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
La seconda query viene eseguita contemporaneamente e la funzione Lambda definita dall'utente prova di nuovo fino a quando il ritardo totale è di 3.000 millisecondi.
```
select exfunc_upper('Varchar');
exfunc_upper
--------------
VARCHAR
(1 row)
```
### Esempio di funzione Lambda definita dall'utente scalare che utilizza una funzione Lambda Python
L'esempio seguente crea una funzione esterna denominata `exfunc_multiplication` e che moltiplica i numeri e restituisce un numero intero. Questo esempio incorpora il successo e i campi `error_msg` nella risposta Lambda. Il campo di successo è impostato su false quando c'è un overflow di numeri interi nel risultato della moltiplicazione e il messaggio `error_msg` è impostato su `Integer multiplication overflow`. La funzione `exfunc_multiplication` accetta tre numeri interi come argomenti di input e restituisce la somma come output intero.
Il nome della funzione Lambda richiamata è `lambda_multiplication`. Il linguaggio utilizzato per questa funzione Lambda è Python 3.8. Assicurarsi di specificare il ruolo IAM.
```
CREATE EXTERNAL FUNCTION exfunc_multiplication(int, int, int)
RETURNS INT
VOLATILE
LAMBDA 'lambda_multiplication'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
```
La funzione Lambda accetta il payload della richiesta ed esegue l'iterazione su ogni riga. Tutti i valori di una singola riga vengono moltiplicati per calcolare il risultato di tale riga, che viene salvato nell'elenco delle risposte. In questo esempio viene utilizzato un valore di successo booleano impostato su true per impostazione predefinita. Se il risultato della moltiplicazione per una riga ha un overflow intero, il valore di successo è impostato su false. Quindi il ciclo di iterazione si interrompe.
Durante la creazione del payload di risposta, se il valore di successo è false, la seguente funzione Lambda aggiunge il campo `error_msg` nel payload. Imposta anche il messaggio di errore su `Integer multiplication overflow`. Se il valore di successo è true, i dati dei risultati vengono aggiunti nel campo dei risultati. Il numero di righe nell'array dei risultati, se presente, è simile al numero di righe ricevute nel payload della richiesta.
Il campo argomenti nella richiesta inviata alla funzione Lambda contiene il payload dei dati. In caso di richiesta batch, è possibile avere più righe nel payload dei dati. La seguente funzione Lambda itera su tutte le righe nel payload dei dati richiesta e itera individualmente su tutti i valori all'interno di una singola riga.
```
import json
def lambda_handler(event, context):
t1 = event['arguments']
# 'len(t1)' represents the number of rows in the request payload.
# The number of results in the response payload should be the same as the number of rows received.
resp = [None]*len(t1)
# By default success is set to 'True'.
success = True
# Iterating over all rows in the request payload.
for i, x in enumerate(t1):
mul = 1
# Iterating over all the values in a single row.
for j, y in enumerate(x):
mul = mul*y
# Check integer overflow.
if (mul >= 9223372036854775807 or mul <= -9223372036854775808):
success = False
break
else:
resp[i] = mul
ret = dict()
ret['success'] = success
if not success:
ret['error_msg'] = "Integer multiplication overflow"
else:
ret['results'] = resp
ret_json = json.dumps(ret)
return ret_json
```
Nell'esempio seguente viene chiamata la funzione esterna con valori letterali.
```
SELECT exfunc_multiplication(8, 9, 2);
exfunc_multiplication
---------------------------
144
(1 row)
```
Nell'esempio seguente viene creata una tabella denominata t\$1multi con tre colonne, c1, c2 e c3, del tipo di dati intero. La funzione esterna viene chiamata passando i nomi delle colonne di questa tabella. I dati vengono inseriti in modo tale da causare l'overflow di interi per mostrare come l'errore viene propagato.
```
CREATE TABLE t_multi (c1 int, c2 int, c3 int);
INSERT INTO t_multi VALUES (2147483647, 2147483647, 4);
SELECT exfunc_multiplication(c1, c2, c3) FROM t_multi;
DETAIL:
-----------------------------------------------
error: Integer multiplication overflow
code: 32004context:
context:
query: 38
location: exfunc_data.cpp:276
process: query2_16_38 [pid=30494]
-----------------------------------------------
```
# CREATE EXTERNAL MODEL
**Topics**
+ [Prerequisiti per CREATE EXTERNAL MODEL](#r_create_external_model_prereqs)
+ [Privilegi richiesti](#r_simple_create_model-privileges)
+ [Controllo dei costi](#r_create_model_cost)
+ [Sintassi di CREATE EXTERNAL MODEL](#r_create_external_model_syntax)
+ [Parametri e impostazioni di CREATE EXTERNAL MODEL](#r_create_external_model_parameters_settings)
+ [Parametri della funzione di inferenza CREATE EXTERNAL MODEL](#r_create_external_model_if_parameters)
## Prerequisiti per CREATE EXTERNAL MODEL
Prima di utilizzare l’istruzione CREATE MODEL, completa i prerequisiti descritti in [Configurazione del cluster per l'utilizzo di Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup). Di seguito è riportato un riepilogo approfondito dei prerequisiti.
+ Crea un cluster Amazon Redshift con la console di AWS gestione o l'interfaccia a riga di AWS comando (CLI AWS ).
+ Allega la policy AWS Identity and Access Management (IAM) durante la creazione del cluster.
+ Per consentire ad Amazon Redshift e Amazon Bedrock di assumere il ruolo per interagire con altri servizi, aggiungi la seguente policy di attendibilità al ruolo IAM.
+ Abilita l'accesso allo specifico LLMs che desideri utilizzare dalla console Amazon Bedrock.
+ (Facoltativo) Se riscontri eccezioni di limitazione provenienti da Amazon Bedrock, ad esempio `Too many requests, please wait before trying again`, anche con piccole quantità di dati, controlla le quote nella sezione **Service Quotas** nell’account di Amazon Bedrock. Verifica che la quota applicata a livello di account sia almeno uguale al valore di quota AWS predefinito per **InvokeModel**le richieste per il modello che stai utilizzando.
Per maggiori dettagli sul ruolo IAM, sulla policy di attendibilità e su altri prerequisiti, consultare [Configurazione del cluster per l'utilizzo di Amazon Redshift ML](getting-started-machine-learning.md#cluster-setup).
## Privilegi richiesti
Di seguito sono riportati i privilegi richiesti per CREATE EXTERNAL MODEL:
+ Superuser
+ Utenti con il privilegio CREATE MODEL
+ Ruoli con il privilegio GRANT CREATE MODEL
## Controllo dei costi
Amazon Redshift ML utilizza le risorse cluster esistenti per creare modelli di previsione, quindi non sono previsti costi aggiuntivi. Tuttavia, i AWS costi per l'utilizzo di Amazon Bedrock dipendono dal modello selezionato. Per ulteriori informazioni consulta [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html).
## Sintassi di CREATE EXTERNAL MODEL
Di seguito è riportata la sintassi completa dell’istruzione CREATE EXTERNAL MODEL.
```
CREATE EXTERNAL MODEL model_name
FUNCTION function_name
IAM_ROLE {default/'arn:aws:iam:::role/'}
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID model_id
[, PROMPT 'prompt prefix']
[, SUFFIX 'prompt suffix']
[, REQUEST_TYPE {RAW|UNIFIED}]
[, RESPONSE_TYPE {VARCHAR|SUPER}]
);
```
Il comando `CREATE EXTERNAL MODEL` crea una funzione di inferenza da utilizzare per generare contenuti.
Di seguito è riportata la sintassi di una funzione di inferenza che `CREATE EXTERNAL MODEL` crea utilizzando `REQUEST_TYPE` uguale a `RAW`:
```
SELECT inference_function_name(request_super)
[FROM table];
```
Di seguito è riportata la sintassi di una funzione di inferenza che `CREATE EXTERNAL MODEL` crea utilizzando `REQUEST_TYPE` uguale a `UNIFIED`:
```
SELECT inference_function_name(input_text, [, inference_config [, additional_model_request_fields]])
[FROM table];
```
Per informazioni su come utilizzare una funzione di inferenza, consulta [Utilizzo di un modello esterno per l’integrazione di Amazon Redshift ML con Amazon Bedrock](machine-learning-br.md#machine-learning-br-use).
## Parametri e impostazioni di CREATE EXTERNAL MODEL
Questa sezione descrive i parametri e le impostazioni del comando `CREATE EXTERNAL MODEL`.
**Topics**
+ [Parametri di CREATE EXTERNAL MODEL](#r_create_external_model_parameters)
+ [Impostazioni di CREATE EXTERNAL MODEL](#r_create_external_model_settings)
### Parametri di CREATE EXTERNAL MODEL
model\$1name
Il nome del modello esterno. Il nome del modello in uno schema deve essere unico.
FUNCTION *function\$1name (data\$1type [,...] )*
Il nome della funzione di inferenza creata da `CREATE EXTERNAL MODEL`. La funzione di inferenza viene utilizzata per inviare richieste ad Amazon Bedrock e recuperare il testo generato da ML.
IAM\$1ROLE * \$1 default \$1 'arn:aws:iam:::role/' \$1*
Il ruolo IAM utilizzato da Amazon Redshift per accedere ad Amazon Bedrock. Per informazioni sul ruolo IAM, consulta [Creazione o aggiornamento di un ruolo IAM per l’integrazione di Amazon Redshift ML con Amazon Bedrock](machine-learning-br.md#machine-learning-br-iam).
MODEL\$1TYPE BEDROCK
Specifica il tipo di modello. L’unico valore valido è `BEDROCK`.
SETTINGS ( MODEL\$1ID model\$1id [,...] )
Specifica le impostazioni del modello esterno. Per informazioni dettagliate, consulta la sezione seguente.
### Impostazioni di CREATE EXTERNAL MODEL
MODEL\$1ID model\$1id
L’identificatore del modello esterno, ad esempio `anthropic.claude-v2`. Per informazioni sul modello Amazon Bedrock IDs, consulta il modello [Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/model-ids.html). IDs
PROMPT 'prompt prefix'
Specifica un prompt statico che Amazon Redshift aggiunge all’inizio di ogni richiesta di inferenza. Supportato solo con `REQUEST_TYPE` uguale a `UNIFIED`.
SUFFIX 'prompt suffix'
Specifica un prompt statico che Amazon Redshift aggiunge alla fine di ogni richiesta di inferenza. Supportato solo con `REQUEST_TYPE` uguale a `UNIFIED`.
REQUEST\$1TYPE \$1 RAW \$1 UNIFIED \$1
Specifica il formato della richiesta inviata ad Amazon Bedrock. I valori validi includono quanto segue:
+ **RAW**: la funzione di inferenza accetta l’input come un unico valore SUPER e restituisce sempre un valore SUPER. Il formato del valore SUPER è specifico del modello Amazon Bedrock selezionato. Un valore SUPER è un modello di previsione che combina più algoritmi per produrre un’unica previsione migliorata.
+ **UNIFIED**: la funzione di inferenza utilizza l’API unificata. Tutti i modelli hanno un’interfaccia unificata e coerente con Amazon Bedrock. Funziona per tutti i modelli che supportano i messaggi. Questo è il valore predefinito.
Per ulteriori informazioni, consulta la [documentazione dell’API Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) nella *documentazione dell’API Amazon Bedrock*.
RESPONSE\$1TYPE \$1 VARCHAR \$1 SUPER \$1
Specifica il formato della risposta. Se il valore dell’impostazione `REQUEST_TYPE` è `RAW`, l’impostazione `RESPONSE_TYPE` è obbligatoria e l’unico valore valido è `SUPER`. Per tutti gli altri valori dell’impostazione `REQUEST TYPE`, il valore predefinito è `VARCHAR` e l’impostazione `RESPONSE_TYPE` è facoltativa. I valori validi includono quanto segue:
+ **VARCHAR**: Amazon Redshift restituisce solo la risposta testuale generata dal modello.
+ **SUPER**: Amazon Redshift restituisce l’intera risposta JSON generata dal modello come super. Ciò include la risposta testuale e informazioni come il motivo dell’interruzione e l’utilizzo dei token di input e output del modello. Un valore SUPER è un modello di previsione che combina più algoritmi per produrre un’unica previsione migliorata.
## Parametri della funzione di inferenza CREATE EXTERNAL MODEL
In questa sezione sono descritti i parametri validi per la funzione di inferenza creata dal comando `CREATE EXTERNAL MODEL`.
### Parametri della funzione di inferenza CREATE EXTERNAL MODEL per `REQUEST_TYPE` uguale a `RAW`
Una funzione di inferenza creata con `REQUEST_TYPE` uguale a `RAW` ha un argomento di input super e restituisce sempre un tipo di dati super. La sintassi dell’input super segue la sintassi della richiesta del modello specifico selezionato in Amazon Bedrock.
### Parametri della funzione di inferenza CREATE EXTERNAL MODEL per `REQUEST_TYPE` uguale a `UNIFIED`
input\$1text
Il testo che Amazon Redshift invia ad Amazon Bedrock.
inference\$1config
Un valore super che contiene parametri facoltativi che Amazon Redshift invia ad Amazon Bedrock. Possono essere inclusi i seguenti:
+ maxTokens
+ stopSequences
+ temperature
+ topP
Questi parametri sono tutti facoltativi e fanno distinzione tra maiuscole e minuscole. Per informazioni su questi parametri, consulta [ InferenceConfiguration](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InferenceConfiguration.html)*Amazon Bedrock API Reference.*
# CREATE EXTERNAL SCHEMA
Crea un nuovo schema esterno nel database corrente. È possibile utilizzare questo schema esterno per connettersi al database Amazon RDS for PostgreSQL o al database Amazon Aurora Edizione compatibile con PostgreSQL. Puoi anche creare uno schema esterno che faccia riferimento a un database in un catalogo di dati esterno come AWS Glue Athena o a un database in un metastore Apache Hive, come Amazon EMR.
Il proprietario di questo schema è l'emittente del comando CREATE EXTERNAL SCHEMA. Per trasferire la proprietà di uno schema esterno, utilizza [ALTER SCHEMA](r_ALTER_SCHEMA.md) per cambiare il proprietario. Usa il comando [GRANT](r_GRANT.md) per concedere l'accesso allo schema ad altri utenti o gruppi di utenti.
Non puoi utilizzare i comandi GRANT o REVOKE per le autorizzazioni su una tabella esterna. Puoi invece concedere o revocare le autorizzazioni per lo schema esterno.
**Nota**
Se attualmente si dispone di tabelle esterne Redshift Spectrum nel catalogo dati di Amazon Athena, è possibile migrare tale catalogo di Athena a un AWS Glue Data Catalog. Per utilizzare AWS Glue Data Catalog con Redshift Spectrum, potrebbe essere necessario modificare le policy AWS Identity and Access Management (IAM). Per ulteriori informazioni, consulta [Aggiornamento al AWS Glue Data Catalog nella Guida per l'utente](https://docs.aws.amazon.com/athena/latest/ug/glue-athena.html#glue-upgrade) di *Athena*.
Per visualizzare i dettagli degli schemi esterni, eseguire una query sulla vista di sistema [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md).
## Sintassi
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento ai dati utilizzando un catalogo dati esterno. Per ulteriori informazioni, consulta [Amazon Redshift Spectrum](c-using-spectrum.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM [ [ DATA CATALOG ] | HIVE METASTORE | POSTGRES | MYSQL | KINESIS | MSK | REDSHIFT | KAFKA ]
[ DATABASE 'database_name' ]
[ SCHEMA 'schema_name' ]
[ REGION 'aws-region' ]
[ IAM_ROLE [ default | 'SESSION' | 'arn:aws:iam:::role/' ] ]
[ AUTHENTICATION [ none | iam | mtls] ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ]
[ URI ['hive_metastore_uri' [ PORT port_number ] | 'hostname' [ PORT port_number ] | 'Kafka bootstrap URL'] ]
[ CLUSTER_ARN 'arn:aws:kafka:::cluster/msk/' ]
[ CATALOG_ROLE [ 'SESSION' | 'catalog-role-arn-string' ] ]
[ CREATE EXTERNAL DATABASE IF NOT EXISTS ]
[ CATALOG_ID 'Amazon Web Services account ID containing Glue or Lake Formation database' ]
```
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento ai dati utilizzando una query federata su RDS POSTGRES o Aurora PostgreSQL. È inoltre possibile creare uno schema esterno che faccia riferimento a fonti di streaming, come Kinesis Data Streams. Per ulteriori informazioni, consulta [Esecuzione di query su dati con query federate in Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM POSTGRES
DATABASE 'federated_database_name' [SCHEMA 'schema_name']
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento ai dati utilizzando una query federata su RDS MySQL o Aurora MySQL. Per ulteriori informazioni, consulta [Esecuzione di query su dati con query federate in Amazon Redshift](federated-overview.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] local_schema_name
FROM MYSQL
DATABASE 'federated_database_name'
URI 'hostname' [ PORT port_number ]
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
SECRET_ARN 'ssm-secret-arn'
```
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento ai dati in un flusso Kinesis. Per ulteriori informazioni, consulta [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KINESIS
IAM_ROLE [ default | 'arn:aws:iam:::role/' ]
```
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento al cluster Streaming gestito da Amazon per Apache Kafka o Confluent Cloud e i relativi argomenti da cui importare dati. Per connetterti, fornisci l’URI del broker. Per ulteriori informazioni, consulta [Importazione in streaming in una vista materializzata](materialized-view-streaming-ingestion.md).
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name
FROM KAFKA
[ IAM_ROLE [ default | 'arn:aws:iam:::role/' ] ]
URI 'Kafka bootstrap URI'
AUTHENTICATION [ none | iam | mtls ]
[ AUTHENTICATION_ARN 'acm-certificate-arn' | SECRET_ARN 'ssm-secret- arn' ];
```
La sintassi seguente descrive il comando CREATE EXTERNAL SCHEMA utilizzato per fare riferimento ai dati utilizzando una query tra database.
```
CREATE EXTERNAL SCHEMA local_schema_name
FROM REDSHIFT
DATABASE 'redshift_database_name' SCHEMA 'redshift_schema_name'
```
## Parameters
IF NOT EXISTS
Clausola che indica che se lo schema specificato esiste già, il comando non deve apportare modifiche e deve restituire un messaggio che lo schema esiste, piuttosto che terminare con un errore. Questa clausola è utile durante lo scripting, quindi lo script non fallisce se CREATE EXTERNAL SCHEMA tenta di creare uno schema già esistente.
local\$1schema\$1name
Il nome del nuovo schema esterno. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
FROM [ DATA CATALOG ] \$1 HIVE METASTORE \$1 POSTGRES \$1 MYSQL \$1 KINESIS \$1 MSK \$1 REDSHIFT
Parola chiave che indica dove si trova il database esterno.
DATA CATALOG indica che il database esterno è definito nel catalogo dati di Athena o AWS Glue Data Catalog.
Se il database esterno è definito in un catalogo dati esterno in una regione AWS diversa, è necessario il parametro REGION. DATA CATALOG è il valore predefinito.
HIVE METASTORE indica che il database esterno è definito in un metastore Apache Hive. Se è specificato HIVE METASTORE, l'URI è obbligatorio.
POSTGRES indica che il database esterno è definito in RDS PostgreSQL o Aurora PostgreSQL.
MYSQL indica che il database esterno è definito in RDS MySQL o Aurora MySQL.
KINESIS indica che l'origine dati è un flusso di Kinesis Data Streams.
MSK indica che l’origine dati è un cluster con provisioning o serverless Amazon MSK.
KAFKA indica che l’origine dati è un cluster Kafka. Puoi utilizzare questa parola chiave sia per Amazon MSK che per Confluent Cloud.
FROM REDSHIFT
Una parola chiave che indica che il database si trova in Amazon Redshift.
DATABASE '*nome\$1database\$1redshift*' SCHEMA '*nome\$1schema\$1redshift*'
Il nome del database Amazon Redshift.
*nome\$1schema redshift* indica lo schema in Amazon Redshift. Il valore di timeout di default per *nome\$1schema redshift* è `public`.
DATABASE '*nome\$1database\$1federato*'
Una parola chiave che indica il nome del database esterno in un motore del database PostgreSQL o MySQL supportato.
[SCHEMA '*nome\$1schema*']
*nome\$1schema* indica lo schema in un motore del database PostgreSQL supportato. Lo *schema\$1name* predefinito è `public`.
Non è possibile specificare uno SCHEMA quando si imposta una query federata su un motore di database MySQL supportato.
REGION '*aws-region*'
Se il database esterno è definito in un catalogo dati Athena o nella AWS Glue Data Catalog, la AWS regione in cui si trova il database. Questo parametro è obbligatorio se il database è definito in un catalogo dati esterno.
URI [ 'hive\$1metastore\$1uri' [ PORT port\$1number ] \$1 'hostname' [ PORT port\$1number ] \$1 'Kafka bootstrap URI' ]
L'URI del nome host e il numero di porta di un motore del database PostgreSQL o MySQL supportato. Il valore *hostname* è il nodo principale del set di repliche. L'endpoint deve essere raggiungibile (instradabile) dal cluster Amazon Redshift. Il port\$1number predefinito per PostgreSQL è 5432. Il port\$1number predefinito per MySQL è 3306.
Il motore di database PostgreSQL o MySQL supportato deve trovarsi nello stesso VPC del cluster Amazon Redshift con un gruppo di sicurezza che colleghi Amazon Redshift e RDS url-rsPostgreSQL o Aurora PostgreSQL. Inoltre puoi utilizzare il routing VPC avanzato per configurare un caso d’uso tra VPC. Per ulteriori informazioni, consulta [Endpoint VPC gestiti da Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-cross-vpc.html).
**Specifica di un URI del metastore Hive**
Se il database si trova in un metastore Hive, specifica l'URI e facoltativamente il numero di porta per il metastore. Il numero di porta predefinito è 9083.
Un URI non contiene una specifica di protocollo ("http://"). Un URI valido esempio è `uri '172.10.10.10'`.
**Specifica di un URI del broker per l’importazione di dati in streaming**
L’inclusione dell’URI bootstrap-broker consente di connettersi a un cluster Amazon MSK o Confluent Cloud e ricevere i dati in streaming. Per ulteriori informazioni e un esempio, consulta [Nozioni di base sull’importazione dati in streaming da Streaming gestito da Amazon per Apache Kafka](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion-getting-started-MSK.html).
IAM\$1ROLE [predefinito \$1 'SESSION' \$1 'arn:aws:iam: :role/ '] ** **
Utilizzare la parola chiave predefinita per fare in modo che Amazon Redshift utilizzi il ruolo IAM impostato come predefinito e associato al cluster quando viene eseguito il comando CREATE EXTERNAL SCHEMA.
Utilizzare `'SESSION'` se ci si connette al cluster Amazon Redshift utilizzando un'identità federata e si accede alle tabelle dallo schema esterno creato con questo comando. Per ulteriori informazioni, consulta l'argomento relativo all'[utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html), che illustra come configurare l'identità federata. Si noti che questa configurazione, che utilizza `'SESSION'` al posto dell'ARN, può essere utilizzata solo se lo schema è stato creato utilizzando `DATA CATALOG`.
L'Amazon Resource Name (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione. Come minimo, il ruolo IAM deve disporre dell'autorizzazione per eseguire un'operazione LIST sul bucket Amazon S3 a cui accedere e un'operazione GET sugli oggetti Amazon S3 contenuti nel bucket.
Quanto segue mostra la sintassi per la stringa di parametro IAM\$1ROLE per un singolo ARN.
```
IAM_ROLE 'arn:aws:iam:::role/'
```
È possibile concatenare i ruoli in modo che il cluster possa presumere un altro ruolo IAM, possibilmente appartenente a un altro account. Puoi concatenare fino a 10 ruoli. Per un esempio di concatenamento di ruoli, vedi [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
Per collegare a questo ruolo IAM una policy di autorizzazioni IAM simile alla seguente.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AccessSecret",
"Effect": "Allow",
"Action": [
"secretsmanager:GetResourcePolicy",
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:ListSecretVersionIds"
],
"Resource": "arn:aws:secretsmanager:us-west-2:123456789012:secret:my-rds-secret-VNenFy"
},
{
"Sid": "VisualEditor1",
"Effect": "Allow",
"Action": [
"secretsmanager:GetRandomPassword",
"secretsmanager:ListSecrets"
],
"Resource": "*"
}
]
}
```
Per la procedura per creare un ruolo IAM da utilizzare con la query federata, consultare [Creazione di un segreto e di un ruolo IAM per l'utilizzo di query federate](federated-create-secret-iam-role.md).
Non includere spazi nell'elenco dei ruoli concatenati.
Quanto segue mostra la sintassi per concatenare tre ruoli.
```
IAM_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
*ssm-secret-arn*SECRET\$1ARN ''
L'Amazon Resource Name (ARN) di un segreto del motore di database PostgreSQL o MySQL supportato creato utilizzando. Gestione dei segreti AWS Per informazioni su come creare e recuperare un ARN per un segreto, consulta [Gestione dei segreti con Gestione dei segreti AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_create-basic-secret.html) nella *Guida per l’utente di Gestione dei segreti AWS * e [Recupero del nome della risorsa Amazon (ARN) del segreto in Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-secrets-manager-integration-retrieving-secret.html).
CATALOG\$1ROLE ['SESSIONE' \$1] *catalog-role-arn-string*
Utilizzare `'SESSION'` per la connessione al cluster Amazon Redshift utilizzando un'identità federata per l'autenticazione e l'autorizzazione al catalogo di dati. Per ulteriori informazioni sul completamento della procedura per l'identità federata, consulta l'argomento relativo all'[utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html). Si noti che il ruolo `'SESSION'` può essere utilizzato solo se lo schema viene creato in DATA CATALOG.
Il nome della risorsa Amazon (ARN) per un ruolo IAM utilizzato dal cluster per l'autenticazione e l'autorizzazione del catalogo dati.
Se CATALOG\$1ROLE non viene specificato, Amazon Redshift utilizza l'IAM\$1ROLE specificato. Il ruolo del catalogo deve disporre dell'autorizzazione per accedere al Data Catalog in AWS Glue o Athena. Per ulteriori informazioni, consulta [Policy IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md).
Quanto segue mostra la sintassi per la stringa di parametro CATALOG\$1ROLE per un singolo ARN.
```
CATALOG_ROLE 'arn:aws:iam:::role/'
```
È possibile concatenare i ruoli in modo che il cluster possa presumere un altro ruolo IAM, possibilmente appartenente a un altro account. Puoi concatenare fino a 10 ruoli. Per ulteriori informazioni, consulta [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
L'elenco di ruoli concatenati non deve includere spazi.
Quanto segue mostra la sintassi per concatenare tre ruoli.
```
CATALOG_ROLE 'arn:aws:iam:::role/,arn:aws:iam:::role/,arn:aws:iam:::role/'
```
CREATE EXTERNAL DATABASE IF NOT EXISTS
Clausola che crea un database esterno con il nome specificato dall'argomento DATABASE, se il database esterno specificato non esiste. Se il database esterno specificato esiste, il comando non apporta modifiche. In questo caso, il comando restituisce un messaggio che il database esterno esiste, anziché terminare con un errore.
CREATE EXTERNAL DATABASE IF NOT EXISTS non può essere usato con HIVE METASTORE.
Per utilizzare CREATE EXTERNAL DATABASE IF NOT EXISTS con il catalogo dati abilitato per AWS Lake Formation, è necessaria l'autorizzazione `CREATE_DATABASE` sul catalogo dati.
CATALOG\$1ID "*ID account Amazon Web Services contenente il database Glue o Lake Formation*"
L'ID dell'account in cui è archiviato il database del catalogo dati.
`CATALOG_ID` può essere specificato solo se si prevede di connettersi al cluster Amazon Redshift o ad Amazon Redshift Serverless utilizzando un'identità federata per l'autenticazione e l'autorizzazione al catalogo di dati configurando una delle seguenti impostazioni:
+ `CATALOG_ROLE` Da a `'SESSION'`
+ `IAM_ROLE` su `'SESSION'` e `'CATALOG_ROLE'` impostati sul valore predefinito
Per ulteriori informazioni sul completamento della procedura per l'identità federata, consulta l'argomento relativo all'[utilizzo di un'identità federata per gestire l'accesso di Amazon Redshift alle risorse locali e alle tabelle esterne di Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/authorization-fas-spectrum.html).
AUTHENTICATION
Il tipo di autenticazione definito per l'importazione di dati in streaming. L'importazione di dati in streaming con i tipi di autenticazione funziona con Amazon Managed Streaming per Apache Kafka. I tipi di `AUTHENTICATION` sono i seguenti:
+ **none**: specifica che non è richiesta alcuna autenticazione. Ciò corrisponde all’accesso non autenticato in MSK o al testo semplice con TLS in Apache Kafka.
+ **iam**: specifica l'autenticazione IAM. Quando scegli questa opzione, assicurati che il ruolo IAM disponga delle autorizzazioni per l'autenticazione IAM. Per ulteriori informazioni sulla definizione dello schema esterno, consulta [Nozioni di base sull’importazione in streaming da origini Apache Kafka](materialized-view-streaming-ingestion-getting-started-MSK.md).
+ **mtls**: specifica che il protocollo Transport Layer Security (TLS) reciproco fornisce comunicazioni sicure facilitando l’autenticazione tra client e server. In questo caso il client è Redshift e il server è Amazon MSK. Per ulteriori informazioni sulla configurazione dell’importazione in streaming con mTLS, consulta [Autenticazione con mTLS per l’importazione in streaming Redshift da origini Apache Kafka](materialized-view-streaming-ingestion-mtls.md).
AUTHENTICATION\$1ARN
L'ARN del AWS Certificate Manager certificato utilizzato da Amazon Redshift per l'autenticazione mtls con Amazon MSK. L’ARN è disponibile nella console ACM quando scegli il certificato emesso.
CLUSTER\$1ARN
Per l’importazione in streaming, CLUSTER\$1ARN è l’identificatore del cluster per il cluster Streaming gestito da Amazon per Apache Kafka da cui stai eseguendo lo streaming. Quando utilizzi CLUSTER\$1ARN, è necessaria una policy del ruolo IAM che includa l’autorizzazione `kafka:GetBootstrapBrokers`. Questa opzione viene fornita per la compatibilità con le versioni precedenti. Attualmente consigliamo di utilizzare l’opzione URI bootstrap-broker per connetterti ai cluster Streaming gestito da Amazon per Apache Kafka. Per ulteriori informazioni, consulta [Importazione dati in streaming](https://docs.aws.amazon.com/redshift/latest/dg/materialized-view-streaming-ingestion.html).
## Note per l’utilizzo
Per i limiti per l'uso del catalogo di dati Athena, consulta [Limiti di Athena](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#amazon-athena-limits) in Riferimenti generali di AWS.
[Per i limiti relativi all'utilizzo di AWS Glue Data Catalog, consulta AWS Glue Limiti in.](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_glue) Riferimenti generali di AWS
Questi limiti non si applicano a un metastore Hive.
È presente un massimo di 9900 schemi per database. Per ulteriori informazioni, consulta [Quote e limiti](https://docs.aws.amazon.com/redshift/latest/mgmt/amazon-redshift-limits.html) nella *Guida alla gestione di Amazon Redshift*.
Per annullare la registrazione dello schema, utilizzare il comando [DROP SCHEMA](r_DROP_SCHEMA.md).
Per visualizzare i dettagli degli schemi esterni, eseguire una query sulle viste di sistema seguenti:
+ [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)
+ [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)
+ [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md)
## Esempi
L'esempio seguente crea uno schema esterno che utilizza un database in un catalogo dati denominato `sampledb` nella regione Stati Uniti occidentali (Oregon). Usa questo esempio con un catalogo dati Athena o AWS Glue .
```
create external schema spectrum_schema
from data catalog
database 'sampledb'
region 'us-west-2'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
L'esempio seguente crea uno schema esterno e un nuovo database esterno denominato `spectrum_db`.
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole'
create external database if not exists;
```
L'esempio seguente crea uno schema esterno che utilizza un database metastore Hive denominato `hive_db`.
```
create external schema hive_schema
from hive metastore
database 'hive_db'
uri '172.10.10.10' port 99
iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
```
Nell'esempio seguente sono concatenati i ruoli per utilizzare il ruolo `myS3Role` per accedere ad Amazon S3 ed è utilizzato `myAthenaRole` per l'accesso al catalogo dati. Per ulteriori informazioni, consulta [Concatenazione di ruoli IAM per Amazon Redshift Spectrum](c-spectrum-iam-policies.md#c-spectrum-chaining-roles).
```
create external schema spectrum_schema
from data catalog
database 'spectrum_db'
iam_role 'arn:aws:iam::123456789012:role/myRedshiftRole,arn:aws:iam::123456789012:role/myS3Role'
catalog_role 'arn:aws:iam::123456789012:role/myAthenaRole'
create external database if not exists;
```
Nell'esempio seguente viene creato uno schema esterno che fa riferimento a un database Aurora PostgreSQL.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM POSTGRES
DATABASE 'my_aurora_db' SCHEMA 'my_aurora_schema'
URI 'endpoint to aurora hostname' PORT 5432
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
Nell'esempio seguente viene creato uno schema esterno per fare riferimento al database sales\$1db importato nel cluster di consumer.
```
CREATE EXTERNAL SCHEMA sales_schema FROM REDSHIFT DATABASE 'sales_db' SCHEMA 'public';
```
Nell'esempio seguente viene creato uno schema esterno che fa riferimento a un database Aurora MySQL.
```
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] myRedshiftSchema
FROM MYSQL
DATABASE 'my_aurora_db'
URI 'endpoint to aurora hostname'
IAM_ROLE 'arn:aws:iam::123456789012:role/MyAuroraRole'
SECRET_ARN 'arn:aws:secretsmanager:us-east-2:123456789012:secret:development/MyTestDatabase-AbCdEf'
```
# CREATE EXTERNAL TABLE
Crea una nuova tabella esterna nello schema specificato. Tutte le tabelle esterne devono essere create in uno schema esterno. Il percorso di ricerca non è supportato per schemi esterni e tabelle esterne. Per ulteriori informazioni, consulta [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
Oltre alle tabelle esterne create utilizzando il comando CREATE EXTERNAL TABLE, Amazon Redshift può fare riferimento a tabelle esterne definite in un AWS Lake Formation catalogo AWS Glue or o in un metastore Apache Hive. Utilizzare il comando [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md) per registrare un database esterno definito nel catalogo esterno e rendere disponibili le tabelle esterne per l'uso in Amazon Redshift. Se la tabella esterna esiste in un AWS Lake Formation catalogo AWS Glue o in un metastore Hive, non è necessario creare la tabella utilizzando CREATE EXTERNAL TABLE. Per visualizzare le tabelle esterne, eseguire una query sulla vista di sistema [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md).
Eseguendo il comando CREATE EXTERNAL TABLE AS, è possibile creare una tabella esterna basata sulla definizione di colonna da una query e scrivere i risultati di tale query in Amazon S3. I risultati sono in formato Apache Parquet o testo delimitato. Se la tabella esterna dispone di una o più chiavi di partizione, Amazon Redshift partiziona i nuovi file in base a tali chiavi di partizione e registra automaticamente le nuove partizioni nel catalogo esterno. Per ulteriori informazioni su CREATE EXTERNAL TABLE AS, consultare [Note per l’utilizzo](r_CREATE_EXTERNAL_TABLE_usage.md).
È possibile eseguire query su una tabella esterna utilizzando la stessa sintassi SELECT utilizzata con altre tabelle Amazon Redshift. È inoltre possibile utilizzare la sintassi INSERT per scrivere nuovi file nella posizione della tabella esterna su Amazon S3. Per ulteriori informazioni, consulta [INSERT (tabella esterna)](r_INSERT_external_table.md).
Per creare una vista con una tabella esterna, includi la clausola WITH NO SCHEMA BINDING nell'istruzione [CREATE VIEW](r_CREATE_VIEW.md).
Non è possibile eseguire CREATE EXTERNAL TABLE all'interno di una transazione (BEGIN ... END). Per ulteriori informazioni sulle transazioni, consultare [Livelli di isolamento in Amazon Redshift](c_serial_isolation.md).
## Privilegi richiesti
Per creare tabelle esterne, devi essere il proprietario dello schema esterno o un utente con privilegi avanzati. Per trasferire la proprietà di uno schema esterno, utilizza ALTER SCHEMA per cambiare il proprietario. L'accesso alle tabelle esterne è controllato dall'accesso allo schema esterno. Non puoi [GRANT](r_GRANT.md) o [REVOKE](r_REVOKE.md) autorizzazioni per una tabella esterna. Puoi invece concedere o revocare USAGE sullo schema esterno.
[Note per l’utilizzo](r_CREATE_EXTERNAL_TABLE_usage.md) dispone di informazioni aggiuntive sulle autorizzazioni specifiche per le tabelle esterne.
## Sintassi
```
CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, …] )
[ PARTITIONED BY (col_name data_type [, … ] )]
[ { ROW FORMAT DELIMITED row_format |
ROW FORMAT SERDE 'serde_name'
[ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
```
Di seguito è riportata la sintassi per CREATE EXTERNAL TABLE AS.
```
CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [, … ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
AS
{ select_statement }
```
## Parameters
*external\$1schema.table\$1name*
Nome della tabella da creare, qualificato da un nome di schema esterno. Le tabelle esterne devono essere create in uno schema esterno. Per ulteriori informazioni, consulta [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).
La lunghezza massima per il nome della tabella è 127 byte; i nomi più lunghi vengono troncati a 127 byte. Puoi utilizzare caratteri multibyte UTF-8 fino a un massimo di quattro byte. Amazon Redshift applica un limite di 9.900 tabelle per cluster, comprese le tabelle temporanee definite dall'utente e le tabelle temporanee create da Amazon Redshift durante l'elaborazione delle query o la manutenzione del sistema. Facoltativamente, puoi qualificare il nome della tabella con il nome del database. Nell'esempio seguente, il nome del database è `spectrum_db`, il nome dello schema esterno è `spectrum_schema` e il nome della tabella è `test`.
```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
Se il database o lo schema specificato non esiste, la tabella non viene creata e l'istruzione restituisce un errore. Non è possibile creare tabelle o viste nei database di sistema `template0`, `template1`, `padb_harvest` o `sys:internal`.
Il nome della tabella deve essere un nome univoco per lo schema specificato.
Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
( *column\$1name* *data\$1type* )
Il nome e il tipo di dati di ciascuna colonna creata.
La lunghezza massima per il nome della colonna è 127 byte; i nomi più lunghi vengono troncati a 127 byte. Puoi utilizzare caratteri multibyte UTF-8 fino a un massimo di quattro byte. Non puoi specificare i nomi di colonna `"$path"` o `"$size"`. Per ulteriori informazioni sui nomi validi, consultare [Nomi e identificatori](r_names.md).
Per impostazione predefinita, Amazon Redshift crea tabelle esterne con le pseudocolonne `$path` e `$size`. Puoi disabilitare la creazione di pseudocolonne per una sessione impostando il parametro di configurazione `spectrum_enable_pseudo_columns` su `false`. Per ulteriori informazioni, consulta [Pseudocolonne](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns).
Se le pseudocolonne sono abilitate, il numero massimo di colonne che è possibile definire in una singola tabella è 1.598. Se le pseudocolonne non sono abilitate, il numero massimo di colonne che puoi definire in una singola tabella è 1.600.
Se stai creando una "tabella di grandi dimensioni", assicurati che il tuo elenco di colonne non superi i limiti della larghezza delle righe per i risultati intermedi durante i carichi e l'elaborazione delle query. Per ulteriori informazioni, consulta [Note per l'utilizzo](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage).
Per un comando CREATE EXTERNAL TABLE AS., non è necessario un elenco di colonne, poiché queste derivano dalla query.
*data\$1type*
Sono supportate le seguenti [Tipi di dati](c_Supported_data_types.md):
+ SMALLINT () INT2
+ NUMERO INTERO (INT,) INT4
+ BIG INT () INT8
+ DECIMAL (NUMERIC)
+ REALE () FLOAT4
+ DOPPIA PRECISIONE (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING): può essere utilizzato con file di dati Parquet e ORC e solo con colonne non partizionate.
+ DATE: può essere utilizzato solo con i file di testo, Parquet o file di dati ORC oppure come colonna di partizione.
+ TIMESTAMP
Per DATE, è possibile utilizzare i formati come descritto di seguito. Per i valori mensili rappresentati tramite cifre, sono supportati i seguenti formati:
+ `mm-dd-yyyy`, ad esempio, `05-01-2017`. Questa è l’impostazione predefinita.
+ `yyyy-mm-dd`, dove l'anno è rappresentato da più di 2 cifre. Ad esempio, `2017-05-01`.
Per i valori mensili rappresentati tramite l'abbreviazione di tre lettere, sono supportati i seguenti formati:
+ `mmm-dd-yyyy`, ad esempio, `may-01-2017`. Questa è l’impostazione predefinita.
+ `dd-mmm-yyyy`, dove l'anno è rappresentato da più di 2 cifre. Ad esempio, `01-may-2017`.
+ `yyyy-mmm-dd`, dove l'anno è rappresentato da più di 2 cifre. Ad esempio, `2017-may-01`.
Per i valori dell'anno che sono costantemente inferiori a 100, l'anno viene calcolato nel modo seguente:
+ Se l'anno è inferiore a 70, l'anno viene calcolato come anno più 2000. Ad esempio, la data 05-01-17 nel formato `mm-dd-yyyy` viene convertito in `05-01-2017`.
+ Se l'anno è inferiore a 100 ma superiore a 69, l'anno viene calcolato come anno più 1900. Ad esempio, la data 05-01-89 nel formato `mm-dd-yyyy` viene convertito in `05-01-1989`.
+ Per i valori dell'anno rappresentati da due cifre, aggiungi zeri iniziali per rappresentare l'anno in 4 cifre.
I valori di timestamp nei file di testo devono essere nel formato `yyyy-mm-dd HH:mm:ss.SSSSSS`, come il seguente valore di timestamp `2017-05-01 11:30:59.000000`.
La lunghezza di una colonna VARCHAR è definita in termini di byte, non caratteri. Ad esempio, una colonna VARCHAR(12) può contenere 12 caratteri a byte singolo o 6 caratteri a due byte. Quando invii una query a una tabella esterna, i risultati sono troncati in modo da essere compatibili con le dimensioni definite della colonna senza restituire un errore. Per ulteriori informazioni, consulta [Storage e intervalli](r_Character_types.md#r_Character_types-storage-and-ranges).
Per garantire le prestazioni migliori, consigliamo di specificare le dimensioni della colonna più piccole compatibili con i dati. Per individuare le dimensioni massime in byte per i valori di una colonna, utilizza la funzione [OCTET\$1LENGTH](r_OCTET_LENGTH.md). Nell'esempio seguente viene restituita la dimensione massima dei valori nella colonna dell'e-mail.
```
select max(octet_length(email)) from users;
max
---
62
```
PARTITIONED BY (*col\$1name* *data\$1type* [, … ] )
Una clausola che definisce una tabella partizionata con una o più colonne di partizione. Viene utilizzata una directory di dati separata per ciascuna combinazione specificata, che può migliorare le prestazioni della query in alcune circostanze. Le colonne partizionate non esistono all'interno dei dati della tabella stessa. Se usi un valore per *col\$1name* uguale a una colonna della tabella, viene restituito un errore.
Dopo aver creato una tabella partizionata, modificare la tabella utilizzando un'istruzione [ALTER TABLE](r_ALTER_TABLE.md) ... ADD PARTITION per registrare nuove partizioni nel catalogo esterno. Quando si aggiunge una partizione, si definisce la posizione della sottocartella su Amazon S3 contenenti i dati della partizione.
Ad esempio, se la tabella `spectrum.lineitem_part` è definita con `PARTITIONED BY (l_shipdate date)`, esegui il seguente comando ALTER TABLE per aggiungere una partizione.
```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
Se utilizzi CREATE EXTERNAL TABLE AS, non è necessario eseguire ALTER TABLE…ADD PARTITION. Amazon Redshift registra automaticamente le nuove partizioni nel catalogo esterno. Amazon Redshift scrive inoltre automaticamente i dati corrispondenti nelle partizioni Amazon S3 in base alla chiave o alle chiavi di partizione definite nella tabella.
Per visualizzare le partizioni, eseguire una query sulla vista di sistema [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).
Per un comando CREATE EXTERNAL TABLE AS, non è necessario specificare il tipo di dati della colonna di partizione perché questa colonna è derivata dalla query.
ROW FORMAT DELIMITED *rowformat*
Clausola che specifica il formato dei dati sottostanti. I valori possibili di *rowformat* sono indicati di seguito:
+ LINES TERMINATED BY '*delimiter*'
+ FIELDS TERMINATED BY '*delimiter*'
Specifica un singolo carattere ASCII per '*delimiter*'. Puoi specificare caratteri ASCII non stampabili utilizzando un ottale, nel formato `'\`*`ddd`*`'` dove *`d`* è una cifra ottale (0 – 7) fino a '\$1177'. L'esempio seguente specifica il carattere BEL (bell) usando l'ottale.
```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
Se ROW FORMAT è omesso, il formato predefinito è DELIMITED FIELDS TERMINATED BY '\$1A' (inizio dell'intestazione) e LINES TERMINATED BY '\$1n' (newline).
ROW FORMAT SERDE '*serde\$1name*' [WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
Clausola che specifica il formato SERDE dei dati sottostanti.
'*serde\$1name*'
Nome della SerDe. È possibile specificare utilizzando i seguenti formati.
+ org.apache.hadoop.hive.serde2. RegexSerDe
+ com.amazonaws.glue.serde. GrokSerDe
+ org.apache.hadoop.hive.serde 2.open CSVSerde
Questo parametro supporta la seguente proprietà per Open: SerDe CSVSerde
```
'wholeFile' = 'true'
```
Impostare la proprietà `wholeFile`a proprietà `true` per analizzare correttamente i nuovi caratteri di riga (\$1 n) all'interno di stringhe virgolate per le richieste OpenCSV.
+ org.openx.data.jsonserde. JsonSerDe
+ Il JSON SERDE supporta anche i file Ion.
+ Il JSON deve essere ben formato.
+ I timestamp in Ion e JSON devono utilizzare il formato. ISO8601
+ Questo parametro supporta la seguente proprietà per: SerDe JsonSerDe
```
'strip.outer.array'='true'
```
Ion/JSON Elabora i file contenenti un array molto grande racchiuso tra parentesi esterne ([...]) come se contenesse più record JSON all'interno dell'array.
+ com.amazon.ionhiveserde. IonHiveSerDe
Il formato Amazon ION fornisce formati di testo e binari, oltre ai tipi di dati. Per una tabella esterna che fa riferimento ai dati in formato ION, devi mappare ogni colonna della tabella verso l'elemento corrispondente nei dati di formato ION. Per ulteriori dettagli, consultare [Amazon Ion](https://amzn.github.io/ion-docs/). È inoltre necessario specificare i formati di input e di output.
WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]
Facoltativamente, specifica i nomi e i valori delle proprietà, separati da virgole.
Se ROW FORMAT è omesso, il formato predefinito è DELIMITED FIELDS TERMINATED BY '\$1A' (inizio dell'intestazione) e LINES TERMINATED BY '\$1n' (newline).
STORED AS *file\$1format*
Il formato per i file di dati.
I formati validi sono:
+ PARQUET
+ RCFILE ( ColumnarSerDe solo per uso di dati, non) LazyBinaryColumnarSerDe
+ SEQUENCEFILE
+ TEXTFILE (per file di testo, inclusi i file JSON)
+ ORC
+ AVRO
+ INPUTFORMAT '*input\$1format\$1classname*' OUTPUTFORMAT '*output\$1format\$1classname*'
Il comando CREATE EXTERNAL TABLE AS supporta solo due formati di file, TEXTFILE e PARQUET.
Per INPUTFORMAT e OUTPUTFORMAT, specifica un nome di classe, come illustrato nel seguente esempio.
```
'org.apache.hadoop.mapred.TextInputFormat'
```
LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*'\$1
Il percorso della cartella o del bucket Amazon S3 con i file di dati o un file manifest che contiene un elenco di percorsi di oggetti Amazon S3. I bucket devono trovarsi nella stessa AWS regione del cluster Amazon Redshift. Per un elenco delle regioni AWS supportate, consultare [Limitazioni di Amazon Redshift Spectrum](c-spectrum-considerations.md).
Se il percorso specifica un bucket o una cartella, ad esempio `'s3://amzn-s3-demo-bucket/custdata/'`, Redshift Spectrum esegue la scansione dei file nel bucket o nella cartella specificati e in qualsiasi sottocartella. Redshift Spectrum ignora i file e i file nascosti che iniziano con un punto o un trattino basso.
Se il percorso specifica un file manifest, l'argomento `'s3://bucket/manifest_file'` deve fare riferimento esplicitamente a un singolo file, ad esempio `'s3://amzn-s3-demo-bucket/manifest.txt'`. Non può fare riferimento a un prefisso della chiave.
Il manifest è un file di testo in formato JSON che elenca l'URL di ciascun file che deve essere caricato da Amazon S3 e la dimensione del file, in byte. L'URL include il nome del bucket e il percorso completo dell'oggetto per il file. I file specificati nel manifesto possono trovarsi in diversi bucket, ma tutti i bucket devono trovarsi nella stessa AWS regione del cluster Amazon Redshift. Se un file viene elencato due volte, viene caricato due volte. L'esempio seguente mostra il JSON per un manifest che carica tre file.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
È possibile rendere obbligatoria l'inclusione di un particolare file. A tale scopo, includere un'opzione `mandatory` a livello di file nel manifest. Quando si esegue una query su una tabella esterna con un file obbligatorio mancante, l'istruzione SELECT ha esito negativo. Assicurarsi che tutti i file inclusi nella definizione della tabella esterna siano presenti. Se non sono tutti presenti, viene visualizzato un errore che mostra il primo file obbligatorio che non viene trovato. L'esempio seguente mostra il JSON per un manifest con l' opzione `mandatory` impostata su `true`.
```
{
"entries": [
{"url":"s3://amzn-s3-demo-bucket1/custdata.1", "mandatory":true, "meta": { "content_length": 5956875 } },
{"url":"s3://amzn-s3-demo-bucket1/custdata.2", "mandatory":false, "meta": { "content_length": 5997091 } },
{"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
]
}
```
Per fare riferimento ai file creati utilizzando UNLOAD, puoi utilizzare il manifest creato utilizzando [UNLOAD](r_UNLOAD.md) con il parametro MANIFEST. Il file manifest è compatibile con un file manifest per [COPY da Amazon S3](copy-parameters-data-source-s3.md), ma usa chiavi diverse. Le chiavi non utilizzate vengono ignorate.
TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*' [, ...] )
Clausola che imposta la definizione della tabella delle proprietà della tabella.
Le proprietà della tabella rispettano la distinzione tra maiuscole e minuscole.
'compression\$1type'='*value*'
Proprietà che imposta il tipo di compressione da utilizzare se il nome file non contiene un'estensione. Se imposti questa proprietà e c'è un'estensione di file, l'estensione viene ignorata e viene utilizzato il valore impostato dalla proprietà. I valori validi per il tipo di compressione sono i seguenti:
+ bzip2
+ gzip
+ nessuno
+ snappy
'data\$1cleansing\$1enabled'='true / false'
Questa proprietà imposta se la gestione dei dati è attiva per la tabella. Se 'data\$1cleansing\$1enabled' è impostata su true, la gestione dei dati è attiva per la tabella. Se 'data\$1cleansing\$1enabled' è impostata su false, la gestione dei dati non è attiva per la tabella. Di seguito è riportato l'elenco delle proprietà di gestione dei dati a livello di tabella controllate da questa proprietà:
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ numeric\$1overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
Per alcuni esempi, consulta [Esempi di gestione dei dati](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling).
'invalid\$1char\$1handling'='*valore*'
Specifica l'azione da eseguire quando i risultati della query contengono valori di caratteri UTF-8 non validi. È possibile specificare le seguenti operazioni:
DISABILITATO
Non esegue la gestione dei caratteri non validi.
FAIL
Annulla le query che restituiscono dati contenenti valori UTF-8 non validi.
SET\$1TO\$1NULL
Sostituisce valori UTF-8 non validi con null.
DROP\$1ROW
Sostituisce ogni valore della riga con null.
REPLACE
Sostituisce il carattere non valido con il carattere sostitutivo specificato tramite `replacement_char`.
'replacement\$1char'='*carattere*'
Specifica il carattere sostitutivo da utilizzare quando si imposta `invalid_char_handling` su `REPLACE`.
'numeric\$1overflow\$1handling'='value'
Specifica l'azione da eseguire quando i dati ORC contengono un numero intero (ad esempio BIGINT o int64) maggiore della definizione di colonna (ad esempio SMALLINT o int16). È possibile specificare le seguenti operazioni:
DISABILITATO
La gestione dei caratteri non validi è disattivata.
FAIL
Se i dati includono caratteri non validi annullare la query.
SET\$1TO\$1NULL
Impostare i caratteri non validi su null.
DROP\$1ROW
Impostare ogni valore della riga su null.
'surplus\$1bytes\$1handling'='*value*'
Specifica come gestire i dati caricati che superano la lunghezza del tipo di dati definito per le colonne contenenti dati VARBYTE. Per impostazione predefinita, Redshift Spectrum imposta il valore su null per i dati che superano la larghezza della colonna.
È possibile specificare le seguenti operazioni da eseguire quando la query restituisce dati che superano la larghezza del tipo di dati:
SET\$1TO\$1NULL
Sostituisce i dati che superano la larghezza della colonna con null.
DISABILITATO
Non esegue la gestione dei byte in eccedenza.
FAIL
Annulla le query che restituiscono dati che superano la larghezza della colonna.
DROP\$1ROW
Elimina tutte le righe contenenti dati che superano la larghezza della colonna.
TRUNCATE
Rimuove i caratteri che superano il numero massimo di caratteri definito per la colonna.
'surplus\$1char\$1handling'='*valore*'
Specifica come gestire i dati caricati che superano la lunghezza del tipo di dati definito per le colonne contenenti dati VARCHAR, CHAR o stringa. Per impostazione predefinita, Redshift Spectrum imposta il valore su null per i dati che superano la larghezza della colonna.
È possibile specificare le seguenti operazioni da eseguire quando la query restituisce dati che superano la larghezza della colonna:
SET\$1TO\$1NULL
Sostituisce i dati che superano la larghezza della colonna con null.
DISABILITATO
Non esegue la gestione dei caratteri in eccedenza.
FAIL
Annulla le query che restituiscono dati che superano la larghezza della colonna.
DROP\$1ROW
Sostituisce ogni valore della riga con null.
TRUNCATE
Rimuove i caratteri che superano il numero massimo di caratteri definito per la colonna.
'column\$1count\$1mismatch\$1handling'='valore’
Determina se il file contiene più o meno valori in una riga rispetto al numero di colonne specificato nella definizione della tabella esterna. Questa proprietà è disponibile solo per il formato di file di testo non compresso. È possibile specificare le seguenti operazioni:
DISABILITATO
La gestione della mancata corrispondenza del conteggio di colonne è disattivata.
FAIL
La query ha esito negativo se viene rilevata una mancata corrispondenza del conteggio delle colonne.
SET\$1TO\$1NULL
Compila i valori mancanti con NULL e ignora i valori aggiuntivi in ogni riga.
DROP\$1ROW
Elimina tutte le righe che contengono errori relativi alla mancata corrispondenza del conteggio delle colonne dalla scansione.
'numRows'='*row\$1count*'
Proprietà che imposta il valore numRows per la definizione della tabella. Per aggiornare in modo esplicito le statistiche di una tabella esterna, imposta la proprietà numRows in modo da indicare le dimensioni della tabella. Amazon Redshift non analizza le tabelle esterne per generare le statistiche delle tabelle che l'ottimizzatore di query utilizza per generare un piano di query. Se le statistiche delle tabelle non sono impostate per una tabella esterna, Amazon Redshift genera un piano di esecuzione delle query basato sul presupposto che le tabelle esterne sono le tabelle più grandi e quelle locali le più piccole.
'skip.header.line.count'='*line\$1count*'
Proprietà che imposta il numero di righe da saltare all'inizio di ogni file sorgente.
'serialization.null.format'=' '
Proprietà che specifica che Spectrum deve restituire un valore `NULL` quando esiste una corrispondenza esatta con il testo fornito in un campo.
'orc.schema.resolution'='mapping\$1type'
Una proprietà che imposta il tipo di mappatura della colonna per le tabelle che utilizzano il formato di dati ORC. La proprietà viene ignorata per tutti gli altri formati di dati.
I valori validi per il tipo di mappatura della colonna sono i seguenti:
+ nome
+ position
Se la proprietà *orc.schema.resolution* viene omessa, le colonne vengono mappate in base al nome per impostazione predefinita. Se *orc.schema.resolution* è impostata su un valore diverso da *'name'* o *'position'*, le colonne vengono mappate in base alla posizione. Per ulteriori informazioni sulla mappatura delle colonne, consulta [Mappatura delle colonne di una tabella esterna alle colonne ORC](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc).
Il comando COPY mappa sui file di dati ORC soltanto in base alla posizione. La proprietà della tabella *orc.schema.resolution* non ha effetto sul comportamento del comando COPY.
'write.parallel'='on / off'
Proprietà che imposta se CREATE EXTERNAL TABLE AS deve scrivere dati in parallelo. Per impostazione predefinita, CREATE EXTERNAL TABLE AS scrive i dati in parallelo in più file, in base al numero di sezioni nel cluster. L'opzione predefinita è "attiva". Quando 'write.parallel' è impostato su off, CREATE EXTERNAL TABLE AS scrive su uno o più file di dati in serie su Amazon S3. Questa proprietà della tabella si applica anche a qualsiasi istruzione INSERT successiva nella stessa tabella esterna.
‘write.maxfilesize.mb'=‘size'
Una proprietà che imposta la dimensione massima (in MB) di ogni file scritto su Amazon S3 da CREATE EXTERNAL TABLE AS. La dimensione deve essere un numero intero valido compreso tra 5 e 6200. La dimensione massima predefinita del file è 6.200 MB. Questa proprietà della tabella si applica anche a qualsiasi istruzione INSERT successiva nella stessa tabella esterna.
'write.kms.key.id'='*valore*'
Puoi specificare una AWS Key Management Service chiave per abilitare la crittografia lato server (SSE) per oggetti Amazon S3, dove il *valore* è uno dei seguenti:
+ `auto`per utilizzare la AWS KMS chiave predefinita memorizzata nel bucket Amazon S3.
+ *kms-key* che si specifica per crittografare i dati.
*select\$1statement*
Istruzione che inserisce una o più righe nella tabella esterna definendo qualsiasi query. Tutte le righe prodotte dalla query vengono scritte in Amazon S3 in formato testo o Parquet in base alla definizione della tabella.
## Esempi
Una raccolta di esempi è disponibile all'indirizzo [Esempi](r_CREATE_EXTERNAL_TABLE_examples.md).
# Note per l’utilizzo
Questo argomento contiene note di utilizzo per [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Non è possibile visualizzare i dettagli per le tabelle Amazon Redshift Spectrum che utilizzano le stesse risorse utilizzate per le tabelle Amazon Redshift standard come [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS o information\$1schema. Se il tuo strumento di business intelligence o di analisi non riconosce le tabelle esterne Redshift Spectrum, configura l'applicazione per eseguire la query su [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) e [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).
## CREATE EXTERNAL TABLE AS
In alcuni casi, puoi eseguire il comando CREATE EXTERNAL TABLE AS su un catalogo AWS Glue dati, un catalogo AWS Lake Formation esterno o un metastore Apache Hive. In questi casi, si utilizza un ruolo AWS Identity and Access Management (IAM) per creare lo schema esterno. Questo ruolo IAM deve disporre di autorizzazioni di lettura e scrittura per Amazon S3.
Se si utilizza un catalogo Lake Formation, il ruolo IAM deve disporre dell'autorizzazione per creare una tabella nel catalogo. In questo caso, deve anche disporre dell'autorizzazione per la posizione del data lake sul percorso di destinazione di Amazon S3. Questo ruolo IAM diventa il proprietario della nuova tabella AWS Lake Formation .
Per garantire che i nomi file siano univoci, Amazon Redshift utilizza il seguente formato per il nome di ogni file caricato in Amazon S3 per impostazione predefinita.
`_