Salta al contenuto principale

05 - Iceberg vs Delta Lake vs Hudi: decision tree

Iceberg, Delta Lake e Hudi a confronto con listati eseguiti: metadati, evoluzione dello schema, manutenzione e tre domande per scegliere il formato di tabella.

Cosa ne pensi di questo articolo?

05 - Iceberg vs Delta Lake vs Hudi: decision tree
Data Engineering 2027Foto:AS PhotographyPexels

In Breve

Iceberg, Delta Lake e Hudi a confronto con listati eseguiti: metadati, evoluzione dello schema, manutenzione e tre domande per scegliere il formato di tabella.

Iceberg, Delta Lake e Hudi trasformano una cartella di file Parquet in una tabella con commit atomici, ma lo fanno con scelte diverse, e la scelta giusta dipende da tre cose che puoi verificare: quali motori leggono e scrivono la tabella, se i dati arrivano in aggiunte o in aggiornamenti per chiave, e chi si occuperà della manutenzione. Non esiste un "migliore" assoluto, e un confronto di velocità serio richiederebbe un cluster che qui non c'è: ho eseguito dal vivo Iceberg e Delta Lake, e ho letto la documentazione di Hudi.

Prerequisiti. Nozioni di Parquet e di che cosa sia una tabella in un data lake; è utile aver letto l'articolo su DuckDB.

Che cosa hanno in comune

I tre formati non sostituiscono Parquet: lo mettono sotto una struttura di metadati che dice quali file compongono la tabella in un dato momento, e fanno avanzare quella struttura con un commit atomico. Il risultato è lo stesso per chi legge: un'istantanea coerente anche mentre qualcuno scrive. Le tre documentazioni lo dicono con parole diverse: Iceberg descrive scritture ottimistiche che sostituiscono atomicamente il file di metadati, il protocollo Delta promette letture a istantanea e scritture serializzabili, Hudi dichiara isolamento a istantanea e controllo di concorrenza ottimistico fra i writer.

È quindi sbagliata la tabella a stelline che circola in molti confronti, con "Serializable" per uno, "Snapshot" per l'altro e "Read Committed" per Hudi: la documentazione di Hudi parla di isolamento a istantanea e di controllo ottimistico, non di Read Committed, e comunque un livello di isolamento non è un punteggio di qualità. Quello che cambia davvero è dove sta lo stato (file di log, albero di manifest, linea temporale), e che cosa devi fare tu per tenerlo sano.

Le versioni correnti alla data di consultazione (2026-11-13), le licenze e chi governa i progetti sono nella tabella; tutte e tre le licenze sono Apache-2.0 secondo i repository su GitHub.

ProgettoVersione consultataLibreria Python usata quiGovernance dichiarata
Apache Iceberg1.12.0 (2026-09-30)pyiceberg 0.12.0Progetto Apache Software Foundation
Delta Lake4.4.1 (2026-10-05)deltalake 1.6.6 (delta-rs)Sotto-progetto della Linux Foundation, dal 2019
Apache Hudi1.2.1 (2026-09-24)nessuna (si scrive con Spark o Flink)Progetto Apache Software Foundation

Il dato di governance serve a una domanda pratica: chi può cambiare le regole del formato? Per tutti e tre il codice è aperto e decide una comunità; ma una licenza può cambiare, come dimostra il caso di lakeFS nell'articolo lakeFS: Git per data lake. Rileggi il file LICENSE di ogni progetto il giorno in cui scegli.

Iceberg: un albero di metadati con id di colonna

Iceberg tiene lo stato in un file di metadati JSON che punta a una lista di manifest, ciascuno dei quali elenca i file di dati con le loro statistiche. Ogni colonna ha un identificativo numerico che non cambia mai: è questo che permette di rinominare una colonna senza toccare i dati. Il listato crea una tabella partizionata per giorno su un catalogo SQLite locale (dentro la cartella di prova), la riempie con due caricamenti, mostra il viaggio nel tempo e poi cambia lo schema.

import collections, pathlib, shutil
import pyarrow as pa
from pyiceberg.catalog.sql import SqlCatalog
from pyiceberg.schema import Schema
from pyiceberg.types import NestedField, LongType, StringType, DoubleType, TimestampType
from pyiceberg.partitioning import PartitionSpec, PartitionField
from pyiceberg.transforms import DayTransform

base = pathlib.Path("lago").resolve()
shutil.rmtree(base, ignore_errors=True); base.mkdir()
catalogo = SqlCatalog("locale", uri=f"sqlite:///{base}/catalogo.db", warehouse=f"file://{base}/magazzino")
catalogo.create_namespace("vendite")

