{"canonical_url":"https://engineer.company/fr/notes/optimise-before-you-shard/","content_markdown":"# Optimiser la base avant de la répartir\n\n2026-10-14\n\nLorsqu'une base de données ralentit sous la charge, la première proposition consiste généralement à ajouter des machines. C'est parfois la bonne réponse. Plus souvent, la lenteur vient d'une poignée d'instructions que personne n'a encore lues, et répartir les données entre serveurs répartit ces instructions sur davantage de matériel sans en rendre une seule moins coûteuse. Un problème apparemment insoluble n'est souvent qu'à un plan de requête d'une réponse élégante, et le passage à l'échelle horizontal est parfois choisi précisément pour que personne n'ait à lire\nla base de données dont vous disposez déjà *(lisez avant d'en acheter davantage)*.\n\nVoici notre ordre de travail avant toute division : observer, optimiser, retirer les lectures du primaire, partitionner les tables autour du point de contention et ne répartir entre serveurs que lorsqu'une machine est remplie de travail utile. La vente éclair où chaque acheteur écrit sur une seule ligne est détaillée dans [Vendre le dernier billet exactement une fois](/fr/notes/selling-limited-stock-without-overselling/). Cette note décrit la méthode qui l'entoure, et sa dernière section examine la proposition inverse : vendre depuis chaque serveur et s'excuser pour les unités vendues deux fois.\n\n## Observer d'abord\n\nPostgreSQL enregistre déjà l'essentiel de ce qu'il faut savoir. Avant toute modification, posez-lui quatre questions.\n\n**Quelles instructions coûtent le plus au total ?** `pg_stat_statements`, une extension chargée via `shared_preload_libraries`, conserve chaque instruction normalisée avec son nombre d'appels et sa durée. Triez par total, pas par moyenne : une requête de 2 ms exécutée un million de fois par heure coûte plus qu'un rapport de deux secondes exécuté deux fois.\n\n```sql\nSELECT calls,\n       round(total_exec_time) AS total_ms,\n       round(mean_exec_time::numeric, 1)\n         AS mean_ms,\n       left(query, 60) AS query\n  FROM pg_stat_statements\n ORDER BY total_exec_time DESC\n LIMIT 10;\n```\n\n**Que fait réellement la première ?** `EXPLAIN (ANALYZE, BUFFERS)` exécute l'instruction et montre le plan choisi, les lignes réellement renvoyées par chaque étape par rapport aux lignes attendues, et le nombre de pages lues. Parcourir un million de lignes pour en renvoyer dix, ou une estimation fausse d'un facteur cent, explique généralement tout. `ANALYZE` exécute ce qu'il explique ; encadrez donc une écriture par `BEGIN` et `ROLLBACK`.\n\n**Qui attend, et qui le bloque ?**\n\n```sql\nSELECT pid, wait_event_type, wait_event,\n       pg_blocking_pids(pid) AS blocked_by,\n       left(query, 60) AS query\n  FROM pg_stat_activity\n WHERE wait_event_type = 'Lock';\n```\n\nSi des lignes apparaissent ici pendant une minute de forte activité, cela signifie que les transactions font la queue les unes derrière les autres, plutôt que d’attendre le matériel. Une machine plus puissante ne supprime pas la nécessité d’exécuter une à une les mises à jour d’une même ligne partagée. Des serveurs applicatifs supplémentaires peuvent ajouter à cette file des clients qui effectuent des écritures.\n\n**Le serveur travaille-t-il ou jongle-t-il ?** Comparez le nombre de sessions actives dans `pg_stat_activity` au nombre de cœurs. Lorsqu'il y a plusieurs fois plus de sessions actives que de cœurs, le serveur passe son temps à basculer de l'une à l'autre ; un pool de connexions corrige cela avant tout ajout matériel. Consultez ensuite `n_dead_tup` dans `pg_stat_user_tables` : une table avec davantage de lignes mortes que vivantes est parcourue à travers ses propres déchets. C'est autovacuum qui prend du retard, pas une base trop petite.\n\nConsignez vos constats. Ils constituent la référence à laquelle chaque étape ultérieure sera comparée, et contiennent souvent déjà la réponse honnête à « devons-nous répartir la base entre serveurs ? ».\n\n## Optimiser l'existant\n\nApproximativement par ordre de rendement de l'effort.\n\n**Des index qui correspondent aux questions.** Les plans ci-dessus nomment les parcours. Un index sur les colonnes filtrées par une requête très sollicitée transforme un parcours en recherche directe, et un index partiel ne contient que les lignes que la requête peut vouloir — par exemple les unités encore en vente. Il rétrécit donc au fil de la vente plutôt que de croître :\n\n```sql\nCREATE INDEX units_unsold\n    ON units (item_id)\n WHERE NOT sold;\n```\n\nChaque index a aussi un coût à chaque écriture ; supprimez donc ceux dont `idx_scan` dans `pg_stat_user_indexes` reste à zéro.\n\n**Des types qui disent ce que représente la valeur.** Les schémas écrits rapidement, par une personne ou un modèle, choisissent `TEXT` là où `SMALLINT` ou `BOOLEAN` suffiraient. Un `BOOLEAN` occupe un octet, un `SMALLINT` deux, et `'yes'` stocké comme texte quatre. PostgreSQL ajoute aussi du remplissage à chaque colonne de largeur fixe selon son alignement ; un ordre de colonnes choisi au hasard coûte donc également des octets. Une unité de stock, écrite rapidement :\n\n```sql\nCREATE TABLE units (\n  sold        text,  -- 'yes' or 'no'\n  id          bigint,\n  reserved    text,  -- 'yes' or 'no'\n  reserved_at timestamptz,\n  item_id     bigint,\n  order_id    bigint\n);\n```\n\nEt la même unité avec des types qui expriment les valeurs, les plus larges en premier :\n\n```sql\nCREATE TABLE units (\n  id          bigint PRIMARY KEY,\n  reserved_at timestamptz,\n  order_id    bigint,\n  item_id     integer NOT NULL,\n  sold        boolean NOT NULL DEFAULT false,\n  reserved    boolean NOT NULL DEFAULT false\n);\n```\n\nSur PostgreSQL 18, la première ligne mesure 72 octets et la seconde 54, soit un quart de moins ; une plus grande partie de la table tient donc en mémoire. Les types refusent aussi des valeurs telles que `'maybe'`, dont l'application devrait autrement se protéger. Une contrainte `CHECK` fait de même pour les plages de valeurs : `quantity smallint CHECK (quantity \u003e 0)`.\n\n**Moins d'allers-retours et le travail là où sont les données.** Chaque instruction envoyée par l'application coûte un aller-retour et une analyse. Une boucle qui lit cent lignes puis les met à jour une par une représente cent un allers-retours là où une instruction ensembliste suffirait. Une page qui récupère chaque unité d'un article pour compter celles qui sont libres transfère des milliers de lignes pour calculer un nombre. Notre règle : ce qui doit voir les données va dans la base — filtrage, comptage, écriture dépendant de l'existant — et les règles métier restent dans l'application, car la puissance de calcul de la base est celle qu'il est le plus difficile d'augmenter dans le système.\n\n**Des mises à jour qui restent sur leur page.** Une ligne modifiée plusieurs fois par minute laisse à chaque fois une nouvelle version d'elle-même. Lorsqu'une mise à jour ne modifie aucune colonne indexée et que la page a de la place, PostgreSQL garde la nouvelle version sur la même page sans toucher aux index : un heap-only tuple, ou une mise à jour HOT. Gardez donc les colonnes fréquemment modifiées hors des index et laissez de l'espace sur les pages :\n\n```sql\nALTER TABLE units SET (fillfactor = 90);\n```\n\nCe réglage s'applique aux pages écrites ensuite ; définissez-le donc avant le chargement des lignes. Sur la table ci-dessus, 2 000 réservations modifiant `reserved`, `reserved_at` et `order_id` ont toutes été HOT. Sur 2 000 mises à jour modifiant `sold`, lu par l'index partiel, aucune ne l'a été. Une unité n'est vendue qu'une fois ; sa réservation peut se répéter. Le rapport entre `n_tup_hot_upd` et `n_tup_upd` dans `pg_stat_user_tables` montre cette proportion sur un système en production.\n\n## Une ligne désigne le premier arrivé\n\nUne unité revient au premier acheteur dont l'instruction l'atteint, et la réservation expire selon l'horloge de la base. Deux colonnes la portent : `reserved`, un booléen, et `reserved_at`, l'instant où il a été défini.\n\n```sql\nUPDATE units\n   SET reserved = true,\n       reserved_at = now(),\n       order_id = :order\n WHERE id = :unit\n   AND NOT sold\n   AND (NOT reserved\n        OR reserved_at\n           \u003c now() - interval '10 minutes')\nRETURNING id;\n```\n\nUne ligne renvoyée : cet acheteur l'a obtenue. Aucune : quelqu'un l'a précédé ou l'unité est vendue. Deux réservations de la même unité attendent sur le verrou de sa ligne. Avec READ COMMITTED, le niveau d'isolation prédéfini de PostgreSQL, la seconde revérifie la clause `WHERE` sur la ligne validée par la première ; exactement une des deux obtient donc une ligne en retour. Une réservation de plus de dix minutes est considérée comme libre ; aucun nettoyage n'est nécessaire pour que la réponse soit correcte.\n\nLe booléen seul donne donc une réponse incomplète. `reserved` reste vrai après expiration, et seules les deux colonnes réunies indiquent si une unité est retenue ; toute requête doit donc interroger les deux. Un nettoyage périodique qui réinitialise les réservations expirées maintient la table cohérente pour les lecteurs de `reserved` seul, mais la correction du résultat ne l'attend jamais. Une contrainte maintient la cohérence de la paire :\n\n```sql\nALTER TABLE units\n  ADD CONSTRAINT reserved_has_time\n  CHECK (NOT reserved\n         OR reserved_at IS NOT NULL);\n```\n\nLa note sur les billets stocke la date limite, `held_until`, plutôt que le début ; c'est la même conception. Lorsque l'acheteur choisit l'unité — un siège, un tirage numéroté — l'instruction la nomme, comme ici. Lorsque n'importe quelle unité convient, la forme `SKIP LOCKED` de cette note en choisit une que personne d'autre ne retient.\n\n## Retirer les lectures du primaire\n\nLa majeure partie du trafic d'une boutique est de la lecture : la page produit, la mention « 3 restants », le panier, l'historique des commandes. Rien de cela ne nécessite le primaire, cette machine qui doit rester disponible pour les écritures. Une réplique en flux continu prend ces lectures, et en ajouter une relève de la configuration là où une répartition entre serveurs constitue un projet.\n\nDeux précautions l'accompagnent. Une réplique a un léger retard ; un acheteur qui vient de réserver une unité puis y lit son panier peut donc ne pas voir la réservation : lisez sur le primaire ce qu'un utilisateur vient d'écrire, ou envoyez-le vers le primaire pendant quelques secondes après chaque écriture. Un rapport long sur une réplique peut aussi être annulé s'il retarde les changements que celle-ci rejoue. La documentation PostgreSQL appelle cela des conflits de requêtes et énumère les réglages qui arbitrent entre ces conflits et le retard de réplication.\n\nLa lecture la moins coûteuse est celle qui n'atteint jamais une base. Lorsque chaque unité d'un article est réservée, personne ne peut l'acheter avant l'expiration ou la libération d'une réservation, et la base peut indiquer exactement quand cela arrivera :\n\n```sql\nSELECT count(*) FILTER (\n         WHERE NOT reserved\n            OR reserved_at\n               \u003c now() - interval '10 minutes')\n         AS free,\n       min(reserved_at) + interval '10 minutes'\n         AS until\n  FROM units\n WHERE item_id = :item\n   AND NOT sold;\n```\n\nLorsque `free` vaut zéro, `until` est l'expiration de la réservation la plus proche : mettez « entièrement réservé » en cache jusqu'à cet instant, jamais au-delà, et tous les visiteurs jusque-là sont refusés par le cache plutôt que par la base. Lorsque `free` vaut zéro et que `until` est vide, toutes les unités sont vendues et la réponse est définitive. Une réservation libérée plus tôt — carte refusée, panier abandonné — supprime l'entrée de cache, et l'unité est immédiatement remise en vente.\n\nLe cache ne dit jamais que non. Un oui vient toujours de l'`UPDATE` conditionnel ci-dessus ; un cache périmé peut donc faire perdre une vente pendant quelques secondes, mais jamais vendre deux fois une unité. C'est le « épuisé » mis en cache de la note sur les billets, avec une date limite.\n\n## Partitionner les tables autour de la ligne très sollicitée\n\nLe partitionnement divise une table en plusieurs selon une clé — un mois, une organisation cliente — derrière un seul nom. Il faut être clair sur ce qu'il ne fait pas : il n'accélère pas une ligne soumise à contention. Cette ligne reste dans une partition, sur une machine, derrière un verrou.\n\nIl maintient en revanche petites les tables autour du point de contention. Les commandes, l'historique des réservations et les événements croissent indéfiniment, et la plupart des requêtes veulent la partie récente :\n\n```sql\nCREATE TABLE orders (\n  id          bigint NOT NULL,\n  created_at  timestamptz NOT NULL\n              DEFAULT now(),\n  item_id     integer NOT NULL,\n  quantity    smallint NOT NULL\n              CHECK (quantity \u003e 0),\n  paid        boolean NOT NULL DEFAULT false,\n  PRIMARY KEY (id, created_at)\n) PARTITION BY RANGE (created_at);\n\nCREATE TABLE orders_2026_10\n  PARTITION OF orders\n  FOR VALUES FROM ('2026-10-01')\n              TO ('2026-11-01');\n```\n\nUne requête indiquant une plage de dates ne lit que les partitions concernées, et les index du mois courant restent assez petits pour tenir en mémoire. La conservation ne passe plus par un `DELETE` de millions de lignes, avec le gonflement et le nettoyage qui suivent, mais par une instruction :\n\n```sql\nALTER TABLE orders\n  DETACH PARTITION orders_2025_10;\n```\n\nLa clé primaire doit inclure la clé de partition, d'où `(id, created_at)`. Une requête qui ne nomme pas cette clé lit chaque partition ; partitionnez donc selon les filtres déjà utilisés par les requêtes.\n\n## Quand la répartition entre serveurs est raisonnable\n\nIl est une limite que cette répartition ne peut pas déplacer : chaque article a un seul responsable. Une unité ne peut pas être réservée sur deux serveurs à la fois ; on déplace donc des articles entiers, jamais la moitié d'un article. Lorsqu'un article dépasse les capacités de sa machine, les compartiments de la note sur les billets divisent son stock en morceaux plus petits, chacun ayant à nouveau exactement un responsable.\n\nDans ce cadre, nous jugeons la répartition raisonnable lorsqu'une des conditions suivantes est remplie, pas avant :\n\n- **Une machine est pleine de travail utile.** Les instructions sont déjà optimisées — une écriture conditionnelle chacune, aucun appel externe dans une transaction, des mises à jour restant sur leur page — et le processeur ou le journal d'écriture anticipée du primaire reste saturé, sur la plus grosse machine qu'il soit raisonnable d'acheter, pour de nombreux articles plutôt qu'un seul. Un article très sollicité relève des compartiments, pas de la répartition entre serveurs.\n- **Les données ont dépassé les capacités de maintenance.** Une sauvegarde ne peut plus être restaurée dans le délai promis à l'entreprise, un index ne peut plus être construit ou une table nettoyée pendant les heures creuses, ou l'ensemble de travail ne tient plus en mémoire.\n- **L'isolation est l'exigence.** Une organisation cliente dont le contrat ou le régulateur impose des données séparées, ou dont la vente ne doit partager aucun disque avec celle d'un autre.\n\nLe coût se reporte sur tout le reste. Les migrations, sauvegardes, restaurations et rapports doivent tenir compte des fragments distincts ; une jointure entre fragments peut être déplacée dans le code applicatif ; une requête ignorant sa clé de répartition peut devoir les interroger tous. C’est la facture que les sections précédentes cherchent à éviter et sur laquelle il est difficile de revenir une fois payée.\n\n## Quand des excuses coûtent moins cher qu'un verrou\n\nIl existe un argument sérieux en faveur de la voie inverse. Laisser chaque serveur vendre le stock qu'il voit, accepter qu'une unité revienne parfois à deux acheteurs, puis laisser l'assistance rembourser l'un d'eux avec des excuses. La logique métier devient à cohérence éventuelle, conçue pour les 99,9 % de requêtes sans collision, et une boucle asynchrone détecte les collisions après coup et les répare. En échange, la boutique n'a jamais à dire « réessayez ». Helland et Campbell présentent la version la plus forte de cet argument dans _Building on Quicksand_ : un système qui accuse réception d'un travail avant que sa sauvegarde l'ait rend toute promesse probabiliste, et les entreprises ont toujours réglé par des excuses les promesses qu'elles ne pouvaient tenir.\n\nNous sommes d'accord avec l'essentiel. Nous divergeons sur l'endroit où appliquer ce compromis.\n\n**La majeure partie d'une boutique devrait être à cohérence éventuelle.** Le catalogue, l'index de recherche, le badge « 3 restants », le panier, les recommandations, les courriels, l'export vers l'entrepôt et les rapports peuvent tous avoir quelques secondes de retard. Les faire attendre le primaire coûte de la vitesse sans rien apporter. Dynamo a été conçu précisément pour cela : le panier Amazon n'oublie ni ne refuse jamais un ajout, même pendant une panne de machines, au prix de fusions susceptibles de réintroduire un article supprimé par l'acheteur. Après la réservation, le paiement de la note sur les billets est déjà asynchrone : une saga d'étapes locales, des messages livrés au moins une fois et des consommateurs idempotents, indexés par commande. Une boucle de rapprochement a sa place dans toute conception qui communique avec un prestataire de paiement, car des webhooks se perdent.\n\n**La réservation est le seul endroit où cela ne tient pas.** « Rare » suppose des collisions rares, alors que dans une vente éclair, les collisions sont la vente. Un serveur qui vend depuis sa propre vue continue jusqu'à apprendre les ventes des autres ; la survente est donc approximativement le taux de tentatives multiplié par le retard de réplication. Dans une simulation simple, deux régions se partagent 2 000 tentatives par seconde, chacune vend depuis son propre décompte et apprend les ventes de l'autre 200 millisecondes plus tard. Sur cinq exécutions d'une vente de 10 000 unités, chacune a vendu entre 191 et 205 unités inexistantes. Le calcul prédit 200 : le taux de tentatives, multiplié par le retard, multiplié par la part des ventes effectuées dans l'autre région. Avec un seul responsable par article, le même modèle a vendu exactement le stock. Cela arrive à chaque épuisement de stock, qu'une panne ait eu lieu ou non, au point culminant, lorsque le plus d'acheteurs regardent.\n\n**Le gain de disponibilité est plus faible qu'il n'y paraît.** Gilbert et Lynch ont démontré le compromis de la cohérence éventuelle : pendant une partition réseau, un système peut répondre ou rester cohérent, pas les deux. Le modèle PACELC d'Abadi ajoute l'autre moitié. Sans partition, le compromis oppose latence et cohérence, et un responsable unique par article avec des instructions optimisées est déjà rapide. Aucune conception n'atteint 100 % : le prestataire de paiement, le DNS et les réseaux qui les relient connaissent leurs propres pannes. Ce que sacrifie la conception stricte est limité. Lorsque le responsable du stock d'un article est inaccessible, cet article cesse de se vendre pendant les secondes nécessaires au basculement, et la section de la note sur la suspension limite celle-ci aux articles de la machine en panne. Le reste de la boutique continue à vendre.\n\n**Des excuses ne sont pas un remboursement.** Le remboursement est la partie peu coûteuse. L'acheteur a reçu un oui et a peut-être déjà réservé son train, posé un jour de congé et prévenu ses amis. Entendre « épuisé » une seconde trop tôt est une déception. Apprendre l'annulation d'une commande confirmée est une promesse rompue. L'assistance est dimensionnée pour une journée ordinaire, et les surventes arrivent ensemble, pendant la minute la plus chargée de l'année. Avant de prévoir le retrait de commandes confirmées, demandez à un juriste à quoi une confirmation engage la boutique.\n\n**Gardez l'asynchronisme et placez-le avant le oui.** La proposition a raison sur un point : l'acheteur n'a pas à attendre sur un verrou. Acceptez chaque clic dans un journal durable et répliqué, avec une partition par article, et indiquez à l'acheteur que la réponse arrive. L'acceptation d'un clic dépend alors uniquement du journal, et un journal répliqué sur trois machines continue d'accepter les écritures si l'une échoue. Un seul responsable par article lit le journal dans l'ordre et décide à la vitesse de la mémoire ; la réponse revient par message en quelques secondes. Lorsque ce responsable bascule, les requêtes attendent dans le journal plutôt que d'être refusées ou vendues deux fois. Le oui est une réservation, suivie du paiement comme dans la note sur les billets ; personne ne paie donc une unité non obtenue. Le rapprochement existe toujours, mais avant la promesse plutôt qu'après.\n\n**Partagez le stock, pas le décompte.** Lorsque l'activité exige que les régions vendent sans se consulter, attribuez à chacune un quota de stock et laissez-la le vendre sans demander à personne. Une région à court de quota en demande davantage et, en fin de vente, les quotas se regroupent sous un responsable unique. Bailis et ses collègues déterminent les règles que des serveurs peuvent respecter sans communiquer ; un stock qui ne doit pas devenir négatif n'en fait pas partie. Les quotas n'éliminent pas cette communication ; ils la déplacent hors du chemin critique, au rare moment de leur réapprovisionnement. C'est la conception à cohérence éventuelle qui conserve l'invariant. Son seul coût est la fin de vente, où un acheteur est refusé dans une région alors qu'une autre a encore du stock.\n\n**Quand la survente est la bonne politique.** Certains biens peuvent être reproduits : un tirage à la demande, un tee-shirt encore disponible chez le fournisseur, une clé de licence. Vendre au-delà du décompte devient alors une commande différée avec une date honnête, et la cohérence éventuelle est la bonne conception. Les compagnies aériennes pratiquent volontairement la surréservation. Elles connaissent les taux de non-présentation, chiffrent le risque et indemnisent selon une règle écrite à l'avance. C'est le critère. Une survente est acceptable lorsque l'entreprise a choisi son ampleur et son remède avant la vente. C'est un défaut lorsqu'elle retombe sur la personne qui a cliqué en dernier.\n\n**Si vous choisissez les excuses, construisez-les comme les paiements.** La boucle décrite par la proposition est un processus de remboursement. Elle nécessite les mêmes choses que tout système déplaçant de l'argent :\n\n- **Un identifiant sur chaque vente**, pour qu'une nouvelle tentative soit la même vente, et un registre de ventes en ajout seul. Le nombre en stock est dérivé du registre, jamais modifié.\n- **Une règle désignant qui conserve l'unité**, explicable à l'acheteur perdant. Ordonnez selon le journal, pas selon les horloges des serveurs, où quelques millisecondes de décalage décideraient du remboursement.\n- **Des compensations idempotentes et journalisées :** annuler, annuler l'autorisation ou rembourser, prévenir l'acheteur. Ce sont les étapes d'annulation de la saga, exécutées par une machine.\n- **Une échéance.** La boucle doit trouver chaque survente avant toute expédition et avant que l'acheteur ne la découvre.\n- **Un budget mesuré.** Les surventes par vente, comparées au nombre accepté par l'entreprise, à côté de l'invariant sur le même tableau de bord, avec une alerte lorsque le budget est épuisé.\n\nNotre réponse consiste à adopter la cohérence éventuelle partout autour de la réservation, la rigueur au moment de réserver et l'asynchronisme pour transmettre la réponse à l'acheteur. Concevez pour le parcours habituel, mais dans une vente éclair, la collision est ce parcours habituel. Si l'entreprise accepte quelques surventes en échange d'un avantage, faites-en un nombre qu'elle a choisi, avec un remède écrit avant la vente, et mesurez-le.\n\n## Ce que nous dirions à la prochaine personne\n\n- **Lisez avant d'acheter.** `pg_stat_statements` et un `EXPLAIN` répondent à davantage de questions de capacité qu'un nouveau serveur.\n- **Faites exprimer aux types la nature des données.** Un booléen stocké comme booléen est plus petit et refuse les absurdités.\n- **Envoyez à la base ce qui doit voir les données, rien d'autre.** Le filtrage et le comptage y ont leur place. Les règles métier non.\n- **Le cache dit non ; seule la base dit oui.** Un cache périmé coûte alors des secondes, jamais une unité.\n- **Le partitionnement est de l'entretien.** Il garde petites les tables autour d'une ligne très sollicitée et ne change rien pour cette ligne.\n- **Répartissez entre serveurs lorsqu'une machine est pleine de travail utile**, pas lorsqu'elle est pleine d'attente.\n- **Rapprochez avant le oui, pas après.** Tout ce qui entoure la réservation peut être à cohérence éventuelle. La réservation elle-même, conçue ainsi, entraîne à chaque vente une survente égale au taux de tentatives multiplié par le retard.\n\n## Sources\n\n- [PostgreSQL : pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n- [PostgreSQL : utilisation d'EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n- [PostgreSQL : le système de statistiques cumulatives](https://www.postgresql.org/docs/current/monitoring-stats.html)\n- [PostgreSQL : types numériques](https://www.postgresql.org/docs/current/datatype-numeric.html)\n- [PostgreSQL : types de caractères](https://www.postgresql.org/docs/current/datatype-character.html)\n- [PostgreSQL : type booléen](https://www.postgresql.org/docs/current/datatype-boolean.html)\n- [PostgreSQL : index partiels](https://www.postgresql.org/docs/current/indexes-partial.html)\n- [PostgreSQL : heap-only tuples (HOT)](https://www.postgresql.org/docs/current/storage-hot.html)\n- [PostgreSQL : partitionnement des tables](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n- [PostgreSQL : réplication en attente active et conflits de requêtes](https://www.postgresql.org/docs/current/hot-standby.html)\n- [Pat Helland et Dave Campbell, Building on Quicksand](https://arxiv.org/abs/0909.1788)\n- [Seth Gilbert et Nancy Lynch, Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services](https://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf)\n- [Daniel Abadi, Consistency Tradeoffs in Modern Distributed Database System Design](https://www.cs.umd.edu/~abadi/papers/abadi-pacelc.pdf)\n- [DeCandia et al., Dynamo: Amazon's Highly Available Key-value Store](https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf)\n- [Hector Garcia-Molina et Kenneth Salem, Sagas](https://www.cs.cornell.edu/andru/cs711/2002fa/reading/sagas.pdf)\n- [Bailis et al., Coordination Avoidance in Database Systems](https://www.vldb.org/pvldb/vol8/p185-bailis.pdf)\n\n\u003chttps://engineer.company/fr/notes/optimise-before-you-shard/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Avant de répartir une base, il faut souvent la lire. Notre ordre : mesurer, optimiser, déporter les lectures, partitionner, puis répartir.","formats":{"gemtext":"https://software.engineer.company/fr/notes/optimise-before-you-shard/index.gmi","gopher":"https://software.engineer.company/fr/notes/optimise-before-you-shard/gophermap","html":"https://software.engineer.company/fr/notes/optimise-before-you-shard/","json":"https://software.engineer.company/fr/notes/optimise-before-you-shard/index.json","markdown":"https://software.engineer.company/fr/notes/optimise-before-you-shard/index.md","pdf":"https://software.engineer.company/fr/notes/optimise-before-you-shard/index.pdf"},"kind":"page","language":"fr","title":"Optimiser la base avant de la répartir","url":"https://software.engineer.company/fr/notes/optimise-before-you-shard/","version":1}