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

Technologie: Ingénierie des donnéesCatégorie: Stockage et performanceNiveau: IntermédiaireMis à jour

Stratégies de partitionnement

Choisir et valider des stratégies de partitionnement des données qui améliorent l’élagage, le parallélisme, la maintenance et le coût, sans créer de skew, de fichiers minuscules ni d’organisations à forte cardinalité.

Sur cette page
  1. Problème
  2. Réponse rapide
  3. Code / commandes
  4. 1. Partitionner par une date métier quand le traitement est borné par date
  5. 2. Partitionner sur la colonne utilisée pour filtrer
  6. 3. Éviter de partitionner par des identifiants uniques
  7. 4. Éviter de partitionner par un horodatage brut
  8. 5. Dériver explicitement une date de partition
  9. 6. Partitionner par plusieurs colonnes uniquement si c’est justifié
  10. 7. Réfléchir au nombre de partitions avant d’écrire
  11. 8. Vérifier la cardinalité des partitions dans PySpark
  12. 9. Vérifier la distribution des partitions sur plusieurs colonnes
  13. 10. Mesurer le skew avant de choisir la clé
  14. 11. Ne pas confondre partitionnement de table et partitions Spark
  15. 12. Inspecter le nombre de partitions d’exécution Spark
  16. 13. Inspecter le nombre de lignes par partition Spark
  17. 14. Repartitionner par une clé lorsque la redistribution est réellement nécessaire
  18. 15. Repartitionner sans clé pour répartir les données plus uniformément
  19. 16. Utiliser coalesce pour réduire les partitions sans shuffle complet
  20. 17. Éviter repartition(1) dans les pipelines de production
  21. 18. Ne pas utiliser coalesce(1) comme solution universelle pour obtenir « un seul fichier CSV »
  22. 19. Le partitionnement par date convient naturellement aux chargements incrémentaux
  23. 20. Le partitionnement peut simplifier la rétention
  24. 21. Ne pas supposer que la suppression d’une partition est toujours une opération purement métadonnées
  25. 22. Utiliser explicitement des filtres de partition
  26. 23. Éviter d’envelopper les colonnes de partition dans des fonctions inutiles
  27. 24. Vérifier l’élagage des partitions avec explain
  28. 25. Vérifier les filtres appliqués avec un mauvais type de données
  29. 26. Le partitionnement ne remplace pas les statistiques de fichiers
  30. 27. Partitionnement et clustering résolvent des problèmes différents
  31. 28. Utiliser des colonnes de partition à cardinalité faible ou moyenne
  32. 29. Le partitionnement par locataire peut être utile mais risqué
  33. 30. Date + locataire peut faire exploser le nombre de partitions
  34. 31. Le partitionnement mensuel peut surpasser le partitionnement quotidien pour les petits jeux de données
  35. 32. Le partitionnement horaire peut se justifier pour de très gros volumes
  36. 33. Le partitionnement à la minute est rarement approprié
  37. 34. Partitionner par des valeurs immuables lorsque c’est possible
  38. 35. Ne pas partitionner par un statut modifiable
  39. 36. Date d’ingestion et date d’événement servent des objectifs différents
  40. 37. Les données arrivant en retard compliquent le partitionnement par date d’événement
  41. 38. Le partitionnement par date d’ingestion simplifie les modèles d’ajout
  42. 39. Envisager deux colonnes de date sans double partitionnement
  43. 40. Éviter de partitionner par chaque filtre courant
  44. 41. Les petits fichiers peuvent anéantir les bénéfices du partitionnement
  45. 42. Vérifier le nombre de fichiers par partition
  46. 43. Compacter les petits fichiers lorsque la plateforme le permet
  47. 44. Éviter de réécrire toutes les partitions pour la modification d’une seule journée
  48. 45. L’écrasement de partition doit être maîtrisé
  49. 46. Les rechargements historiques doivent cibler des plages de partitions explicites
  50. 47. Valider le nombre de lignes par partition après un rechargement historique
  51. 48. Rapprocher les indicateurs métier par partition
  52. 49. L’élagage des partitions n’aide que si la requête utilise la colonne de partition
  53. 50. Encourager les requêtes bornées
  54. 51. Éviter les analyses complètes accidentelles
  55. 52. Le partitionnement ne remplace pas l’élagage des colonnes
  56. 53. Le partitionnement ne remplace pas le filtrage précoce
  57. 54. Le partitionnement ne corrige pas une mauvaise jointure
  58. 55. Le partitionnement ne corrige pas automatiquement le skew de la source
  59. 56. Recourir au salage uniquement si le skew est réel et justifie la complexité
  60. 57. Ne pas saler les partitions de stockage à la légère
  61. 58. Le partitionnement par hachage peut répartir la charge uniformément
  62. 59. Le partitionnement par plages aide les données ordonnées
  63. 60. Le partitionnement par liste convient aux catégories connues
  64. 61. La stratégie de partitionnement doit intégrer les prévisions de croissance
  65. 62. Tenir compte des partitions vides ou clairsemées
  66. 63. Garder les colonnes de partition visibles dans les métadonnées de la table
  67. 64. Ne pas rendre les consommateurs dépendants des chemins physiques des répertoires
  68. 65. Partitionnement et rétention doivent s’aligner autant que possible
  69. 66. Le partitionnement peut améliorer l’isolation des défaillances
  70. 67. Consigner la portée des partitions dans les journaux d’exécution
  71. 68. Détecter les partitions manquantes
  72. 69. Détecter les chargements de partition en double
  73. 70. Traiter les colonnes de partition comme faisant partie du contrat de données
  74. 71. Repartitionner une grande table existante est une migration
  75. 72. Valider avant et après le repartitionnement
  76. 73. Ne pas supposer que plus de partitions signifie plus de parallélisme
  77. 74. Ne pas supposer que moins de partitions est toujours mieux
  78. 75. Adapter le partitionnement aux opérations de maintenance
  79. 76. Adapter le partitionnement à la sécurité uniquement si la plateforme l’applique correctement
  80. 77. Le partitionnement peut interagir avec la concurrence
  81. 78. Éviter les écrasements complets et concurrents de la table
  82. 79. Partitionner par système source uniquement si cela aide l’exploitation
  83. 80. Utiliser une liste de vérification de décision reproductible
  84. Interpréter le résultat
  85. Points à vérifier
  86. Les requêtes analysent encore la plupart des données
  87. Trop de fichiers minuscules
  88. Une partition est beaucoup plus volumineuse que les autres
  89. Les rechargements historiques sont coûteux
  90. Les partitions quotidiennes sont presque vides
  91. Les requêtes filtrent fréquemment une colonne à forte cardinalité
  92. Notes de production
  93. Le partitionnement est un choix de conception physique
  94. L’élagage des partitions doit être vérifié
  95. Taille des fichiers et partitionnement doivent être considérés ensemble
  96. L’organisation des partitions doit évoluer lentement
  97. Éviter les chiffres magiques indépendants de la plateforme
  98. Erreurs fréquentes
  99. 1. Partitionner par chaque colonne de filtre
  100. 2. Partitionner par des identifiants uniques
  101. 3. Partitionner par un horodatage brut
  102. 4. Utiliser repartition(1) pour créer un seul fichier de sortie
  103. 5. Confondre partitions d’exécution Spark et partitions de table
  104. 6. Supposer que le partitionnement corrige le skew
  105. 7. Ignorer les petits fichiers
  106. 8. Reconstruire toute la table pour des modifications limitées à une partition
  107. 9. Choisir des colonnes de partition sans preuve tirée des requêtes
  108. 10. Traiter les partitions physiques comme une frontière de sécurité
  109. Étape suivante
  110. Pour aller plus loin