schema = Schema(NestedField(1, "order_id", LongType(), required=True),
                NestedField(2, "cliente", StringType()),
                NestedField(3, "importo", DoubleType()),
                NestedField(4, "ts", TimestampType()))
spec = PartitionSpec(PartitionField(source_id=4, field_id=1000, transform=DayTransform(), name="ts_giorno"))
tabella = catalogo.create_table("vendite.ordini", schema=schema, partition_spec=spec)

def lotto(da, a, giorno):
    # order_id e' "required" nella tabella: anche lo schema Arrow deve dichiararlo non nullo
    schema_arrow = pa.schema([pa.field("order_id", pa.int64(), nullable=False), pa.field("cliente", pa.string()),
                              pa.field("importo", pa.float64()), pa.field("ts", pa.timestamp("us"))])
    return pa.table({"order_id": list(range(da, a)), "cliente": [f"c{i % 7}" for i in range(da, a)],
                     "importo": [float(i % 50) for i in range(da, a)], "ts": [giorno] * (a - da)}, schema=schema_arrow)
import datetime as dt
tabella.append(lotto(0, 1000, dt.datetime(2026, 11, 1, 10)))
tabella.append(lotto(1000, 2000, dt.datetime(2026, 11, 2, 10)))
primo = tabella.history()[0].snapshot_id
print("snapshot:", len(tabella.snapshots()), "| righe attuali:", tabella.scan().to_arrow().num_rows)
print("viaggio nel tempo, primo snapshot:", tabella.scan(snapshot_id=primo).to_arrow().num_rows, "righe")

# evoluzione dello schema: solo metadati, i file di dati restano gli stessi
file_prima = sorted(p.name for p in base.rglob("*.parquet"))
with tabella.update_schema() as upd:
    upd.add_column("canale", StringType())
    upd.rename_column("cliente", "cliente_id")
tabella = catalogo.load_table("vendite.ordini")
file_dopo = sorted(p.name for p in base.rglob("*.parquet"))
print("file Parquet prima e dopo l'evoluzione identici:", file_prima == file_dopo, f"({len(file_dopo)} file)")
print("colonne:", [f.name for f in tabella.schema().fields])
lette = tabella.scan().to_arrow()
print("canale nelle righe vecchie:", set(lette["canale"].to_pylist()), "| id colonne:", [f.field_id for f in tabella.schema().fields])

# che cosa c'e' sul disco
tipi = collections.Counter(("metadata.json" if p.name.endswith("metadata.json") else p.suffix) for p in base.rglob("*") if p.is_file() and "catalogo" not in p.name)
print("file sul disco per tipo:", dict(sorted(tipi.items())))

# Output:
# snapshot: 2 | righe attuali: 2000
# viaggio nel tempo, primo snapshot: 1000 righe
# file Parquet prima e dopo l'evoluzione identici: True (2 file)
# colonne: ['order_id', 'cliente_id', 'importo', 'ts', 'canale']
# canale nelle righe vecchie: {None} | id colonne: [1, 2, 3, 4, 5]
# file sul disco per tipo: {'.avro': 4, '.parquet': 2, 'metadata.json': 4}

Tre cose da leggere nell'uscita. Dopo due append ci sono due snapshot, e la scansione del primo restituisce solo le prime 1000 righe: è il viaggio nel tempo, che costa un identificativo e niente copie. L'evoluzione dello schema (aggiunta di canale, rinomina di cliente in cliente_id) non ha riscritto nessun file Parquet: i due file sono gli stessi prima e dopo, e gli id di colonna 1-5 non sono cambiati. Sul disco ci sono 4 file di metadati JSON (uno per commit), 4 file Avro (liste di manifest e manifest) e i 2 Parquet di dati.

Due insidie che l'esecuzione ha mostrato. La colonna order_id è dichiarata obbligatoria e lo schema Arrow deve dichiararla non nulla, altrimenti append fallisce con un confronto di campi; e il partizionamento per giorno richiede il pacchetto pyiceberg-core, senza il quale l'errore è NotInstalledError. Infine la manutenzione non è automatica: la documentazione di Iceberg raccomanda di far scadere gli snapshot con expireSnapshots e di compattare i file con l'azione rewriteDataFiles, entrambe operazioni da pianificare.

Delta Lake: un log di transazioni

Delta tiene lo stato in una cartella _delta_log di file numerati, ciascuno con le azioni di un commit: add e remove di file, metaData, protocol. Per riavvolgere la tabella si rilegge il log fino alla versione voluta; periodicamente un file di checkpoint in Parquet riassume lo stato per non rileggere tutto. Il listato usa la libreria deltalake senza Spark, e passa in rassegna il log, il viaggio nel tempo, l'evoluzione dello schema, la manutenzione.

