JSONL vs Parquet: Scegliere il Formato Dati Giusto

Un confronto completo tra JSONL (JSON Lines) e Apache Parquet. Comprendi i compromessi in compressione, prestazioni delle query, imposizione dello schema e supporto dell'ecosistema per scegliere il formato giusto per i tuoi carichi di lavoro sui dati.

Ultimo aggiornamento: Febbraio 2026

Cos'è JSONL?

JSONL (JSON Lines) è un formato dati basato su testo in cui ogni riga contiene un singolo oggetto JSON autonomo separato da caratteri di nuova riga. È un'estensione naturale dell'ubiquo formato JSON, progettato specificamente per lo streaming e i dati in stile log. Poiché ogni riga è un documento JSON indipendente, i file possono essere estesi senza riscrivere i dati esistenti e possono essere elaborati riga per riga con un overhead di memoria minimo.

JSONL è diventato il formato standard di interscambio per i dati di addestramento di machine learning (fine-tuning di OpenAI, dataset di Hugging Face), log delle applicazioni, flussi di eventi e qualsiasi scenario in cui i dati arrivano in modo incrementale. La sua natura leggibile dall'uomo lo rende facile da ispezionare con qualsiasi editor di testo o strumento da riga di comando come grep, head e jq.

employees.jsonl
{"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 colonnare progettato per query analitiche efficienti su grandi dataset. Invece di memorizzare i dati riga per riga come JSONL, Parquet organizza i valori per colonna, il che significa che leggere un singolo campo su milioni di righe richiede la scansione solo della colonna rilevante piuttosto che di ogni record completo. Questo layout colonnare permette una compressione aggressiva perché i valori all'interno di una colonna tendono ad essere simili per tipo e distribuzione.

Parquet è stato creato all'interno dell'ecosistema Apache Hadoop ed è ora il formato di archiviazione de facto per i data lake costruiti su AWS S3, Google Cloud Storage e Azure Blob Storage. È profondamente integrato con Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery e virtualmente ogni motore analitico moderno. I file Parquet incorporano uno schema rigoroso nei loro metadati, così i consumatori conoscono sempre i tipi esatti e la struttura dei dati senza documentazione esterna.

Leggere e scrivere Parquet con Python
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 Fianco a Fianco

La seguente tabella riassume le differenze chiave tra JSONL e Parquet nelle dimensioni che contano di più quando si sceglie un formato dati per il tuo progetto.

CaratteristicaJSONLParquet
Layout dei DatiOrientato alle righe, basato su testo. Ogni riga è un oggetto JSON completo.Orientato alle colonne, binario. Valori memorizzati per colonna con gruppi di righe.
CodificaTesto puro UTF-8. Leggibile dall'uomo, modificabile in qualsiasi editor di testo.Binario con codifiche dizionario, RLE e bit-packing. Non leggibile dall'uomo.
CompressioneCompressione esterna opzionale (gzip, zstd). Nomi dei campi ripetuti ogni riga.Compressione colonnare integrata (Snappy, Zstd, Gzip). File 2-10 volte più piccoli.
Prestazioni delle QueryDeve scansionare l'intero file per qualsiasi query. Nessun pruning delle colonne o predicate pushdown.Il pruning delle colonne e il predicate pushdown saltano i dati irrilevanti. Ordini di grandezza più veloce per le query analitiche.
SchemaSenza schema. Ogni riga può avere campi e tipi diversi. Flessibile ma soggetto a errori.Schema tipizzato rigoroso incorporato nei metadati del file. Imposto in lettura e scrittura.
Streaming / AppendEccellente. Aggiungi una nuova riga alla fine del file. Ideale per l'ingestione in tempo reale.Scarso. Richiede la riscrittura o la creazione di nuove partizioni del file per aggiungere dati.
Leggibile dall'UomoSì. Ispeziona con cat, head, grep, jq o qualsiasi editor di testo.No. Richiede strumenti specializzati (parquet-tools, PyArrow, DuckDB) per l'ispezione.
EcosistemaUniversale. Supportato da ogni linguaggio di programmazione con un parser JSON.Focalizzato sull'analisi. Profonda integrazione con Spark, Hive, Presto, DuckDB, Snowflake, BigQuery.

Benchmark delle Prestazioni

Il divario di prestazioni tra JSONL e Parquet diventa significativo su larga scala. Di seguito sono riportati benchmark rappresentativi per un dataset di 10 milioni di righe con 20 colonne (un mix di stringhe, interi, float e timestamp).

Dimensione del File (Compressione)

JSONL~4.2 GB grezzo, ~1.1 GB con gzip
Parquet~0.5 GB con Snappy, ~0.4 GB con Zstd

Scansione Completa della Tabella

JSONL~45 secondi (analizza ogni riga JSON)
Parquet~8 secondi (decodifica binaria, letture vettorizzate)

Velocità di Scrittura

JSONL~30 secondi (serializzazione + scrittura testo)
Parquet~22 secondi (codifica + compressione colonne)

Query su Singola Colonna

JSONL~45 secondi (deve comunque leggere l'intero file)
Parquet~1.5 secondi (legge solo la colonna target)

Benchmark misurati con Python (pandas + PyArrow) su un MacBook Pro M2 con 16 GB di RAM. I risultati reali variano in base all'hardware, alla distribuzione dei dati e al codec di compressione.

Quando Usare JSONL vs Parquet

JSONLMigliore per JSONL
  • Ingestione di log in tempo reale e streaming di eventi
  • Dati di addestramento ML per OpenAI, Anthropic e Hugging Face
  • Interscambio dati tra microservizi e API
  • Dati semi-strutturati con schemi variabili per record
  • Prototipazione rapida e debug dove la leggibilità umana conta
  • Dati append-only dove i record arrivano continuamente
  • Dataset di piccole e medie dimensioni (sotto 1 GB) che non necessitano di query analitiche
ParquetMigliore per Parquet
  • Archiviazione data lake su S3, GCS o Azure Blob
  • Query analitiche con Spark, Presto, DuckDB o Snowflake
  • Aggregazioni colonnari (SUM, AVG, COUNT) su miliardi di righe
  • Requisiti rigorosi di imposizione dello schema e governance dei dati
  • Archiviazione a lungo termine dove il costo dello storage conta (file 2-10 volte più piccoli)
  • Feature store e pipeline di feature ML che leggono colonne specifiche
  • Dataset superiori a 1 GB dove le prestazioni delle query sono critiche

Architettura Ibrida: Ingestione JSONL, Archiviazione Parquet

Nelle piattaforme dati di produzione, JSONL e Parquet non si escludono a vicenda. Un pattern comune ed efficace è usare JSONL per l'ingestione dei dati e Parquet per l'archiviazione a lungo termine e l'analisi. Questo approccio ibrido combina i punti di forza di entrambi i formati: la semplicità di JSONL per la cattura dei dati in tempo reale e l'efficienza di Parquet per le query a valle.

La pipeline funziona in tre fasi. Primo, gli eventi o record grezzi vengono aggiunti ai file JSONL man mano che arrivano, perché JSONL supporta append veloci e senza lock. Secondo, un job batch periodico (orario, giornaliero o attivato dalla dimensione del file) legge i file JSONL accumulati, valida e trasforma i dati e li converte in formato Parquet. Terzo, i file Parquet risultanti vengono archiviati in un data lake partizionato per data, regione o altre dimensioni per query efficienti.

1. Ingestione come JSONL

Raccogli eventi grezzi, log e risposte API come file JSONL. Append veloci, nessuno schema richiesto e facile da debuggare in tempo reale.

2. Trasformazione e Validazione

Leggi periodicamente i batch JSONL, applica la validazione dello schema, pulisci e normalizza i dati e gestisci i record malformati.

3. Archiviazione come Parquet

Scrivi i dati validati come file Parquet partizionati nel tuo data lake. Interroga con Spark, DuckDB o qualsiasi motore analitico.

Pipeline da JSONL a Parquet
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 JSONL Gratuiti

Lavori con file JSONL? Usa i nostri strumenti gratuiti basati su browser per visualizzare, validare e convertire dati JSONL istantaneamente. Nessuna installazione o upload necessari.

Lavora con File JSONL Online

Visualizza, valida e converti file JSONL fino a 1 GB direttamente nel tuo browser. Nessun upload necessario, 100% privato.

Domande Frequenti

JSONL vs Parquet — Velocita, Archiviazione e Quando Usare...