Problème

Le partitionnement peut rendre le traitement de grands jeux de données analytiques plus rapide et moins coûteux, mais un mauvais partitionnement produit souvent l’effet inverse.

Les problèmes courants sont notamment :

  • des requêtes qui analysent trop de données
  • des millions de fichiers minuscules
  • une partition chaude qui porte l’essentiel de la charge
  • des colonnes de partition trop granulaires
  • des pipelines quotidiens qui réécrivent d’énormes portions d’une table
  • des filtres qui ne s’alignent pas sur les limites des partitions
  • des organisations à forte cardinalité, coûteuses à lister et à maintenir
  • des partitions choisies par habitude plutôt qu’à partir de données réelles sur la charge

L’objectif est de partitionner en fonction de la façon dont les données sont filtrées, écrites, maintenues et mises à l’échelle, et non simplement en fonction des colonnes disponibles.

Réponse rapide

Utilisez ce modèle de décision :

Les requêtes filtrent couramment sur une colonne stable à cardinalité faible/moyenne
→ envisager de partitionner sur cette colonne

Les données sont naturellement traitées/reconstruites par date
→ le partitionnement par date est souvent utile

Identifiant à très forte cardinalité
→ en général, ne pas partitionner dessus

Une partition reçoit la majorité des lignes
→ repartitionner par cette clé créera probablement du skew

Le jeu de données est assez petit pour être analysé efficacement
→ ne pas partitionner simplement parce que la plateforme le permet

Un bon premier test consiste à se demander :

1. Quels filtres éliminent le plus de données ?
2. Quelles limites sont utilisées pour les chargements incrémentiels/backfills ?
3. Combien de partitions existeront ?
4. Combien de fichiers chaque partition contiendra-t-elle ?
5. Les partitions sont-elles suffisamment équilibrées pour le traitement parallèle ?

Code / commandes

1. Partitionner par une date métier quand le traitement est borné par date

Exemple d’organisation :

/orders/order_date=2026-10-01/
/orders/order_date=2026-10-02/
/orders/order_date=2026-10-03/

C’est utile lorsque les charges de travail courantes sont :

ingestion quotidienne
rapprochement quotidien
reporting par plage de dates
backfills limités à une date

Une requête telle que :

WHERE order_date >= '2026-10-01'
  AND order_date <  '2026-10-08'

peut permettre au moteur d’ignorer les partitions de dates sans rapport.


2. Partitionner sur la colonne utilisée pour filtrer

Bon alignement :

colonne de partition
→ order_date

filtre courant
→ WHERE order_date = '2026-10-04'

Mauvais alignement :

colonne de partition
→ country

filtre courant
→ WHERE created_at >= ...

Le partitionnement n’aide l’élagage que si la requête peut éliminer des partitions.


3. Éviter de partitionner par des identifiants uniques