import json, pathlib, shutil
import pyarrow as pa
from deltalake import DeltaTable, write_deltalake

percorso = pathlib.Path("delta_ordini").resolve()
shutil.rmtree(percorso, ignore_errors=True)

def lotto(da, a):
    return pa.table({"order_id": list(range(da, a)), "cliente": [f"c{i % 7}" for i in range(da, a)],
                     "importo": [float(i % 50) for i in range(da, a)]})

write_deltalake(str(percorso), lotto(0, 1000))                       # versione 0
write_deltalake(str(percorso), lotto(1000, 2000), mode="append")    # versione 1
log = sorted(p.name for p in (percorso / "_delta_log").iterdir())
print("file del log:", log)

azioni = [list(json.loads(riga))[0] for riga in (percorso / "_delta_log" / log[0]).read_text().splitlines()]
print("azioni nella versione 0:", azioni)

dt = DeltaTable(str(percorso))
print("versione attuale:", dt.version(), "| righe:", dt.to_pyarrow_table().num_rows)
print("viaggio nel tempo, versione 0:", DeltaTable(str(percorso), version=0).to_pyarrow_table().num_rows, "righe")

# schema evolution: una colonna nuova richiede di dirlo esplicitamente
nuovo = lotto(2000, 2100).append_column("canale", pa.array(["web"] * 100))
try:
    write_deltalake(str(percorso), nuovo, mode="append")
except Exception as e:
    print("senza schema_mode:", type(e).__name__)
write_deltalake(str(percorso), nuovo, mode="append", schema_mode="merge")
dt = DeltaTable(str(percorso))
print("colonne dopo il merge dello schema:", [f.name for f in dt.schema().fields])
print("canale nelle righe vecchie:", sorted({str(v) for v in dt.to_pyarrow_table()["canale"].to_pylist()}))

# manutenzione: e' un'operazione esplicita, non automatica
dt.delete("order_id < 500")
dt = DeltaTable(str(percorso))
print("file nel log attivo prima di compact:", len(dt.file_uris()))
dt.optimize.compact()
print("file dopo compact:", len(DeltaTable(str(percorso)).file_uris()), "| righe:", DeltaTable(str(percorso)).to_pyarrow_table().num_rows)
print("vacuum a secco, file candidati alla rimozione:", len(DeltaTable(str(percorso)).vacuum(retention_hours=0, dry_run=True, enforce_retention_duration=False)))

# checkpoint: un riassunto Parquet dello stato, scritto su richiesta (qui) o in automatico dopo N commit
dt.create_checkpoint()
print("dopo il checkpoint:", sorted(p.name for p in (percorso / "_delta_log").iterdir() if "checkpoint" in p.name or p.name == "_last_checkpoint"))

# Output:
# file del log: ['00000000000000000000.json', '00000000000000000001.json']
# azioni nella versione 0: ['commitInfo', 'protocol', 'metaData', 'add']
# versione attuale: 1 | righe: 2000
# viaggio nel tempo, versione 0: 1000 righe
# senza schema_mode: SchemaMismatchError
# colonne dopo il merge dello schema: ['order_id', 'cliente', 'importo', 'canale']
# canale nelle righe vecchie: ['None', 'web']
# file nel log attivo prima di compact: 3
# file dopo compact: 1 | righe: 1600
# vacuum a secco, file candidati alla rimozione: 4
# dopo il checkpoint: ['00000000000000000004.checkpoint.parquet', '_last_checkpoint']

Il log dopo due scritture ha due file, e il primo contiene le azioni commitInfo, protocol, metaData e add. Aggiungere una colonna senza dirlo viene respinto con SchemaMismatchError: serve schema_mode="merge", e le righe vecchie leggono None nella colonna nuova. Dopo una cancellazione, il numero di file attivi era 3 e la compattazione li ha portati a 1 con 1600 righe, mentre il vacuum a secco elenca i 4 file non più referenziati. In questo listato l'ho forzato con retention a zero ore solo perché è un'esecuzione a secco su dati di prova: la documentazione di Delta indica 7 giorni come valore predefinito della ritenzione dei file cancellati, e su una tabella vera non va ridotta alla leggera.

Il confronto con Iceberg, a parità di esperimento: stessa evoluzione di schema ma con un'azione esplicita; stesso viaggio nel tempo ma per numero di versione; stessa manutenzione manuale (optimize.compact, vacuum, create_checkpoint). Nessuno dei due è "automatico": chi lo dice scambia la disponibilità di un comando con la sua esecuzione.

