Autor: Jerry Fan

JSONL a Parquet: jak wybrać odpowiedni format danych

Szczegółowe porównanie JSONL (JSON Lines) i Apache Parquet. Poznaj różnice w kompresji, wydajności zapytań, egzekwowaniu schematu i obsłudze przez narzędzia, aby wybrać format dopasowany do sposobu przetwarzania Twoich danych.

Czym jest JSONL?

JSONL (JSON Lines) to tekstowy format danych, w którym każda linia zawiera jeden samodzielny obiekt JSON, a poszczególne obiekty są rozdzielone znakami nowej linii. To naturalne rozszerzenie powszechnie używanego formatu JSON, zaprojektowane z myślą o przetwarzaniu strumieniowym i danych takich jak logi. Ponieważ każda linia jest niezależnym dokumentem JSON, do pliku można dopisywać nowe dane bez przepisywania istniejących, a całość przetwarzać linia po linii przy minimalnym zużyciu pamięci.

JSONL stał się standardowym formatem wymiany danych treningowych w uczeniu maszynowym (fine-tuning w OpenAI, zbiory danych Hugging Face), logów aplikacji i strumieni zdarzeń. Sprawdza się wszędzie tam, gdzie dane napływają stopniowo. Jest czytelny dla człowieka, więc jego zawartość łatwo sprawdzić w dowolnym edytorze tekstu lub za pomocą narzędzi wiersza poleceń, takich jak grep, head i 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}

Czym jest Parquet?

Apache Parquet to binarny format kolumnowy zaprojektowany z myślą o wydajnych zapytaniach analitycznych na dużych zbiorach danych. JSONL zapisuje dane wiersz po wierszu, natomiast Parquet grupuje wartości według kolumn. Odczyt pojedynczego pola z milionów wierszy wymaga więc przeskanowania tylko odpowiedniej kolumny, zamiast wszystkich pełnych rekordów. Taki układ pozwala uzyskać wysoki stopień kompresji, ponieważ wartości w obrębie kolumny zwykle mają podobny typ i rozkład.

Parquet powstał w ekosystemie Apache Hadoop i jest dziś de facto standardowym formatem przechowywania danych w jeziorach danych opartych na AWS S3, Google Cloud Storage i Azure Blob Storage. Jest ściśle zintegrowany z Apache Spark, Apache Hive, Presto, DuckDB, Snowflake, BigQuery i praktycznie każdym nowoczesnym silnikiem analitycznym. Pliki Parquet zawierają w metadanych ściśle określony schemat, dzięki czemu aplikacje odczytujące dane znają ich dokładne typy i strukturę bez dodatkowej dokumentacji.

Odczyt i zapis plików Parquet w Pythonie
import pyarrow.parquet as pq
import pandas as pd


# Zapisz DataFrame do 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')


# Odczytaj konkretne kolumny (zaleta kolumnowa)
df = pq.read_table('employees.parquet', columns=['name', 'salary']).to_pandas()

JSONL a Parquet: zestawienie różnic

Poniższa tabela podsumowuje najważniejsze różnice między JSONL a Parquet pod kątem wyboru formatu danych do Twojego projektu.

CechaJSONLParquet
Układ danychWierszowy, tekstowy. Każda linia zawiera kompletny obiekt JSON.Kolumnowy, binarny. Wartości są zapisywane kolumnami w obrębie grup wierszy.
KodowanieZwykły tekst UTF-8. Czytelny dla człowieka, można go edytować w dowolnym edytorze tekstu.Zapis binarny z kodowaniem słownikowym, RLE i pakowaniem bitów. Nie da się go bezpośrednio odczytać jako tekstu.
KompresjaOpcjonalna kompresja zewnętrzna (gzip, zstd). Nazwy pól powtarzają się w każdym wierszu.Wbudowana kompresja kolumnowa (Snappy, Zstd, Gzip). Pliki 2-10x mniejsze.
Wydajność zapytańKażde zapytanie wymaga przeskanowania całego pliku. Brak mechanizmów column pruning i predicate pushdown.Mechanizmy column pruning i predicate pushdown pozwalają pomijać niepotrzebne dane. Zapytania analityczne są szybsze o rzędy wielkości.
SchematNie wymaga schematu. Każda linia może zawierać inne pola i typy. Zapewnia elastyczność, ale sprzyja błędom.Ściśle określony schemat z typami danych, zapisany w metadanych pliku. Jego zgodność jest sprawdzana przy odczycie i zapisie.
Przetwarzanie strumieniowe / dopisywanieSprawdza się doskonale. Wystarczy dopisać nową linię na końcu pliku. Idealny do przyjmowania danych w czasie rzeczywistym.Sprawdza się słabo. Dodanie danych wymaga przepisania plików lub utworzenia nowych partycji z plikami.
Czytelność dla człowiekaTak. Zawartość można sprawdzić za pomocą cat, head, grep, jq lub dowolnego edytora tekstu.Nie. Do sprawdzenia zawartości potrzebne są specjalistyczne narzędzia (parquet-tools, PyArrow, DuckDB).
EkosystemUniwersalny. Obsługiwany w każdym języku programowania, który ma parser JSON.Nastawiony na analitykę. Ścisła integracja z narzędziami Spark, Hive, Presto, DuckDB, Snowflake i BigQuery.

