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à.
# Esecuzione di query su set di dati Apache Hudi
[https://hudi.incubator.apache.org/](https://hudi.incubator.apache.org/) è un framework open source per la gestione dei dati che semplifica l'elaborazione incrementale dei dati. Le operazioni di inserimento, aggiornamento, upsert ed eliminazione a livello di registro vengono elaborate in modo molto più granulare, riducendo il sovraccarico. `Upsert` si riferisce alla possibilità di inserire registri in un set di dati esistente se non esistono già o di aggiornarli.
Hudi gestisce gli eventi di inserimento e aggiornamento dei dati senza creare molti file di piccole dimensioni che possono causare problemi di prestazioni per l'analisi. Apache Hudi tiene traccia automaticamente delle modifiche e unisce i file in modo che abbiano dimensioni ottimali. Ciò evita la necessità di creare soluzioni personalizzate in grado di monitorare e riscrivere molti file di piccole dimensioni in meno file di grandi dimensioni.
I set di dati Hudi sono adatti per i seguenti casi d'uso:
+ il rispetto delle normative sulla privacy come il [Regolamento generale sulla protezione dei dati](https://en.wikipedia.org/wiki/General_Data_Protection_Regulation) (GDPR) e la [Legge sulla privacy dei consumatori della California](https://en.wikipedia.org/wiki/California_Consumer_Privacy_Act) (CCPA), che danno alle persone il diritto di rimuovere le informazioni personali o di modificare il modo in cui vengono utilizzati i loro dati.
+ Utilizzo di dati in streaming da sensori e altri dispositivi IoT (Internet of Things) che richiedono specifici eventi di inserimento e aggiornamento dei dati.
+ Implementazione di un [sistema di acquisizione dei dati di modifica o change data capture (CDC)](https://en.wikipedia.org/wiki/Change_data_capture).
Un set di dati Hudi può essere tra i seguenti tipi:
+ **Copia in scrittura (CoW)**: i dati vengono memorizzati in un formato colonnare (Parquet) e ogni aggiornamento crea una nuova versione dei file durante una scrittura.
+ **Unisci in lettura (MoR)** — I dati vengono archiviati utilizzando una combinazione di formati a colonne (Parquet) e basati su righe (Avro). Gli aggiornamenti vengono registrati nei file `delta` basati su righe e vengono compattati in base alle necessità per creare nuove versioni dei file colonnari.
Con i set di dati CoW, ogni volta che c'è un aggiornamento a un record, il file che contiene il record viene riscritto con i valori aggiornati. Quando si lavora con un set di dati MoR, ogniqualvolta è disponibile un aggiornamento Hudi scrive solo la riga per il registro modificato. MoR è più adatto per carichi di lavoro pesanti in scrittura o modifiche con meno letture. CoW è più adatto per carichi di lavoro pesanti di lettura su dati che cambiano meno frequentemente.
Hudi fornisce tre tipi di query per accedere ai dati:
+ **Query snapshot**: query che vedono l'ultima snapshot della tabella a partire da una determinata operazione di commit o compattazione. Per le tabelle MoR, le query snapshot espongono lo stato più recente della tabella unendo i file di base e delta della parte di file più recente al momento della query.
+ **Query incrementali**: le query vedono solo i nuovi dati scritti nella tabella, dal momento di un determinato commit/compattazione. Questo fornisce in modo efficace flussi di modifica per abilitare pipeline di dati incrementali.
+ **Leggi query ottimizzate**: per le tabelle MoR, le query vedono i dati più recenti compattati. Per le tabelle CoW, le query vedono i dati più recenti impegnati.
Nella tabella seguente vengono illustrati i possibili tipi di query Hudi per ciascun tipo di tabella.
| Tipo tabella | Possibili tipi di query Hudi |
| --- | --- |
| Copia in scrittura | snapshot, incrementale |
| Unisci in lettura | snapshot, incrementale, lettura ottimizzata |
Per ulteriori informazioni sui compromessi tra i tipi di tabella e query, consulta [Tipi di tabella e query](https://hudi.apache.org/docs/table_types/) nella documentazione di Apache Hudi.
## Cambiamento terminologico Hudi: le viste sono ora query
A partire dal rilascio della versione 0.5.1 di Apache Hudi, quelle che in precedenza venivano chiamate viste sono ora chiamate query. Nella tabella seguente vengono riepilogate le modifiche tra i termini precedenti e quelli nuovi.
| Vecchio termine | Nuovo termine |
| --- | --- |
| CoW: visualizzazione ottimizzata per la lettura MoR: visualizzazione in tempo reale | Query snapshot |
| Visualizzazione incrementale | Query incrementale |
| Visualizzazione ottimizzata per la lettura MoR | Query ottimizzata per la lettura |
**Topics**
+ [Cambiamento terminologico Hudi: le viste sono ora query](#querying-hudi-hudi-dataset-table-types-terminology)
+ [Considerazioni e limitazioni](querying-hudi-in-athena-considerations-and-limitations.md)
+ [Esempi di creazione di tabelle Copia su scrittura (CoW)](querying-hudi-copy-on-write-create-table-examples.md)
+ [Esempi di creazione di tabelle Unisci in lettura (MoR)](querying-hudi-merge-on-read-create-table-examples.md)
+ [Usa i metadati Hudi per migliorare le prestazioni](querying-hudi-metadata-table.md)
+ [Risorse aggiuntive](querying-hudi-additional-resources.md)
# Considerazioni e limitazioni
Quando si utilizza Athena per leggere le tabelle Apache Hudi, considerare i seguenti punti.
+ **Operazioni di lettura e scrittura**: Athena può leggere set di dati Hudi compattati ma non scrivere dati Hudi.
+ **Versioni Hudi** — Athena supporta la versione Hudi 0.14.0 (predefinita) e 0.15.0. Athena non può garantire la compatibilità di lettura con le tabelle create con versioni successive di Hudi. Per ulteriori informazioni sulle funzionalità e sul controllo delle versioni di Hudi, consulta la [documentazione di Hudi](https://hudi.apache.org/) sul sito Web di Apache. Nota che la versione 0.15.0 del connettore Hudi su Athena non supporta le tabelle con bootstrap. Per utilizzare la versione 0.15.0 del connettore Hudi, impostate la seguente proprietà della tabella:
```
ALTER TABLE table_name SET TBLPROPERTIES ('athena_enable_native_hudi_connector_implementation' = 'true')
```
+ **Interrogazioni tra account: la versione 0.15.0 del connettore Hudi non supporta le interrogazioni** tra account.
+ **Tipi di query**: attualmente, Athena supporta le query snapshot e le query ottimizzate per la lettura, ma non le query incrementali. Sulle tabelle MoR, tutti i dati esposti a query ottimizzate di lettura sono compattati. Ciò fornisce buone prestazioni ma non include i commit delta più recenti. Le query snapshot contengono i dati più aggiornati ma incorrono in un sovraccarico computazionale che rende queste query meno performanti. Per ulteriori informazioni sui compromessi tra i tipi di tabella e query, consulta [Tipi di tabella e query](https://hudi.apache.org/docs/table_types/) nella documentazione di Apache Hudi.
+ **Query incrementali: Athena non supporta le query** incrementali.
+ **CTAS**: Athena non supporta [CTAS](ctas.md) o [INSERT INTO](insert-into.md) per i dati Hudi. Se desideri il supporto Athena per la scrittura di dataset Hudi, invia un feedback ad athena-feedback@amazon.com.
Per ulteriori informazioni sulla scrittura di dati Hudi, vedere le seguenti risorse:
+ [Utilizzo di un set di dati Hudi](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hudi-work-with-dataset.html) nella [Guida al rilascio di Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/).
+ [Scrittura di dati](https://hudi.apache.org/docs/0.8.0/writing_data.html) nella documentazione di Apache Hudi.
+ **MSCK REPAIR TABLE**: l’utilizzo di MSCK REPAIR TABLE sulle tabelle Hudi in Athena non è supportato. Se devi caricare una tabella Hudi non creata in, usa. AWS Glue[ALTER TABLE ADD PARTITION](alter-table-add-partition.md)
+ **Ignorare gli oggetti Amazon Glacier non supportati**: se gli oggetti nella tabella Apache Hudi si trovano in una classe di archiviazione Amazon Glacier, l’impostazione della proprietà della tabella `read_restored_glacier_objects` su `false` non ha alcun effetto.
Ad esempio, supponiamo di emettere il seguente comando:
```
ALTER TABLE table_name SET TBLPROPERTIES ('read_restored_glacier_objects' = 'false')
```
Per le tabelle Iceberg e Delta Lake, il comando produce l'errore Chiave delle proprietà della tabella non supportata: read\$1restored\$1glacier\$1objects. Per le tabelle Hudi, il comando `ALTER TABLE` non produce un errore, ma gli oggetti Amazon Glacier ancora non verranno ignorati. L'esecuzione delle query `SELECT` dopo il comando `ALTER TABLE` continuerà a restituire tutti gli oggetti.
+ Interrogazioni con **indicazione temporale: attualmente, le query** che tentano di leggere le colonne con data e ora nelle tabelle in tempo reale di Hudi hanno esito negativo o producono risultati vuoti. Questa limitazione si applica solo alle query che leggono una colonna con timestamp. Le interrogazioni che includono solo colonne diverse da timestamp della stessa tabella hanno esito positivo.
Le query non riuscite restituiscono un messaggio simile al seguente:
GENERIC\$1INTERNAL\$1ERROR: classe org.apache.hadoop.io. ArrayWritablenon può essere trasmesso alla classe org.apache.hadoop.hive.serde2.io. TimestampWritableV2 (org.apache.hadoop.io. ArrayWritable e org.apache.hadoop.hive.serde2.io. TimestampWritableLe V2 si trovano nel modulo senza nome del loader io.trino.server. PluginClassLoader @75c67992)
+ **Autorizzazioni Lake Formation su 0.15.0 Hudi Connector** — Questa limitazione si applica solo quando si sceglie di utilizzare il connettore Hudi nativo (versione 0.15.0) impostando la proprietà della tabella su. `athena_enable_native_hudi_connector_implementation` `true` Per impostazione predefinita, Athena utilizza il connettore Hudi versione 0.14.0, che non richiede questa autorizzazione aggiuntiva. Per interrogare una tabella protetta da Lake Formation, devi concedere le autorizzazioni di Lake Formation sia alla posizione dei dati della tabella che alla directory dei `.hoodie` metadati. Ad esempio, se la tua tabella Hudi si trova in`s3://bucket/hudi-table/`, devi registrarti e concedere le autorizzazioni a entrambi `s3://bucket/hudi-table/` e `s3://bucket/hudi-table/.hoodie/` in Lake Formation. La `.hoodie` directory contiene file di metadati (ad esempio`hoodie.properties`) che Athena deve leggere durante la pianificazione delle query. Senza autorizzazioni per l'accesso alla `.hoodie` directory, le query avranno esito negativo con errori di autorizzazione negata.
# Esempi di creazione di tabelle Copia su scrittura (CoW)
Se hai già delle tabelle Hudi create in AWS Glue, puoi interrogarle direttamente in Athena. Quando crei tabelle partizionate Hudi in Athena, è necessario eseguire `ALTER TABLE ADD PARTITION` per caricare i dati Hudi prima di poterli interrogare.
## Tabella CoW non partizionata
L'esempio seguente crea una tabella CoW non partizionata in Athena.
```
CREATE EXTERNAL TABLE `non_partition_cow`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int,
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/non_partition_cow/'
```
## Tabella CoW partizionata
L'esempio seguente crea una tabella CoW partizionata in Athena.
```
CREATE EXTERNAL TABLE `partition_cow`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int)
PARTITIONED BY (
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/partition_cow/'
```
Il seguente esempio `ALTER TABLE ADD PARTITION` aggiunge due partizioni all'esempio di tabella `partition_cow`.
```
ALTER TABLE partition_cow ADD
PARTITION (event_type = 'one') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_cow/one/'
PARTITION (event_type = 'two') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_cow/two/'
```
# Esempi di creazione di tabelle Unisci in lettura (MoR)
Hudi crea due tabelle nel metastore per MoR: una tabella per le query snapshot e una tabella per le query ottimizzate per la lettura. Entrambe le tabelle sono interrogabili. Nelle versioni Hudi precedenti alla 0.5.1, la tabella per le query ottimizzate per la lettura aveva il nome specificato al momento della creazione della tabella. A partire da Hudi versione 0.5.1, al nome della tabella viene aggiunto il suffisso `_ro` per impostazione predefinita. Il nome della tabella per le query snapshot è il nome specificato seguito da `_rt`.
## Tabella Unisci in lettura (MoR) non partizionata
L'esempio seguente crea una tabella MoR non partizionata in Athena per le query ottimizzate per la lettura. Le query ottimizzate di lettura utilizzano il formato di input `HoodieParquetInputFormat`.
```
CREATE EXTERNAL TABLE `nonpartition_mor`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int,
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/nonpartition_mor/'
```
L'esempio seguente crea una tabella MoR non partizionata in Athena per le query snapshot. Per le query snapshot, utilizzare il formato di input `HoodieParquetRealtimeInputFormat`.
```
CREATE EXTERNAL TABLE `nonpartition_mor_rt`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int,
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.realtime.HoodieParquetRealtimeInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/nonpartition_mor/'
```
## Tabella Unisci in lettura (MoR) partizionata
L'esempio seguente crea una tabella MoR partizionata in Athena per le query ottimizzate per la lettura.
```
CREATE EXTERNAL TABLE `partition_mor`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int)
PARTITIONED BY (
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.HoodieParquetInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/partition_mor/'
```
Il seguente esempio `ALTER TABLE ADD PARTITION` aggiunge due partizioni all'esempio di tabella `partition_mor`.
```
ALTER TABLE partition_mor ADD
PARTITION (event_type = 'one') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_mor/one/'
PARTITION (event_type = 'two') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_mor/two/'
```
L'esempio seguente crea una tabella MoR partizionata in Athena per le query snapshot.
```
CREATE EXTERNAL TABLE `partition_mor_rt`(
`_hoodie_commit_time` string,
`_hoodie_commit_seqno` string,
`_hoodie_record_key` string,
`_hoodie_partition_path` string,
`_hoodie_file_name` string,
`event_id` string,
`event_time` string,
`event_name` string,
`event_guests` int)
PARTITIONED BY (
`event_type` string)
ROW FORMAT SERDE
'org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe'
STORED AS INPUTFORMAT
'org.apache.hudi.hadoop.realtime.HoodieParquetRealtimeInputFormat'
OUTPUTFORMAT
'org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat'
LOCATION
's3://amzn-s3-demo-bucket/folder/partition_mor/'
```
Analogamente, il seguente esempio `ALTER TABLE ADD PARTITION` aggiunge due partizioni all'esempio di tabella `partition_mor_rt`.
```
ALTER TABLE partition_mor_rt ADD
PARTITION (event_type = 'one') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_mor/one/'
PARTITION (event_type = 'two') LOCATION 's3://amzn-s3-demo-bucket/folder/partition_mor/two/'
```
# Usa i metadati Hudi per migliorare le prestazioni
Apache Hudi dispone di una [tabella di metadati](https://hudi.apache.org/docs/next/metadata/) contenente funzionalità di indicizzazione per migliorare le prestazioni, come l'elenco dei file, il salto dei dati utilizzando le statistiche delle colonne e un indice basato sul filtro Bloom.
Di queste funzionalità Athena attualmente supporta solo l'indice di elenco dei file. L'indice di elenco dei file elimina le chiamate al file system come "list files" recuperando le informazioni da un indice che mantiene una mappatura tra partizione e file. Ciò rimuove il bisogno di elencare in modo ricorsivo ogni singola partizione nel percorso della tabella per avere una visualizzazione del file system. Quando utilizzi set di dati di grandi dimensioni, questa indicizzazione riduce drasticamente la latenza che altrimenti si verificherebbe quando si ottiene l'elenco dei file durante la scrittura e le query. Inoltre, evita colli di bottiglia come restrizioni di limiti di richiesta nelle chiamate `LIST` Amazon S3.
**Nota**
Al momento Athena non supporta il salto dei dati o l'indicizzazione del filtro Bloom.
## Abilitazione della tabella di metadati Hudi
Per impostazione predefinita, l'elenco dei file basato su tabelle di metadati è disabilitato. Per abilitare la tabella di metadati Hudi e la relativa funzionalità di elenco dei file, imposta la proprietà della tabella `hudi.metadata-listing-enabled` su `TRUE`.
**Esempio**
L'esempio `ALTER TABLE SET TBLPROPERTIES` seguente abilita la tabella di metadati nella tabella di esempio `partition_cow`.
```
ALTER TABLE partition_cow SET TBLPROPERTIES('hudi.metadata-listing-enabled'='TRUE')
```
## Usa i metadati generati da bootstrap
A partire da Apache Hudi v. 0.6.0, la funzione dell'operazione Bootstrap fornisce prestazioni migliori con i set di dati Parquet esistenti. Invece di riscrivere il set di dati, un'operazione Bootstrap può generare solo metadati, lasciando il set di dati in posizione.
Puoi usare Athena per interrogare le tabelle da un'operazione Bootstrap proprio come altre tabelle basate sui dati in Amazon S3. Nell'istruzione `CREATE TABLE`, specifica il percorso della tabella Hudi nella clausola `LOCATION`.
Per ulteriori informazioni sulla creazione di tabelle Hudi utilizzando l'operazione di bootstrap in Amazon EMR, consulta l'articolo [Nuove funzionalità di Apache Hudi disponibili in Amazon EMR nel Big Data](https://aws.amazon.com/blogs/big-data/new-features-from-apache-hudi-available-in-amazon-emr/) Blog. AWS
# Risorse aggiuntive
Per ulteriori risorse sull’utilizzo di Apache Hudi con Athena, consulta le seguenti risorse.
## Video
Il video seguente mostra come puoi usare Amazon Athena per interrogare un dataset Apache Hudi ottimizzato per la lettura nel tuo data lake basato su Amazon S3.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TVcreqxBaGA)
## Post del blog
I seguenti post del blog AWS Big Data includono descrizioni di come utilizzare Apache Hudi con Athena.
+ [Usa AWS Data Exchange per condividere senza problemi i set di dati Apache Hudi](https://aws.amazon.com/blogs/big-data/use-aws-data-exchange-to-seamlessly-share-apache-hudi-datasets/)
+ [Crea un data lake near-real-time transazionale basato su Apache HUDI utilizzando Amazon AWS DMS Kinesis, AWS Glue streaming ETL e visualizzazione dei dati con Quick](https://aws.amazon.com/blogs/big-data/create-an-apache-hudi-based-near-real-time-transactional-data-lake-using-aws-dms-amazon-kinesis-aws-glue-streaming-etl-and-data-visualization-using-amazon-quicksight/)
+ Per informazioni sull'utilizzo di connettori AWS Glue personalizzati e processi AWS Glue 2.0 per creare una tabella Apache Hudi su cui è possibile eseguire query con Athena, vedere [Scrittura su tabelle Apache Hudi](https://aws.amazon.com/blogs/big-data/writing-to-apache-hudi-tables-using-aws-glue-connector/) utilizzando un connettore personalizzato. AWS Glue
+ Per un articolo sull'utilizzo di Apache Hudi e Amazon Athena per creare un framework di elaborazione dati per un data lake, [consulta Simplify operations data processing in data lake AWS Glue using](https://aws.amazon.com/blogs/big-data/simplify-operational-data-processing-in-data-lakes-using-aws-glue-and-apache-hudi/) and Apache Hudi. AWS Glue