Import et export de données JSONL : PostgreSQL, MongoDB et autres bases de données
Un guide complet pour importer des fichiers JSONL dans vos bases de données et exporter leurs enregistrements au format JSONL. Vous y trouverez les commandes COPY de PostgreSQL, les outils en ligne de commande de MongoDB, JSON_TABLE de MySQL, des scripts SQLite et des méthodes d’import en masse adaptées à la production.
Pourquoi choisir JSONL pour importer et exporter des données ?
JSONL (JSON Lines) s’est imposé comme un format de choix pour échanger des données entre bases de données et systèmes externes. Chaque ligne contient un objet JSON indépendant et autonome : vous pouvez donc traiter les enregistrements en flux, un par un, sans charger tout le jeu de données en mémoire. C’est essentiel pour migrer des millions de lignes entre des instances PostgreSQL, synchroniser des collections MongoDB avec un entrepôt de données ou alimenter des pipelines de machine learning à partir d’exports de bases de données.
Par rapport au CSV, JSONL conserve les types de données, accepte les objets imbriqués et les tableaux, et évite les ambiguïtés liées à l’échappement des délimiteurs. Un fichier JSONL peut contenir les données d’une colonne jsonb de PostgreSQL sans aucune modification, alors qu’en CSV, il faudrait aplatir la structure imbriquée ou échapper son contenu. Contrairement à un tableau JSON complet, JSONL se prête au traitement en flux : vous pouvez traiter, valider ou transformer chaque enregistrement dès sa lecture, sans attendre la fin de l’analyse du fichier.
Tous les grands systèmes de bases de données disposent désormais d’outils pour JSONL. PostgreSQL permet de charger des lignes avec COPY en les convertissant en jsonb ; MongoDB fournit mongoimport et mongoexport, qui utilisent JSONL par défaut ; MySQL 8.0 a introduit JSON_TABLE pour extraire des données structurées ; et SQLite propose l’extension JSON1. Les sections suivantes détaillent les commandes, les scripts et les bonnes pratiques propres à chaque base de données.
PostgreSQL : importer et exporter du JSONL
PostgreSQL propose plusieurs façons de travailler avec JSONL. La commande COPY est la méthode la plus rapide pour les imports en masse, tandis que le type jsonb permet de stocker et d’interroger nativement des données semi-structurées. Pour alimenter des tables structurées, vous pouvez extraire les champs JSONL et les convertir en colonnes typées pendant l’import.
La méthode la plus rapide pour importer du JSONL dans PostgreSQL consiste à charger chaque ligne sous forme de valeur jsonb avec la commande COPY. Créez une table contenant une seule colonne jsonb, puis utilisez COPY FROM pour charger le fichier en flux directement dans la base de données.
-- 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;Pour exporter des données en JSONL, utilisez row_to_json() ou to_jsonb() pour convertir chaque ligne en objet JSON, puis écrivez le résultat dans un fichier avec COPY. Chaque ligne de la table occupe une ligne dans le fichier de sortie.
-- 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]",...}Pour les imports en production, utilisez un script Python avec psycopg2 pour lire un fichier JSONL et insérer les enregistrements dans des colonnes typées. Vous gardez ainsi la maîtrise de la validation, de la gestion des erreurs et de la taille des lots.
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 : prise en charge native de JSONL
MongoDB prend pleinement en charge JSONL grâce à ses outils en ligne de commande Database Tools. Les utilitaires mongoimport et mongoexport utilisent ce format par défaut, ce qui fait de MongoDB l’une des bases de données les plus simples à utiliser pour échanger des données JSONL. Chaque ligne d’un fichier JSONL correspond directement à un document MongoDB.
mongoimport lit un fichier JSONL et insère chaque ligne sous forme de document dans la collection indiquée. Il prend en charge le mode upsert, la conversion des types des champs et les insertions en parallèle pour atteindre un débit élevé.
# 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 écrit chaque document d’une collection sur une seule ligne JSON. Vous pouvez filtrer les documents, sélectionner les champs à exporter et trier le résultat. Vous obtenez un fichier JSONL valide, prêt à être traité par tout système en aval.
# 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 : utiliser JSONL avec JSON_TABLE et des scripts
Contrairement à MongoDB, MySQL ne propose pas de commande intégrée pour importer du JSONL. MySQL 8.0 a toutefois introduit JSON_TABLE, qui permet d’extraire des données structurées à partir de chaînes JSON. Pour les imports JSONL en masse, les méthodes les plus fiables consistent à combiner LOAD DATA INFILE pour charger les données brutes et JSON_TABLE pour les extraire, ou à utiliser un langage de script comme Python.
Chargez le fichier JSONL sous forme de texte brut dans une table de staging, puis utilisez JSON_TABLE pour extraire les champs et alimenter une table structurée. Ces deux étapes s’effectuent entièrement dans 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;Pour plus de souplesse, utilisez un script Python avec mysql-connector-python pour lire un fichier JSONL et insérer les enregistrements par lots. Cette méthode traite efficacement les fichiers volumineux et permet de signaler les erreurs en détail.
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 : une solution légère pour importer du JSONL
SQLite convient très bien au développement local et aux jeux de données de taille modeste. Il ne propose pas de commande native d’import JSONL, mais son extension JSON1 fournit la fonction json_extract() pour manipuler les données JSON. Un simple script Python permet d’importer efficacement des fichiers JSONL en s’appuyant sur la gestion des transactions intégrée à SQLite.
Utilisez sqlite3, le module fourni avec Python, pour lire un fichier JSONL et insérer ses enregistrements dans une base SQLite. Regrouper toutes les insertions dans une seule transaction améliore considérablement les performances sur les fichiers volumineux.
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;Bonnes pratiques pour les imports en masse
L’import de fichiers JSONL volumineux dans une base de données demande de soigner la gestion des transactions, des erreurs et des ressources. Les bonnes pratiques suivantes s’appliquent à tous les systèmes de bases de données et vous aideront à créer des pipelines d’import fiables, adaptés à la production.
Regrouper les insertions par transaction
PerformanceN’effectuez jamais une transaction par ligne insérée. Regroupez les insertions par lots de 500 à 5 000 lignes dans chaque transaction. Vous divisez ainsi par 10 à 100 les E/S disque et le surcoût lié aux verrous. Pour la plupart des bases de données, les gains les plus importants sont obtenus avec des lots de 1 000 lignes. Au-delà, les gains s’amenuisent et le coût d’un rollback augmente en cas d’échec.
Gestion des erreurs ligne par ligne
FiabilitéAnalysez et validez chaque ligne JSONL séparément. Pour toute ligne dont la validation ou l’insertion échoue, consignez le numéro de ligne et le message d’erreur. Utilisez ON CONFLICT / ON DUPLICATE KEY pour gérer les violations de contraintes d’unicité sans interrompre tout l’import. Conservez les lignes en échec dans un fichier d’erreurs distinct afin de pouvoir les examiner plus tard.
Suivi de la progression
ObservabilitéPour les fichiers contenant des millions de lignes, consignez la progression tous les N enregistrements, par exemple tous les 10 000. Suivez le nombre total de lignes lues, les insertions réussies, les doublons ignorés et les erreurs. Calculez et affichez le débit d’import (enregistrements/seconde) pour repérer les goulots d’étranglement. Ces indicateurs sont essentiels pour surveiller les imports de longue durée.
Ce pattern générique combine le traitement par lots, la gestion des erreurs et le suivi de la progression. Adaptez-le à n’importe quelle base de données en remplaçant la fonction d’insertion.
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 statsPréparez vos données avec des outils JSONL gratuits
Avant d’importer du JSONL dans votre base de données, validez le format du fichier et convertissez vos données d’un format à l’autre. Nos outils en ligne gratuits effectuent tous les traitements localement dans votre navigateur : vos données ne quittent jamais votre machine.
Exportez vos données JSONL dans des fichiers CSV pour les analyser dans Excel ou Google Sheets.
Validez vos fichiers JSONL ligne par ligne. Repérez immédiatement les erreurs de syntaxe et les problèmes d’encodage ou de format.
Apprenez à valider des fichiers JSONL avec JSON Schema. Couvre Python, Node.js, les outils CLI et l’automatisation CI/CD.
Les stratégies pour traiter des gigaoctets de données JSONL : lecture en streaming, gestion de la mémoire, découpage des fichiers, compression et outils en ligne.
Apprenez à utiliser JSONL comme format d’échange dans vos pipelines ETL : streaming avec Apache Kafka, DAG Airflow, chargement dans Snowflake et BigQuery, et conception de pipelines tolérants aux pannes.