Parcourir les aide-mémoire · Ingénierie des données
CSV, JSON, Parquet ou Delta
Choisissez entre CSV, JSON, Parquet et Delta selon le schéma, les performances analytiques, la mutabilité, l’interopérabilité, la fiabilité et les exigences d’un data lake en production.
Sur cette page
- Problème
- Réponse rapide
- Code / commandes
- 1. CSV : lire et écrire avec pandas
- 2. CSV : définir les types explicitement
- 3. CSV : traiter délibérément les valeurs nulles
- 4. CSV : préciser l’encodage si nécessaire
- 5. CSV : utiliser des blocs pour les gros fichiers
- 6. CSV : valider la forme des lignes
- 7. CSV : les guillemets comptent
- 8. CSV : le délimiteur fait partie du contrat
- 9. CSV : points forts
- 10. JSON : lire du JSON délimité par des sauts de ligne avec pandas
- 11. JSON Lines est préférable à un gigantesque tableau JSON pour les fichiers de type flux
- 12. Tableau JSON standard
- 13. JSON : structure imbriquée
- 14. Aplatir le JSON imbriqué avec précaution
- 15. Les tableaux JSON peuvent modifier le grain des données
- 16. JSON : utiliser des horodatages explicites
- 17. JSON : le schéma est flexible, pas inexistant
- 18. JSON : éviter les documents gigantesques et profondément imbriqués pour l’analytique
- 19. JSON : points forts
- 20. Parquet : lire avec pandas
- 21. Parquet : écrire avec pandas
- 22. Parquet : lire avec PySpark
- 23. Parquet : sélectionner uniquement les colonnes nécessaires
- 24. Parquet : filtrer tôt
- 25. Parquet stocke des données typées en colonnes
- 26. Parquet est adapté à l’analytique
- 27. Parquet reste un ensemble de fichiers
- 28. Partitionner Parquet délibérément
- 29. Éviter les partitions à très forte cardinalité
- 30. Éviter les fichiers Parquet minuscules
- 31. Éviter un unique fichier Parquet gigantesque
- 32. Compression Parquet
- 33. L’évolution du schéma Parquet n’est pas un protocole transactionnel
- 34. Delta : ce qu’il apporte
- 35. Delta : lire une table avec PySpark
- 36. Delta : ajout (append)
- 37. Delta : écraser délibérément
- 38. Delta : MERGE
- 39. Un MERGE Delta exige des clés source déterministes
- 40. Delta prend en charge les suppressions
- 41. Delta prend en charge les mises à jour
- 42. Historique d’une table Delta
- 43. Voyage dans le temps Delta
- 44. VACUUM affecte la capacité de récupération historique
- 45. Delta n’est pas un serveur de base de données
- 46. Delta n’est pas « un autre type de fichier qui remplace Parquet »
- 47. Ne pas modifier directement les fichiers de données Delta
- 48. Ne pas traiter à la légère un répertoire Delta comme du Parquet ordinaire
- 49. Exemple de parcours CSV vs Parquet
- 50. JSON vs Parquet pour les journaux
- 51. CSV vs JSON pour l’échange
- 52. Parquet vs Delta
- 53. CSV devrait rarement être le format analytique organisé
- 54. JSON devrait rarement être le format analytique final à fort volume
- 55. Conserver la source brute lorsque la traçabilité compte
- 56. Ajouter des métadonnées d’ingestion
- 57. Valider explicitement le schéma
- 58. Valider les types de données après l’analyse
- 59. Utiliser un schéma explicite pour l’ingestion Spark
- 60. Éviter l’inférence de schéma à chaque exécution en production
- 61. Les données décimales méritent des types explicites
- 62. Les dates et horodatages exigent une sémantique de fuseau horaire claire
- 63. CSV ne distingue pas nativement les types
- 64. JSON a des types mais reste ambigu
- 65. Parquet conserve des types physiques plus riches
- 66. La compression dépend du format
- 67. Un CSV compressé en gzip peut être petit mais rester coûteux à interroger
- 68. La divisibilité compte pour le traitement distribué
- 69. Éviter un fichier par ligne/événement
- 70. Les problèmes de petits fichiers sont des problèmes opérationnels
- 71. Format de fichier et organisation de la table sont des décisions distinctes
- 72. Format et compression sont des décisions distinctes
- 73. Format et sémantique de table sont des décisions distinctes
- 74. Éviter d’écrire en Delta si les consommateurs ne comprennent que le Parquet brut
- 75. Choisir le format d’échange selon le consommateur
- 76. Ne pas faire de CSV la source de vérité interne simplement parce que les utilisateurs veulent des exports CSV
- 77. Ne pas faire de JSON la source de vérité uniquement parce que l’API source utilise JSON
- 78. Combiner des données brutes immuables et des tables organisées mutables
- 79. Valider les allers-retours lorsque l’interopérabilité compte
- 80. Choisir selon la charge de travail, pas la popularité
- Interpréter le résultat
- Points à vérifier
- Les colonnes CSV changent de type d’une exécution à l’autre
- Le nombre de lignes JSON augmente de façon inattendue après l’aplatissement
- Une requête Parquet parcourt encore trop de données
- Un MERGE Delta échoue ou se comporte de façon ambiguë
- Le voyage dans le temps Delta n’atteint plus une ancienne version
- Le stockage contient des millions de fichiers minuscules
- Notes de production
- Les formats d’échange et les formats analytiques servent des objectifs différents
- Le schéma doit être explicite
- Delta exige des lecteurs/écrivains compatibles avec Delta
- L’organisation des fichiers peut compter autant que le format
- La rétention affecte la capacité de récupération
- Les consommateurs externes définissent les contraintes d’interopérabilité
- Erreurs fréquentes
- 1. Traiter CSV comme des données typées
- 2. Aplatir du JSON sans définir le grain
- 3. Utiliser JSON pour de grands parcours analytiques répétés
- 4. Traiter Parquet comme une table transactionnelle
- 5. Considérer Delta comme un encodage de remplacement de Parquet
- 6. Lire directement des fichiers Delta comme du Parquet ordinaire
- 7. Partitionner par des identifiants à forte cardinalité
- 8. Créer un unique fichier de sortie gigantesque
- 9. Laisser l’inférence de schéma définir les contrats de production
- 10. Choisir un seul format pour toutes les couches
- Étape suivante
- Pour aller plus loin
Problème
Vous devez stocker ou échanger des données et choisir un format adapté à la charge de travail.
Un mauvais choix peut entraîner inutilement :
- un coût d’analyse syntaxique
- une dérive de schéma
- un surcoût de stockage
- des analyses lentes
- des mises à jour fragiles
- des données en double
- une mauvaise interopérabilité
- une reprise difficile
L’objectif n’est pas de désigner un gagnant universel.
L’objectif est d’utiliser le bon format pour le rôle qu’il joue dans la plateforme de données.
Réponse rapide
Utilisez ce modèle de décision :
Échange simple et lisible par un humain
→ CSV
Charges utiles d’API/d’événements imbriquées ou semi-structurées
→ JSON
Analyses à forte lecture sur des fichiers immuables
→ Parquet
Tables analytiques nécessitant transactions ACID, mises à jour, suppressions, MERGE, gestion du schéma et historique de table
→ Delta
Un modèle de production courant est :
échange externe/avec la source
→ CSV / JSON
zone d’atterrissage brute durable
→ format natif de la source ou Parquet/Delta
analytique organisée
→ tables Delta reposant sur Parquet
couche de service/entrepôt
→ tables Delta / d’entrepôt
La distinction pratique :
CSV / JSON
→ formats de sérialisation
Parquet
→ format de fichier analytique en colonnes
Delta
→ format de table construit sur Parquet + journal des transactions
Code / commandes
1. CSV : lire et écrire avec pandas
Lecture :
import pandas as pd
df = pd.read_csv(
"orders.csv",
dtype={
"order_id": "string",
"customer_id": "string",
},
parse_dates=["created_at"],
)
Écriture :
df.to_csv(
"orders.csv",
index=False,
)
Utilisez CSV lorsque l’interopérabilité et la simplicité comptent davantage qu’un schéma strict ou l’efficacité analytique.
2. CSV : définir les types explicitement
Mauvais :
df = pd.read_csv("orders.csv")
si les identifiants ou les dates doivent être interprétés de manière fiable.
Mieux :
df = pd.read_csv(
"orders.csv",
dtype={
"order_id": "string",
"postal_code": "string",
},
parse_dates=["created_at"],
)
Cela permet d’éviter des problèmes tels que :
00123
→ lu comme 123
identifiant de grande taille
→ lu comme numérique
texte ressemblant à une date
→ interprété de façon incohérente
3. CSV : traiter délibérément les valeurs nulles
Exemple :
df = pd.read_csv(
"orders.csv",
na_values=["", "NULL", "null"],
keep_default_na=True,
)
Ne supposez pas que toute chaîne vide ou toute chaîne "NULL" a la même signification métier.
Définissez explicitement le contrat de la source.
4. CSV : préciser l’encodage si nécessaire
df = pd.read_csv(
"orders.csv",
encoding="utf-8",
)
Si l’encodage est inconnu, ne le devinez pas silencieusement dans un pipeline de production.
Capturez les échecs et examinez le contrat de la source.
5. CSV : utiliser des blocs pour les gros fichiers
for chunk in pd.read_csv(
"large_orders.csv",
chunksize=100_000,
):
process(chunk)
À utiliser lorsque le fichier est trop volumineux pour un traitement en mémoire confortable.
Le découpage en blocs ne rend pas CSV colonnaire ni indexé ; il contrôle uniquement l’utilisation de la mémoire.
6. CSV : valider la forme des lignes
Échec typique :
12 colonnes attendues
une ligne contient 13 délimiteurs
En production, suivez le nombre de lignes mal formées et isolez les enregistrements défectueux plutôt que de les supprimer silencieusement.
7. CSV : les guillemets comptent
Exemple de champ :
"Smith, John"
contient une virgule mais doit rester une seule colonne.
Utilisez des lecteurs/écrivains conformes aux standards plutôt qu’un split(",") manuel.
8. CSV : le délimiteur fait partie du contrat
Certains systèmes utilisent :
,
;
|
\t
Exemple :
df = pd.read_csv(
"orders.psv",
sep="|",
)
Ne supposez pas que tout « CSV » utilise une virgule.
9. CSV : points forts
Adapté pour :
exports simples
inspection manuelle
compatibilité avec les tableurs
intégrations héritées
petits fichiers d’échange
Points faibles :
pas de schéma strict
pas de structure imbriquée
typage pauvre
coût de parcours élevé
problèmes de délimiteurs/guillemets
10. JSON : lire du JSON délimité par des sauts de ligne avec pandas
Pour JSON Lines / NDJSON :
df = pd.read_json(
"events.jsonl",
lines=True,
)
C’est courant pour les jeux de données d’événements et de journaux.
11. JSON Lines est préférable à un gigantesque tableau JSON pour les fichiers de type flux
JSON Lines :
{"eventId": 1, "type": "click"}
{"eventId": 2, "type": "view"}
{"eventId": 3, "type": "purchase"}
Chaque ligne est une valeur JSON indépendante.
Avantages :
- écriture incrémentale
- traitement ligne par ligne
- reprise partielle plus facile
- courant dans les pipelines de journaux/d’événements
12. Tableau JSON standard
Exemple :
[
{
"eventId": 1,
"type": "click"
},
{
"eventId": 2,
"type": "view"
}
]
C’est utile pour les réponses d’API et les documents bornés.
C’est moins pratique pour ajouter des données à de grands jeux de données d’événements.
13. JSON : structure imbriquée
Exemple :
{
"orderId": 123,
"customer": {
"customerId": 45,
"country": "US"
},
"items": [
{
"sku": "A1",
"qty": 2
}
]
}
JSON convient naturellement aux données imbriquées/semi-structurées.
Ce n’est pas le cas de CSV.
14. Aplatir le JSON imbriqué avec précaution
Avec pandas :
import json
import pandas as pd
with open("orders.json", "r", encoding="utf-8") as f:
payload = json.load(f)
orders = pd.json_normalize(payload)
En présence de tableaux, définissez d’abord le grain attendu.
L’aplatissement de données imbriquées peut multiplier les lignes de façon inattendue.
15. Les tableaux JSON peuvent modifier le grain des données
Exemple :
1 commande
avec
5 articles
Aplatir à une ligne par article produit :
5 lignes
N’agrégez pas ensuite en supposant que le grain d’origine est toujours d’une commande par ligne.
16. JSON : utiliser des horodatages explicites
Préférez des représentations standard de type ISO :
{
"createdAt": "2026-10-04T15:30:00Z"
}
à des chaînes dépendantes des paramètres régionaux telles que :
10/04/26 3:30 PM
Les clients doivent tout de même analyser les valeurs selon le contrat documenté.
17. JSON : le schéma est flexible, pas inexistant
JSON n’impose pas de schéma par lui-même.
Les systèmes de production doivent tout de même définir :
- les champs obligatoires
- les types
- les champs pouvant être nuls
- le versionnage
- les règles de compatibilité
Une représentation flexible ne supprime pas le besoin d’un contrat de données.
18. JSON : éviter les documents gigantesques et profondément imbriqués pour l’analytique
Le JSON imbriqué peut être coûteux à analyser de façon répétée.
Un bon modèle est :
ingérer le JSON source
→ conserver la charge utile brute
→ analyser/normaliser une seule fois
→ écrire en Parquet/Delta analytique
19. JSON : points forts
Adapté pour :
API
événements
journaux
données semi-structurées
enregistrements imbriqués
évolution du schéma en périphérie
Points faibles :
verbeux
orienté lignes
noms de champs répétés
parcours analytiques coûteux
ambiguïté des types
20. Parquet : lire avec pandas
df = pd.read_parquet(
"orders.parquet",
columns=[
"order_id",
"created_at",
"amount",
],
)
Sélectionner uniquement les colonnes nécessaires réduit les E/S.
C’est un avantage clé du stockage en colonnes.
21. Parquet : écrire avec pandas
df.to_parquet(
"orders.parquet",
index=False,
)
La compression dépend du moteur et de la configuration par défaut.
En production, choisissez la compression délibérément lorsque l’interopérabilité ou les performances comptent.
22. Parquet : lire avec PySpark
df = (
spark.read
.parquet("/data/orders")
)
23. Parquet : sélectionner uniquement les colonnes nécessaires
df = (
spark.read
.parquet("/data/orders")
.select(
"order_id",
"created_at",
"amount",
)
)
L’élagage des colonnes réduit la quantité de données lues.
24. Parquet : filtrer tôt
df = (
spark.read
.parquet("/data/orders")
.filter("order_date >= '2026-10-01'")
.select(
"order_id",
"order_date",
"amount",
)
)
Le predicate pushdown et l’élagage des partitions peuvent réduire le travail de parcours lorsque les statistiques et l’organisation des fichiers le permettent.
Vérifiez avec le plan de requête au lieu de supposer que chaque filtre est poussé vers la source.
25. Parquet stocke des données typées en colonnes
Contrairement à CSV, Parquet peut conserver des types tels que :
integer
decimal
timestamp
boolean
string
structures imbriquées
Cela réduit l’analyse syntaxique répétée et l’inférence de schéma.
26. Parquet est adapté à l’analytique
Avantages typiques :
élagage des colonnes
compression
schéma typé
prise en charge du predicate pushdown
parcours efficaces
prise en charge des données imbriquées
Cela le rend bien meilleur que CSV/JSON pour les requêtes analytiques répétées.
27. Parquet reste un ensemble de fichiers
Un dossier de fichiers Parquet ne fournit pas automatiquement :
transactions de table ACID
mises à jour atomiques sur plusieurs fichiers
sémantique MERGE
historique de table
coordination des écritures concurrentes
C’est là que des formats de table comme Delta apportent de la valeur.
28. Partitionner Parquet délibérément
Exemple d’organisation des répertoires :
/orders/order_date=2026-10-01/
/orders/order_date=2026-10-02/
Utilisez des partitions lorsqu’elles servent les filtres courants et la maintenance.
Ne partitionnez pas sur toutes les colonnes possibles.
29. Éviter les partitions à très forte cardinalité
Mauvais candidats :
order_id
transaction_id
customer_email
Ils peuvent créer un nombre énorme de répertoires/petits fichiers.
Préférez des colonnes de partition ayant une réelle utilité pour la gestion ou le filtrage des données.
30. Éviter les fichiers Parquet minuscules
Des milliers ou des millions de fichiers minuscules augmentent :
- le surcoût des métadonnées
- le coût d’ouverture des fichiers
- le travail de l’ordonnanceur
- le surcoût de planification des requêtes
Compactez les fichiers lorsque la plateforme ou la charge de travail l’exige.
Il n’existe pas de taille de fichier idéale universelle.
31. Éviter un unique fichier Parquet gigantesque
Un fichier massif peut réduire le parallélisme et compliquer la réécriture ou la reprise.
La taille des fichiers doit tenir compte :
- du moteur
- du stockage
- de la charge de travail
- de la concurrence
- du partitionnement
32. Compression Parquet
Codecs courants :
Snappy
Gzip
Zstandard
Compromis :
plus de compression
↔
plus de CPU
Choisissez selon la charge de travail et l’interopérabilité.
33. L’évolution du schéma Parquet n’est pas un protocole transactionnel
Ajouter, supprimer ou modifier des champs dans des fichiers Parquet distincts peut produire des schémas mixtes.
Certains moteurs savent fusionner les schémas, mais cela a des conséquences sur l’exactitude et les performances.
Encadrez explicitement les changements de schéma.
34. Delta : ce qu’il apporte
Une table Delta se compose généralement de :
fichiers de données Parquet
+
journal des transactions _delta_log
Le journal des transactions fournit une sémantique de table telle que :
- les transactions ACID
- les contrôles d’application/d’évolution du schéma
- les mises à jour/suppressions
- MERGE
- l’historique de table
- la gestion de la concurrence
- le voyage dans le temps/la lecture de versions
35. Delta : lire une table avec PySpark
df = (
spark.read
.format("delta")
.table("silver.orders")
)
ou par chemin :
df = (
spark.read
.format("delta")
.load("/tables/silver/orders")
)
Préférez les références de table lorsque votre plateforme ou votre catalogue les gère.
36. Delta : ajout (append)
(
df.write
.format("delta")
.mode("append")
.saveAsTable("bronze.orders")
)
Utilisez append pour les enregistrements immuables/nouveaux lorsque le traitement des doublons est déjà défini.
37. Delta : écraser délibérément
(
df.write
.format("delta")
.mode("overwrite")
.saveAsTable("silver.orders_rebuild")
)
L’écrasement (overwrite) peut remplacer les données de la table.
Ne l’utilisez que pour reconstruire le périmètre prévu.
Pour un remplacement limité à certaines partitions, utilisez le modèle de remplacement de partitions pris en charge par la plateforme plutôt que d’écraser aveuglément toute la table.
38. Delta : MERGE
from delta.tables import DeltaTable
target = DeltaTable.forName(
spark,
"silver.orders",
)
(
target.alias("t")
.merge(
source=df.alias("s"),
condition="t.order_id = s.order_id",
)
.whenMatchedUpdateAll()
.whenNotMatchedInsertAll()
.execute()
)
À utiliser lorsque des lignes peuvent être insérées ou mises à jour.
Vérifiez l’unicité de la source avant le MERGE.
39. Un MERGE Delta exige des clés source déterministes
Mauvaise source :
order_id 123 apparaît deux fois
Un MERGE peut devenir ambigu ou échouer selon l’opération et le comportement du moteur.
Vérifiez le grain de la source :
from pyspark.sql import functions as F
duplicates = (
df.groupBy("order_id")
.count()
.filter(F.col("count") > 1)
)
Résolvez les doublons avant d’écrire.
40. Delta prend en charge les suppressions
Exemple :
target.delete(
"is_deleted = true"
)
La suppression est transactionnelle au niveau de la table.
Méfiez-vous des prédicats trop larges en production.
41. Delta prend en charge les mises à jour
Exemple :
target.update(
condition="status = 'pending'",
set={
"status": "'expired'"
},
)
Utilisez des prédicats ciblés et relus.
42. Historique d’une table Delta
SQL :
DESCRIBE HISTORY silver.orders;
À utiliser pour inspecter :
- l’opération
- la version
- l’horodatage
- les métadonnées d’utilisateur/de job lorsqu’elles sont disponibles
- les paramètres/métriques de l’opération selon la plateforme
L’historique améliore l’observabilité mais ne remplace pas une journalisation d’audit métier.
43. Voyage dans le temps Delta
Exemple :
previous = (
spark.read
.format("delta")
.option("versionAsOf", 42)
.table("silver.orders")
)
ou :
previous = (
spark.read
.format("delta")
.option(
"timestampAsOf",
"2026-10-04T12:00:00Z",
)
.table("silver.orders")
)
La disponibilité de l’historique dépend des fichiers de journal et de données conservés.
44. VACUUM affecte la capacité de récupération historique
La maintenance Delta peut supprimer d’anciens fichiers de données qui ne sont plus nécessaires à l’état actuel de la table.
Si la rétention est réduite de façon agressive, les anciennes versions peuvent ne plus être lisibles.
Ne raccourcissez pas la rétention sans comprendre :
- les lecteurs actifs
- les jobs de streaming
- les exigences de voyage dans le temps
- les besoins de retour arrière/de reprise
45. Delta n’est pas un serveur de base de données
Delta fournit une sémantique de table au-dessus de fichiers/d’un stockage objet.
Il ne fournit pas automatiquement :
- une latence OLTP au niveau de la ligne
- un service applicatif transactionnel arbitraire à forte concurrence
- des procédures stockées
- une sémantique de connexion de base de données
Utilisez-le pour les charges de travail analytiques/lakehouse.
46. Delta n’est pas « un autre type de fichier qui remplace Parquet »
Les fichiers de données sous-jacents sont des fichiers Parquet.
Le journal des transactions Delta ajoute un comportement de table autour de ces fichiers.
Cette distinction compte lors du dépannage ou de l’intégration avec des moteurs.
47. Ne pas modifier directement les fichiers de données Delta
Mauvais :
supprimer manuellement un fichier Parquet
remplacer un fichier en dehors du protocole transactionnel
Cela peut corrompre la cohérence de la table, car le journal des transactions référence toujours l’état de la table.
Écrivez via des outils compatibles avec Delta.
48. Ne pas traiter à la légère un répertoire Delta comme du Parquet ordinaire
Lire uniquement :
*.parquet
peut ignorer :
- les suppressions
- les mises à jour
- l’état transactionnel
- les fichiers retirés
- la sémantique des versions
Utilisez un lecteur compatible avec Delta pour les tables Delta.
49. Exemple de parcours CSV vs Parquet
Supposons qu’une requête ait besoin de :
order_id
amount
dans un jeu de données de 50 colonnes.
CSV exige normalement d’analyser des lignes contenant toutes les colonnes.
Parquet peut lire uniquement les blocs de colonnes nécessaires.
C’est pourquoi Parquet est généralement meilleur pour les parcours analytiques.
50. JSON vs Parquet pour les journaux
Bon flux :
événements bruts
→ JSON Lines
→ normalisation
→ Parquet/Delta
JSON préserve la fidélité à la source.
Parquet/Delta améliorent les requêtes analytiques répétées.
51. CSV vs JSON pour l’échange
Choisissez CSV lorsque :
structure tabulaire plate
compatibilité maximale
export/import simple
Choisissez JSON lorsque :
données imbriquées
champs facultatifs
charges utiles hiérarchiques
sémantique d’API/d’événements
52. Parquet vs Delta
Choisissez Parquet lorsque :
fichiers analytiques immuables
échange de fichiers simple
aucun comportement de table transactionnel nécessaire
Choisissez Delta lorsque :
la table est mutable
MERGE est nécessaire
lecteurs/écrivains concurrents
l’application du schéma compte
historique/voyage dans le temps nécessaire
53. CSV devrait rarement être le format analytique organisé
CSV peut rester pertinent lorsque l’interopérabilité l’exige.
Mais pour l’analytique interne à grande échelle, analyser de façon répétée de gros jeux de données CSV représente généralement un surcoût inutile.
Préférez un format en colonnes typé.
54. JSON devrait rarement être le format analytique final à fort volume
JSON est précieux aux frontières d’ingestion.
L’analytique organisée gagne généralement à le convertir en :
Parquet
ou
Delta
une fois le schéma/grain compris.
55. Conserver la source brute lorsque la traçabilité compte
Un modèle Bronze utile :
stocker le fichier/la charge utile d’origine
+
les métadonnées d’ingestion
Cela facilite :
- la réexécution
- l’audit
- les corrections du parseur
- les changements de schéma
- les litiges avec la source
56. Ajouter des métadonnées d’ingestion
Colonnes utiles :
source_file
ingested_at
batch_id
source_system
record_hash
N’écrasez pas la sémantique de la source avec les métadonnées d’ingestion.
Conservez les deux.
57. Valider explicitement le schéma
Exemple en PySpark :
expected = {
"order_id",
"created_at",
"amount",
}
actual = set(df.columns)
missing = expected - actual
if missing:
raise ValueError(
f"Missing required columns: {sorted(missing)}"
)
La validation du schéma est particulièrement importante pour les sources CSV/JSON.
58. Valider les types de données après l’analyse
Exemple :
df.printSchema()
Recherchez des anomalies telles que :
string au lieu de timestamp
double au lieu de decimal
colonne inférée contenant uniquement des valeurs nulles
Ne vous fiez pas à l’inférence pour les pipelines de production critiques.
59. Utiliser un schéma explicite pour l’ingestion Spark
Exemple :
from pyspark.sql.types import (
StructType,
StructField,
StringType,
TimestampType,
DecimalType,
)
schema = StructType([
StructField("order_id", StringType(), False),
StructField("created_at", TimestampType(), True),
StructField("amount", DecimalType(18, 2), True),
])
Puis :
df = (
spark.read
.schema(schema)
.json("/landing/orders/*.json")
)
Cela évite une inférence incohérente d’un fichier à l’autre.
60. Éviter l’inférence de schéma à chaque exécution en production
L’inférence peut :
- parcourir des données supplémentaires
- varier selon les échantillons de la source
- inférer des types différents après des changements de la source
Un schéma explicite est plus prévisible.
61. Les données décimales méritent des types explicites
Les valeurs financières ne devraient pas être stockées automatiquement en virgule flottante.
Préférez une précision/échelle décimale adaptée lorsque l’arithmétique exacte est requise.
Exemple :
DECIMAL(18,2)
La précision correcte dépend des exigences métier.
62. Les dates et horodatages exigent une sémantique de fuseau horaire claire
Pour l’échange :
2026-10-04T15:30:00Z
est plus clair qu’un horodatage local sans décalage.
Stockez explicitement la sémantique de fuseau horaire/UTC.
63. CSV ne distingue pas nativement les types
Ces valeurs :
00123
123
true
2026-10-04
sont toutes du texte dans le fichier.
C’est le lecteur qui décide de leur type.
C’est une raison majeure de valider l’analyse syntaxique.
64. JSON a des types mais reste ambigu
JSON prend en charge :
string
number
boolean
null
array
object
Mais il ne distingue pas :
la largeur des entiers
la précision décimale
le type timestamp
le type date
sans contrat de schéma.
65. Parquet conserve des types physiques plus riches
Cela améliore l’interopérabilité entre moteurs analytiques lorsque des types compatibles sont utilisés.
Validez tout de même le comportement entre moteurs pour :
- les horodatages
- les décimaux
- les types imbriqués
- les annotations logiques
66. La compression dépend du format
Tendance générale :
CSV
→ généralement volumineux sauf compression externe
JSON
→ verbeux, car les noms de champs se répètent
Parquet
→ forte compression en colonnes
Delta
→ même compression des données Parquet + surcoût du journal des transactions
La taille réelle dépend de la distribution des données et du codec.
67. Un CSV compressé en gzip peut être petit mais rester coûteux à interroger
La compression réduit la taille de stockage/de transfert.
Elle ne rend pas CSV :
- typé
- colonnaire
- lisible de façon sélective
Une requête peut encore devoir décompresser et analyser le flux.
68. La divisibilité compte pour le traitement distribué
Les gros fichiers compressés peuvent réduire l’efficacité de la lecture parallèle selon le comportement de la compression/du conteneur.
Parquet est conçu pour les lectures analytiques parallèles.
Ne créez pas un énorme fichier texte compressé en espérant des performances distribuées idéales.
69. Éviter un fichier par ligne/événement
Tous les formats souffrent d’un nombre excessif de fichiers.
Le stockage objet et les moteurs distribués ont un surcoût non négligeable de métadonnées/d’ouverture de fichiers.
Regroupez les enregistrements dans des fichiers de taille raisonnable selon la charge de travail.
70. Les problèmes de petits fichiers sont des problèmes opérationnels
Symptômes :
- temps de planification long
- listage des répertoires lent
- nombre de tâches excessif
- surcoût des métadonnées
- faible efficacité des parcours
Corrigez au niveau de l’ingestion/de l’organisation des écritures plutôt que d’ajouter seulement de la puissance de calcul.
71. Format de fichier et organisation de la table sont des décisions distinctes
Exemple :
format Parquet
+
partitionnement par date
+
fichiers de taille raisonnable
peut offrir de bonnes performances.
Un mauvais partitionnement et des fichiers minuscules peuvent rendre même Parquet lent.
72. Format et compression sont des décisions distinctes
Exemple :
Parquet + Snappy
Parquet + Zstd
CSV + gzip
JSONL + gzip
Choisissez les deux intentionnellement.
73. Format et sémantique de table sont des décisions distinctes
Parquet
→ format de fichier
Delta
→ format/protocole de table utilisant des fichiers Parquet
C’est l’une des distinctions les plus importantes.
74. Éviter d’écrire en Delta si les consommateurs ne comprennent que le Parquet brut
Si le consommateur externe ne sait pas interpréter la sémantique des tables Delta, décidez s’il faut :
- exposer un accès aux tables pris en charge
- exporter un instantané Parquet
- exporter en CSV/JSON
- utiliser une interface de partage/de requête
Ne demandez pas aux consommateurs de lire le répertoire Delta comme du Parquet quelconque.
75. Choisir le format d’échange selon le consommateur
Pour une livraison externe :
utilisateur métier
→ CSV peut être le plus simple
intégration d’API
→ JSON
moteur analytique
→ Parquet
plateforme compatible lakehouse
→ Delta
L’architecture doit tenir compte des capacités en aval.
76. Ne pas faire de CSV la source de vérité interne simplement parce que les utilisateurs veulent des exports CSV
Conservez une représentation interne typée.
Exportez en CSV à la frontière.
Cela préserve la qualité analytique tout en maintenant la compatibilité.
77. Ne pas faire de JSON la source de vérité uniquement parce que l’API source utilise JSON
Conservez le JSON brut si nécessaire, puis normalisez-le dans des tables analytiques gouvernées.
78. Combiner des données brutes immuables et des tables organisées mutables
Modèle courant :
Bronze
→ ajout des données brutes/alignées sur la source
Silver
→ Delta nettoyé/dédoublonné/mis à jour par upsert
Gold
→ Delta/entrepôt prêt pour les consommateurs
Cela sépare la capacité de réexécution de la mutabilité des données organisées.
79. Valider les allers-retours lorsque l’interopérabilité compte
Exemple :
écrire le fichier
→ le lire avec le moteur cible
→ comparer le nombre de lignes, le schéma et les champs clés
Ne supposez pas qu’une écriture réussie avec une bibliothèque garantit une compatibilité parfaite partout.
80. Choisir selon la charge de travail, pas la popularité
Ordre de décision :
1. Qui consomme les données ?
2. Les données sont-elles plates ou imbriquées ?
3. Un typage strict est-il nécessaire ?
4. La charge de travail est-elle analytique ?
5. Des mises à jour/suppressions/MERGE sont-ils nécessaires ?
6. L’interopérabilité compte-t-elle plus que la vitesse des requêtes ?
7. Avons-nous besoin de transactions/d’historique ?
8. Quelle échelle/organisation des fichiers est attendue ?
Choisissez ensuite le format.
Interpréter le résultat
| Format | Usage idéal | Point fort principal | Limite principale |
|---|---|---|---|
| CSV | Échange/export de données plates | Compatibilité universelle | Typage faible, analytique coûteuse |
| JSON | API/événements/données semi-structurées | Structure imbriquée et flexible | Verbeux, analyses répétées coûteuses |
| Parquet | Fichiers analytiques | Parcours typés en colonnes | Aucune sémantique de table transactionnelle à lui seul |
| Delta | Tables lakehouse mutables | ACID + MERGE + historique sur Parquet | Nécessite des outils compatibles avec Delta |
Un modèle mental pratique est :
CSV
→ texte adapté aux tableurs
JSON
→ texte structuré adapté aux applications/événements
Parquet
→ fichiers en colonnes adaptés à l’analytique
Delta
→ sémantique de table analytique autour de Parquet
Points à vérifier
Les colonnes CSV changent de type d’une exécution à l’autre
Vérifiez :
- l’inférence de schéma
- les zéros en tête
- les marqueurs de valeurs nulles
- les lignes mal formées
- les changements de paramètres régionaux/de format de date
Utilisez un schéma explicite.
Le nombre de lignes JSON augmente de façon inattendue après l’aplatissement
Des tableaux imbriqués ont probablement modifié le grain du résultat.
Validez les clés métier avant l’agrégation.
Une requête Parquet parcourt encore trop de données
Vérifiez :
- les colonnes sélectionnées
- les filtres
- l’élagage des partitions
- les statistiques des fichiers
- l’organisation des fichiers
- les petits fichiers
- le plan de requête
Un MERGE Delta échoue ou se comporte de façon ambiguë
Vérifiez :
- les clés en double dans la source
- le grain de la cible
- la condition de merge
- les écritures concurrentes
Le voyage dans le temps Delta n’atteint plus une ancienne version
Vérifiez la rétention/VACUUM et la disponibilité des fichiers de données.
Le stockage contient des millions de fichiers minuscules
Corrigez la stratégie de regroupement/partitionnement/compactage en amont.
Notes de production
Les formats d’échange et les formats analytiques servent des objectifs différents
CSV/JSON optimisent la compatibilité et la fidélité à la source.
Parquet/Delta optimisent le traitement analytique et un comportement de table gouverné.
Le schéma doit être explicite
Les formats texte en particulier exigent une gestion délibérée du schéma.
L’inférence est pratique pour l’exploration, pas comme contrat de production solide.
Delta exige des lecteurs/écrivains compatibles avec Delta
Ne contournez pas le protocole transactionnel en modifiant les fichiers manuellement.
L’organisation des fichiers peut compter autant que le format
Le partitionnement et le comportement des petits fichiers peuvent dominer les performances.
La rétention affecte la capacité de récupération
L’historique Delta et le voyage dans le temps dépendent des fichiers de transactions/de données conservés.
Ne réduisez pas la rétention à la légère.
Les consommateurs externes définissent les contraintes d’interopérabilité
Parfois, CSV est le bon format de sortie même si la plateforme interne utilise Delta.
Utilisez des formats différents selon les frontières.
Erreurs fréquentes
1. Traiter CSV comme des données typées
Le fichier stocke du texte. Les lecteurs infèrent/attribuent les types.
2. Aplatir du JSON sans définir le grain
Les tableaux peuvent multiplier les enregistrements.
3. Utiliser JSON pour de grands parcours analytiques répétés
Normalisez une seule fois et écrivez des données en colonnes.
4. Traiter Parquet comme une table transactionnelle
Parquet seul ne fournit pas de sémantique de table ACID.
5. Considérer Delta comme un encodage de remplacement de Parquet
Delta utilise des fichiers de données Parquet plus un journal des transactions.
6. Lire directement des fichiers Delta comme du Parquet ordinaire
Vous risquez d’ignorer l’état de la table et les fichiers retirés.
7. Partitionner par des identifiants à forte cardinalité
Cela crée un nombre excessif de répertoires/fichiers.
8. Créer un unique fichier de sortie gigantesque
Cela peut réduire le parallélisme et accroître le risque opérationnel.
9. Laisser l’inférence de schéma définir les contrats de production
Le schéma peut dériver de façon inattendue.
10. Choisir un seul format pour toutes les couches
L’échange avec la source, le stockage brut, l’analytique organisée et la livraison externe nécessitent souvent des formats différents.
Ce contenu vous a-t-il été utile ?
Que pourrions-nous améliorer ?
Merci — cela m’aide à améliorer Javi Builds.
Restez au courant
Recevez uniquement les nouvelles de Javi Builds qui vous intéressent.
Consultez votre boîte de réception
Je vous ai envoyé un lien de confirmation. Votre abonnement sera actif après confirmation.