novembre 2026
Version control for transactional data
Un protocole à la git pour PostgreSQL : le pourquoi, le quoi et le comment ; les projets open source qui le construisent déjà, les limites de leur conception, et une meilleure voie bâtie sur ce que Postgres possède déjà.
Résumé
Les équipes logicielles versionnent leur code avec git et ne songeraient pas un instant à travailler sans lui, et pourtant la base de données qui sous-tend ce code, l’état le plus précieux et le moins réversible qu’une organisation détienne, est encore modifiée sur place, sans branche, sans comparaison et sans fusion. Un champ animé de projets open source promet de combler cette lacune et d’apporter git à la base de données, et le présent article en expose le pourquoi, le quoi et le comment. Nous soutenons que l’enjeu véritable n’est pas la création de branches mais la fusion, la capacité de réconcilier des lignes divergentes de données transactionnelles, et nous montrons que le champ s’est scindé en deux camps qui abandonnent chacun la moitié du problème : Dolt et DoltgreSQL remportent une véritable sémantique git en réimplémentant le moteur de base de données et en laissant Postgres natif de côté, tandis que Neon et Supabase conservent Postgres mais offrent une branche qui peut bifurquer et jamais ne rejoindre. Nous proposons une meilleure voie. Non un moteur dérivé ni une couche de stockage dérivée, mais un protocole de gestion de versions bâti sur le journal d’écriture anticipée, la concurrence multiversion et le décodage logique que Postgres fournit déjà, avec la fusion sémantique et consciente des contraintes comme opération de première classe. La gestion de versions des données devrait séparer le modèle de versions du stockage, de la même manière que git a séparé le modèle d’objets du transport.
Mots-clés : PostgreSQL ; gestion de versions de bases de données ; git pour les données ; création de branches de données ; migration de schéma ; fusion à trois voies ; résolution de conflits ; journal d’écriture anticipée ; décodage logique ; contrôle de concurrence multiversion ; MVCC ; copie sur écriture ; CRDT ; Dolt ; DoltgreSQL ; Neon ; Supabase ; tables temporelles ; provenance des données ; souveraineté numérique
1. Introduction
Demandez à un développeur de travailler une journée sans git et vous obtiendrez un refus net. Créer des branches, valider, comparer et fusionner sont si profondément tissés dans la manière dont les logiciels se construisent que leur absence est impensable. Demandez maintenant au même développeur comment il versionne la base de production, le schéma et les données que le code existe pour servir, et la réponse est presque toujours un penaud rien. La base est modifiée sur place. Une migration s’exécute vers l’avant et, si elle tourne mal, une restauration affolée depuis la sauvegarde de la nuit dernière est le seul chemin de retour. Deux ingénieurs ne peuvent pas développer contre des copies divergentes des données et les réconcilier plus tard ; ils se relaient, ou ils s’écrasent mutuellement. L’état le plus précieux et le moins réversible qu’une organisation détienne est le seul maillon de la pile dépourvu de toute gestion de versions.
C’est une lacune étrange, et un champ grandissant de projets open source s’est donné pour but de la combler sous une bannière que tout le monde comprend : git pour votre base de données. La promesse séduit d’emblée. Créez une branche de la base pour essayer une modification risquée en isolement. Comparez deux versions pour voir exactement ce qu’une migration a fait. Donnez à chaque analyste sa propre ligne de données et fusionnez le bon travail en retour. Voyagez vers n’importe quel état passé aussi aisément qu’avec git checkout. Si la gestion de versions a transformé la façon dont nous écrivons du code, soutient l’argument, elle peut transformer la façon dont nous gérons les données.
Nous pensons que l’argument est juste, et le présent article de position porte sur la manière de le rendre vrai. Nous expliquons pourquoi des données sous gestion de versions importent (section 2), ce qu’un protocole à la git doit réellement fournir, chose plus vaste et plus ardue qu’il n’y paraît d’abord (section 3), et où en sont les projets actuels, en rendant à chacun son mérite et en dressant un état lucide des limites de leur conception (section 4). Puis nous présentons notre thèse : que le champ s’est acculé à un faux choix, et que la meilleure voie pour Postgres est un protocole bâti sur les primitives qu’il fournit déjà plutôt qu’un nouveau moteur ou une bifurcation impossible à fusionner (section 5). Nashua privilégie les outils best-of-breed et les saines pratiques à tout produit unique, et tel est l’esprit ici : non le plaidoyer d’un seul projet, mais un argument sur la manière dont cela devrait être construit.
2. Pourquoi versionner la base de données
Le dossier commence avec le travail que l’on fait déjà mal à la main. Les migrations de schéma en sont l’exemple évident. Chaque équipe qui exploite une base exécute des migrations, et chaque équipe a connu l’effroi particulier d’une migration qui ne peut être annulée proprement. Une base sous gestion de versions fait d’une migration un commit : réversible, inspectable et testable sur une branche avant qu’elle ne touche la production. La comparaison n’est pas une conjecture tirée du script de migration ; c’est la modification réelle du schéma et des données, calculée et relisable comme n’importe quelle pull request.
Vient ensuite la boucle de développement et de test. Les équipes modernes veulent une base réaliste pour chaque branche de fonctionnalité et chaque prévisualisation de pull request, alimentée de données proches de la production, dressée en quelques secondes et jetée lorsque la branche fusionne. Le faire en restaurant des copies complètes est lent et coûteux ; le faire en partageant une seule base invite aux collisions. Des branches peu coûteuses et instantanées résolvent un problème réel et quotidien, ce qui explique précisément pourquoi les produits de branches ont trouvé un marché avide.
Au-delà de la boucle quotidienne se tiennent les raisons plus profondes. La reproductibilité : un scientifique des données qui peut arrimer une analyse à un état validé précis des données peut reproduire un résultat des mois plus tard, tout comme l’auditeur qui le met en question. La provenance et l’audit : une base dont l’histoire est une chaîne de commits signés répond à qui a changé quoi, et quand, par construction plutôt que par un déclencheur ajouté après coup. Ce n’est pas un agrément dans les secteurs réglementés ; le régime DORA de l’Union européenne et ses semblables attendent des entités financières qu’elles démontrent l’intégrité et la traçabilité de leurs données, et une histoire versionnée est démontrable d’une manière qu’une table mutable ne l’est pas. La restauration : le retour à un instant donné cesse d’être une opération de sauvegarde et devient un checkout. Et la collaboration devient enfin possible sur les données comme elle l’est sur le code, avec des lignes de travail indépendantes qui convergent par la revue plutôt que par le verrouillage.
Rien de tout cela n’est exotique. C’est la machinerie ordinaire du génie logiciel, appliquée au seul actif qui y a obstinément résisté. La question n’est pas de savoir si la base mérite la gestion de versions. Elle la mérite à l’évidence. La question est ce qu’il faudrait pour lui en donner la vraie.
3. Ce qu’un protocole à la git signifie
Il vaut la peine d’être précis sur ce que git fournit réellement, car on prend couramment la moitié facile pour le tout. Git est un magasin d’objets adressé par le contenu : chaque version de chaque fichier est un blob nommé par le hachage de son contenu, les arbres composent les blobs en un instantané, et un commit nomme un arbre avec ses parents, formant un graphe orienté acyclique immuable de l’histoire. Par-dessus ce magasin reposent deux couches de confort : les refs, qui sont des noms humains pour des points du graphe, de sorte que main et feature ne sont que des étiquettes sur des commits ; et les opérations, parmi lesquelles diff et merge sont celles qui comptent.
L’opération décisive, celle qui fait de git un outil de collaboration plutôt qu’une sauvegarde sophistiquée, est la fusion à trois voies. Lorsque deux branches divergent, git ne demande pas laquelle l’emporte. Il trouve leur ancêtre commun, calcule ce que chaque côté a changé par rapport à cet ancêtre, et combine les modifications, ne signalant que les endroits où les deux côtés ont touché la même chose de façons incompatibles. C’est ce qui permet à une centaine de personnes de travailler en parallèle et de converger. Créer des branches sans fusionner n’est qu’une copie bon marché ; créer des branches avec fusion, c’est la gestion de versions.
Portez cela à une base de données et la correspondance est suggestive mais non triviale, comme l’expose la figure 1. Un commit devrait être un instantané immuable de la base entière à un instant logique. Une branche devrait être une ligne nommée de tels instantanés. Une comparaison devrait rapporter les lignes et les objets de schéma qui ont changé entre deux commits. Et une fusion devrait réconcilier deux lignes divergentes de données en une seule. Les trois premières sont, pour l’essentiel, un problème de stockage et de nommage. La quatrième est l’ardue, et c’est là que l’analogie avec git cesse d’être confortable.
Le texte fusionne parce qu’un fichier source est une séquence ordonnée par lignes sans règle sur son contenu ; git peut raccorder deux ensembles de modifications de lignes et le résultat reste un fichier valide par définition. Une base de données n’est pas ainsi. Son contenu est gouverné par des invariants : les clés primaires doivent rester uniques, les clés étrangères doivent se résoudre, les contraintes de vérification doivent tenir, et, par-dessus toutes celles-là, les données doivent encore signifier quelque chose. Deux branches qui insèrent chacune un client avec la même clé naturelle n’ont pas produit un conflit de fusion au sens textuel ; elles ont produit un état que le schéma interdit. Deux branches qui décrémentent chacune le solde d’un compte d’un montant différent ne peuvent pas toutes deux simplement l’emporter. Une fusion de données doit respecter les règles des données, et parfois l’intention qui les sous-tend. Voilà le contenu véritable de l’expression git pour la base de données, et c’est l’épreuve à l’aune de laquelle les projets existants devraient être mesurés.
4. L’état de l’art, et ses limites
Le champ se divise nettement en trois groupes, et la division est instructive car chaque groupe se définit par ce qu’il abandonne. Le tableau 1 les met côte à côte.
Tableau 1. Où en sont les approches actuelles. PG natif désigne le véritable moteur PostgreSQL, avec ses extensions et son écosystème, plutôt qu’une réimplémentation de son protocole de communication. Le schéma est frappant : le seul projet doté d’une véritable fusion de données est celui qui quitte Postgres, et tout outil qui conserve Postgres renonce à la fusion.
| Projet | Approche | PG natif | Branche | Comparaison de données | Fusion de données | Modèle de conflit |
|---|---|---|---|---|---|---|
| Dolt | nouveau moteur, DAG Merkle | non | oui | oui | oui | par cellule, structurel |
| DoltgreSQL | nouveau moteur, protocole PG | non | oui | oui | oui | par cellule, structurel |
| Neon | stockage en copie sur écriture | oui | oui | non | non | aucun |
| Branches Supabase | instance par branche | oui | oui | schéma seulement | non | aucun |
| Outils temporels / d’audit | histoire linéaire | oui | non | dans le temps | non | aucun |
| Un protocole (proposé) | sur WAL + MVCC | oui | oui | oui | oui | sémantique, conscient des contraintes |
4.1 Réimplémenter le moteur : Dolt et DoltgreSQL
Dolt est la réalisation la plus complète de l’idée, et il mérite un vrai crédit. C’est une base de données SQL open source conçue de fond en comble pour être versionnée : son stockage est un graphe orienté acyclique de Merkle adressé par le contenu, structuré par des arbres probabilistes, souvent appelés prolly trees, qui lui donnent le partage structurel et les comparaisons rapides de git tout en demeurant une base indexée et interrogeable. Branche, comparaison, fusion, clonage, push et pull sont des opérations SQL et en ligne de commande de première classe. Dolt est, véritablement, git pour les données, et DoltgreSQL étend le même moteur pour parler le protocole de communication de PostgreSQL afin que les clients Postgres puissent s’y connecter.
Le coût est bien en vue dans cette phrase : conçue de fond en comble. Dolt n’est pas Postgres. C’est un nouveau moteur qui réimplémente une base de données et, dans le cas de DoltgreSQL, le protocole Postgres par-dessus. Une organisation qui l’adopte n’ajoute pas la gestion de versions au Postgres qu’elle exploite ; elle remplace Postgres par autre chose et hérite des caractéristiques de performance de cette autre chose et de la longue traîne d’extensions Postgres qu’elle ne reproduit pas, PostGIS et pgvector et le reste sur quoi s’appuient les systèmes de production. DoltgreSQL a atteint une version 1.0 en 2026 et se révèle d’une compatibilité impressionnante, mais être compatible avec le dialecte Postgres n’est pas la même chose qu’être Postgres. Pour un projet parti de zéro qui place la gestion de versions au-dessus de tout, cela peut être un échange équitable. Pour l’immense parc installé de Postgres de production, remplacer le moteur pour gagner la gestion de versions, c’est une très grosse queue qui remue un chien très important.
Il existe une limitation plus subtile, et elle importe pour l’argument à venir. La fusion de Dolt est calquée sur celle de git : elle opère une cellule à la fois, prenant les modifications de chaque côté par rapport à l’ancêtre commun et les combinant, et là où les deux côtés ont changé la même cellule, elle enregistre un conflit à résoudre par un humain. C’est une fusion structurelle, et c’est le bon comportement par défaut, mais elle est aveugle au sens. Elle ne sait pas que deux incréments concurrents d’un niveau de stock devraient s’additionner plutôt que de se heurter, ni que deux insertions partageant une clé naturelle ne sont pas une coïncidence mais une contradiction. Dolt détecte bien les violations de contraintes qu’une fusion introduit et les fait remonter pour résolution plutôt que de valider en silence un état rompu, ce qui est à son crédit, mais une détection après coup n’est pas la même chose qu’une fusion qui comprend le sens des données. Le modèle structurel est le plafond de ce que peut faire une fusion par cellule.
4.2 Créer des branches dans le stockage : Neon et Supabase
Le deuxième groupe conserve Postgres, précisément ce que Dolt abandonne, et achète ses branches plus bas dans la pile. Neon refond l’architecture du stockage de Postgres, séparant le calcul d’un service de stockage multiversion et structuré en journal, et les branches découlent de cette conception presque gratuitement : une branche est une bifurcation en copie sur écriture du stockage à un point choisi du journal, créée en quelques secondes quelle que soit la taille de la base, car rien n’est copié avant d’être écrit. Supabase propose des branches dans un esprit similaire, dressant une instance Postgres distincte par branche et la raccordant à un flux de prévisualisation piloté par Git, et le même motif de copie sur écriture parcourt tout l’écosystème, des branches porteuses de données de Xata aux clones légers ZFS de Postgres.ai. Tous sont réellement utiles, et pour la boucle de développement et de test de la section 2, ils sont proches de l’idéal.
Mais regardez à nouveau le tableau. Ce sont des branches qui peuvent bifurquer et jamais ne rejoindre. Neon peut créer une branche à un instant et diverger d’elle ; il ne peut pas refondre les modifications de données de cette branche dans son parent, car rien dans une bifurcation de stockage en copie sur écriture ne sait réconcilier deux ensembles d’écritures de pages divergentes en un seul état cohérent et respectueux des contraintes. Ce n’est pas un oubli à corriger ; c’est la conséquence de résoudre le problème à la couche de stockage, où l’unité est une page opaque, plutôt qu’à la couche logique, où l’unité est une ligne porteuse de sens. Les branches de Supabase sont orientées vers les migrations de schéma pour les environnements de prévisualisation, non vers la fusion de données. Le résultat est un puissant clonage en copie sur écriture, chose réelle et précieuse, revêtant le vocabulaire de la gestion de versions tout en n’en livrant que la moitié facile. Appeler branche une bifurcation sans fusion, c’est emprunter une promesse que la conception ne peut tenir.
4.3 Journaliser l’histoire : tables temporelles et pistes d’audit
Un troisième groupe est parfois entraîné dans la même conversation et devrait en être distingué. Les tables temporelles versionnées par le système, telles que normalisées dans SQL:2011 et approchées dans Postgres par des extensions comme temporal_tables, et les cadres d’audit comme pgMemento, donnent une histoire à une table : chaque ligne porte l’intervalle de temps durant lequel elle était en vigueur, et l’on peut interroger la base telle qu’elle se présentait à n’importe quel instant passé. C’est précieux, et cela fournit la provenance et la lecture à un instant donné que réclamait la section 2. Mais c’est une histoire unique et linéaire. Il n’y a ni branche ni fusion, aucune ligne de travail parallèle à réconcilier. Le voyage dans le temps n’est pas la gestion de versions ; il en est un axe, celui qu’il fut toujours le plus facile d’ajouter.
4.4 Trois préoccupations, fusionnées à tort
Prenez du recul et le schéma est clair. Chaque projet répond aux trois mêmes questions d’un coup et en regroupe les réponses en un produit unique : comment l’histoire est modélisée, comment une version est physiquement stockée, et comment les conflits sont résolus. Dolt fusionne un modèle de versions à la git à un moteur de stockage sur mesure et à un modèle de conflit par cellule, et pour obtenir le premier il faut prendre les trois. Neon fusionne un modèle de versions mince à un moteur de stockage en copie sur écriture et à aucun modèle de conflit. Parce que les trois sont soudés ensemble, vous ne pouvez pas conserver Postgres et avoir tout de même la fusion, et vous ne pouvez obtenir de personne une fusion sémantique, car le modèle de conflit est ce que le moteur de stockage a rendu facile. Le faux choix que présente le champ, Postgres sans fusion ou fusion sans Postgres, est un artéfact de la fusion de préoccupations logiquement séparées. Séparez-les et une meilleure conception apparaît.
5. Une meilleure voie : un protocole, non une bifurcation
Notre proposition est de cesser de construire des bases versionnées et de commencer à définir un protocole de gestion de versions pour la base que nous avons déjà. Le geste est le même que celui de git lui-même : le génie de git fut de séparer le modèle d’objets, commits, arbres et refs, du transport qui les déplace, afin que le modèle puisse survivre à toute implémentation particulière. La gestion de versions des bases devrait séparer le modèle de versions, commits, branches et fusions, du stockage physique qui les matérialise, afin qu’elle puisse tourner sur du Postgres standard au lieu d’exiger un nouveau moteur. La figure 2 en montre la forme.
5.1 Le substrat que Postgres fournit déjà
Le fait frappant, et le cœur de notre argument, est l’ampleur de la machinerie que Postgres possède déjà. Son contrôle de concurrence multiversion conserve plusieurs versions de chaque ligne et remet à chaque transaction un instantané cohérent de la base à un instant logique : c’est un commit, à son nom près. Son journal d’écriture anticipée est un relevé ordonné et durable de chaque modification jamais appliquée, autrement dit un reflog. Et le décodage logique, le mécanisme mûr qui alimente déjà la réplication logique, transforme ce journal en un flux propre et ordonné de modifications au niveau des lignes que tout client peut consommer. Trois des quatre primitives de git, les instantanés immuables, un journal d’histoire et un flux de modifications, se trouvent déjà au sein de Postgres, comme le montrait la figure 1. Un protocole n’a pas besoin de les reconstruire. Il lui suffit d’ajouter les deux choses qui manquent à Postgres : des refs nommées persistantes sur cette histoire, et une fusion qui comprend les données.
Capturer des commits, dès lors, consiste à consommer le flux de décodage logique et à enregistrer les modifications de chaque transaction comme un jeu de modifications adressé par le contenu, haché par son contenu afin que des modifications identiques partagent le stockage et que tout jeu de modifications puisse être nommé et récupéré par son hachage. Un slot est créé une fois, et les modifications sont drainées et stockées :
SELECT pg_create_logical_replication_slot(
'vc', 'pgoutput');
-- les modifications de chaque transaction, dans l'ordre,
-- hachées et stockées comme objet commit
SELECT * FROM pg_logical_slot_get_changes(
'vc', NULL, NULL);
Rien ici ne bifurque le moteur ni n’atteint sous la ligne. Le protocole lit ce que Postgres émet déjà et bâtit le graphe de versions à côté.
5.2 Commits, refs et branches
Avec des jeux de modifications pour commits, le reste de la moitié facile est de la tenue de comptes. Un commit enregistre son parent ou ses parents et le hachage de contenu du jeu de modifications qu’il introduit, formant le même graphe orienté acyclique immuable qu’utilise git. Une ref est un nom pointant vers un commit, et une branche est une ref qui se déplace à mesure que de nouveaux commits lui sont ajoutés. Ces métadonnées sont menues, ce sont des données relationnelles ordinaires, et elles peuvent résider dans un schéma au sein de la base même qu’elles versionnent ou dans un magasin compagnon. Parce qu’un commit est défini par des modifications logiques adressées par le contenu plutôt que par des pages physiques, il est portable : il signifie la même chose sur n’importe quel Postgres, sur site ou dans n’importe quel cloud, ce qui est précisément la propriété qu’une bifurcation de stockage en copie sur écriture ne peut offrir. Le modèle de versions est pur protocole, et il ne porte aucun enfermement.
5.3 Fusion sémantique et consciente des contraintes
Voici la moitié ardue, et le lieu où un protocole peut faire ce qu’aucun outil actuel ne fait. Parce que les commits sont des jeux de modifications logiques plutôt que des pages opaques, une fusion à trois voies peut opérer là où réside le sens. Étant donné deux branches et leur ancêtre commun, le protocole calcule les modifications au niveau des lignes de chaque côté et les combine, puis fait les deux choses qui distinguent une fusion de base de données d’une fusion de texte. D’abord, il valide le résultat proposé contre le schéma vivant, chaque contrainte, chaque clé et chaque relation de clé étrangère, afin qu’une fusion ne puisse jamais valider un état que la base rejetterait ; une violation est levée comme un conflit, non écrite comme une corruption. Ensuite, et c’est là la véritable avancée, il résout les recouvrements au moyen de politiques déclarées par table et par colonne par les personnes qui possèdent le sens des données, plutôt que par une seule règle aveugle par cellule.
Ces politiques sont là où entre l’intention du domaine. Une colonne de compteur peut être déclarée fusionner en additionnant les deltas appliqués de chaque côté, le comportement d’un type de données répliqué convergent, de sorte que deux incréments concurrents s’additionnent correctement au lieu de se heurter. Un horodatage de dernière mise à jour peut fusionner en prenant la valeur la plus récente. Une relation à valeur d’ensemble peut fusionner par union. Une collision de clé naturelle peut être déclarée conflit inconditionnel, car le sens du schéma dit que les deux lignes sont la même entité. Là où aucune politique ne s’applique et où les deux côtés ont touché la même valeur, le protocole fait exactement ce que fait git et s’arrête pour un humain, présentant le conflit en termes de lignes et de valeurs plutôt que de pages. Une déclaration pourrait se lire aussi simplement que ceci :
MERGE POLICY ON inventory (on_hand)
USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
USING conflict; -- même SKU, même article
C’est l’élément dont l’art antérieur montre la possibilité. Des systèmes adressés par le contenu dotés de fonctions de fusion définies par l’utilisateur existent déjà hors du monde relationnel : Irmin, le magasin à la git derrière certaines parties du projet MirageOS, est bâti autour exactement de cette idée de données fusionnables avec une logique de fusion personnalisée, et la littérature sur les types de données répliqués convergents et commutatifs rend un compte rigoureux du moment où des modifications concurrentes peuvent être fusionnées sans conflit. La théorie de la confluence invariante, de Bailis et ses collègues, va un pas plus loin et nous dit précisément quels invariants une fusion peut préserver sans coordination et lesquels, l’unicité globale et les clés étrangères parmi eux, provablement ne le peut pas. Ce n’est pas un conseil de désespoir ; c’est la raison pour laquelle une collision de clé naturelle doit être déclarée conflit plutôt qu’écartée par le vœu, et cela dit à un protocole exactement où une politique automatique est sûre et où un humain doit trancher. Ce qui n’a pas été fait, c’est d’apporter cette fusion sémantique au Postgres natif et transactionnel, gouverné par les contraintes propres du schéma. Voilà le problème ouvert qui mérite d’être résolu, et celui que les produits de branches ont contourné plutôt que traversé.
5.4 La matérialisation comme optimisation
Une objection recevable est que rejouer les modifications logiques pour reconstruire une branche pourrait être lent pour une grande base. La réponse est le découplage lui-même : la manière dont une branche est physiquement matérialisée ne fait pas partie du modèle de versions, elle peut donc être choisie librement et changée plus tard. Une branche peut être rejouée depuis les jeux de modifications quand elle est petite ou rarement utilisée, ou dressée comme instantané en copie sur écriture quand elle doit être rapide, à l’aide d’instantanés de système de fichiers tels que ZFS ou du stockage même en copie sur écriture que Neon et ses semblables ont construit. Autrement dit, les excellents moteurs à bifurcation rapide ne sont pas des concurrents de ce protocole ; ils en sont un backend possible pour la matérialisation, la fusion et le modèle de versions portable étant fournis au-dessus d’eux. Le protocole dit ce que signifient une branche et une fusion ; la couche de stockage est libre de les rendre rapides.
5.5 Des limites honnêtes
Nous ne prétendons pas que c’est facile, et un article de position qui ferait mine du contraire mériterait la méfiance. La fusion sémantique est véritablement ardue : écrire des politiques par table correctes demande du soin, les branches longuement divergentes accumulent des conflits qu’aucune politique ne peut résoudre sans jugement, et les flux de modifications à très fort volume soulèvent de vraies questions de stockage et de débit pour le journal de commits. Valider une grande fusion contre chaque contrainte a un coût, et certains invariants, comme le prouve la théorie de la confluence invariante, ne peuvent être réconciliés sans coordination du tout, aussi un protocole honnête les fait-il remonter comme des conflits plutôt que de feindre de les résoudre. Ce sont les raisons pour lesquelles le problème demeure ouvert, non des raisons de le déclarer insoluble. Ce qu’achète l’approche par protocole, c’est que la partie ardue, la fusion, est abordée au seul endroit où elle peut l’être bien, à la couche logique, le schéma en main, au lieu d’être abandonnée à la couche de stockage ou aplatie en une règle par cellule. Cela signifie aussi que le travail se cumule : parce que c’est un protocole sur du Postgres standard, chaque amélioration du moteur, chaque extension, chaque outil d’exploitation continue de fonctionner en dessous.
6. Ce que cela signifie en pratique
Pour une organisation qui choisit aujourd’hui, le conseil honnête suit le tableau. Si ce qu’il vous faut, ce sont des bases peu coûteuses et instantanées pour le développement, les tests et les prévisualisations de pull requests, les outils de branches en copie sur écriture sont excellents et vous devriez les employer, en ayant les idées claires qu’une branche y est une bifurcation jetable, non une ligne de travail que vous fusionnerez en retour. Si vous partez de zéro et que la gestion de versions est la raison d’être du système, Dolt est un outil sérieux et capable, pourvu que vous acceptiez de choisir un nouveau moteur plutôt que d’étendre Postgres. Et si ce que vous voulez est la promesse entière, créer des branches, comparer et fusionner sur le Postgres de production que vous exploitez et en qui vous avez déjà confiance, la réponse honnête est qu’aucun produit ne la livre encore, et ce sur quoi il convient de parier est un protocole bâti sur les primitives propres de Postgres plutôt qu’une nouvelle bifurcation du moteur ou du stockage.
Cette dernière position est celle que tient Nashua, et elle est d’une seule pièce avec la façon dont nous lisons tout ce paysage. Nous privilégions les outils best-of-breed et les standards ouverts aux plateformes à fournisseur unique, et nous nous méfions de l’enfermement partout où il se cache, y compris à l’intérieur d’une couche de stockage qui peut créer des branches mais ne laisse jamais vos données partir à conditions égales. Un modèle de versions qui est pur protocole, portable sur n’importe quel Postgres et n’importe quelle infrastructure, sur site ou cloud, laisse fermement à l’organisation le choix d’où et de comment exécuter. Le cloud et l’hébergement sur site sont l’un comme l’autre de bons foyers pour les données ; un protocole qui ne se soucie pas duquel est précisément l’enjeu.
7. Conclusion
La base de données mérite la gestion de versions qui a transformé toute autre partie du génie logiciel, et les projets qui poursuivent ce but ont raison de le poursuivre. Mais l’enjeu est la fusion, non la seule branche, et le champ s’est scindé entre des outils qui fusionnent en quittant Postgres et des outils qui conservent Postgres en renonçant à la fusion. Cette scission n’est pas inévitable. Elle vient de la fusion de trois préoccupations séparables, le modèle de versions, le stockage physique et la résolution de conflits, en un seul produit. Séparez-les, bâtissez le modèle de versions comme un protocole sur le journal d’écriture anticipée, le stockage multiversion et le décodage logique que Postgres fournit déjà, et placez une fusion sémantique et consciente des contraintes en son centre, et le faux choix se dissout. Git a gagné sa place en séparant le modèle de la machine. Les données méritent la même chose, et Postgres, de manière presque unique, possède déjà les pièces pour la rendre réelle. Nashua préférerait aider à construire cela que d’en vendre une bifurcation.
References
DoltHub (2026). Dolt: Git for Data. https://github.com/dolthub/dolt
DoltHub (2026). Prolly Trees: the data structure behind Dolt. https://docs.dolthub.com/architecture/storage-engine/prolly-tree
DoltHub (2026). DoltgreSQL: a Postgres-flavoured Dolt. https://github.com/dolthub/doltgresql
DoltHub (2026). Merge and conflict resolution in Dolt. https://docs.dolthub.com/sql-reference/version-control/merges
Neon (2026). Branching in Neon: copy-on-write Postgres. https://neon.tech/docs/introduction/branching
Supabase (2026). Branching documentation. https://supabase.com/docs/guides/deployment/branching
The PostgreSQL Global Development Group (2026). PostgreSQL documentation: Logical Decoding. https://www.postgresql.org/docs/current/logicaldecoding.html
The PostgreSQL Global Development Group (2026). PostgreSQL documentation: Concurrency Control (MVCC). https://www.postgresql.org/docs/current/mvcc.html
The PostgreSQL Global Development Group (2026). PostgreSQL documentation: Write-Ahead Logging (WAL). https://www.postgresql.org/docs/current/wal-intro.html
Al-Kateb, M. et al.; ISO/IEC 9075:2011 (SQL:2011) system-versioned tables; and temporal_tables for PostgreSQL. https://github.com/arkhipov/temporal_tables
Bitterlich, F. (2026). pgMemento: audit trail and versioning for PostgreSQL. https://github.com/pgMemento/pgMemento
Chacon, S. and Straub, B. (2014). Pro Git, 2nd edition, Apress. https://git-scm.com/book
Shapiro, M., Preguiça, N., Baquero, C. and Zawirski, M. (2011). Conflict-free Replicated Data Types. SSS 2011. https://hal.inria.fr/inria-00609399
Bailis, P., Fekete, A., Franklin, M. J., Ghodsi, A., Hellerstein, J. M. and Stoica, I. (2015). Coordination Avoidance in Database Systems, which introduces invariant confluence. VLDB. https://arxiv.org/abs/1402.2237
Xata and ClickHouse (2026). Managed Postgres with instant branching. https://clickhouse.com/blog/managed-postgres-ga-xata-acquisition
Postgres.ai (2026). Database Lab Engine: instant thin clones of PostgreSQL. https://postgres.ai/
Gazagnaire, T. et al. (2026). Irmin: a distributed, git-like, mergeable store. https://irmin.org/
TerminusDB (2026). TerminusDB: a git-like graph database. https://terminusdb.com/
PlanetScale (2026). Branching and deploy requests. https://planetscale.com/docs/concepts/branching