Choix généralement mauvais :

order_id
transaction_id
session_id
customer_email
request_id

Pourquoi :

forte cardinalité
→ nombre énorme de partitions
→ partitions/fichiers minuscules
→ surcharge de métadonnées
→ planification coûteuse des répertoires/de la table

Utilisez plutôt ces champs comme colonnes de données, index, clés de clustering ou clés de tri, lorsque la plateforme prend en charge ces fonctionnalités.


4. Éviter de partitionner par un horodatage brut

Mauvais :

event_timestamp=2026-10-04T14:37:21.123456Z

Cela peut créer une partition par valeur d’horodatage.

Mieux :

event_date=2026-10-04

ou, uniquement lorsque le volume et les modèles d’accès le justifient :

event_hour=2026-10-04-14

Choisissez la limite utile la plus grossière.


5. Dériver explicitement une date de partition

PySpark :

from pyspark.sql import functions as F

df = df.withColumn(
    "event_date",
    F.to_date("event_time"),
)

Puis écrivez :

(
    df.write
    .format("delta")
    .mode("append")
    .partitionBy("event_date")
    .saveAsTable("bronze.events")
)

N’utilisez cette approche que si le partitionnement par date correspond au modèle de lecture/écriture.


6. Partitionner par plusieurs colonnes uniquement si c’est justifié

Exemple :

event_date
+
region

peut être utile si :

les requêtes filtrent presque toujours sur les deux
et
chaque combinaison contient suffisamment de données

Mais cela peut rapidement multiplier le nombre de partitions.

Exemple :

365 dates
×
50 régions
=
18 250 partitions/an

Le calcul est simple ; savoir si c’est raisonnable dépend du volume et du comportement de la plateforme.


7. Réfléchir au nombre de partitions avant d’écrire

Estimez :

nombre de combinaisons distinctes de valeurs de partition

Exemple :

date
→ 365/an

date + pays
→ 365 × number_of_countries

date + customer_id
→ potentiellement des millions

Évitez de créer une organisation de répertoires/table qui croît avec une dimension à forte cardinalité non maîtrisée.


8. Vérifier la cardinalité des partitions dans PySpark

from pyspark.sql import functions as F

df.groupBy("event_date").agg(
    F.count("*").alias("rows")
).orderBy(
    F.desc("rows")
).show(100, truncate=False)

Cela aide à révéler une distribution inégale.


9. Vérifier la distribution des partitions sur plusieurs colonnes

(
    df.groupBy(
        "event_date",
        "region",
    )
    .agg(
        F.count("*").alias("rows")
    )
    .orderBy(
        F.desc("rows")
    )
    .show(100, truncate=False)
)

Recherchez les combinaisons dont le nombre de lignes diffère fortement.


10. Mesurer le skew avant de choisir la clé

Exemple :

stats = (
    df.groupBy("merchant_id")
    .count()
    .orderBy(F.desc("count"))
)

stats.show(50, truncate=False)

Si quelques marchands dominent les données, partitionner par merchant_id peut créer des partitions chaudes.


11. Ne pas confondre partitionnement de table et partitions Spark

Ce sont des concepts différents.

Partitionnement de table/stockage :

event_date=2026-10-04/

Partitionnement d’exécution Spark :

façon dont les lignes sont réparties entre les tâches

Une table peut être partitionnée par date tandis que Spark utilise de nombreuses partitions d’exécution au sein d’une même date.


12. Inspecter le nombre de partitions d’exécution Spark

df.rdd.getNumPartitions()

Cela vous indique le nombre de partitions d’exécution du DataFrame courant.

Cela ne vous indique pas l’organisation des partitions de stockage de la table.


13. Inspecter le nombre de lignes par partition Spark

from pyspark.sql import functions as F

partition_rows = (
    df.withColumn(
        "_spark_partition_id",
        F.spark_partition_id(),
    )
    .groupBy("_spark_partition_id")
    .count()
    .orderBy(F.desc("count"))
)

partition_rows.show(100, truncate=False)

Utilisez cette requête pour détecter le skew d’exécution.


14. Repartitionner par une clé lorsque la redistribution est réellement nécessaire

df2 = df.repartition(
    200,
    "customer_id",
)

À utiliser lorsqu’une opération en aval tire profit de la colocalisation des lignes ayant la même clé.

Ne choisissez pas 200 à l’aveugle ; le bon nombre dépend de la taille des données et des ressources du cluster.


15. Repartitionner sans clé pour répartir les données plus uniformément

df2 = df.repartition(200)

Cette opération déclenche un shuffle.

À utiliser lorsque vous avez réellement besoin d’un nombre plus homogène de partitions d’exécution.

Ne repartitionnez pas systématiquement dans chaque pipeline.


16. Utiliser coalesce pour réduire les partitions sans shuffle complet

df2 = df.coalesce(20)

Utile après un filtrage important, lorsque le DataFrame contient de nombreuses partitions presque vides.

coalesce convient généralement pour réduire le nombre de partitions, pas pour équilibrer des données fortement asymétriques.


17. Éviter repartition(1) dans les pipelines de production

df.repartition(1)

force toute la sortie à passer par une seule partition d’exécution.

Conséquences typiques :

goulot d’étranglement sur une seule tâche
parallélisme médiocre
risque de fichiers volumineux
écritures lentes

