Parcourir les aide-mémoire · Ingénierie des données

Technologie: Ingénierie des donnéesCatégorie: Stockage et formats de fichiersNiveau: IntermédiaireMis à jour

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
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. CSV : lire et écrire avec pandas
  5. 2. CSV : définir les types explicitement
  6. 3. CSV : traiter délibérément les valeurs nulles
  7. 4. CSV : préciser l’encodage si nécessaire
  8. 5. CSV : utiliser des blocs pour les gros fichiers
  9. 6. CSV : valider la forme des lignes
  10. 7. CSV : les guillemets comptent
  11. 8. CSV : le délimiteur fait partie du contrat
  12. 9. CSV : points forts
  13. 10. JSON : lire du JSON délimité par des sauts de ligne avec pandas
  14. 11. JSON Lines est préférable à un gigantesque tableau JSON pour les fichiers de type flux
  15. 12. Tableau JSON standard
  16. 13. JSON : structure imbriquée
  17. 14. Aplatir le JSON imbriqué avec précaution
  18. 15. Les tableaux JSON peuvent modifier le grain des données
  19. 16. JSON : utiliser des horodatages explicites
  20. 17. JSON : le schéma est flexible, pas inexistant
  21. 18. JSON : éviter les documents gigantesques et profondément imbriqués pour l’analytique
  22. 19. JSON : points forts
  23. 20. Parquet : lire avec pandas
  24. 21. Parquet : écrire avec pandas
  25. 22. Parquet : lire avec PySpark
  26. 23. Parquet : sélectionner uniquement les colonnes nécessaires
  27. 24. Parquet : filtrer tôt
  28. 25. Parquet stocke des données typées en colonnes
  29. 26. Parquet est adapté à l’analytique
  30. 27. Parquet reste un ensemble de fichiers
  31. 28. Partitionner Parquet délibérément
  32. 29. Éviter les partitions à très forte cardinalité
  33. 30. Éviter les fichiers Parquet minuscules
  34. 31. Éviter un unique fichier Parquet gigantesque
  35. 32. Compression Parquet
  36. 33. L’évolution du schéma Parquet n’est pas un protocole transactionnel
  37. 34. Delta : ce qu’il apporte
  38. 35. Delta : lire une table avec PySpark
  39. 36. Delta : ajout (append)
  40. 37. Delta : écraser délibérément
  41. 38. Delta : MERGE
  42. 39. Un MERGE Delta exige des clés source déterministes
  43. 40. Delta prend en charge les suppressions
  44. 41. Delta prend en charge les mises à jour
  45. 42. Historique d’une table Delta
  46. 43. Voyage dans le temps Delta
  47. 44. VACUUM affecte la capacité de récupération historique
  48. 45. Delta n’est pas un serveur de base de données
  49. 46. Delta n’est pas « un autre type de fichier qui remplace Parquet »
  50. 47. Ne pas modifier directement les fichiers de données Delta
  51. 48. Ne pas traiter à la légère un répertoire Delta comme du Parquet ordinaire
  52. 49. Exemple de parcours CSV vs Parquet
  53. 50. JSON vs Parquet pour les journaux
  54. 51. CSV vs JSON pour l’échange
  55. 52. Parquet vs Delta
  56. 53. CSV devrait rarement être le format analytique organisé
  57. 54. JSON devrait rarement être le format analytique final à fort volume
  58. 55. Conserver la source brute lorsque la traçabilité compte
  59. 56. Ajouter des métadonnées d’ingestion
  60. 57. Valider explicitement le schéma
  61. 58. Valider les types de données après l’analyse
  62. 59. Utiliser un schéma explicite pour l’ingestion Spark
  63. 60. Éviter l’inférence de schéma à chaque exécution en production
  64. 61. Les données décimales méritent des types explicites
  65. 62. Les dates et horodatages exigent une sémantique de fuseau horaire claire
  66. 63. CSV ne distingue pas nativement les types
  67. 64. JSON a des types mais reste ambigu
  68. 65. Parquet conserve des types physiques plus riches
  69. 66. La compression dépend du format
  70. 67. Un CSV compressé en gzip peut être petit mais rester coûteux à interroger
  71. 68. La divisibilité compte pour le traitement distribué
  72. 69. Éviter un fichier par ligne/événement
  73. 70. Les problèmes de petits fichiers sont des problèmes opérationnels
  74. 71. Format de fichier et organisation de la table sont des décisions distinctes
  75. 72. Format et compression sont des décisions distinctes
  76. 73. Format et sémantique de table sont des décisions distinctes
  77. 74. Éviter d’écrire en Delta si les consommateurs ne comprennent que le Parquet brut
  78. 75. Choisir le format d’échange selon le consommateur
  79. 76. Ne pas faire de CSV la source de vérité interne simplement parce que les utilisateurs veulent des exports CSV
  80. 77. Ne pas faire de JSON la source de vérité uniquement parce que l’API source utilise JSON
  81. 78. Combiner des données brutes immuables et des tables organisées mutables
  82. 79. Valider les allers-retours lorsque l’interopérabilité compte
  83. 80. Choisir selon la charge de travail, pas la popularité
  84. Interpréter le résultat
  85. Points à vérifier
  86. Les colonnes CSV changent de type d’une exécution à l’autre
  87. Le nombre de lignes JSON augmente de façon inattendue après l’aplatissement
  88. Une requête Parquet parcourt encore trop de données
  89. Un MERGE Delta échoue ou se comporte de façon ambiguë
  90. Le voyage dans le temps Delta n’atteint plus une ancienne version
  91. Le stockage contient des millions de fichiers minuscules
  92. Notes de production
  93. Les formats d’échange et les formats analytiques servent des objectifs différents
  94. Le schéma doit être explicite
  95. Delta exige des lecteurs/écrivains compatibles avec Delta
  96. L’organisation des fichiers peut compter autant que le format
  97. La rétention affecte la capacité de récupération
  98. Les consommateurs externes définissent les contraintes d’interopérabilité
  99. Erreurs fréquentes
  100. 1. Traiter CSV comme des données typées
  101. 2. Aplatir du JSON sans définir le grain
  102. 3. Utiliser JSON pour de grands parcours analytiques répétés
  103. 4. Traiter Parquet comme une table transactionnelle
  104. 5. Considérer Delta comme un encodage de remplacement de Parquet
  105. 6. Lire directement des fichiers Delta comme du Parquet ordinaire
  106. 7. Partitionner par des identifiants à forte cardinalité
  107. 8. Créer un unique fichier de sortie gigantesque
  108. 9. Laisser l’inférence de schéma définir les contrats de production
  109. 10. Choisir un seul format pour toutes les couches
  110. Étape suivante
  111. 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.

Étape suivante

Choisissez en fonction de la charge de travail.

  • Besoin d’un export/import simple de données plates → utilisez CSV.
  • Besoin de charges utiles d’API/d’événements imbriquées → utilisez JSON/JSON Lines.
  • Besoin de parcours analytiques efficaces sur des données immuables → utilisez Parquet.
  • Besoin de MERGE, de mises à jour, de suppressions, de concurrence et d’historique → utilisez Delta.
  • L’ingestion CSV/JSON est lente de façon répétée → normalisez une seule fois en Parquet/Delta.
  • Les requêtes Parquet restent lentes → examinez le partitionnement, l’élagage, les colonnes sélectionnées et l’organisation des fichiers.
  • Les écritures Delta entrent en conflit → examinez la concurrence et les modèles d’écriture.
  • Le voyage dans le temps compte → définissez une politique de rétention/VACUUM pour Delta.
  • Les consommateurs externes ne savent pas lire Delta → exportez dans un format interopérable adapté.
  • Besoin d’une conception plus large de la couche de tables → passez à Architecture Medallion : référence rapide.

← Tous les aide-mémoire