JSONL vs Parquet: come scegliere il formato dati giusto
Un confronto completo tra JSONL (JSON Lines) e Apache Parquet. Scopri i compromessi in termini di compressione, prestazioni delle query, rispetto dello schema e supporto nell’ecosistema, per scegliere il formato più adatto alle tue esigenze di elaborazione dei dati.
Cos'è JSONL?
JSONL (JSON Lines) è un formato dati testuale in cui ogni riga contiene un singolo oggetto JSON autonomo, separato dal successivo da un carattere di nuova riga. È un’estensione naturale del diffusissimo formato JSON, pensata appositamente per lo streaming e per dati come i log. Poiché ogni riga è un documento JSON indipendente, puoi aggiungere dati in fondo al file senza riscrivere quelli esistenti ed elaborarli riga per riga con un consumo di memoria aggiuntivo minimo.
JSONL è diventato il formato standard per lo scambio di dati di addestramento per il machine learning (fine-tuning di OpenAI, dataset di Hugging Face), log applicativi e flussi di eventi, e per tutti gli scenari in cui i dati arrivano in modo incrementale. Essendo un formato leggibile, puoi esaminarlo facilmente con qualsiasi editor di testo o con strumenti da riga di comando come grep, head e jq.
{"id": 1, "name": "Alice", "role": "engineer", "salary": 95000}
{"id": 2, "name": "Bob", "role": "designer", "salary": 88000}
{"id": 3, "name": "Charlie", "role": "manager", "salary": 105000}Cos'è Parquet?
Apache Parquet è un formato di archiviazione binario e colonnare, progettato per eseguire query analitiche in modo efficiente su dataset di grandi dimensioni. Anziché memorizzare i dati riga per riga come JSONL, Parquet organizza i valori per colonna: per leggere un singolo campo su milioni di righe basta quindi scansionare la colonna interessata, senza leggere ogni record per intero. Questa organizzazione consente una compressione elevata, perché i valori di una stessa colonna tendono ad avere tipo e distribuzione simili.
Parquet è nato nell’ecosistema Apache Hadoop e oggi è il formato di archiviazione di fatto per i data lake su AWS S3, Google Cloud Storage e Azure Blob Storage. Si integra strettamente con Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery e praticamente tutti i moderni motori di analisi. I file Parquet includono nei metadati uno schema rigoroso, così chi li legge conosce sempre i tipi esatti e la struttura dei dati, senza bisogno di documentazione esterna.
import pyarrow.parquet as pq
import pandas as pd
# Write a DataFrame to Parquet
df = pd.DataFrame({
'id': [1, 2, 3],
'name': ['Alice', 'Bob', 'Charlie'],
'role': ['engineer', 'designer', 'manager'],
'salary': [95000, 88000, 105000]
})
df.to_parquet('employees.parquet')
# Read specific columns (columnar advantage)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()JSONL vs Parquet: confronto diretto
La tabella seguente riassume le principali differenze tra JSONL e Parquet negli aspetti più importanti per scegliere il formato dati del tuo progetto.
| Caratteristica | JSONL | Parquet |
|---|---|---|
| Organizzazione dei dati | Formato testuale organizzato per righe. Ogni riga è un oggetto JSON completo. | Formato binario organizzato per colonne. I valori sono memorizzati per colonna, in gruppi di righe. |
| Codifica | Testo semplice UTF-8. Leggibile e modificabile con qualsiasi editor di testo. | Formato binario con codifica a dizionario, RLE e bit-packing. Non leggibile direttamente. |
| Compressione | Compressione esterna facoltativa (gzip, zstd). I nomi dei campi si ripetono a ogni riga. | Compressione colonnare integrata (Snappy, Zstd, Gzip). File 2-10 volte più piccoli. |
| Prestazioni delle query | Ogni query richiede la scansione dell’intero file. Non supporta column pruning né predicate pushdown. | Column pruning e predicate pushdown permettono di saltare i dati non necessari. Le query analitiche sono più veloci di ordini di grandezza. |
| Schema | Nessuno schema obbligatorio. Ogni riga può avere campi e tipi diversi. Flessibile, ma soggetto a errori. | Schema tipizzato rigoroso incluso nei metadati del file. Il rispetto dello schema è verificato in lettura e in scrittura. |
| Streaming / Aggiunta in coda | Ottimo supporto. Basta aggiungere una riga in fondo al file. Ideale per acquisire dati in tempo reale. | Supporto limitato. Per aggiungere dati occorre riscrivere il file o creare nuove partizioni. |
| Leggibilità | Sì. Puoi esaminare i dati con cat, head, grep, jq o qualsiasi editor di testo. | No. Per esaminare i dati servono strumenti specifici (parquet-tools, PyArrow, DuckDB). |
| Ecosistema | Universale. Supportato da qualsiasi linguaggio di programmazione dotato di un parser JSON. | Orientato all’analisi dei dati. Stretta integrazione con Spark, Hive, Presto, DuckDB, Snowflake e BigQuery. |
Benchmark delle prestazioni
Su larga scala, il divario di prestazioni tra JSONL e Parquet diventa enorme. Ecco alcuni benchmark rappresentativi su un dataset di 10 milioni di righe e 20 colonne, con un mix di stringhe, interi, float e timestamp.
Dimensioni del file (compressione)
Scansione dell’intera tabella
Velocità di scrittura
Query su una singola colonna
Benchmark eseguiti con Python (pandas + PyArrow) su un MacBook Pro M2 con 16 GB di RAM. I risultati effettivi variano in base all’hardware, alla distribuzione dei dati e al codec di compressione.
Quando usare JSONL e quando Parquet
- Acquisizione di log in tempo reale e streaming di eventi
- Dati di addestramento ML per OpenAI, Anthropic e Hugging Face
- Scambio di dati tra microservizi e API
- Dati semistrutturati con schemi che variano da un record all’altro
- Prototipazione rapida e debug quando è importante poter leggere direttamente i dati
- Dati append-only con un flusso continuo di nuovi record
- Dataset di piccole e medie dimensioni (meno di 1 GB) che non richiedono query analitiche
- Archiviazione di data lake su S3, GCS o Azure Blob
- Query analitiche con Spark, Presto, DuckDB o Snowflake
- Aggregazioni per colonna (SUM, AVG, COUNT) su miliardi di righe
- Requisiti di rigoroso rispetto dello schema e di governance dei dati
- Archiviazione a lungo termine quando il costo dello storage è importante (file 2-10 volte più piccoli)
- Feature store e pipeline di feature ML che leggono colonne specifiche
- Dataset più grandi di 1 GB per cui le prestazioni delle query sono fondamentali
Architettura ibrida: acquisizione in JSONL, archiviazione in Parquet
Nelle piattaforme dati in produzione, JSONL e Parquet possono convivere. Un approccio comune ed efficace consiste nell’usare JSONL per acquisire i dati e Parquet per l’archiviazione a lungo termine e l’analisi. Questa architettura ibrida unisce i punti di forza dei due formati: la semplicità di JSONL nell’acquisizione in tempo reale e l’efficienza di Parquet per le query nelle fasi successive.
La pipeline si articola in tre fasi. Per prima cosa, gli eventi o i record grezzi vengono aggiunti ai file JSONL man mano che arrivano, grazie al supporto di JSONL per aggiunte in coda rapide e senza lock. Poi, un job batch periodico, eseguito ogni ora, ogni giorno o al raggiungimento di una certa dimensione del file, legge i file JSONL accumulati, valida e trasforma i dati e li converte in Parquet. Infine, i file Parquet ottenuti vengono archiviati in un data lake partizionato per data, regione o altre dimensioni, per rendere efficienti le query.
1. Acquisisci i dati in JSONL
Raccogli eventi grezzi, log e risposte delle API in file JSONL. L’aggiunta in coda è rapida, non serve uno schema e il debug in tempo reale è semplice.
2. Trasforma e valida
Leggi periodicamente i batch di file JSONL, verifica la conformità allo schema, pulisci e normalizza i dati e gestisci i record malformati.
3. Archivia in Parquet
Scrivi i dati validati nel tuo data lake sotto forma di file Parquet partizionati. Esegui le query con Spark, DuckDB o qualsiasi motore di analisi.
import json
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from pathlib import Path
from datetime import datetime
def jsonl_to_parquet(jsonl_dir: str, parquet_dir: str):
"""Convert accumulated JSONL files to partitioned Parquet."""
records = []
for jsonl_file in Path(jsonl_dir).glob('*.jsonl'):
with open(jsonl_file, 'r') as f:
for line in f:
line = line.strip()
if line:
records.append(json.loads(line))
if not records:
return
df = pd.DataFrame(records)
# Add partition column
df['date'] = datetime.now().strftime('%Y-%m-%d')
table = pa.Table.from_pandas(df)
pq.write_to_dataset(
table,
root_path=parquet_dir,
partition_cols=['date'],
compression='zstd'
)
print(f'Converted {len(records)} records to Parquet')
jsonl_to_parquet('raw_events/', 'data_lake/')Prova i nostri strumenti gratuiti per JSONL
Lavori con file JSONL? Usa i nostri strumenti gratuiti nel browser per visualizzare, validare e convertire subito i dati JSONL. Non devi installare nulla né caricare file.
Strategie per elaborare gigabyte di dati JSONL: lettura in streaming, gestione della memoria, suddivisione dei file, compressione e strumenti online.
Comprimi file JSONL con gzip, zstd, lz4 e snappy. Scopri i rapporti di compressione, lo streaming di dati compressi e l'ottimizzazione di JSONL per archiviazione e trasferimento.
Impara a usare JSONL come formato di scambio nelle pipeline ETL. La guida tratta lo streaming con Apache Kafka, i DAG di Airflow, il caricamento in Snowflake e BigQuery e la progettazione di pipeline tolleranti ai guasti.
Esporta i dati JSONL in fogli di calcolo CSV. Ideale per le analisi in Excel o Google Sheets.
Impara le best practice per la formattazione dei file JSONL, la coerenza dello schema, la gestione degli errori, l’ottimizzazione delle prestazioni e l’organizzazione dei file. Evita gli errori più comuni con esempi pratici.