À réserver aux sorties volontairement minuscules, lorsqu’un fichier unique est une véritable exigence.


18. Ne pas utiliser coalesce(1) comme solution universelle pour obtenir « un seul fichier CSV »

Si un consommateur externe a besoin d’un seul fichier, envisagez une étape d’export distincte.

Ne réduisez pas un grand pipeline distribué à une seule tâche simplement pour la commodité du nommage.


19. Le partitionnement par date convient naturellement aux chargements incrémentaux

Exemple :

charger les données du jour
→ écrire la partition du jour

Cela aligne les limites d’ingestion et de maintenance.

Cela facilite aussi les rechargements historiques (backfills) maîtrisés :

retraiter une date

au lieu de réécrire toute la table.


20. Le partitionnement peut simplifier la rétention

Exemple :

event_date < retention_cutoff

Si les données sont partitionnées par date, les opérations de rétention peuvent souvent cibler plus naturellement les anciennes partitions de dates.

Le comportement exact de la suppression (delete/drop) dépend de la technologie de stockage/table.


21. Ne pas supposer que la suppression d’une partition est toujours une opération purement métadonnées

Dans les formats de table modernes, les suppressions peuvent encore impliquer :

  • des mises à jour du journal des transactions
  • des marqueurs de suppression de fichiers
  • un vacuum/nettoyage ultérieur
  • des contrôles de concurrence

Utilisez les opérations prises en charge par le format de table.


22. Utiliser explicitement des filtres de partition

Bon :

df = (
    spark.read
    .table("silver.orders")
    .filter(
        (F.col("order_date") >= F.lit("2026-10-01")) &
        (F.col("order_date") <  F.lit("2026-11-01"))
    )
)

Cela fournit à l’optimiseur un prédicat de partition direct.


23. Éviter d’envelopper les colonnes de partition dans des fonctions inutiles

Modèle potentiellement moins favorable à l’élagage :

WHERE YEAR(order_date) = 2026

Plus direct :

WHERE order_date >= '2026-01-01'
  AND order_date <  '2027-01-01'

Les prédicats directs sont généralement plus faciles à analyser pour les optimiseurs.

Vérifiez l’élagage réel dans le plan d’exécution.


24. Vérifier l’élagage des partitions avec explain

PySpark :

filtered = (
    spark.read
    .table("silver.orders")
    .filter("order_date = '2026-10-04'")
)

filtered.explain("formatted")

Vérifiez si les filtres de partition sont appliqués.

Ne supposez pas que l’élagage a eu lieu simplement parce que la table est partitionnée.


25. Vérifier les filtres appliqués avec un mauvais type de données

Si la colonne de partition est une date mais que le client transmet des chaînes mal formées, l’élagage et l’exactitude des résultats peuvent en souffrir.

Utilisez des types compatibles.

Exemple :

from pyspark.sql import functions as F

filtered = df.filter(
    F.col("order_date") == F.to_date(
        F.lit("2026-10-04")
    )
)

26. Le partitionnement ne remplace pas les statistiques de fichiers

Les formats en colonnes et les moteurs de table peuvent aussi utiliser :

  • des statistiques min/max
  • le data skipping (saut de données)
  • le clustering
  • le tri

Une colonne non partitionnée peut rester efficace pour les requêtes si l’organisation physique le permet.

Ne transformez pas chaque colonne de filtre en colonne de partition.


27. Partitionnement et clustering résolvent des problèmes différents

Partitionnement :

subdivision grossière en répertoires/de la table

Clustering/tri/organisation des données :

organise les données dans/entre les fichiers pour améliorer le saut de données

Si une colonne est fréquemment filtrée mais de cardinalité trop élevée pour le partitionnement, le clustering peut être mieux adapté lorsqu’il est pris en charge.


28. Utiliser des colonnes de partition à cardinalité faible ou moyenne

Les candidates souvent pertinentes sont notamment :

date
mois
région
source_system
tenant_group
environnement

uniquement si elles s’alignent sur le filtrage et le volume de données.

Le bon choix dépend de la charge de travail.


29. Le partitionnement par locataire peut être utile mais risqué

Partitionnez par locataire (tenant) uniquement lorsque :

  • le nombre de locataires est suffisamment borné
  • l’isolation des requêtes est importante
  • le volume par locataire est significatif

Risques :

des milliers/millions de locataires
→ trop de partitions

un locataire énorme
→ skew sévère

30. Date + locataire peut faire exploser le nombre de partitions

Exemple :

10 000 locataires
×
365 jours
=
3,65 millions de combinaisons/an

Même si beaucoup sont vides, cette conception est un signal d’alerte.

Préférez un regroupement plus grossier ou une autre stratégie d’organisation.


31. Le partitionnement mensuel peut surpasser le partitionnement quotidien pour les petits jeux de données

Si le volume quotidien est minime, les partitions quotidiennes peuvent créer trop de petits fichiers.

Mensuel :

2026-10

peut être préférable lorsque :

  • les requêtes couvrent généralement plusieurs mois
  • l’élagage quotidien n’est pas nécessaire
  • le volume quotidien est faible

Choisissez la granularité en fonction du volume de données et des modèles de requêtes.


32. Le partitionnement horaire peut se justifier pour de très gros volumes