Hudi: la linea temporale e le chiavi di record

Hudi nasce per l'ingestione incrementale e per gli aggiornamenti per chiave, e lo mostra nel modello: ogni record ha una chiave, ogni tabella una linea temporale di azioni, e un campo di ordinamento decide chi vince fra due versioni dello stesso record. Esistono due tipi di tabella. In Copy-on-Write ogni aggiornamento riscrive i file base, quindi la scrittura costa di più e la lettura è più semplice; in Merge-on-Read gli aggiornamenti si accodano a file di log che la lettura applica, quindi si scrive più in fretta e si legge con un costo maggiore, come dice la tabella di confronto della documentazione.

# Schema da adattare, non eseguito: Hudi si scrive con Spark (o Flink) e qui non c'e' Spark.
# Opzioni e pacchetto sono quelli della guida rapida di Hudi 1.2.1, non verificati su un cluster.
#   pyspark --packages org.apache.hudi:hudi-spark3.5-bundle_2.13:1.2.1 \
#           --conf spark.serializer=org.apache.spark.serializer.KryoSerializer
from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("hudi-ordini").getOrCreate()
opzioni = {
    "hoodie.table.name": "ordini",
    "hoodie.datasource.write.recordkey.field": "order_id",        # chi e' lo stesso record
    "hoodie.datasource.write.partitionpath.field": "giorno",
    "hoodie.table.ordering.fields": "ts",                         # fra due versioni dello stesso record vince ts piu' alto
    "hoodie.datasource.write.operation": "upsert",
    "hoodie.datasource.write.table.type": "MERGE_ON_READ",         # oppure COPY_ON_WRITE
}
modifiche = spark.read.json("cdc/ordini.json")                    # record nuovi e variati
modifiche.write.format("hudi").options(**opzioni).mode("append").save("lago/ordini_hudi")

Questo schema non è stato eseguito: Hudi si scrive con Spark o Flink, e non ho avviato né l'uno né l'altro. Le opzioni sono quelle della guida rapida della versione 1.2.1. Una differenza rispetto ai tutorial vecchi: la guida usa hoodie.table.ordering.fields per il campo di ordinamento, mentre molti esempi riportano il nome precedente precombine.field. Controlla la documentazione della tua versione prima di copiare le opzioni. La concorrenza è documentata come isolamento a istantanea fra writer, lettori e servizi di tabella, controllo ottimistico fra writer.

Leggere le tre tabelle da DuckDB

Per leggere questi formati senza Spark, DuckDB ha due estensioni ufficiali, delta e iceberg, che si installano da sole al primo uso. Il listato legge le due tabelle create sopra e riporta numero di righe e somma dell'importo. Le funzioni si chiamano delta_scan e iceberg_scan (non read_delta, che compare in alcuni tutorial). Iceberg vuole il percorso del file di metadati più recente.

import duckdb, pathlib

con = duckdb.connect()
con.execute("INSTALL delta; LOAD delta; INSTALL iceberg; LOAD iceberg;")

# Delta: delta_scan sulla cartella della tabella
print("delta  :", con.execute("SELECT count(*), sum(importo) FROM delta_scan('delta_ordini')").fetchall())

# Iceberg: iceberg_scan vuole il file di metadati piu' recente
metadati = sorted(pathlib.Path("lago").rglob("*.metadata.json"))[-1]
print("iceberg:", con.execute(f"SELECT count(*), sum(importo) FROM iceberg_scan('{metadati}')").fetchall())

# Output:
# delta  : [(1600, 39200.0)]
# iceberg: [(2000, 49000.0)]

I conteggi coincidono con quanto scritto: 1600 righe nella tabella Delta dopo la cancellazione, 2000 in quella Iceberg. Dalla documentazione di DuckDB 2.0: le tabelle Iceberg lette direttamente dai metadati sono in sola lettura, mentre la scrittura richiede un catalogo REST; l'estensione Delta legge e può creare tabelle e aggiungere righe. Non ho trovato Hudi fra le estensioni core elencate nella documentazione, quindi per Hudi serve un altro motore. Nella stessa documentazione compare anche DuckLake, un formato del progetto DuckDB, con la versione 1.1 pubblicata insieme a DuckDB 2.0. Per elaborare poi i risultati con un DataFrame, vedi Polars e pandas e la pipeline con DuckDB e Polars.

Come scegliere

