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

# Lavorare con le tabelle Iceberg utilizzando Trino
<a name="iceberg-trino"></a>

Questa sezione descrive come configurare e gestire le tabelle Iceberg utilizzando [Trino](https://trino.io/docs/current/) su Amazon [EMR](https://docs.aws.amazon.com/emr/). Gli esempi sono codice standard che puoi eseguire su un cluster Amazon EMR su EC2. **Gli esempi di codice e le configurazioni in questa sezione presuppongono che tu stia utilizzando la release emr-7.9.0 di Amazon EMR.**

## Configurazione di Amazon EMR su EC2
<a name="trino-emr-setup"></a>

1. Crea un `iceberg.properties` file con il seguente contenuto. L'`iceberg.file-format=parquet`impostazione determina il formato di archiviazione predefinito per le nuove tabelle se il formato non è specificato esplicitamente nell'`CREATE TABLE`istruzione.

   ```
   connector.name=iceberg
   iceberg.catalog.type=glue
   iceberg.file-format=parquet
   fs.native-s3.enabled=true
   ```

1. Carica il file `iceberg.properties` nel bucket S3. 

1. Crea un'azione di bootstrap che copia il `iceberg.properties` file dal tuo bucket S3 e lo archivia come file di configurazione Trino nel cluster Amazon EMR che creerai. Assicurati di sostituirlo `<S3-bucket-name>` con il nome del bucket S3. 

   ```
   #!/bin/bash
   set -ex
   sudo aws s3 cp s3://<S3-bucket-name>/iceberg.properties /etc/trino/conf/catalog/iceberg.properties
   ```

1. Crea un cluster Amazon EMR con Trino installato e specifica l'esecuzione dello script precedente come azione di bootstrap. Ecco un esempio di comando AWS Command Line Interface (AWS CLI) per creare il cluster:

   ```
   aws emr create-cluster --release-label emr-7.9.0 \
   --applications Name=Trino \
   --region <region> \
   --name Trino_Iceberg_Cluster \
   --bootstrap-actions '[{"Path":"s3://<S3-bucket-name>/bootstrap.sh","Name":"Add iceberg.properties"}]' \
   --instance-groups '[{"InstanceGroupType":"MASTER","InstanceCount":1,"InstanceType":"m5.xlarge"},{"InstanceGroupType":"CORE","InstanceCount":3,"InstanceType":"m5.xlarge"}]' \
   --service-role "<IAM-service-role>" \
   --ec2-attributes '{"KeyName":"<key-name>","InstanceProfile":"<EMR-EC2-instance-profile>"}'
   ```

   dove sostituisci:
   + `<S3-bucket-name>`con il nome del tuo bucket S3
   + `<region>`con le tue specifiche Regione AWS
   + `<key-name>`con la tua key pair. Se la key pair non esiste, verrà creata.
   + `<IAM-service-role>`con il tuo ruolo di servizio Amazon EMR che segue il [principio del privilegio minimo](https://aws.amazon.com/blogs/security/techniques-for-writing-least-privilege-iam-policies/). 
   + `<EMR-EC2-instance-profile>`con il profilo della tua [istanza](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-ranger-iam-ec2.html). 

1. Una volta inizializzato il cluster Amazon EMR, puoi inizializzare una sessione Trino eseguendo il seguente comando:

   ```
   trino-cli
   ```

1. Nella CLI di Trino, puoi visualizzare i cataloghi eseguendo:

   ```
   SHOW CATALOGS;
   ```

## Creazione di tabelle Iceberg
<a name="trino-create-table"></a>

Per creare una tabella Iceberg, puoi usare l'istruzione. `CREATE TABLE`  Ecco un esempio di creazione di una tabella partizionata che utilizza il partizionamento nascosto Iceberg:

```
CREATE TABLE iceberg.iceberg_db.iceberg_table (
             userid int,
             firstname varchar,
             city varchar)
        WITH (
             format = 'PARQUET',
             partitioning = ARRAY['city', 'bucket(userid, 16)'],
             location = 's3://<S3-bucket>/<prefix>');
```

**Nota**  
Se non specifichi il formato, verrà utilizzato il `iceberg.file-format` valore configurato nella sezione precedente.

Per inserire dati, usa il `INSERT INTO` comando. Ecco un esempio:

```
INSERT INTO iceberg.iceberg_db.iceberg_table (userid, firstname, city)
VALUES 
    (1001, 'John', 'New York'),
    (1002, 'Mary', 'Los Angeles'),
    (1003, 'Mateo', 'Chicago'),
    (1004, 'Shirley', 'Houston'),
    (1005, 'Diego', 'Miami'),
    (1006, 'Nikki', 'Seattle'),
    (1007, 'Pat', 'Boston'),
    (1008, 'Terry', 'San Francisco'),
    (1009, 'Richard', 'Denver'),
    (1010, 'Pat', 'Phoenix');
```

## Leggere dalle tabelle Iceberg
<a name="trino-read-data"></a>

È possibile leggere lo stato più recente della tabella Iceberg utilizzando un'`SELECT`istruzione, come segue:

```
SELECT * FROM iceberg.iceberg_db.iceberg_table;
```

## Trasformazione dei dati in tabelle Iceberg
<a name="trino-upsert-data"></a>

È possibile eseguire un'operazione di upsert (inserire contemporaneamente nuovi record e aggiornare quelli esistenti) utilizzando l'istruzione. `MERGE INTO` Ecco un esempio:

```
MERGE INTO iceberg.iceberg_db.iceberg_table target
USING (
      VALUES 
        (1001, 'John Updated', 'Boston'),       -- Update existing user
        (1002, 'Mary Updated', 'Seattle'),      -- Update existing user
        (1011, 'Martha', 'Portland'),           -- Insert new user
        (1012, 'Paulo', 'Austin')               -- Insert new user
    ) AS source (userid, firstname, city)
   ON target.userid = source.userid
 WHEN MATCHED THEN
      UPDATE SET 
        firstname = source.firstname,
        city = source.city
 WHEN NOT MATCHED THEN
      INSERT (userid, firstname, city)
      VALUES (source.userid, source.firstname, source.city);
```

## Eliminazione di record dalle tabelle Iceberg
<a name="trino-delete-data"></a>

Per eliminare i dati da una tabella Iceberg, utilizzate l'`DELETE FROM`espressione e specificate un filtro che corrisponda alle righe da eliminare. Ecco un esempio:

```
DELETE FROM iceberg.iceberg_db.iceberg_table WHERE userid IN (1003, 1004);
```

## Esecuzione di query sui metadati di tabelle Iceberg
<a name="trino-query-metadata"></a>

Iceberg fornisce l'accesso ai suoi metadati tramite SQL. È possibile accedere ai metadati per ogni tabella (`<table_name>`) interrogando il namespace. `"<table_name>.$<metadata_table>"` Per un elenco completo delle tabelle di metadati, consulta [Ispezione](https://iceberg.apache.org/docs/latest/spark-queries/#inspecting-tables) delle tabelle nella documentazione di Iceberg.

Ecco un elenco di esempio di query per ispezionare i metadati di Iceberg:

```
SELECT  FROM iceberg.iceberg_db."iceberg_table$snapshots";
SELECT  FROM iceberg.iceberg_db."iceberg_table$history";
SELECT  FROM iceberg.iceberg_db."iceberg_table$partitions";
SELECT  FROM iceberg.iceberg_db."iceberg_table$files";
SELECT  FROM iceberg.iceberg_db."iceberg_table$manifests";
SELECT  FROM iceberg.iceberg_db."iceberg_table$refs";
SELECT * FROM iceberg.iceberg_db."iceberg_table$metadata_log_entries";
```

Ad esempio, questa query: 

```
 SELECT * FROM iceberg.iceberg_db."iceberg_table$snapshots";
```

fornisce l'output:

![\[Risultato dell'interrogazione dei metadati della tabella Iceberg.\]](http://docs.aws.amazon.com/it_it/prescriptive-guidance/latest/apache-iceberg-on-aws/images/querying-metadata-trino.png)


## Usare i viaggi nel tempo
<a name="trino-time-travel"></a>

Ogni operazione di scrittura (inserimento, aggiornamento, annullamento o eliminazione) in una tabella Iceberg crea una nuova istantanea. È quindi possibile utilizzare queste istantanee per viaggiare nel tempo, per tornare indietro nel tempo e controllare lo stato di una tabella nel passato.

La seguente interrogazione sui viaggi nel tempo mostra lo stato di una tabella in base a uno specifico: `snapshot_id`

```
SELECT *
FROM iceberg.iceberg_db.iceberg_table FOR VERSION AS OF 241938428756831817;
```

La seguente query sul viaggio nel tempo mostra lo stato di una tabella in base a un timestamp specifico:

```
SELECT *
FROM iceberg.iceberg_db.iceberg_table FOR TIMESTAMP AS OF TIMESTAMP '2025-05-28 16:09:40.268 UTC'
```

## Considerazioni sull'utilizzo di Iceberg con Trino
<a name="trino-considerations"></a>

Le operazioni di scrittura di Trino sulle tabelle Iceberg seguono la [merge-on-read](https://docs.aws.amazon.com/prescriptive-guidance/latest/apache-iceberg-on-aws/best-practices-write.html#write-update-strategy)progettazione, quindi creano file di eliminazione posizionali invece di riscrivere interi file di dati interessati da aggiornamenti o eliminazioni. Se vuoi usare questo copy-on-write approccio, prendi in considerazione l'utilizzo di Spark per le operazioni di scrittura.