Exemple :

event_date=2026-10-04/
event_hour=14/

À utiliser uniquement lorsque :

  • chaque heure contient encore un volume de données substantiel
  • les requêtes/rechargements historiques portent souvent sur une heure précise
  • les partitions quotidiennes sont trop volumineuses pour être gérées efficacement

N’utilisez pas le partitionnement horaire par défaut pour les données d’événements.


33. Le partitionnement à la minute est rarement approprié

À moins que le volume de données et les modèles d’accès soient extrêmes, les partitions à la minute créent généralement un excès de métadonnées et une fragmentation des fichiers.

Préférez un partitionnement plus grossier associé aux statistiques au niveau des fichiers.


34. Partitionner par des valeurs immuables lorsque c’est possible

Si la clé de partition change :

changements de région
changements de classification client

la ligne peut devoir passer d’une partition à une autre.

Les clés fondées sur la date d’événement ou la date d’ingestion sont souvent plus simples, car elles sont stables.


35. Ne pas partitionner par un statut modifiable

Mauvaise candidate :

status = pending / complete / cancelled

Les lignes changent fréquemment de statut.

Cela entraîne des réécritures de fichiers et une charge de maintenance.

Utilisez-la plutôt comme colonne ordinaire ou comme dimension de clustering.


36. Date d’ingestion et date d’événement servent des objectifs différents

event_date :

moment où l’événement métier s’est produit

ingestion_date :

moment où la plateforme l’a reçu

Le choix de partition dépend :

  • du modèle de requêtes
  • du modèle de rejeu
  • des données arrivant en retard
  • de la rétention

Ne les traitez pas comme interchangeables.


37. Les données arrivant en retard compliquent le partitionnement par date d’événement

Exemple :

event_date = 2026-10-01
arrive le 2026-10-04

Si la table est partitionnée par event_date, le pipeline doit écrire dans une partition plus ancienne.

C’est souvent acceptable, mais prévoyez :

  • la concurrence
  • le chevauchement des rechargements historiques
  • le coût de réécriture/mise à jour des partitions

38. Le partitionnement par date d’ingestion simplifie les modèles d’ajout

Si toutes les nouvelles arrivées atterrissent sous :

ingestion_date = aujourd’hui

les écritures sont naturellement orientées ajout (append).

Mais les requêtes métier qui filtrent par date d’événement peuvent analyser davantage de données.

Choisissez en fonction de la charge de travail dominante.


39. Envisager deux colonnes de date sans double partitionnement

Vous pouvez stocker :

event_date
ingestion_date

mais ne partitionner que par l’une d’elles.

L’autre reste interrogeable et peut bénéficier des statistiques de fichiers/du clustering.


40. Éviter de partitionner par chaque filtre courant

Si les utilisateurs filtrent par :

date
pays
marchand
produit
canal
statut

vous ne devez pas créer une organisation de partitions sur six colonnes.

Le partitionnement est un découpage grossier.

Utilisez d’autres techniques d’optimisation pour les dimensions supplémentaires.


41. Les petits fichiers peuvent anéantir les bénéfices du partitionnement

Exemple :

event_date=2026-10-04/
  25 000 fichiers

Même si l’élagage fonctionne, le coût de planification des requêtes et d’ouverture des fichiers peut rester élevé.

Partitionnement et dimensionnement des fichiers doivent être conçus ensemble.


42. Vérifier le nombre de fichiers par partition

Les méthodes exactes varient selon la plateforme.

Sur le principe, collectez :

valeur de partition
nombre de fichiers
octets totaux
taille moyenne des fichiers

Recherchez :

beaucoup de fichiers minuscules
un fichier géant
fort déséquilibre

43. Compacter les petits fichiers lorsque la plateforme le permet

Pour Delta Lake, une opération de maintenance peut être :

OPTIMIZE silver.orders;

La prise en charge et le comportement varient selon la plateforme.

Ne planifiez pas un compactage agressif à l’aveugle ; mesurez si les petits fichiers sont réellement le problème.


44. Éviter de réécrire toutes les partitions pour la modification d’une seule journée

Mauvais modèle :

lire toute la table
unir les nouvelles données
écraser toute la table

Préférez un ajout ciblé, un MERGE ou le remplacement de partition lorsque la sémantique de la table le permet.


45. L’écrasement de partition doit être maîtrisé

Si vous remplacez une partition, assurez-vous que la portée de l’écriture ne peut pas remplacer accidentellement des données sans rapport.

Utilisez l’écrasement dynamique de partitions, le remplacement fondé sur un prédicat ou les opérations de table transactionnelles prises en charge par votre plateforme.

Ne vous fiez pas à des scripts fragiles de suppression de chemins.


46. Les rechargements historiques doivent cibler des plages de partitions explicites

Exemple :

2026-09-01
au
2026-09-07

Consignez la plage exacte dans les métadonnées du job.

N’exécutez pas un processus illimité de type « reconstruire les données récentes » sans limite déterministe.


47. Valider le nombre de lignes par partition après un rechargement historique

Exemple :

(
    df.groupBy("event_date")
    .agg(F.count("*").alias("rows"))
    .orderBy("event_date")
    .show(100, truncate=False)
)

Comparez avec les volumes attendus de la source.


48. Rapprocher les indicateurs métier par partition

