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

# Effettuare aggiornamenti degli schemi
<a name="make-schema-updates"></a>

Questo argomento descrive alcune delle modifiche che è possibile apportare allo schema nelle istruzioni `CREATE TABLE` senza alterare effettivamente i dati. Per aggiornare uno schema, in alcuni casi puoi utilizzare un comando `ALTER TABLE`, ma in altri casi non è possibile modificare effettivamente una tabella esistente. Crea invece una tabella con un nuovo nome che modifica lo schema utilizzato nell'istruzione originale `CREATE TABLE`.

A seconda dell'evoluzione prevista degli schemi, per continuare a utilizzare le query Athena, è necessario scegliere un formato di dati compatibile. 

Considera un'applicazione che legge le informazioni sugli ordini da una tabella `orders` esistente in due formati: CSV e Parquet. 

L'esempio seguente crea una tabella in formato Parquet:

```
CREATE EXTERNAL TABLE orders_parquet (
   `orderkey` int, 
   `orderstatus` string, 
   `totalprice` double, 
   `orderdate` string, 
   `orderpriority` string, 
   `clerk` string, 
   `shippriority` int
) STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_ parquet/';
```

L'esempio seguente crea la stessa tabella in formato CSV:

```
CREATE EXTERNAL TABLE orders_csv (
   `orderkey` int, 
   `orderstatus` string, 
   `totalprice` double, 
   `orderdate` string, 
   `orderpriority` string, 
   `clerk` string, 
   `shippriority` int
) 
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/orders_csv/';
```

I seguenti argomenti, mostrano come gli aggiornamenti di queste tabelle influenzano le query Athena.

**Topics**
+ [

# Aggiungi colonne all'inizio o al centro della tabella
](updates-add-columns-beginning-middle-of-table.md)
+ [

# Aggiungi colonne alla fine di una tabella
](updates-add-columns-end-of-table.md)
+ [

# Rimuovi colonne
](updates-removing-columns.md)
+ [

# Rinominare le colonne
](updates-renaming-columns.md)
+ [

# Riordina colonne
](updates-reordering-columns.md)
+ [

# Modifica il tipo di dati di una colonna
](updates-changing-column-type.md)

# Aggiungi colonne all'inizio o al centro della tabella
<a name="updates-add-columns-beginning-middle-of-table"></a>

L'aggiunta di colonne è una delle modifiche più frequenti di uno schema. Ad esempio, è possibile aggiungere una nuova colonna per arricchire la tabella con nuovi dati. In alternativa, è possibile aggiungere una nuova colonna se è cambiata la fonte di una colonna esistente e mantenere la versione precedente di questa colonna per regolare le applicazioni che dipendono da essa.

Per aggiungere colonne all'inizio o al centro della tabella e continuare a eseguire query su tabelle esistenti, utilizzate AVRO, JSON e Parquet e ORC se la loro SerDe proprietà è impostata su «Leggi per nome». Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).

Non aggiungere colonne all'inizio o al centro della tabella in CSV e TSV, poiché questi formati dipendono dall'ordinamento. L'aggiunta di una colonna in questi casi porterebbe a errori di mancata corrispondenza tra schemi quando lo schema di partizioni viene modificato.

 L'esempio seguente crea una nuova tabella che aggiunge una colonna `o_comment` al centro di una tabella basata su dati JSON.

