Door Jerry Fan

JSONL vs Parquet: het juiste dataformaat kiezen

Een uitgebreide vergelijking van JSONL (JSON Lines) en Apache Parquet. Ontdek de verschillen in compressie, queryprestaties, schemavalidatie en ondersteuning binnen het ecosysteem, zodat je het juiste formaat kiest voor je dataverwerking.

Wat is JSONL?

JSONL (JSON Lines) is een tekstformaat waarin elke regel één zelfstandig JSON-object bevat. De regels worden gescheiden door newline-tekens. Het is een natuurlijke uitbreiding van het veelgebruikte JSON-formaat, speciaal ontworpen voor streaming en logdata. Omdat elke regel een afzonderlijk JSON-document is, kun je data aan bestanden toevoegen zonder de bestaande inhoud te herschrijven. Je kunt de bestanden bovendien regel voor regel verwerken met een minimaal extra geheugengebruik.

JSONL is uitgegroeid tot het standaard uitwisselingsformaat voor trainingsdata voor machine learning (fine-tuning bij OpenAI, datasets van Hugging Face), applicatielogs, event streams en andere toepassingen waarbij data geleidelijk binnenkomt. Omdat het formaat direct leesbaar is, kun je de inhoud eenvoudig bekijken met een teksteditor of commandlinetools zoals grep, head en 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}

Wat is Parquet?

Apache Parquet is een binair opslagformaat dat data per kolom opslaat, ontworpen voor efficiënte analytische queries op grote datasets. JSONL slaat data rij voor rij op; Parquet groepeert de waarden per kolom. Als je één veld uit miljoenen rijen wilt lezen, hoeft Parquet dus alleen de betreffende kolom te scannen in plaats van alle volledige records. Deze kolomindeling maakt sterke compressie mogelijk, doordat de waarden binnen een kolom vaak vergelijkbaar zijn qua type en verdeling.

Parquet is ontstaan binnen het Apache Hadoop-ecosysteem en is inmiddels de de facto standaard voor opslag in data lakes op AWS S3, Google Cloud Storage en Azure Blob Storage. Het is nauw geïntegreerd met Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery en vrijwel elke moderne analytics-engine. Parquet-bestanden leggen een strikt schema vast in hun metadata. Daardoor weten toepassingen die de bestanden lezen altijd precies welke datatypes en structuur ze kunnen verwachten, zonder externe documentatie.

Parquet lezen en schrijven met Python
import pyarrow.parquet as pq
import pandas as pd


# Schrijf een DataFrame naar 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')


# Lees specifieke kolommen (kolomvoordeel)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()

JSONL vs Parquet: de verschillen op een rij

De onderstaande tabel vat de belangrijkste verschillen tussen JSONL en Parquet samen, met de aspecten die het zwaarst wegen bij de keuze van een dataformaat voor je project.

EigenschapJSONLParquet
Data-indelingRijgeoriënteerd tekstformaat. Elke regel bevat een volledig JSON-object.Kolomgeoriënteerd binair formaat. Waarden worden per kolom opgeslagen, gegroepeerd in row groups.
CoderingPlatte tekst in UTF-8. Direct leesbaar en te bewerken in elke teksteditor.Binair, met dictionary encoding, RLE en bit-packing. Niet direct leesbaar.
CompressieOptionele externe compressie (gzip, zstd). Veldnamen worden in elke rij herhaald.Ingebouwde compressie per kolom (Snappy, Zstd, Gzip). 2-10x kleinere bestanden.
QueryprestatiesVoor elke query moet het volledige bestand worden gescand. Geen column pruning of predicate pushdown.Column pruning en predicate pushdown slaan niet-relevante data over. Ordes van grootte sneller bij analytische queries.
SchemaGeen vast schema. Elke regel kan andere velden en datatypes bevatten. Flexibel, maar foutgevoelig.Een strikt getypeerd schema ligt vast in de bestandsmetadata en wordt bij het lezen en schrijven afgedwongen.
Streaming / data toevoegenUitstekend. Je voegt eenvoudig een nieuwe regel toe aan het einde van het bestand. Ideaal om data in realtime binnen te halen.Beperkt geschikt. Om data toe te voegen, moet je bestanden herschrijven of nieuwe bestandspartities aanmaken.
Leesbaar voor mensenJa. Bekijk de inhoud met cat, head, grep, jq of een teksteditor.Nee. Om de inhoud te bekijken, heb je gespecialiseerde tools nodig (parquet-tools, PyArrow, DuckDB).
EcosysteemUniverseel. Ondersteund door elke programmeertaal met een JSON-parser.Gericht op analytics. Nauw geïntegreerd met Spark, Hive, Presto, DuckDB, Snowflake en BigQuery.