Pour les données financières ou de commandes, le nombre de lignes seul ne suffit pas.

Exemple :

(
    df.groupBy("order_date")
    .agg(
        F.count("*").alias("rows"),
        F.sum("amount").alias("amount"),
    )
    .orderBy("order_date")
)

Cela aide à détecter des données dupliquées ou manquantes après des écritures limitées à une partition.


49. L’élagage des partitions n’aide que si la requête utilise la colonne de partition

Si la plupart des requêtes sont :

WHERE customer_id = 123

mais que la table n’est partitionnée que par :

order_date

alors le partitionnement par date peut ne pas réduire l’analyse, sauf si un filtre de date est également fourni.

Comprenez le comportement réel des requêtes.


50. Encourager les requêtes bornées

Pour les grandes tables de faits, exigez des consommateurs qu’ils fournissent une limite de date utile lorsque c’est possible.

Exemple de contrat d’API/de rapport :

start_date
end_date

Cela permet à la couche de stockage d’élaguer les données de façon intentionnelle.


51. Éviter les analyses complètes accidentelles

Mauvais :

SELECT *
FROM huge_fact_table;

Mieux :

SELECT
    order_id,
    order_date,
    amount
FROM huge_fact_table
WHERE order_date >= '2026-10-01'
  AND order_date <  '2026-11-01';

Le partitionnement ne peut pas vous protéger contre toutes les requêtes non bornées.


52. Le partitionnement ne remplace pas l’élagage des colonnes

Même au sein des partitions sélectionnées, lire des colonnes inutiles coûte des E/S.

Utilisez les deux :

élagage des partitions
+
élagage des colonnes

53. Le partitionnement ne remplace pas le filtrage précoce

Appliquez les filtres les plus sélectifs avant :

  • les jointures
  • les agrégations
  • les shuffles

lorsque la sémantique le permet.

Le partitionnement du stockage aide la lecture en entrée, pas chaque étape ultérieure.


54. Le partitionnement ne corrige pas une mauvaise jointure

Si une jointure multiplie les lignes de façon inattendue, le partitionnement risque seulement de produire plus vite le mauvais résultat.

Validez d’abord :

clés de jointure
cardinalité
granularité de sortie

55. Le partitionnement ne corrige pas automatiquement le skew de la source

Si une clé détient la plupart des enregistrements :

merchant_id = 1
→ 60 % des lignes

partitionner par cette clé peut concentrer le travail.

Mesurez d’abord la distribution.


56. Recourir au salage uniquement si le skew est réel et justifie la complexité

En cas de skew extrême sur une jointure ou une agrégation, le salage (salting) peut répartir une clé chaude sur plusieurs clés dérivées.

Exemple de principe :

merchant_id=1
→ 1_0, 1_1, 1_2, ...

Cela ajoute de la complexité et nécessite souvent une seconde étape d’agrégation.

N’y recourez qu’après avoir confirmé le skew lors de l’exécution réelle.


57. Ne pas saler les partitions de stockage à la légère

Le salage est avant tout une technique d’exécution/de jointure.

Créer des partitions de stockage physiques aléatoires peut compliquer les requêtes et la maintenance.


58. Le partitionnement par hachage peut répartir la charge uniformément

Sur le principe :

hash(customer_id) % N

peut produire des compartiments (buckets) plus équilibrés.

Utile dans certains systèmes de stockage/traitement.

Mais cela réduit généralement l’élagage intuitif pour les requêtes par date ou par plage.

Choisissez en fonction du moteur et de la charge de travail.


59. Le partitionnement par plages aide les données ordonnées

Exemple :

customer_id 1–1,000,000
customer_id 1,000,001–2,000,000

Le partitionnement par plages peut s’aligner sur des modèles d’accès ordonnés.

Faites attention lorsque les nouvelles données se concentrent à une extrémité de la plage.


60. Le partitionnement par liste convient aux catégories connues

Exemple :

region = US
region = EU
region = APAC

Utile lorsque les catégories sont stables et suffisamment équilibrées.

Si une catégorie domine, le parallélisme peut en pâtir.


61. La stratégie de partitionnement doit intégrer les prévisions de croissance

Demandez-vous :

Combien de partitions aujourd’hui ?
Combien dans 1 an ?
Combien dans 5 ans ?

Une conception qui semble correcte avec 100 locataires peut échouer avec 100 000.


62. Tenir compte des partitions vides ou clairsemées

Le nombre théorique de partitions peut être bien supérieur au nombre de partitions effectivement remplies.

Néanmoins, les organisations clairsemées à forte cardinalité sont souvent un signal d’alerte, car les métadonnées et la structure des répertoires peuvent croître de façon imprévisible.


63. Garder les colonnes de partition visibles dans les métadonnées de la table

Les utilisateurs doivent pouvoir découvrir :

colonne(s) de partitionnement de la table

sans inspecter manuellement les chemins de stockage.

Utilisez les métadonnées du catalogue/de la table et la documentation.


64. Ne pas rendre les consommateurs dépendants des chemins physiques des répertoires

Un consommateur doit interroger :

table + prédicat de partition

et non construire des chemins de stockage internes, sauf si le contrat exige explicitement un accès au niveau des chemins.

Cela permet de garder l’organisation de la table modifiable.


