Di Jerry Fan

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.

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 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.

Lettura e scrittura di file 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 diretto

La tabella seguente riassume le principali differenze tra JSONL e Parquet negli aspetti più importanti per scegliere il formato dati del tuo progetto.

CaratteristicaJSONLParquet
Organizzazione dei datiFormato 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.
CodificaTesto semplice UTF-8. Leggibile e modificabile con qualsiasi editor di testo.Formato binario con codifica a dizionario, RLE e bit-packing. Non leggibile direttamente.
CompressioneCompressione 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 queryOgni 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.
SchemaNessuno 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 codaOttimo 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).
EcosistemaUniversale. 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)

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

Scansione dell’intera tabella

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

Velocità di scrittura

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

Query su una singola colonna

JSONL~45 secondi (occorre comunque leggere l’intero file)
Parquet~1.5 secondi (lettura della sola colonna richiesta)

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

JSONLQuando scegliere JSONL
  • 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
ParquetQuando scegliere Parquet
  • 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.

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/')

Lavora con i file JSONL online

Visualizza, valida e converti file JSONL fino a 1 GB direttamente nel tuo browser. Non devi caricare alcun file: i dati restano privati al 100%.

Domande frequenti

Riferimenti