- Strona główna
- Przewodnik
- Import i eksport danych JSONL: PostgreSQL, MongoDB i inne bazy danych
Import i eksport danych JSONL: PostgreSQL, MongoDB i inne bazy danych
Kompleksowy przewodnik po imporcie plików JSONL do baz danych i eksporcie rekordów do formatu JSONL. Omawia polecenia COPY w PostgreSQL, narzędzia CLI MongoDB, JSON_TABLE w MySQL, skrypty dla SQLite oraz wzorce importu masowego do zastosowań produkcyjnych.
Dlaczego warto używać JSONL do importu i eksportu danych?
JSONL (JSON Lines) stał się jednym z najchętniej wybieranych formatów do przenoszenia danych między bazami a systemami zewnętrznymi. Każda linia zawiera niezależny, kompletny obiekt JSON, więc możesz przetwarzać rekordy strumieniowo, jeden po drugim, bez wczytywania całego zbioru do pamięci. Ma to kluczowe znaczenie przy migracji milionów wierszy między instancjami PostgreSQL, synchronizacji kolekcji MongoDB z hurtownią danych czy przekazywaniu danych wyeksportowanych z bazy do potoków uczenia maszynowego.
W porównaniu z CSV format JSONL zachowuje typy danych, obsługuje zagnieżdżone obiekty i tablice oraz eliminuje niejednoznaczności związane z zapisem separatorów w danych. Plik JSONL może przenieść zawartość kolumny jsonb z PostgreSQL w niezmienionej postaci, podczas gdy CSV wymagałby spłaszczenia zagnieżdżonej struktury lub użycia sekwencji ucieczki. W odróżnieniu od pełnej tablicy JSON format JSONL umożliwia przetwarzanie strumieniowe: możesz przetwarzać, walidować lub przekształcać każdy rekord od razu po odczytaniu, bez czekania na sparsowanie całego pliku.
Wszystkie najważniejsze systemy baz danych mają już narzędzia do pracy z JSONL. PostgreSQL pozwala wczytywać wiersze poleceniem COPY z rzutowaniem na jsonb, MongoDB udostępnia narzędzia mongoimport i mongoexport, które domyślnie korzystają z JSONL, MySQL 8.0 wprowadził JSON_TABLE do wyodrębniania danych o określonej strukturze, a SQLite oferuje rozszerzenie JSON1. W kolejnych sekcjach znajdziesz konkretne polecenia, skrypty i zalecane praktyki dla każdej z tych baz.
PostgreSQL: import i eksport JSONL
PostgreSQL oferuje kilka sposobów pracy z JSONL. Polecenie COPY zapewnia najszybszy import masowy, a typ jsonb pozwala bezpośrednio przechowywać dane częściowo ustrukturyzowane i wykonywać na nich zapytania. Przy imporcie do tabel z kolumnami o określonych typach możesz parsować pola JSONL i przypisywać je do odpowiednich kolumn.
Najszybszy sposób importu JSONL do PostgreSQL to wczytanie każdej linii jako wartości jsonb za pomocą polecenia COPY. Utwórz tabelę z jedną kolumną jsonb, a następnie użyj COPY FROM, aby strumieniowo wczytać plik bezpośrednio do bazy danych.
-- Create a staging table with a single jsonb column
CREATE TABLE staging_import (data jsonb);
-- Import the JSONL file (each line becomes one row)
\COPY staging_import (data) FROM 'users.jsonl';
-- Verify the import
SELECT count(*) FROM staging_import;
SELECT data->>'name' AS name, data->>'email' AS email
FROM staging_import
LIMIT 5;
-- Move data into a structured table
INSERT INTO users (name, email, age)
SELECT
data->>'name',
data->>'email',
(data->>'age')::int
FROM staging_import;Aby wyeksportować dane do JSONL, użyj row_to_json() lub to_jsonb() do przekształcenia każdego wiersza w obiekt JSON, a następnie zapisz wynik do pliku poleceniem COPY. Każdemu wierszowi tabeli będzie odpowiadać jedna linia w pliku wynikowym.
-- Export entire table as JSONL
\COPY (
SELECT row_to_json(t)
FROM (SELECT id, name, email, created_at FROM users) t
) TO 'users_export.jsonl';
-- Export with filtering and transformation
\COPY (
SELECT row_to_json(t)
FROM (
SELECT id, name, email,
created_at::text AS created_at
FROM users
WHERE active = true
ORDER BY id
) t
) TO 'active_users.jsonl';
-- Verify: each line is valid JSON
-- {"id":1,"name":"Alice","email":"[email protected]",...}W zastosowaniach produkcyjnych użyj skryptu w Pythonie z biblioteką psycopg2, aby odczytać plik JSONL i wstawić rekordy do kolumn o określonych typach. Zapewni Ci to pełną kontrolę nad walidacją, obsługą błędów i wielkością partii danych.
import json
import psycopg2
from psycopg2.extras import execute_values
def import_jsonl_to_postgres(file_path, conn_string):
conn = psycopg2.connect(conn_string)
cur = conn.cursor()
batch = []
batch_size = 1000
total = 0
with open(file_path, 'r') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
record = json.loads(line)
batch.append((
record['name'],
record['email'],
record.get('age'),
))
except (json.JSONDecodeError, KeyError) as e:
print(f"Skipping line {line_num}: {e}")
continue
if len(batch) >= batch_size:
execute_values(
cur,
"INSERT INTO users (name, email, age) "
"VALUES %s ON CONFLICT (email) DO NOTHING",
batch
)
total += len(batch)
batch = []
print(f"Imported {total} records...")
if batch:
execute_values(
cur,
"INSERT INTO users (name, email, age) "
"VALUES %s ON CONFLICT (email) DO NOTHING",
batch
)
total += len(batch)
conn.commit()
cur.close()
conn.close()
print(f"Done. Imported {total} records.")
# Usage
import_jsonl_to_postgres('users.jsonl', 'postgresql://localhost/mydb')MongoDB: natywna obsługa JSONL
MongoDB zapewnia pełną obsługę JSONL za pośrednictwem pakietu narzędzi wiersza poleceń Database Tools. Narzędzia mongoimport i mongoexport domyślnie korzystają z formatu JSONL, dzięki czemu MongoDB należy do baz, w których wymiana danych w tym formacie jest najprostsza. Każda linia pliku JSONL odpowiada bezpośrednio jednemu dokumentowi MongoDB.
mongoimport odczytuje plik JSONL i wstawia każdą linię jako dokument do wskazanej kolekcji. Obsługuje tryb upsert, konwersję typów pól oraz równoległe wstawianie dokumentów, które zapewnia wysoką przepustowość.
# Basic import: each line becomes a document
mongoimport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--file=users.jsonl
# Upsert mode: update existing documents by _id
mongoimport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--file=users.jsonl \
--mode=upsert \
--upsertFields=email
# Drop collection before import (clean slate)
mongoimport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--file=users.jsonl \
--drop
# Import with parallel workers for large files
mongoimport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--file=large_users.jsonl \
--numInsertionWorkers=4mongoexport zapisuje każdy dokument kolekcji w osobnej linii JSON. Możesz filtrować dokumenty, wybierać pola i sortować wyniki. Otrzymasz poprawny plik JSONL, gotowy do przetworzenia przez dowolny system na dalszym etapie.
# Export entire collection as JSONL (default format)
mongoexport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--out=users_export.jsonl
# Export with query filter
mongoexport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--query='{"active": true}' \
--out=active_users.jsonl
# Export specific fields only
mongoexport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--fields=name,email,created_at \
--out=users_partial.jsonl
# Export with sorting
mongoexport \
--uri="mongodb://localhost:27017/mydb" \
--collection=users \
--sort='{"created_at": -1}' \
--out=users_sorted.jsonlMySQL: obsługa JSONL za pomocą JSON_TABLE i skryptów
MySQL nie ma wbudowanego polecenia importu JSONL takiego jak MongoDB, ale w wersji MySQL 8.0 pojawiła się funkcja JSON_TABLE, która pozwala wyodrębniać dane o określonej strukturze z ciągów JSON. Najbardziej niezawodny sposób masowego importu JSONL to połączenie LOAD DATA INFILE do wczytania surowych danych z JSON_TABLE do wyodrębnienia pól lub użycie języka skryptowego, takiego jak Python.
Wczytaj plik JSONL jako surowy tekst do tabeli pośredniej, a następnie użyj JSON_TABLE, aby wyodrębnić pola i zapisać je w kolumnach tabeli docelowej. Oba etapy wykonasz w całości w MySQL.
-- Step 1: Create a staging table for raw lines
CREATE TABLE jsonl_staging (
id INT AUTO_INCREMENT PRIMARY KEY,
raw_line TEXT NOT NULL
);
-- Step 2: Load the JSONL file as raw text
LOAD DATA INFILE '/var/lib/mysql-files/users.jsonl'
INTO TABLE jsonl_staging
LINES TERMINATED BY '\n'
(raw_line);
-- Step 3: Extract structured data with JSON_TABLE
INSERT INTO users (name, email, age)
SELECT jt.name, jt.email, jt.age
FROM jsonl_staging,
JSON_TABLE(
raw_line, '$'
COLUMNS (
name VARCHAR(255) PATH '$.name',
email VARCHAR(255) PATH '$.email',
age INT PATH '$.age'
)
) AS jt;
-- Step 4: Clean up staging table
DROP TABLE jsonl_staging;
-- Verify the import
SELECT * FROM users LIMIT 5;Jeśli potrzebujesz większej elastyczności, użyj skryptu w Pythonie z biblioteką mysql-connector-python, aby odczytać plik JSONL i wstawiać rekordy partiami. Ten sposób pozwala wydajnie obsługiwać duże pliki i szczegółowo raportować błędy.
import json
import mysql.connector
def import_jsonl_to_mysql(file_path, config):
conn = mysql.connector.connect(**config)
cursor = conn.cursor()
batch = []
batch_size = 1000
total = 0
insert_sql = (
"INSERT INTO users (name, email, age) "
"VALUES (%s, %s, %s) "
"ON DUPLICATE KEY UPDATE name=VALUES(name)"
)
with open(file_path, 'r') as f:
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
record = json.loads(line)
batch.append((
record['name'],
record['email'],
record.get('age'),
))
except (json.JSONDecodeError, KeyError) as e:
print(f"Skipping line {line_num}: {e}")
continue
if len(batch) >= batch_size:
cursor.executemany(insert_sql, batch)
conn.commit()
total += len(batch)
batch = []
print(f"Imported {total} records...")
if batch:
cursor.executemany(insert_sql, batch)
conn.commit()
total += len(batch)
cursor.close()
conn.close()
print(f"Done. Imported {total} records.")
# Usage
import_jsonl_to_mysql('users.jsonl', {
'host': 'localhost',
'user': 'root',
'password': 'secret',
'database': 'mydb'
})SQLite: prosty import JSONL
SQLite świetnie sprawdza się podczas lokalnego tworzenia oprogramowania i przy mniejszych zbiorach danych. Nie ma wprawdzie natywnego polecenia importu JSONL, ale rozszerzenie JSON1 udostępnia funkcję json_extract() do pracy z danymi JSON. Prosty skrypt w Pythonie pozwala wydajnie importować pliki JSONL dzięki wbudowanej w SQLite obsłudze transakcji.
Użyj wbudowanego w Pythona modułu sqlite3, aby odczytać plik JSONL i wstawić rekordy do bazy SQLite. Objęcie wszystkich operacji wstawiania jedną transakcją znacznie poprawia wydajność przy dużych plikach.
import json
import sqlite3
def import_jsonl_to_sqlite(jsonl_path, db_path):
conn = sqlite3.connect(db_path)
cursor = conn.cursor()
# Create table if it doesn't exist
cursor.execute("""
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
email TEXT UNIQUE,
age INTEGER,
raw_json TEXT
)
""")
total = 0
errors = 0
with open(jsonl_path, 'r') as f:
# Use a transaction for bulk insert performance
conn.execute('BEGIN TRANSACTION')
for line_num, line in enumerate(f, 1):
line = line.strip()
if not line:
continue
try:
record = json.loads(line)
cursor.execute(
"INSERT OR IGNORE INTO users "
"(name, email, age, raw_json) "
"VALUES (?, ?, ?, ?)",
(
record['name'],
record.get('email'),
record.get('age'),
line, # Store original JSON
)
)
total += 1
except (json.JSONDecodeError, KeyError) as e:
errors += 1
print(f"Line {line_num}: {e}")
conn.commit()
conn.close()
print(f"Imported {total} records, {errors} errors")
# Usage
import_jsonl_to_sqlite('users.jsonl', 'app.db')
# Query with json_extract (SQLite JSON1 extension)
# SELECT json_extract(raw_json, '$.name') FROM users;Dobre praktyki importu masowego
Import dużych plików JSONL do bazy danych wymaga zadbania o transakcje, obsługę błędów i zarządzanie zasobami. Poniższe praktyki sprawdzają się we wszystkich systemach baz danych i pomogą Ci tworzyć niezawodne potoki importu do zastosowań produkcyjnych.
Wstawianie partiami w transakcjach
WydajnośćNigdy nie twórz osobnej transakcji dla każdego wstawianego wiersza. Grupuj operacje wstawiania w partie po 500-5000 wierszy na transakcję. Zmniejsza to narzut operacji dyskowych I/O i blokad 10-100x. W większości baz danych największe korzyści daje wielkość partii równa 1000. Dalsze zwiększanie partii przynosi coraz mniejsze korzyści, a w razie błędu zwiększa koszt wycofania transakcji.
Obsługa błędów dla poszczególnych linii
NiezawodnośćParsuj i waliduj każdą linię JSONL osobno. Jeśli walidacja lub wstawienie danych się nie powiedzie, zapisz w logu numer linii i komunikat błędu. Użyj ON CONFLICT / ON DUPLICATE KEY, aby obsłużyć naruszenia ograniczeń unikalności bez przerywania całego importu. Zapisuj problematyczne linie do osobnego pliku błędów, aby móc je później przeanalizować.
Śledzenie postępu
ObserwowalnośćW przypadku plików liczących miliony linii zapisuj postęp w logach co N rekordów (na przykład co 10 000). Śledź łączną liczbę odczytanych linii, poprawnie wstawionych rekordów, pominiętych duplikatów i błędów. Obliczaj i wyświetlaj szybkość importu (rekordy/sekundę), aby wykrywać wąskie gardła wydajności. Te informacje są niezbędne do monitorowania długotrwałych importów.
Ten uniwersalny wzorzec łączy przetwarzanie partiami, obsługę błędów i śledzenie postępu. Możesz dostosować go do dowolnej bazy danych, podmieniając funkcję wstawiającą rekordy.
import json
import time
def batch_import_jsonl(file_path, insert_fn, batch_size=1000):
"""Generic JSONL batch importer with error handling."""
batch = []
stats = {
'total_lines': 0,
'imported': 0,
'skipped': 0,
'errors': 0
}
start_time = time.time()
error_file = open(file_path + '.errors', 'w')
with open(file_path, 'r') as f:
for line_num, line in enumerate(f, 1):
stats['total_lines'] = line_num
line = line.strip()
if not line:
stats['skipped'] += 1
continue
try:
record = json.loads(line)
batch.append(record)
except json.JSONDecodeError as e:
stats['errors'] += 1
error_file.write(f"{line_num}\t{e}\t{line}\n")
continue
if len(batch) >= batch_size:
inserted = insert_fn(batch)
stats['imported'] += inserted
batch = []
if line_num % 10000 == 0:
elapsed = time.time() - start_time
rate = stats['imported'] / elapsed
print(
f"Progress: {line_num:,} lines | "
f"{stats['imported']:,} imported | "
f"{rate:,.0f} records/sec"
)
# Flush remaining batch
if batch:
inserted = insert_fn(batch)
stats['imported'] += inserted
error_file.close()
elapsed = time.time() - start_time
print(f"\nComplete in {elapsed:.1f}s")
print(f" Lines: {stats['total_lines']:,}")
print(f" Imported: {stats['imported']:,}")
print(f" Errors: {stats['errors']:,}")
return statsPrzygotuj dane za pomocą bezpłatnych narzędzi JSONL
Przed importem JSONL do bazy danych sprawdź poprawność formatu pliku i przekonwertuj dane między formatami. Nasze bezpłatne narzędzia online przetwarzają wszystko lokalnie w Twojej przeglądarce, więc dane nigdy nie opuszczają Twojego komputera.
Eksportuj dane JSONL do arkuszy CSV, aby wygodnie analizować je w Excelu lub Google Sheets.
Waliduj pliki JSONL linia po linii. Od razu wykrywaj błędy składni, problemy z kodowaniem i niezgodności z formatem.
Dowiedz się, jak walidować pliki JSONL przy użyciu JSON Schema. Obejmuje Python, Node.js, narzędzia CLI i automatyzację CI/CD.
Sposoby przetwarzania gigabajtów danych JSONL: odczyt strumieniowy, zarządzanie pamięcią, dzielenie plików, kompresja i narzędzia online.
Dowiedz się, jak używać JSONL jako formatu wymiany danych w pipeline’ach ETL. Poznaj przetwarzanie strumieniowe w Apache Kafka, DAG-i w Airflow, ładowanie danych do Snowflake i BigQuery oraz projektowanie pipeline’ów odpornych na awarie.