65. Partitionnement et rétention doivent s’aligner autant que possible

Si la politique est :

conserver 13 mois

et que la table est partitionnée par mois/date, le nettoyage peut être plus simple à raisonner.

Mais utilisez la sémantique de suppression/rétention prise en charge par le format de table.


66. Le partitionnement peut améliorer l’isolation des défaillances

Une écriture erronée limitée à :

event_date=2026-10-04

est plus facile à réparer qu’un écrasement complet de la table.

C’est l’une des raisons pour lesquelles les conceptions incrémentales bornées par date sont attrayantes sur le plan opérationnel.


67. Consigner la portée des partitions dans les journaux d’exécution

Métadonnées de job utiles :

job_id
partition_start
partition_end
partition_column
row_count
status
code_version

Cela améliore le rejeu et la réponse aux incidents.


68. Détecter les partitions manquantes

Si une partition est attendue par jour ouvré, surveillez les trous.

Sur le principe :

dates attendues
MINUS
dates réelles

Une exécution réussie du pipeline ne prouve pas que toutes les partitions attendues sont arrivées.


69. Détecter les chargements de partition en double

Stockez des métadonnées de lot/de chargement afin de pouvoir identifier :

même lot source
écrit deux fois

Le partitionnement seul n’empêche pas les doublons.


70. Traiter les colonnes de partition comme faisant partie du contrat de données

Passer de :

event_date

à :

ingestion_month

peut affecter :

  • les plans de requête
  • la rétention
  • les rechargements historiques
  • les filtres en aval
  • la logique des jobs

Ne modifiez pas à la légère l’organisation des partitions des grandes tables de production.


71. Repartitionner une grande table existante est une migration

Préoccupations typiques d’une migration :

coût de la réécriture complète
lecteurs concurrents
bascule
validation
retour arrière
duplication du stockage

Planifiez-la comme une migration de données.


72. Valider avant et après le repartitionnement

Comparez :

nombre de lignes
totaux métier
unicité des clés
couverture des dates
schéma
performances des requêtes
nombre de fichiers
taille du stockage

Ne jugez pas le succès à la seule vitesse des requêtes.


73. Ne pas supposer que plus de partitions signifie plus de parallélisme

Trop de partitions minuscules peuvent augmenter :

  • la charge de planification des tâches
  • le travail sur les métadonnées
  • le coût d’ouverture des fichiers

Le parallélisme a des rendements décroissants.


74. Ne pas supposer que moins de partitions est toujours mieux

Une partition géante peut créer :

  • des tâches de longue durée
  • un parallélisme médiocre
  • de grosses réécritures
  • des points chauds

L’objectif est l’équilibre.


75. Adapter le partitionnement aux opérations de maintenance

Si les opérations consistent fréquemment à :

reconstruire une date
supprimer un mois
rapprocher une région

un partitionnement aligné sur ces périmètres peut simplifier la maintenance.


76. Adapter le partitionnement à la sécurité uniquement si la plateforme l’applique correctement

Ne supposez pas que la séparation physique des partitions équivaut à un contrôle d’accès.

La sécurité doit être assurée par :

  • les autorisations sur les tables
  • la sécurité au niveau des lignes
  • une autorisation tenant compte des locataires
  • les stratégies de la plateforme

L’organisation des partitions n’est pas en soi une frontière de sécurité.


77. Le partitionnement peut interagir avec la concurrence

Deux jobs qui écrivent dans des partitions différentes peuvent entrer moins souvent en conflit que deux jobs qui réécrivent la même partition, mais le comportement exact dépend du format de table et du moteur.

Pour Delta, utilisez des écritures compatibles avec Delta et gérez la concurrence selon la sémantique de la plateforme.


78. Éviter les écrasements complets et concurrents de la table

Même si les jobs ciblent des données logiquement distinctes, un écrasement complet de la table est une opération large.

Préférez des écritures à portée restreinte.


79. Partitionner par système source uniquement si cela aide l’exploitation

Exemple :

source_system = crm
source_system = billing
source_system = web

Cela peut faciliter le retraitement propre à chaque source.

Mais si chaque requête couvre toutes les sources et que chaque source est petite, cela peut ajouter une fragmentation inutile.


80. Utiliser une liste de vérification de décision reproductible

Avant de partitionner une table, répondez à ces questions :

1. Quels sont les filtres dominants ?
2. Quelles sont les limites des chargements incrémentiels/backfills ?
3. Combien de valeurs de partition distinctes existent aujourd’hui et plus tard ?
4. Les données sont-elles réparties uniformément ?
5. Chaque partition contiendra-t-elle suffisamment de données ?
6. Les écritures modifieront-elles fréquemment d’anciennes partitions ?
7. Les statistiques de fichiers/le clustering peuvent-ils résoudre le problème à la place ?
8. La table est-elle assez grande pour tirer le moindre bénéfice du partitionnement ?

Si ces questions ne donnent pas de réponse claire, évitez un partitionnement prématuré.

Interpréter le résultat