La scelta si legge meglio come tre domande in sequenza, perché la prima restringe il campo per le altre. Prima: quali motori devono leggere e scrivere? Se hai Spark e Flink e vuoi aggiornamenti per chiave da un flusso di cambiamenti, Hudi è costruito per quello e la sua documentazione lo mette al centro; se vuoi tabelle lette da molti motori diversi, Iceberg ha una specifica indipendente dal motore, giunta alla versione 3 con nuovi tipi di dato; se lavori già con l'ecosistema Delta, il protocollo è documentato e la libreria Rust permette di scrivere senza Spark.

Seconda: come arrivano i dati? Per caricamenti a lotti in aggiunta, tutti e tre vanno bene e la differenza si sposta sulla manutenzione. Per un flusso di aggiornamenti per chiave, il modello di Hudi (chiave di record e campo di ordinamento) è quello che la sua documentazione mette più esplicitamente al centro, mentre Iceberg e Delta lo coprono con operazioni di merge e di cancellazione a livello di riga. Terza: chi esegue la manutenzione? Per tutti e tre sono operazioni da pianificare (scadenza degli snapshot, compattazione, pulizia dei file orfani, checkpoint), e il costo organizzativo di quelle operazioni conta quanto le prestazioni.

La tabella riassume dove guardare per ogni criterio e come verificarlo sul tuo caso, senza assegnare punteggi:

CriterioDove guardareCome verificare
Motori che leggonoDocumentazione del tuo motore (DuckDB, Trino, Spark, Flink)Elenco delle estensioni e dei connettori della versione che usi
Motori che scrivonoIdem; per Iceberg da DuckDB serve un catalogo RESTProva di una scrittura su una copia dei dati
Aggiornamenti per chiaveDocumentazione Hudi (chiave di record, campo di ordinamento) e operazioni di merge di Iceberg e DeltaUn caricamento di prova con record duplicati e fuori ordine
Evoluzione dello schemaIceberg: id di colonna; Delta: schema_modeAggiungi e rinomina una colonna come nei listati e controlla i file
ManutenzionePagine di maintenance di ciascun progettoPianifica e prova scadenza degli snapshot, compattazione, pulizia

Se dopo le tre domande più formati restano ammissibili, vince quello che il tuo team sa far funzionare di notte: nei dati, il formato peggiore è quello che nessuno sa riparare. Per mettere uno di questi formati dentro un'architettura completa, vai all'ultimo articolo della serie, Modern Data Stack: un'architettura minima; per leggerli con un motore leggero, DuckDB in produzione.

Che cosa sai fare adesso

Sai spiegare che cosa hanno in comune i tre formati e dove divergono, creare e interrogare una tabella Iceberg e una Delta senza Spark, vedere con i tuoi occhi che l'evoluzione dello schema non riscrive i dati, leggerle da DuckDB con le funzioni giuste, e scegliere con tre domande invece che con una classifica a stelle. Sai anche che nessuna cifra di velocità di questo articolo è stata inventata: non ce n'è nessuna, e quelle dei confronti che trovi online vanno accettate solo se dichiarano macchina, dati, versioni e metodo.

Domande frequenti

Quale formato è il più veloce?

Non l'ho misurato: un confronto equo richiede lo stesso motore, gli stessi dati e la manutenzione allo stesso stadio, e qui non c'è un cluster. Diffida delle tabelle senza macchina, versioni e metodo: l'articolo non ne riporta nessuna.

Servono davvero Spark o un cluster per usarli?

Per Iceberg e Delta no: i listati sopra creano, scrivono e leggono le tabelle con Python su un solo computer. Per Hudi la guida rapida usa Spark; la documentazione cita anche hudi-rs, un'implementazione nativa in Rust con collegamenti per Python, che non ho provato.

Posso leggere la stessa tabella con più motori?

Sì, se ciascun motore supporta il formato: nell'esperimento DuckDB ha letto la tabella scritta da pyiceberg e quella scritta da deltalake. Controlla sempre quali versioni del formato e quali funzioni (cancellazioni, tipi nuovi) il motore sa leggere.

Un formato sostituisce lakeFS?

No: i formati versionano una tabella, lakeFS versiona un insieme di oggetti con rami e merge. Possono convivere; i dettagli e la licenza sono nell'articolo dedicato.

Fonti

Le versioni e le licenze vengono dai rilasci e dai repository su GitHub dei tre progetti, consultati il 2026-11-13 tramite i rispettivi indirizzi pubblici. I listati Iceberg, Delta e DuckDB sono stati eseguiti con Python 3.14.4, pyiceberg 0.12.0, deltalake 1.6.6 e DuckDB 2.0.0; i primi due e l'ultimo due volte con uscita identica. Lo schema Hudi non è stato eseguito.

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti