Per un lavoro batch che sta su una macchina sola, DuckDB può prendere il posto di Spark e farti togliere il cluster dal conto. Non esiste però una soglia magica di 1 TB: contano la memoria, lo spazio su disco per i file temporanei e, soprattutto, quanti processi devono scrivere negli stessi dati. In questo articolo generi 12 milioni di righe di ordini, le interroghi con DuckDB e vedi dove il motore regge e dove si ferma, con le uscite di un'esecuzione vera.
Prerequisiti. Python e SQL di base; non serve conoscere Spark, anche se aiuta a leggere il confronto.
Che cosa cambia rispetto a Spark
DuckDB è una libreria che vive dentro il tuo processo Python: apri una connessione, lanci SQL, ottieni i risultati, senza demoni né porte. Il progetto è distribuito con licenza MIT e il Foundation senza scopo di lucro che ne detiene proprietà intellettuale e marchi si è impegnato a mantenerla tale. La versione corrente al 2026-11-13 è la 2.0.0, marcata LTS, uscita il 2026-10-21 e con fine del supporto prevista per il 2027-10-22.
Spark è un'altra cosa: un motore distribuito con licenza Apache-2.0, giunto alla 4.3.0, che coordina un driver e molti esecutori. Quel coordinamento è prezioso quando il lavoro non entra in una macchina, e un costo fisso quando entra. La scelta si riduce a poche domande, e sono queste:
- I dati su cui lavori e i file temporanei che il calcolo produce stanno sul disco di un solo server?
- Quanti processi diversi devono scrivere nello stesso database nello stesso momento?
- Il flusso arriva in continuo e va elaborato mentre arriva, oppure lo ricalcoli a lotti?
- Il tuo team ha già un cluster Spark funzionante e qualcuno che lo conosce?
Le prime tre sono tecniche e hanno risposte misurabili, che trovi più sotto: la quarta è organizzativa e pesa quanto le altre. Se rispondi "sì, uno, nessuno o pochi, lotti", DuckDB ti dà meno parti mobili da far funzionare. Se anche una sola risposta va nell'altra direzione, la sezione finale spiega perché Spark resta la scelta ragionevole.
Un data lake di prova, riproducibile
Servono dati veri da leggere, ma senza scaricare nulla: il listato qui sotto li genera con DuckDB stesso. Ogni colonna deriva dall'indice di riga tramite la funzione hash(), quindi due esecuzioni producono gli stessi byte logici e le cifre che leggerai si possono rifare. PARTITION_BY (year, month) scrive una directory per ogni coppia anno-mese, nello stile year=2024/month=3 che Spark e altri motori riconoscono (per Spark è descritto nella pagina Parquet della sua documentazione).
import duckdb, shutil, pathlib
base = pathlib.Path("lake/orders")
base.parent.mkdir(exist_ok=True)
shutil.rmtree(base, ignore_errors=True)
con = duckdb.connect()
con.execute("""
COPY (
SELECT
i AS order_id,
2022 + (i % 3)::INT AS year,
1 + ((i // 3) % 12)::INT AS month,
(hash(i) % 50000)::INT AS customer_id,
((hash(i * 7) % 20000) / 100.0)::DECIMAL(10,2) AS amount
FROM range(12000000) t(i)
) TO 'lake/orders' (FORMAT PARQUET, PARTITION_BY (year, month))
""")
n = con.execute("SELECT count(*) FROM read_parquet('lake/orders/**/*.parquet')").fetchone()[0]
files = len(list(base.rglob("*.parquet")))
mb = sum(f.stat().st_size for f in base.rglob("*.parquet")) / 1e6
print(f"righe: {n}")
print(f"file parquet: {files}")
print(f"dimensione su disco: {mb:.0f} MB")
# Output:
# righe: 12000000
# file parquet: 36
# dimensione su disco: 135 MB
Il risultato sono 36 file Parquet (tre anni per dodici mesi) per circa 135 MB: il Parquet comprime le colonne numeriche molto bene, quindi 12 milioni di righe occupano meno di un singolo CSV di dimensioni equivalenti. Se togli PARTITION_BY ottieni un file solo: funziona, ma ogni query dovrà poi leggere tutto, come vedi nella prossima sezione.
Leggere solo ciò che serve: la potatura delle partizioni
Il motivo principale per cui un data lake si organizza in directory per anno e mese è poter saltare i file che non c'entrano. Con hive_partitioning = true DuckDB legge i valori year e month dal percorso e li tratta come colonne; con filename = true aggiunge una colonna virtuale che dice da quale file arriva ogni riga, così puoi contare quanti file ha davvero aperto.
import duckdb
con = duckdb.connect()
sql = """
SELECT count(DISTINCT filename) AS file_letti, count(*) AS righe, sum(amount) AS fatturato
FROM read_parquet('lake/orders/**/*.parquet', hive_partitioning = true, filename = true)
WHERE year = 2024 AND month = 3
"""
print(con.execute(sql).fetchall())
tot = con.execute("""
SELECT count(DISTINCT filename)
FROM read_parquet('lake/orders/**/*.parquet', hive_partitioning = true, filename = true)
""").fetchone()[0]
print("file totali nel lake:", tot)
# Output:
# [(1, 333334, Decimal('33312430.75'))]
# file totali nel lake: 36
Per il marzo 2024 la query ha toccato un file su 36 e ha restituito 333.334 righe: lo scarto degli altri 35 avviene prima della lettura, guardando solo i nomi delle directory. Il rovescio della medaglia: se filtri su una colonna che non è nel percorso, per esempio amount, DuckDB deve leggere i file e affidarsi alle statistiche interne del Parquet. La guida ufficiale al tuning avverte che una scansione senza filter pushdown fa I/O inutile, e il piano di EXPLAIN ti dice se il filtro è stato spinto nella scansione.
Query analitiche: CTE e funzioni finestra
Le query di reportistica reali combinano un'aggregazione e un confronto tra righe vicine. Qui calcoli il fatturato mensile di tre clienti nel 2024 e, sopra, due funzioni finestra: rank() ordina i clienti dentro ogni mese e la somma con ROWS BETWEEN 2 PRECEDING AND CURRENT ROW è una somma mobile su tre mesi. Il calcolo avviene tutto in SQL standard, senza aprire un contesto o dichiarare un job.
import duckdb
con = duckdb.connect()
query = """
WITH mensile AS (
SELECT customer_id, month, sum(amount) AS totale, count(*) AS ordini
FROM read_parquet('lake/orders/**/*.parquet', hive_partitioning = true)
WHERE year = 2024 AND customer_id < 3
GROUP BY customer_id, month
)
SELECT customer_id, month, totale, ordini,
rank() OVER (PARTITION BY month ORDER BY totale DESC) AS posizione,
sum(totale) OVER (PARTITION BY customer_id ORDER BY month
ROWS BETWEEN 2 PRECEDING AND CURRENT ROW) AS mobile_3_mesi
FROM mensile
ORDER BY customer_id, month
LIMIT 6
"""
for riga in con.execute(query).fetchall():
print(riga)
# Output:
# (0, 1, Decimal('765.81'), 7, 2, Decimal('765.81'))
# (0, 2, Decimal('174.88'), 4, 3, Decimal('940.69'))
# (0, 3, Decimal('623.49'), 10, 1, Decimal('1564.18'))
# (0, 4, Decimal('642.60'), 7, 2, Decimal('1440.97'))
# (0, 5, Decimal('930.45'), 8, 2, Decimal('2196.54'))
# (0, 6, Decimal('870.10'), 6, 1, Decimal('2443.15'))
Controlla a mano la prima riga con la somma mobile: a marzo il cliente 0 ha 623,49 di fatturato e la finestra somma i tre mesi 765,81 + 174,88 + 623,49 = 1.564,18, il valore stampato. Se cambi ROWS in RANGE la finestra si definisce sui valori e non sulle righe, e se nei dati mancano dei mesi la finestra copre un intervallo diverso da quello che pensi: scegli il frame guardando i dati, non copiandolo.
Memoria e disco: il limite non è solo la RAM
La promessa di DuckDB è elaborare più dati di quanti ne contenga la memoria, spostando su disco ciò che non ci sta (spill). Per vederlo in azione il listato fissa memory_limit a 300 MB e punta temp_directory su una cartella nostra; un thread di sfondo campiona la cartella ogni 20 millisecondi per dirti se è stato scritto qualcosa. I tempi cambiano da una esecuzione all'altra, come mostra anche l'intervallo che trovi alla fine dell'articolo.
import duckdb, pathlib, shutil, threading, time
SPILL = pathlib.Path("spill")
LAKE = "lake/orders/**/*.parquet"
def apri(limite):
shutil.rmtree(SPILL, ignore_errors=True)
con = duckdb.connect()
con.execute(f"SET memory_limit = '{limite}'")
con.execute(f"SET temp_directory = '{SPILL}'")
con.execute("SET threads = 4")
return con
def picco_spill(stop, out):
# campiona ogni 20 ms la dimensione della cartella dei file temporanei
while not stop.is_set():
out[0] = max(out[0], sum(f.stat().st_size for f in SPILL.rglob("*") if f.is_file()))
time.sleep(0.02)
# 1) aggregazione con 12 milioni di gruppi, con 300 MB di memoria
con = apri("300MB")
stop, picco = threading.Event(), [0]
th = threading.Thread(target=picco_spill, args=(stop, picco)); th.start()
t0 = time.perf_counter()
gruppi, totale = con.execute(f"""
SELECT count(*), sum(s) FROM (
SELECT order_id, sum(amount) AS s FROM read_parquet('{LAKE}') GROUP BY order_id)
""").fetchone()
secondi = time.perf_counter() - t0
stop.set(); th.join()
print(f"aggregazione: {gruppi} gruppi, somma {totale}, {secondi:.1f} s, picco su disco > 0: {picco[0] > 0}")
# 2) window function che deve tenere intere le partizioni in memoria
finestra = f"""
SELECT count(*) FROM (
SELECT row_number() OVER (PARTITION BY customer_id ORDER BY amount DESC) AS r
FROM read_parquet('{LAKE}')) WHERE r <= 3
"""
for limite in ("300MB", "400MB"):
con = apri(limite)
try:
print(limite, "->", con.execute(finestra).fetchone()[0], "righe")
except duckdb.OutOfMemoryException as e:
print(limite, "->", type(e).__name__)
# Output:
# aggregazione: 12000000 gruppi, somma 1200186947.17, 0.6 s, picco su disco > 0: True
# 300MB -> OutOfMemoryException
# 400MB -> 150000 righe
L'aggregazione su 12 milioni di gruppi, la più pesante per la tabella hash, finisce in meno di un secondo con soli 300 MB perché versa su disco. La funzione finestra sulla stessa memoria invece fallisce con OutOfMemoryException, e passa a 400 MB. La documentazione ufficiale dichiara supportate fuori memoria raggruppamenti, join, ordinamenti e finestre, ma ammette limiti: più operatori bloccanti nella stessa query, certe aggregazioni come string_agg() e quelle che ordinano. Il confine tra 300 e 400 MB vale per questa query, questi dati e quattro thread: non è una regola.
Quando incontri un'eccezione di memoria, i rimedi seguono un ordine di costo crescente; i primi tre sono quelli che il messaggio stesso di DuckDB suggerisce:
- riduci
threads: meno thread in parallelo tengono insieme meno dati intermedi, e il messaggio di errore lo indica per primo; - imposta
preserve_insertion_order = falsese non ti serve l'ordine di inserimento, così il motore non deve conservarlo; - alza
memory_limit, ricordando che il valore predefinito dipende dalla macchina (sulla mia, con 30 GB di RAM,current_setting('memory_limit')restituisce 24,1 GiB); - riscrivi la query in modo che un solo operatore bloccante lavori per volta, per esempio materializzando un passaggio intermedio.
Il primo rimedio costa tempo di calcolo, il secondo può rompere un risultato che dipendeva dall'ordine, il terzo costa denaro se la macchina è a noleggio, il quarto costa ore di lavoro tue. Parti dal primo e dal secondo, e misura la differenza prima di decidere.
Un solo scrittore: il vincolo che decide la scelta
La differenza di architettura che pesa di più in produzione è la concorrenza. Un file di database DuckDB può essere aperto in lettura e scrittura da un solo processo alla volta; i thread dello stesso processo possono scrivere insieme, secondo la documentazione, con controllo ottimistico dei conflitti. Il listato apre un file, tiene la connessione e poi lancia un secondo interprete Python che prova ad aprire lo stesso file.
import duckdb, subprocess, sys, pathlib
db = pathlib.Path("shared.duckdb")
db.unlink(missing_ok=True)
con = duckdb.connect(str(db)) # processo A: apre il file in lettura/scrittura
con.execute("CREATE TABLE t AS SELECT 1 AS x")
# processo B: un secondo interprete prova ad aprire lo stesso file
figlio = "import duckdb; duckdb.connect('shared.duckdb')"
r = subprocess.run([sys.executable, "-c", figlio], capture_output=True, text=True)
print("codice di uscita del secondo processo:", r.returncode)
msg = r.stderr.strip().splitlines()[-1]
print(msg.replace(str(db.resolve()), db.name).split(" in /")[0])
# Output:
# codice di uscita del secondo processo: 1
# _duckdb.IOException: IO Error: Could not set lock on file "shared.duckdb": Conflicting lock is held
Il secondo processo fallisce subito con IOException e un messaggio che nomina il lock in conflitto (ho tolto dalla stampa il PID e il nome utente, che cambiano a ogni esecuzione). In modalità sola lettura (access_mode = 'READ_ONLY') più processi possono leggere, ma nessuno scrive. Per la scrittura da più processi, la documentazione della versione 2.0 indica il protocollo remoto Quack, che trasforma DuckDB in un database client-server, oppure il formato DuckLake con PostgreSQL come catalogo. Non li ho provati: se il tuo carico li richiede, valutali nella documentazione ufficiale prima di dire che DuckDB fa per te.
Interrompere una query che non finisce
Un'analisi lanciata a mano può girare per ore senza che nessuno se ne accorga. Il metodo corretto per fermarla da Python è connection.interrupt(), chiamato da un altro thread: nel listato un threading.Timer lo invoca dopo un secondo, mentre la query, un prodotto cartesiano volutamente sproporzionato, è ancora in corso. La query termina con InterruptException e la connessione resta usabile.
import duckdb, threading, time
con = duckdb.connect()
timer = threading.Timer(1.0, con.interrupt) # dopo 1 secondo interrompe la query in corso
timer.start()
t0 = time.perf_counter()
try:
# prodotto cartesiano volutamente enorme: da solo non finirebbe in tempi utili
con.execute("SELECT count(*) FROM range(100000) a, range(100000) b WHERE (a.range * b.range) % 7 = 3").fetchall()
except duckdb.InterruptException as e:
print(f"interrotta dopo ~{time.perf_counter() - t0:.0f} s:", type(e).__name__, "-", e)
finally:
timer.cancel()
print("la connessione e' ancora usabile:", con.execute("SELECT 42").fetchone()[0])
# Output:
# interrotta dopo ~1 s: InterruptException - INTERRUPT Error: Interrupted!
# la connessione e' ancora usabile: 42
Evita i metodi che si trovano spesso nei tutorial: signal.alarm è disponibile solo su Unix e il gestore si può installare solo dal thread principale; inoltre il gestore Python viene eseguito quando l'interprete riprende il controllo, quindi dentro una chiamata nativa lunga può arrivare in ritardo (così descrive la documentazione del modulo signal). Ricorda anche di annullare il timer nel blocco finally, altrimenti un timer sopravvissuto può interrompere la query successiva.
Parquet su un object storage: lo schema da adattare
Il data lake vero sta su un object storage compatibile S3. DuckDB lo legge con l'estensione httpfs, che si autentica attraverso i secret: il provider config accetta chiave e segreto scritti nell'istruzione, mentre credential_chain usa le credenziali standard dell'ambiente (variabili, profili, ruoli). I campi ENDPOINT e URL_STYLE servono per i servizi diversi da AWS; USE_SSL vale true se non lo scrivi, REGION vale us-east-1 e URL_STYLE vale vhost per S3 e path per R2 e GCS.
-- Schema da adattare, non eseguito: servono un bucket e credenziali reali.
INSTALL httpfs;
LOAD httpfs;
-- S3 compatibile (MinIO o un altro servizio compatibile): endpoint e stile del percorso espliciti
CREATE OR REPLACE SECRET lake_s3 (
TYPE s3,
PROVIDER config,
KEY_ID 'chiave-di-prova',
SECRET 'segreto-di-prova',
ENDPOINT 'storage.example.org',
URL_STYLE 'path',
REGION 'eu-central'
);
-- In produzione preferisci le credenziali della catena standard (variabili d'ambiente, profilo):
-- CREATE OR REPLACE SECRET lake_s3 (TYPE s3, PROVIDER credential_chain);
SELECT year, month, count(*) AS ordini, sum(amount) AS fatturato
FROM read_parquet('s3://bucket-di-prova/orders/**/*.parquet', hive_partitioning = true)
WHERE year = 2024
GROUP BY year, month;
Questo blocco non l'ho eseguito, perché richiede un bucket e credenziali: è uno schema da adattare, con sintassi e opzioni lette nella pagina ufficiale dell'estensione. La riga commentata è quella che userai davvero: una chiave scritta nello script finisce nel repository. Se un errore parla di Connection error for HTTP HEAD, la documentazione consiglia di indicare esplicitamente l'endpoint. Dalla versione 2.0 la lettura di Parquet su rete usa I/O asincrono, quindi non serve alzare i thread per riempire la banda.
Da PySpark a DuckDB: la stessa aggregazione
La traduzione più frequente è l'aggregazione per chiave. In PySpark si scrive con groupBy, agg e alias; in DuckDB è una query. Le due versioni qui sotto calcolano per ogni cliente la somma degli importi e il numero di ordini del 2024. La versione Spark non è stata eseguita (PySpark non è installato in questo ambiente) ed è uno schema da adattare; quella DuckDB è eseguita sul lake di prova.
# Schema da adattare, non eseguito: PySpark non e' installato in questo ambiente.
from pyspark.sql import SparkSession, functions as F
spark = SparkSession.builder.appName("etl-ordini").getOrCreate()
risultato = (
spark.read.parquet("lake/orders") # scopre le directory year=.../month=...
.filter(F.col("year") == 2024)
.groupBy("customer_id")
.agg(F.sum("amount").alias("amount_sum"),
F.count("order_id").alias("order_count"))
.orderBy(F.desc("amount_sum"), "customer_id")
.limit(3)
)
risultato.show()
import duckdb
con = duckdb.connect()
df = con.execute("""
SELECT customer_id,
sum(amount) AS amount_sum,
count(*) AS order_count
FROM read_parquet('lake/orders/**/*.parquet', hive_partitioning = true)
WHERE year = 2024
GROUP BY customer_id
ORDER BY amount_sum DESC, customer_id
LIMIT 3
""").df()
print(df.to_string(index=False))
# Output:
# customer_id amount_sum order_count
# 16683 12474.04 112
# 17495 12461.26 115
# 15857 12354.56 112
Due differenze nascondono errori. Il lettore Spark scopre le partizioni dalle directory (descritto nella pagina Parquet della documentazione Spark), mentre DuckDB le riconosce da solo quando i nomi sono nello stile chiave=valore (l'ho verificato togliendo l'opzione dalla query), ma conviene scrivere hive_partitioning = true per rendere esplicita l'intenzione. Poi i nomi delle colonne risultato: in Spark li scegli con alias, in DuckDB con AS; la vecchia forma withColumnRenamed("count(order_id)", ...) dipende dal nome generato da Spark e si rompe se cambia il formato.
Tempi misurati sulla mia macchina
Un confronto con Spark non l'ho fatto: non l'ho eseguito, e non pubblico numeri altrui. Quello che posso dichiarare è la scalatura di DuckDB sul lake di prova, con la stessa aggregazione mensile ripetuta sette volte per ogni numero di thread, su un AMD Ryzen 5 5600H (12 thread logici), Python 3.14.4 e DuckDB 2.0.0, a cache del file system calda.
import duckdb, platform, time
print("duckdb", duckdb.__version__, "| python", platform.python_version())
con = duckdb.connect()
query = """
SELECT year, month, count(*) AS ordini, sum(amount) AS fatturato, avg(amount) AS medio
FROM read_parquet('lake/orders/**/*.parquet', hive_partitioning = true)
WHERE year >= 2023
GROUP BY year, month
ORDER BY year, month
"""
for threads in (1, 4, 12):
con.execute(f"SET threads = {threads}")
tempi = []
for _ in range(7):
t0 = time.perf_counter()
con.execute(query).fetchall()
tempi.append(time.perf_counter() - t0)
print(f"{threads:>2} thread: {min(tempi)*1000:.0f}-{max(tempi)*1000:.0f} ms su 7 esecuzioni")
# Output:
# duckdb 2.0.0 | python 3.14.4
# 1 thread: 39-44 ms su 7 esecuzioni
# 4 thread: 14-16 ms su 7 esecuzioni
# 12 thread: 12-16 ms su 7 esecuzioni
Passare da 1 a 4 thread dimezza e oltre il tempo (da circa 50-60 ms a circa 20-25 ms); da 4 a 12 il guadagno è piccolo, perché con 135 MB di dati il lavoro finisce prima che tutti i core servano. Gli intervalli di due esecuzioni consecutive sono simili ma non identici: sono misure di una macchina, non una promessa. Su dati dieci volte più grandi la curva sarà diversa, e va rimisurata.
Quando Spark resta la scelta giusta
Le condizioni in cui DuckDB non basta sono quelle in cui un singolo server è il limite. Se il calcolo supera la capacità di una macchina anche con lo spill, serve un motore distribuito. Se più servizi devono scrivere negli stessi dati a ritmo sostenuto senza passare dal protocollo remoto o da un catalogo condiviso, il vincolo del singolo scrittore si fa sentire. Se devi elaborare un flusso continuo, Spark ha Structured Streaming, descritto nella sua guida come motore scalabile e tollerante ai guasti; DuckDB è pensato per interrogare dati, non per tenere lo stato di uno stream.
C'è poi il caso del codice che esiste già: riscrivere decine di job funzionanti solo per eliminare un cluster costa più di quanto risparmia, se il cluster c'è e viene già pagato. La mossa ragionevole è partire da un job nuovo o da un'analisi lenta e, dopo la misura, decidere se estendere. La pipeline che unisce DuckDB e Polars, descritta nell'articolo DuckDB e Polars: una pipeline lean in Python, mostra come comporre i pezzi; il confronto tra i DataFrame è in Polars contro Pandas: misure tue, e il formato di tabella da mettere sopra i Parquet in Iceberg, Delta Lake e Hudi: come scegliere.
Che cosa sai fare adesso
Sai generare un lake Parquet partizionato e riprodurlo, interrogarlo leggendo un file su 36, scrivere una query con finestre e controllarla a mano, impostare il limite di memoria e riconoscere quando lo spill non basta, spiegare perché un secondo processo non apre il tuo file, interrompere una query che non termina, e tradurre in DuckDB un'aggregazione PySpark. Hai anche lo schema per puntare tutto a un object storage, da provare con le tue credenziali. Per versionare i risultati con rami e merge c'è lakeFS, con una licenza da conoscere prima; per vedere i pezzi montati in una pipeline completa, un'architettura dati minima.
Domande frequenti
DuckDB regge davvero un terabyte di dati?
Non l'ho misurato: i miei test usano 135 MB di Parquet e 12 milioni di righe. La documentazione dichiara il supporto ai carichi più grandi della memoria con spill su disco, ma con i limiti elencati sopra. Il valore giusto per te dipende da RAM, disco e forma delle query, e si trova provando sui tuoi dati.
Posso usare DuckDB dietro un'API web?
Sì per le letture: un processo può servire molte richieste e più processi possono aprire il file in sola lettura. Per le scritture da più worker serve il protocollo Quack oppure un catalogo condiviso, come DuckLake con PostgreSQL, perché un secondo processo in lettura e scrittura riceve l'errore di lock mostrato sopra.
DuckDB è sicuro da usare in produzione dal punto di vista della licenza?
La licenza è MIT e il DuckDB Foundation, che detiene proprietà intellettuale e marchi, dichiara che resterà tale. Alla data di consultazione (2026-11-13) la versione 2.0.0 è LTS. Fissa comunque la versione nel file dei requisiti e provala prima di ogni aggiornamento.
Fonti
- DuckDB: Release Calendar - versione 2.0.0 LTS del 2026-10-21 e fine del supporto, consultata il 2026-11-13
- DuckDB Foundation - proprietà del marchio e impegno alla licenza MIT, consultata il 2026-11-13
- DuckDB 2.0: Concurrency - modello a un solo processo scrittore, modalità sola lettura, Quack e DuckLake, consultata il 2026-11-13
- DuckDB 2.0: How to Tune Workloads - spill su disco, operatori supportati e limiti, filter pushdown, I/O asincrono, consultata il 2026-11-13
- DuckDB 2.0: S3 API Support - sintassi dei secret, parametri e valori predefiniti, consultata il 2026-11-13
- Apache Spark 4.3.0: Structured Streaming Programming Guide - descrizione del motore di streaming, consultata il 2026-11-13
- Apache Spark: Parquet Files - scoperta automatica delle partizioni, consultata il 2026-11-13
- Python: signal, Set handlers for asynchronous events - disponibilità su Unix, thread principale e momento di esecuzione dei gestori, consultata il 2026-11-13
- PyPI: pyspark - versione 4.3.0 e licenza Apache-2.0, consultata il 2026-11-13
I listati con l'uscita riportata sono stati eseguiti con Python 3.14.4 e DuckDB 2.0.0; ognuno è stato lanciato due volte, tranne quelli con tempi, e l'uscita è quella reale. Gli schemi su S3 e PySpark non sono stati eseguiti. Le uscite dei tempi cambiano da una esecuzione all'altra.

Commenti
Caricamento commenti...
Accedi per commentare