Testy wydajności

Przy dużej skali różnica wydajności między JSONL a Parquet staje się ogromna. Poniżej przedstawiamy reprezentatywne wyniki testów dla zbioru danych z 10 milionami wierszy i 20 kolumnami (zawierającymi ciągi znaków, liczby całkowite, liczby zmiennoprzecinkowe i znaczniki czasu).

Rozmiar pliku (kompresja)

JSONL~4,2 GB bez kompresji, ~1,1 GB z gzip
Parquet~0,5 GB ze Snappy, ~0,4 GB z Zstd

Pełne skanowanie tabeli

JSONL~45 sekund (parsowanie każdej linii JSON)
Parquet~8 sekund (dekodowanie binarne, odczyt wektorowy)

Szybkość zapisu

JSONL~30 sekund (serializacja + zapis tekstu)
Parquet~22 sekundy (kodowanie + kompresja kolumn)

Zapytanie o pojedynczą kolumnę

JSONL~45 sekund (nadal trzeba odczytać cały plik)
Parquet~1,5 sekundy (odczyt tylko wskazanej kolumny)

Testy przeprowadzono w Pythonie (pandas + PyArrow) na MacBooku Pro z procesorem M2 i 16 GB RAM. Rzeczywiste wyniki zależą od sprzętu, rozkładu danych i użytego kodeka kompresji.

Kiedy wybrać JSONL, a kiedy Parquet

JSONLGdzie najlepiej sprawdza się JSONL
  • Zbieranie logów w czasie rzeczywistym i strumieniowanie zdarzeń
  • Dane treningowe ML dla OpenAI, Anthropic i Hugging Face
  • Wymiana danych między mikroserwisami i API
  • Dane częściowo ustrukturyzowane, w których schemat może się różnić między rekordami
  • Szybkie prototypowanie i debugowanie, gdy ważna jest czytelność danych dla człowieka
  • Dane, do których dopisuje się kolejne rekordy w miarę ich ciągłego napływania
  • Małe i średnie zbiory danych (poniżej 1 GB), które nie wymagają zapytań analitycznych
ParquetGdzie najlepiej sprawdza się Parquet
  • Przechowywanie danych w jeziorach danych na S3, GCS lub Azure Blob
  • Zapytania analityczne z użyciem narzędzi Spark, Presto, DuckDB lub Snowflake
  • Agregacje kolumnowe (SUM, AVG, COUNT) na miliardach wierszy
  • Ścisłe egzekwowanie schematu i wymagania dotyczące zarządzania danymi
  • Długoterminowa archiwizacja, gdy liczą się koszty przechowywania (pliki 2-10x mniejsze)
  • Magazyny cech (feature stores) i pipeline’y cech ML odczytujące konkretne kolumny
  • Zbiory danych większe niż 1 GB, w których kluczowa jest wydajność zapytań

Architektura hybrydowa: zbieranie danych w JSONL, przechowywanie w Parquet

W produkcyjnych platformach danych JSONL i Parquet mogą się uzupełniać. Popularne i skuteczne rozwiązanie to zbieranie danych w JSONL, a następnie używanie Parquet do ich długoterminowego przechowywania i analizy. Takie podejście hybrydowe łączy zalety obu formatów: prostotę JSONL przy zbieraniu danych w czasie rzeczywistym oraz wydajność Parquet przy wykonywaniu zapytań na dalszych etapach przetwarzania.

Pipeline składa się z trzech etapów. Najpierw surowe zdarzenia lub rekordy są dopisywane do plików JSONL w miarę napływania, ponieważ JSONL pozwala szybko dopisywać dane bez blokad. Następnie zadanie wsadowe, uruchamiane co godzinę, codziennie lub po osiągnięciu określonego rozmiaru pliku, odczytuje zgromadzone pliki JSONL, waliduje i przekształca dane oraz konwertuje je do formatu Parquet. Na końcu powstałe pliki Parquet trafiają do jeziora danych podzielonego na partycje według daty, regionu lub innych wymiarów, co umożliwia wydajne wykonywanie zapytań.

1. Zbieraj dane w JSONL

Zbieraj surowe zdarzenia, logi i odpowiedzi API w plikach JSONL. Dane można szybko dopisywać bez ustalonego schematu, a debugowanie w czasie rzeczywistym jest proste.

2. Przekształcaj i waliduj

Regularnie odczytuj partie danych JSONL, sprawdzaj ich zgodność ze schematem, oczyszczaj i normalizuj dane oraz obsługuj niepoprawne rekordy.

3. Przechowuj dane w Parquet

Zapisuj zwalidowane dane w jeziorze danych jako pliki Parquet podzielone na partycje. Wykonuj zapytania za pomocą Spark, DuckDB lub dowolnego silnika analitycznego.

Pipeline konwersji JSONL do 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):
    """Konwertuj zgromadzone pliki JSONL na partycjonowany 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)
    # Dodaj kolumne partycji
    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'Przekonwertowano {len(records)} rekordow do Parquet')


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

Pracuj z plikami JSONL online

Przeglądaj, waliduj i konwertuj pliki JSONL o rozmiarze do 1 GB bezpośrednio w przeglądarce. Bez przesyłania plików, z zachowaniem 100% prywatności.

Najczęściej zadawane pytania

Źródła