Stratégie Cas d’usage idéal Risque principal
Aucun partitionnement Tables petites/moyennes, analyses larges Moins d’élagage sur de très grands volumes
Date Analyses bornées dans le temps et chargements incrémentaux Trop de partitions minuscules si le volume est faible
Mois Séries temporelles à plus faible volume Élagage moins précis
Heure Séries temporelles à très fort volume Explosion du nombre de partitions
Région/catégorie Catégories stables et bornées Catégories inégales/asymétriques
Locataire Charges fortement limitées à un locataire Forte cardinalité / locataires chauds
Date + dimension Charges très volumineuses, filtrées de façon constante Nombre de partitions multiplicatif
Hachage/bucket Distribution équilibrée des clés Élagage par plage ou intuitif faible
Plage Accès ordonné/par plage Extrémités de plage chaudes / rééquilibrage

Le compromis le plus important est :

meilleur élagage
contre
davantage de métadonnées de partitions/fichiers

Points à vérifier

Les requêtes analysent encore la plupart des données

Vérifiez :

  • que le prédicat utilise la colonne de partition
  • que les types de données correspondent
  • si des fonctions masquent le prédicat de partition
  • que les filtres sont appliqués tôt
  • que le moteur signale réellement l’élagage des partitions

Trop de fichiers minuscules

Vérifiez :

  • la granularité des partitions
  • la fréquence d’écriture
  • le comportement « un fichier par tâche »
  • le besoin de compactage

Une partition est beaucoup plus volumineuse que les autres

Vérifiez le skew sur :

locataire
région
marchand
date

Une seule partition chaude peut dominer la durée d’exécution.

Les rechargements historiques sont coûteux

Vérifiez si les limites des partitions s’alignent sur la portée des rechargements historiques.

Sinon, la table réécrit ou analyse peut-être trop de données.

Les partitions quotidiennes sont presque vides

Utilisez un partitionnement plus grossier, par exemple mensuel, ou aucun partitionnement.

Les requêtes filtrent fréquemment une colonne à forte cardinalité

Envisagez le clustering, le data skipping ou l’indexation plutôt qu’un partitionnement physique.

Notes de production

Le partitionnement est un choix de conception physique

Il affecte :

  • le coût de lecture
  • le coût d’écriture
  • la maintenance
  • les métadonnées
  • la concurrence
  • l’organisation des fichiers

Traitez-le comme la conception d’un schéma ou d’un index, pas comme un élément décoratif.

L’élagage des partitions doit être vérifié

Utilisez les plans d’exécution et les métriques d’analyse.

Ne supposez pas que l’optimiseur a exploité votre organisation.

Taille des fichiers et partitionnement doivent être considérés ensemble

Une bonne clé de partition associée à une fragmentation de fichiers catastrophique reste une mauvaise conception.

L’organisation des partitions doit évoluer lentement

Changer de stratégie de partitionnement sur une grande table nécessite généralement une réécriture/migration.

Éviter les chiffres magiques indépendants de la plateforme

Il n’existe pas de valeur idéale universelle pour :

nombre de partitions
taille des fichiers
lignes par partition

Mesurez avec votre moteur, votre stockage et votre charge de travail.

Erreurs fréquentes

1. Partitionner par chaque colonne de filtre

Cela provoque une explosion des combinaisons de partitions.

2. Partitionner par des identifiants uniques

Les clés à forte cardinalité créent des partitions minuscules et une surcharge de métadonnées.

3. Partitionner par un horodatage brut

La cardinalité des horodatages est généralement trop élevée.

4. Utiliser repartition(1) pour créer un seul fichier de sortie

Cela détruit le parallélisme distribué.

5. Confondre partitions d’exécution Spark et partitions de table

Elles résolvent des problèmes différents.

6. Supposer que le partitionnement corrige le skew

Une clé de partition asymétrique peut aggraver le skew.

7. Ignorer les petits fichiers

L’élagage des partitions peut rester lent lorsque chaque partition contient des milliers de fichiers minuscules.

8. Reconstruire toute la table pour des modifications limitées à une partition

Utilisez des écritures ciblées lorsque c’est possible.

9. Choisir des colonnes de partition sans preuve tirée des requêtes

Une partition qui n’est jamais filtrée est souvent une complexité inutile.

10. Traiter les partitions physiques comme une frontière de sécurité

Utilisez de véritables contrôles d’autorisation et de sécurité.

Étape suivante

Appuyez-vous sur le comportement observé de la charge de travail pour choisir l’action suivante.

  • Grande table de séries temporelles avec filtres de date → envisagez un partitionnement par date.
  • Les partitions quotidiennes sont minuscules → passez à des partitions mensuelles plus grossières, ou supprimez le partitionnement.
  • Une clé domine les données → évitez de partitionner par cette clé ; étudiez le traitement du skew.
  • Les requêtes filtrent des colonnes à forte cardinalité → évaluez plutôt le clustering, le data skipping ou l’indexation.
  • Des analyses profondes persistent malgré le partitionnement → inspectez l’élagage dans le plan d’exécution.
  • Il existe des millions de fichiers minuscules → traitez le modèle d’écriture et la stratégie de compactage.
  • Les rechargements historiques réécrivent trop de données → alignez les limites des partitions sur le périmètre de reprise.
  • Besoin de modifier un schéma de partitionnement existant → traitez-le comme une migration de table maîtrisée.
  • Vous ne savez pas s’il faut partitionner → mesurez d’abord la taille de la table, les modèles de filtre, la cardinalité, le skew et les périmètres de maintenance.

← Tous les aide-mémoire