Prestatiebenchmarks

Bij grote hoeveelheden data loopt het prestatieverschil tussen JSONL en Parquet flink op. Hieronder staan representatieve benchmarks voor een dataset met 10 miljoen rijen en 20 kolommen (een mix van strings, integers, floats en timestamps).

Bestandsgrootte (compressie)

JSONL~4,2 GB ongecomprimeerd, ~1,1 GB met gzip
Parquet~0,5 GB met Snappy, ~0,4 GB met Zstd

Volledige tabelscan

JSONL~45 seconden (elke JSON-regel parseren)
Parquet~8 seconden (binair decoderen, gevectoriseerd lezen)

Schrijfsnelheid

JSONL~30 seconden (serialiseren + tekst schrijven)
Parquet~22 seconden (kolommen coderen + comprimeren)

Query op één kolom

JSONL~45 seconden (het hele bestand moet nog steeds worden gelezen)
Parquet~1,5 seconden (alleen de gevraagde kolom wordt gelezen)

Deze benchmarks zijn gemeten met Python (pandas + PyArrow) op een M2 MacBook Pro met 16 GB RAM. De resultaten in de praktijk hangen af van de hardware, de verdeling van de data en de gebruikte compressiecodec.

Wanneer kies je JSONL en wanneer Parquet?

JSONLKies JSONL voor
  • Logs in realtime binnenhalen en event streaming
  • ML-trainingsdata voor OpenAI, Anthropic en Hugging Face
  • Data-uitwisseling tussen microservices en API's
  • Semigestructureerde data waarbij het schema per record verschilt
  • Snel prototypes bouwen en debuggen wanneer leesbaarheid belangrijk is
  • Append-only data waarbij voortdurend nieuwe records binnenkomen
  • Kleine tot middelgrote datasets (minder dan 1 GB) waarvoor je geen analytische queries nodig hebt
ParquetKies Parquet voor
  • Opslag in data lakes op S3, GCS of Azure Blob
  • Analytische queries met Spark, Presto, DuckDB of Snowflake
  • Aggregaties per kolom (SUM, AVG, COUNT) over miljarden rijen
  • Strikte eisen aan schemahandhaving en data governance
  • Langdurige archivering waarbij opslagkosten zwaar wegen (2-10x kleinere bestanden)
  • Feature stores en ML-featurepipelines die specifieke kolommen lezen
  • Datasets groter dan 1 GB waarbij queryprestaties doorslaggevend zijn

Hybride architectuur: data binnenhalen als JSONL, opslaan als Parquet

Op dataplatforms in productie kun je JSONL en Parquet prima naast elkaar gebruiken. Een veelgebruikte en effectieve aanpak is om data als JSONL binnen te halen en Parquet te gebruiken voor langdurige opslag en analytics. Zo combineer je de sterke punten van beide formaten: de eenvoud van JSONL om data in realtime vast te leggen en de efficiëntie van Parquet voor queries verderop in de pipeline.

De pipeline bestaat uit drie stappen. Eerst voeg je ruwe events of records toe aan JSONL-bestanden zodra ze binnenkomen. JSONL ondersteunt namelijk het snel toevoegen van data zonder locks. Vervolgens leest een periodieke batchtaak de verzamelde JSONL-bestanden, valideert en transformeert de data en zet deze om naar Parquet. Die taak draait elk uur, dagelijks of zodra bestanden een bepaalde grootte bereiken. Tot slot sla je de Parquet-bestanden op in een data lake, gepartitioneerd op datum, regio of andere dimensies, zodat je er efficiënt queries op kunt uitvoeren.

1. Data binnenhalen als JSONL

Verzamel ruwe events, logs en API-responses in JSONL-bestanden. Je kunt snel data toevoegen, hebt geen schema nodig en kunt eenvoudig in realtime debuggen.

2. Transformeren en valideren

Lees periodiek batches JSONL-data, valideer ze tegen een schema, schoon de data op, normaliseer deze en handel onjuist gevormde records af.

3. Opslaan als Parquet

Schrijf gevalideerde data als gepartitioneerde Parquet-bestanden naar je data lake. Voer queries uit met Spark, DuckDB of een andere analytics-engine.

Pipeline van JSONL naar 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):
    """Converteer verzamelde JSONL-bestanden naar gepartitioneerd 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)
    # Voeg partitiekolom toe
    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'{len(records)} records geconverteerd naar Parquet')


jsonl_to_parquet('raw_events/', 'data_lake/')

Werk online met JSONL-bestanden

Bekijk, valideer en converteer JSONL-bestanden tot 1 GB direct in je browser. Je hoeft niets te uploaden: je data blijft 100% privé.

Veelgestelde vragen

Bronnen