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