```
CREATE EXTERNAL TABLE orders_json_column_addition (
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderstatus` string, 
   `o_comment` string, 
   `o_totalprice` double, 
   `o_orderdate` string, 
   `o_orderpriority` string, 
   `o_clerk` string, 
   `o_shippriority` int, 
) 
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/orders_json/';
```

# Aggiungi colonne alla fine di una tabella
<a name="updates-add-columns-end-of-table"></a>

Se si creano tabelle in uno dei formati supportati da Athena, ad esempio Parquet, ORC, Avro, JSON, CSV e TSV, è possibile utilizzare l'istruzione `ALTER TABLE ADD COLUMNS` per aggiungere colonne dopo le colonne esistenti ma prima delle colonne di partizione.

Nell'esempio seguente viene aggiunta una colonna `comment` alla fine della tabella `orders_parquet` prima di qualsiasi colonna di partizione: 

```
ALTER TABLE orders_parquet ADD COLUMNS (comment string)
```

**Nota**  
Per visualizzare una nuova colonna di tabella nell'editor di query Athena dopo l'esecuzione di `ALTER TABLE ADD COLUMNS`, aggiornare manualmente l'elenco di tabelle nell'editor e quindi espandere nuovamente la tabella.

# Rimuovi colonne
<a name="updates-removing-columns"></a>

Potrebbe essere necessario rimuovere colonne dalle tabelle se queste non contengono più dati o per limitare l'accesso ai dati in esse contenuti.
+ È possibile rimuovere colonne da tabelle in formato JSON, Avro e Parquet e ORC se la lettura è per nome. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access). 
+ Sconsigliamo di rimuovere colonne delle tabelle in CSV e TSV se si desidera conservare le tabelle già create in Athena. La rimozione di una colonna altera lo schema e richiede di ricreare la tabella senza la colonna rimossa.

In questo esempio, si rimuove una colonna ``totalprice`` da una tabella in Parquet e si esegue una query. In Athena, il formato Parquet è letto per nome per impostazione predefinita e questo è il motivo per cui omettiamo la configurazione SERDEPROPERTIES che specifica la lettura per nome. Tieni presente che la seguente query va a buon fine anche se si modifica lo schema:

```
CREATE EXTERNAL TABLE orders_parquet_column_removed (
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderstatus` string, 
   `o_orderdate` string, 
   `o_orderpriority` string, 
   `o_clerk` string, 
   `o_shippriority` int, 
   `o_comment` string
) 
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```

# Rinominare le colonne
<a name="updates-renaming-columns"></a>

È possibile rinominare le colonne nelle tabelle per correggere l'ortografia, rendere i nomi delle colonne più descrittivi o riutilizzare una colonna esistente per evitare il riordinamento delle colonne.

È possibile rinominare le colonne se si archiviano i dati in CSV e TSV o in Parquet e ORC con configurazione per la lettura per indice. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access). 

Athena legge i dati in CSV e TSV nell'ordine delle colonne nello schema e li restituisce nello stesso ordine. Non utilizza i nomi delle colonne per la mappatura dei dati a una colonna e questo è il motivo per cui è possibile rinominare le colonne in CSV o TSV senza interrompere le query Athena. 

Una strategia per rinominare le colonne consiste nel creare una nuova tabella basata sugli stessi dati sottostanti, ma utilizzando nuovi nomi di colonna. Il seguente esempio crea una nuova tabella `orders_parquet` chiamata `orders_parquet_column_renamed`. L'esempio modifica il nome ``o_totalprice`` della colonna in ``o_total_price`` e quindi esegue una query in Athena: 

```
CREATE EXTERNAL TABLE orders_parquet_column_renamed (
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderstatus` string, 
   `o_total_price` double, 
   `o_orderdate` string, 
   `o_orderpriority` string, 
   `o_clerk` string, 
   `o_shippriority` int, 
   `o_comment` string
) 
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```

Nel caso della tabella Parquet, la query seguente viene eseguita, ma la colonna rinominata non mostra i dati poiché l'accesso alla stessa è avvenuto per nome (impostazione predefinita in Parquet) anziché per indice:

```
SELECT * 
FROM orders_parquet_column_renamed;
```

Di seguito un esempio di query con una tabella in CSV:

```
CREATE EXTERNAL TABLE orders_csv_column_renamed (
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderstatus` string, 
   `o_total_price` double, 
   `o_orderdate` string, 
   `o_orderpriority` string, 
   `o_clerk` string, 
   `o_shippriority` int, 
   `o_comment` string
) 
ROW FORMAT DELIMITED FIELDS TERMINATED BY ','
LOCATION 's3://amzn-s3-demo-bucket/orders_csv/';
```

Nel caso della tabella CSV, la query seguente viene eseguita e i dati vengono visualizzati in tutte le colonne, compresa quella che è stata rinominata:

```
SELECT * 
FROM orders_csv_column_renamed;
```

# Riordina colonne
<a name="updates-reordering-columns"></a>

È possibile riordinare le colonne solo per tabelle con dati in formati che leggono per nome, ad esempio JSON o Parquet, i quali leggono per nome per impostazione predefinita. Se necessario, è possibile fare in modo che anche ORC legga per nome. Per informazioni, consulta [Comprendere l’accesso agli indici per Apache ORC e Apache Parquet](handling-schema-updates-chapter.md#index-access).

L'esempio seguente crea una nuova tabella con le colonne in un ordine diverso:

```
CREATE EXTERNAL TABLE orders_parquet_columns_reordered (
   `o_comment` string,
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderpriority` string, 
   `o_orderstatus` string, 
   `o_clerk` string, 
   `o_shippriority` int, 
   `o_orderdate` string
) 
STORED AS PARQUET
LOCATION 's3://amzn-s3-demo-bucket/orders_parquet/';
```

# Modifica il tipo di dati di una colonna
<a name="updates-changing-column-type"></a>

Potresti voler utilizzare un tipo di colonna diverso quando il tipo esistente non può più contenere la quantità di informazioni richieste. Ad esempio, i valori di una colonna ID potrebbero superare la dimensione del tipo di dati `INT` e richiedere l'uso del tipo di dati `BIGINT`.

## Considerazioni
<a name="updates-changing-column-type-considerations"></a>

Quando si prevede di utilizzare un tipo di dati diverso per una colonna, considerare i seguenti punti: 
+ Nella maggior parte dei casi, non è possibile modificare direttamente il tipo di dati di una colonna. Al contrario, si ricrea la tabella Athena e si definisce la colonna con il nuovo tipo di dati. 
+ Solo alcuni tipi di dati possono essere letti come altri tipi di dati. Consulta la tabella in questa sezione per i tipi di dati che possono essere trattati in tal modo.
+ Per i dati in Parquet e ORC, non puoi utilizzare un tipo di dati diverso per una colonna se la tabella non è partizionata. 
+ Per le tabelle partizionate in Parquet e ORC, il tipo di colonna di una partizione può essere diverso dal tipo di colonna di un'altra partizione e, se possibile, Athena eseguirà `CAST` per il tipo desiderato. Per informazioni, consulta [Evitare errori di mancata corrispondenza tra schemi per tabelle con partizioni](updates-and-partitions.md#partitions-dealing-with-schema-mismatch-errors).
+ Per le tabelle create utilizzando l'[LazySimpleSerDe](lazy-simple-serde.md)unico, è possibile utilizzare l'`ALTER TABLE REPLACE COLUMNS`istruzione per sostituire le colonne esistenti con un tipo di dati diverso, ma tutte le colonne esistenti che si desidera conservare devono essere ridefinite nell'istruzione, altrimenti verranno eliminate. Per ulteriori informazioni, consulta [ALTER TABLE REPLACE COLUMNS](alter-table-replace-columns.md).
+ Solo per le tabelle Apache Iceberg, puoi utilizzare l'istruzione [ALTER TABLE CHANGE COLUMN](querying-iceberg-alter-table-change-column.md) per modificare il tipo di dati di una colonna. `ALTER TABLE REPLACE COLUMNS` non è supportato per le tabelle Iceberg. Per ulteriori informazioni, consulta [Evoluzione dello schema della tabella Iceberg](querying-iceberg-evolving-table-schema.md).

**Importante**  
Consigliamo vivamente di testare e verificare le query prima di modificare il tipo di dati. Se Athena non è in grado di utilizzare il tipo di dati di destinazione, la query `CREATE TABLE` potrebbe avere esito negativo. 

## Utilizzare tipi di dati compatibili
<a name="updates-changing-column-type-use-compatible-data-types"></a>

Quando possibile, utilizza tipi di dati compatibili. La tabella seguente elenca i tipi di dati che possono essere trattati come altri tipi di dati:


| Tipo di dati originale | Tipi di dati di destinazione disponibili | 
| --- | --- | 
| STRING | BYTE, TINYINT, SMALLINT, INT, BIGINT | 
| BYTE | TINYINT, SMALLINT, INT, BIGINT | 
| TINYINT | SMALLINT, INT, BIGINT | 
| SMALLINT | INT, BIGINT | 
| INT | BIGINT | 
| FLOAT | DOUBLE | 

L'esempio seguente mostra l'utilizzo dell'istruzione `CREATE TABLE` per la tabella `orders_json` originale per creare una nuova tabella denominata `orders_json_bigint`. La nuova tabella utilizza `BIGINT` anziché `INT` come tipo di dati per la colonna ``o_shippriority``. 

```
CREATE EXTERNAL TABLE orders_json_bigint (
   `o_orderkey` int, 
   `o_custkey` int, 
   `o_orderstatus` string, 
   `o_totalprice` double, 
   `o_orderdate` string, 
   `o_orderpriority` string, 
   `o_clerk` string, 
   `o_shippriority` BIGINT
) 
ROW FORMAT SERDE 'org.openx.data.jsonserde.JsonSerDe'
LOCATION 's3://amzn-s3-demo-bucket/orders_json';
```

La seguente query viene eseguita correttamente, in modo analogo alla query `SELECT` originale, prima della modifica del tipo di dati:

```
Select * from orders_json 
LIMIT 10;
```