november 2026

Version control for transactional data

Een git-achtig protocol voor PostgreSQL: het waarom, het wat en het hoe; de open-source projecten die het al bouwen, waar hun ontwerp tekortschiet, en een betere weg gebouwd op wat Postgres al heeft.

Samenvatting

Softwareteams versiebeheren hun code met git en zouden er niet van dromen zonder te werken, en toch wordt de database onder die code, de waardevolste en minst omkeerbare staat die een organisatie bezit, nog altijd ter plaatse bewerkt, zonder branch, zonder diff en zonder merge. Een levendig veld van open-source projecten belooft die kloof te dichten en git naar de database te brengen, en dit artikel zet het waarom, het wat en het hoe uiteen. Wij betogen dat de echte winst niet het branchen is maar het mergen, het vermogen om uiteenlopende lijnen van transactionele data te verzoenen, en wij laten zien dat het veld uiteen is gevallen in twee kampen die elk de helft van het probleem opgeven: Dolt en DoltgreSQL winnen echte git-semantiek door de database-engine opnieuw te bouwen en native Postgres achter zich te laten, terwijl Neon en Supabase Postgres behouden maar een branch bieden die wel kan aftakken en nooit weer kan samenkomen. Wij stellen een betere weg voor. Geen afgesplitste engine en geen afgesplitste opslaglaag, maar een versiebeheerprotocol gebouwd op de write-ahead log, multiversion concurrency en logical decoding die Postgres al meelevert, met een semantische, constraint-bewuste merge als eersterangsoperatie. Versiebeheer voor data zou het versiemodel van de opslag moeten scheiden, zoals git het objectmodel van het transport scheidde.

Trefwoorden: PostgreSQL; databaseversiebeheer; git voor data; data-branching; schemamigratie; three-way merge; conflictoplossing; write-ahead log; logical decoding; multiversion concurrency control; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; temporele tabellen; dataherkomst; digitale soevereiniteit

1. Inleiding

Vraag een ontwikkelaar om een dag zonder git te werken en je krijgt een botte weigering. Branchen, committen, diffen en mergen zijn zo verweven met hoe software gebouwd wordt dat hun afwezigheid ondenkbaar is. Vraag diezelfde ontwikkelaar nu hoe zij de productiedatabase versiebeheren, het schema en de data die de code bestaat om te bedienen, en het antwoord is bijna altijd een beschaamd niets. De database wordt ter plaatse bewerkt. Een migratie draait voorwaarts en als het misgaat is een panische herstelactie vanuit de back-up van gisteravond de enige weg terug. Twee engineers kunnen niet tegen uiteenlopende kopieën van de data ontwikkelen en deze later verzoenen; zij wisselen elkaar af, of zij overschrijven elkaar. De waardevolste en minst omkeerbare staat die een organisatie bezit, is het ene onderdeel van de stack zonder enig versiebeheer.

Dit is een vreemde kloof, en een groeiend veld van open-source projecten heeft zich voorgenomen die te dichten onder een vaandel dat iedereen begrijpt: git voor je database. De pitch is onmiddellijk aantrekkelijk. Branch de database om een riskante wijziging geïsoleerd te proberen. Diff twee versies om precies te zien wat een migratie deed. Geef elke analist zijn eigen lijn van data en merge het goede werk terug. Reis naar elke voorbije staat even gemakkelijk als git checkout. Als versiebeheer veranderde hoe wij code schrijven, zo luidt het betoog, dan kan het veranderen hoe wij data beheren.

Wij denken dat het betoog klopt, en dit is een opinieartikel over hoe het waar te maken. Wij leggen uit waarom versiebeheerde data ertoe doet (paragraaf 2), wat een git-achtig protocol werkelijk moet bieden, wat meer en lastiger is dan het eerst lijkt (paragraaf 3), en waar de projecten van vandaag staan, met waardering waar die verdiend is en een heldere beschouwing van waar hun ontwerpen tekortschieten (paragraaf 4). Vervolgens voeren wij ons pleidooi: dat het veld zichzelf in een valse keuze heeft gemanoeuvreerd, en dat de betere weg voor Postgres een protocol is gebouwd op de primitieven die het al meelevert in plaats van een nieuwe engine of een niet-mergebare fork (paragraaf 5). Nashua onderschrijft best-of-breed gereedschappen en gedegen praktijk boven welk enkel product dan ook, en dat is hier de geest: geen pleidooi voor één project, maar een betoog over hoe dit gebouwd zou moeten worden.

2. Waarom de database versiebeheren

Het pleidooi begint met het werk dat mensen nu al slecht met de hand doen. Schemamigraties zijn het voor de hand liggende voorbeeld. Elk team dat een database draait, draait migraties, en elk team heeft de bijzondere angst gevoeld van een migratie die niet schoon ongedaan gemaakt kan worden. Een versiebeheerde database maakt van een migratie een commit: omkeerbaar, inspecteerbaar en testbaar op een branch voordat die de productie raakt. De diff is geen gok op basis van het migratiescript; het is de werkelijke wijziging aan schema en data, berekend en beoordeelbaar als elke willekeurige pull request.

Dan is er de ontwikkel- en testlus. Moderne teams willen een realistische database voor elke feature-branch en elke pull-request-preview, gevuld met productieachtige data, in seconden opgestart en weggegooid wanneer de branch mergt. Dat doen door volledige kopieën te herstellen is traag en duur; het doen door één database te delen nodigt uit tot botsingen. Goedkope, directe branches lossen een reëel en dagelijks probleem op, wat precies de reden is dat de branchingproducten een gretige markt gevonden hebben.

Voorbij de dagelijkse lus liggen de diepere redenen. Reproduceerbaarheid: een datawetenschapper die een analyse kan vastpinnen aan een exact vastgelegde staat van de data, kan een resultaat maanden later reproduceren, en zo ook de auditor die het in twijfel trekt. Herkomst en audit: een database wiens historie een keten van ondertekende commits is, beantwoordt wie wat veranderde, en wanneer, door constructie in plaats van door een erop geschroefde trigger. Dit is geen franje in gereguleerde sectoren; het DORA-regime van de Europese Unie en zijn verwanten verwachten dat financiële entiteiten de integriteit en traceerbaarheid van hun data aantonen, en een versiebeheerde historie is aantoonbaar op een manier die een muteerbare tabel niet is. Herstel: point-in-time-herstel houdt op een back-upoperatie te zijn en wordt een checkout. En samenwerking wordt eindelijk mogelijk op data zoals die het op code is, met onafhankelijke lijnen van werk die samenkomen door review in plaats van door vergrendeling.

Niets hiervan is exotisch. Het is de gewone machinerie van software-engineering, toegepast op het ene bezit dat zich er hardnekkig tegen verzet heeft. De vraag is niet of de database versiebeheer verdient. Dat verdient hij duidelijk. De vraag is wat er nodig zou zijn om hem het echte werk te geven.

3. Wat een git-achtig protocol betekent

Het loont de moeite om precies te zijn over wat git werkelijk biedt, want de gemakkelijke helft wordt routinematig voor het geheel aangezien. Git is een inhoudsgeadresseerde objectopslag: elke versie van elk bestand is een blob genoemd naar de hash van zijn inhoud, trees stellen blobs samen tot een momentopname, en een commit noemt een tree samen met zijn ouders, en vormt zo een onveranderlijke gerichte acyclische graaf van historie. Boven op die opslag zitten twee lagen van gemak: refs, dat zijn menselijke namen voor punten in de graaf, zodat main en feature slechts labels op commits zijn; en operaties, waarvan diff en merge degene zijn die ertoe doen.

De beslissende operatie, degene die van git een samenwerkingsgereedschap maakt in plaats van een opgedirkte back-up, is de three-way merge. Wanneer twee branches uiteenlopen, vraagt git niet welke wint. Het vindt hun gemeenschappelijke voorouder, berekent wat elke kant veranderde ten opzichte van die voorouder, en combineert de wijzigingen, en markeert alleen de plaatsen waar beide kanten hetzelfde ding op onverenigbare wijzen aanraakten. Dat is wat honderd mensen in parallel laat werken en laat samenkomen. Branchen zonder mergen is slechts een goedkope kopie; branchen met mergen is versiebeheer.

Draag dit over naar een database en de afbeelding is suggestief maar niet triviaal, zoals figuur 1 uiteenzet. Een commit zou een onveranderlijke momentopname van de hele database op een logisch moment moeten zijn. Een branch zou een genoemde lijn van zulke momentopnamen moeten zijn. Een diff zou de rijen en schema-objecten moeten rapporteren die tussen twee commits veranderden. En een merge zou twee uiteenlopende lijnen van data tot één moeten verzoenen. De eerste drie zijn in wezen een opslag- en naamgevingsprobleem. De vierde is de moeilijke, en het is waar de analogie met git ophoudt comfortabel te zijn.

Figuur 1. Het git-objectmodel geprojecteerd op Postgres. Drie van de vier bouwstenen van git bestaan al binnen Postgres als de MVCC-momentopname, de write-ahead log en logical decoding; wat ontbreekt is een persistente branch-ref en, bovenal, een merge die de data begrijpt. Een protocol hoeft alleen de twee warme kaders te leveren, niet de drie blauwe opnieuw te bouwen.
Figuur 1. Het git-objectmodel geprojecteerd op Postgres. Drie van de vier bouwstenen van git bestaan al binnen Postgres als de MVCC-momentopname, de write-ahead log en logical decoding; wat ontbreekt is een persistente branch-ref en, bovenal, een merge die de data begrijpt. Een protocol hoeft alleen de twee warme kaders te leveren, niet de drie blauwe opnieuw te bouwen.

Tekst mergt omdat een bronbestand een regel-geordende reeks is zonder regels over zijn inhoud; git kan twee sets regelwijzigingen aan elkaar lassen en het resultaat is per definitie nog steeds een geldig bestand. Een database is niet zo. Haar inhoud wordt beheerst door invarianten: primaire sleutels moeten uniek blijven, foreign keys moeten oplossen, check-constraints moeten standhouden, en, boven dat alles, de data moet nog steeds iets betekenen. Twee branches die elk een klant met dezelfde natuurlijke sleutel invoegen, hebben geen mergeconflict in de tekstuele zin geproduceerd; zij hebben een staat geproduceerd die het schema verbiedt. Twee branches die elk een rekeningsaldo met een ander bedrag verlagen, kunnen niet beide eenvoudigweg winnen. Een merge voor data moet de regels van de data respecteren, en soms de bedoeling erachter. Dat is de werkelijke inhoud van de frase git voor de database, en het is de toets waaraan de bestaande projecten gemeten zouden moeten worden.

4. De stand van de techniek, en waar die tekortschiet

Het veld valt netjes uiteen in drie groepen, en de verdeling is leerzaam omdat elke groep bepaald wordt door wat zij opgeeft. Tabel 1 zet ze naast elkaar.

Tabel 1. Waar de huidige benaderingen staan. Native PG betekent de echte PostgreSQL-engine, met zijn extensies en ecosysteem, in plaats van een herimplementatie van zijn wire-protocol. Het patroon is scherp: het enige project met echte data-merge is het project dat Postgres verlaat, en elk gereedschap dat Postgres behoudt, geeft merge op.

Project Aanpak Native PG Branch Data-diff Data-merge Conflictmodel
Dolt nieuwe engine, Merkle-DAG nee ja ja ja celgewijs, structureel
DoltgreSQL nieuwe engine, PG-wire nee ja ja ja celgewijs, structureel
Neon copy-on-write-opslag ja ja nee nee geen
Supabase-branching instantie per branch ja ja alleen schema nee geen
Temporele / audit-tools lineaire historie ja nee in de tijd nee geen
Een protocol (voorgesteld) over WAL + MVCC ja ja ja ja semantisch, constraint-bewust

4.1 De engine herimplementeren: Dolt en DoltgreSQL

Dolt is de meest complete realisatie van het idee, en het verdient echte waardering. Het is een open-source SQL-database die vanaf de grond op is gebouwd om versiebeheerd te zijn: zijn opslag is een inhoudsgeadresseerde Merkle gerichte acyclische graaf, gestructureerd met probabilistische bomen, vaak prolly trees genoemd, die het de structurele deling en snelle diffs van git geven terwijl het een geïndexeerde, bevraagbare database blijft. Branch, diff, merge, clone, push en pull zijn eersterangs SQL- en opdrachtregeloperaties. Dolt is, werkelijk, git voor data, en DoltgreSQL breidt dezelfde engine uit om het PostgreSQL-wire-protocol te spreken zodat Postgres-clients kunnen verbinden.

De kosten liggen in die zin voor het grijpen: vanaf de grond op gebouwd. Dolt is geen Postgres. Het is een nieuwe engine die een database herimplementeert en, in het geval van DoltgreSQL, het Postgres-protocol daar bovenop. Een organisatie die het adopteert, voegt geen versiebeheer toe aan de Postgres die zij draait; zij vervangt Postgres door iets anders en erft de prestatiekenmerken van dat iets en de lange staart van Postgres-extensies die het niet reproduceert, PostGIS en pgvector en de rest waar productiesystemen op leunen. DoltgreSQL bereikte een 1.0-release in 2026 en is indrukwekkend compatibel, maar compatibel met het Postgres-dialect is niet hetzelfde als Postgres zijn. Voor een greenfield-project dat versiebeheer boven alles waardeert, kan dat een eerlijke ruil zijn. Voor de enorme geïnstalleerde basis van productie-Postgres is de engine vervangen om versiebeheer te winnen een zeer grote staart die met een zeer belangrijke hond kwispelt.

Er is een subtielere beperking, en die doet ertoe voor het komende betoog. De merge van Dolt is gemodelleerd op die van git: hij werkt een cel tegelijk, neemt de wijzigingen van elke kant ten opzichte van de gemeenschappelijke voorouder en combineert ze, en waar beide kanten dezelfde cel veranderden, legt hij een conflict vast voor een mens om op te lossen. Dit is structurele merge, en het is de juiste standaard, maar hij is semantisch blind. Hij weet niet dat twee gelijktijdige verhogingen van een voorraadniveau zouden moeten optellen in plaats van botsen, of dat twee invoegingen die een natuurlijke sleutel delen geen toeval zijn maar een tegenspraak. Dolt detecteert wél constraintschendingen die een merge introduceert en brengt ze naar voren voor oplossing in plaats van stilzwijgend een kapotte staat vast te leggen, wat het siert, maar detectie achteraf is niet hetzelfde als een merge die de betekenis van de data begrijpt. Het structurele model is het plafond van wat celgewijze merge kan doen.

4.2 De opslag branchen: Neon en Supabase

De tweede groep behoudt Postgres, precies het ding dat Dolt opgeeft, en koopt zijn branching lager in de stack. Neon herarchitecteert de Postgres-opslag, scheidt compute van een multiversion, loggestructureerde opslagdienst, en branching valt bijna gratis uit dat ontwerp: een branch is een copy-on-write-aftakking van de opslag op een gekozen punt in de log, in seconden aangemaakt ongeacht hoe groot de database is, omdat er niets gekopieerd wordt totdat het geschreven wordt. Supabase biedt branching in eenzelfde geest, zet een aparte Postgres-instantie per branch op en draadt die in een Git-gedreven preview-workflow, en hetzelfde copy-on-write-patroon loopt dwars door het ecosysteem heen, van de datadragende branches van Xata tot de ZFS-thin-clones van Postgres.ai. Allemaal zijn zij werkelijk nuttig, en voor de ontwikkel- en testlus van paragraaf 2 benaderen zij het ideaal.

Maar kijk nog eens naar de tabel. Dit zijn branches die wel kunnen aftakken en nooit weer kunnen samenkomen. Neon kan een branch op een moment aanmaken en daarvan uiteenlopen; het kan de datawijzigingen van die branch niet terugmergen in zijn ouder, omdat niets in een copy-on-write-opslagaftakking weet hoe het twee sets uiteenlopende paginaschrijvingen tot één coherente, constraint-respecterende staat moet verzoenen. Dat is geen vergetelheid om te verhelpen; het is het gevolg van het probleem oplossen op de opslaglaag, waar de eenheid een ondoorzichtige pagina is, in plaats van op de logische laag, waar de eenheid een rij met betekenis is. De branches van Supabase zijn gericht op schemamigraties voor preview-omgevingen, niet op het mergen van data überhaupt. Het resultaat is krachtig copy-on-write-klonen, wat een reëel en waardevol ding is, getooid met het vocabulaire van versiebeheer terwijl het slechts de gemakkelijke helft ervan levert. Een aftakking zonder een merge een branch noemen leent een belofte die het ontwerp niet kan nakomen.

4.3 Historie loggen: temporele tabellen en audit trails

Een derde groep wordt soms in hetzelfde gesprek meegezogen en zou onderscheiden moeten worden. Systeem-versiebeheerde temporele tabellen, zoals gestandaardiseerd in SQL:2011 en benaderd in Postgres door extensies zoals temporal_tables, en auditraamwerken zoals pgMemento, geven een tabel een historie: elke rij draagt de tijdspanne waarvoor hij actueel was, en je kunt de database bevragen zoals die op elk voorbij moment stond. Dit is waardevol, en het levert de herkomst en het point-in-time-lezen die paragraaf 2 vroeg. Maar het is een enkele, lineaire historie. Er is geen branch en geen merge, geen parallelle lijnen van werk om te verzoenen. Tijdreizen is geen versiebeheer; het is er één as van, degene die altijd het gemakkelijkst toe te voegen was.

4.4 Drie zorgen, verkeerd versmolten

Neem afstand en het patroon is helder. Elk project beantwoordt dezelfde drie vragen tegelijk, en bundelt de antwoorden in één product: hoe historie gemodelleerd wordt, hoe een versie fysiek opgeslagen wordt, en hoe conflicten opgelost worden. Dolt versmelt een git-achtig versiemodel met een op maat gemaakte opslag-engine en een celgewijs conflictmodel, en om het eerste te krijgen moet je alle drie nemen. Neon versmelt een dun versiemodel met een copy-on-write-opslag-engine en helemaal geen conflictmodel. Omdat de drie aan elkaar gelast zijn, kun je Postgres niet behouden en toch merge hebben, en kun je van niemand semantische merge hebben, omdat het conflictmodel is wat de opslag-engine toevallig gemakkelijk maakte. De valse keuze die het veld presenteert, Postgres zonder merge of merge zonder Postgres, is een artefact van het versmelten van zorgen die logisch gescheiden zijn. Trek ze uit elkaar en een beter ontwerp verschijnt.

5. Een betere weg: een protocol, geen fork

Ons voorstel is om te stoppen met het bouwen van versiebeheerde databases en te beginnen met het definiëren van een versiebeheerprotocol voor de database die wij al hebben. De zet is dezelfde die git zelf maakte: de genialiteit van git was om het objectmodel, commits en trees en refs, te scheiden van het transport dat ze rondbeweegt, zodat het model elke bepaalde implementatie kon overleven. Databaseversiebeheer zou het versiemodel, commits en branches en merges, moeten scheiden van de fysieke opslag die ze materialiseert, zodat het op standaard-Postgres kan draaien in plaats van een nieuwe engine te vereisen. Figuur 2 toont de vorm ervan.

Figuur 2. Een versiebeheerprotocol over native Postgres. De engine aan de basis is ongewijzigd, standaard-Postgres met zijn constraints en extensies intact. Daarboven legt logical decoding wijzigingen vast als inhoudsgeadresseerde commits, levert een dunne modellaag branches en refs, en verzoent semantische merge, het ene werkelijk moeilijke deel, divergentie door te valideren tegen het levende schema en per-tabel-beleid toe te passen. Hoe een branch fysiek gematerialiseerd wordt, is een verwisselbare optimalisatie, geen deel van het contract.
Figuur 2. Een versiebeheerprotocol over native Postgres. De engine aan de basis is ongewijzigd, standaard-Postgres met zijn constraints en extensies intact. Daarboven legt logical decoding wijzigingen vast als inhoudsgeadresseerde commits, levert een dunne modellaag branches en refs, en verzoent semantische merge, het ene werkelijk moeilijke deel, divergentie door te valideren tegen het levende schema en per-tabel-beleid toe te passen. Hoe een branch fysiek gematerialiseerd wordt, is een verwisselbare optimalisatie, geen deel van het contract.

5.1 Het substraat dat Postgres al meelevert

Het opvallende, en het hart van ons betoog, is hoeveel van de machinerie Postgres al heeft. Zijn multiversion concurrency control houdt meerdere versies van elke rij bij en overhandigt elke transactie een consistente momentopname van de database op een logisch moment: dat is een commit in alles behalve de naam. Zijn write-ahead log is een geordend, duurzaam register van elke wijziging die ooit is toegepast, wat wil zeggen een reflog. En logical decoding, het volwassen mechanisme dat al logische replicatie aandrijft, verandert die log in een schone, geordende stroom van wijzigingen op rijniveau die elke client kan consumeren. Drie van de vier primitieven van git, onveranderlijke momentopnamen, een historielog en een wijzigingsstroom, zitten al binnen Postgres, zoals figuur 1 liet zien. Een protocol hoeft ze niet opnieuw te bouwen. Het hoeft alleen de twee dingen toe te voegen die Postgres mist: persistente genoemde refs over die historie, en een merge die de data begrijpt.

Commits vastleggen is dan een kwestie van de logical-decoding-stroom consumeren en de wijzigingen van elke transactie vastleggen als een inhoudsgeadresseerde wijzigingsset, gehasht naar zijn inhoud zodat identieke wijzigingen opslag delen en elke wijzigingsset genoemd en opgehaald kan worden aan de hand van zijn hash. Een slot wordt eenmaal aangemaakt, en de wijzigingen worden afgetapt en opgeslagen:

SELECT pg_create_logical_replication_slot(
  'vc', 'pgoutput');

-- de wijzigingen van elke transactie, op volgorde,
-- gehasht en opgeslagen als commit-object
SELECT * FROM pg_logical_slot_get_changes(
  'vc', NULL, NULL);

Niets hier forkt de engine of reikt onder de rij. Het protocol leest wat Postgres al uitzendt en bouwt de versiegraaf ernaast op.

5.2 Commits, refs en branches

Met wijzigingssets als commits is de rest van de gemakkelijke helft boekhouding. Een commit legt zijn ouder of ouders vast en de inhoudshash van de wijzigingsset die hij introduceert, en vormt dezelfde onveranderlijke gerichte acyclische graaf die git gebruikt. Een ref is een naam die naar een commit wijst, en een branch is een ref die meebeweegt naarmate nieuwe commits eraan toegevoegd worden. Deze metadata is klein, het is gewone relationele data, en het kan leven in een schema binnen de database die het versiebeheert of in een begeleidende opslag. Omdat een commit gedefinieerd wordt door inhoudsgeadresseerde logische wijzigingen in plaats van door fysieke pagina’s, is hij overdraagbaar: hij betekent hetzelfde op elke Postgres, on-premises of in welke cloud dan ook, wat precies de eigenschap is die een copy-on-write-opslagaftakking niet kan bieden. Het versiemodel is puur protocol, en het draagt geen lock-in.

5.3 Semantische, constraint-bewuste merge

Hier is de moeilijke helft, en de plek waar een protocol kan doen wat geen enkel huidig gereedschap doet. Omdat commits logische wijzigingssets zijn in plaats van ondoorzichtige pagina’s, kan een three-way merge opereren waar betekenis leeft. Gegeven twee branches en hun gemeenschappelijke voorouder, berekent het protocol de wijzigingen op rijniveau van elke kant en combineert ze, en doet dan de twee dingen die een databasemerge van een tekstmerge onderscheiden. Ten eerste valideert het het voorgestelde resultaat tegen het levende schema, elke constraint, sleutel en foreign-key-relatie, zodat een merge nooit een staat kan vastleggen die de database zou afwijzen; een schending wordt als een conflict opgeworpen, niet als corruptie geschreven. Ten tweede, en dit is de werkelijke vooruitgang, lost het overlappingen op met beleid dat per tabel en per kolom gedeclareerd wordt door de mensen die de betekenis van de data bezitten, in plaats van een enkele blinde celgewijze regel.

Dat beleid is waar domeinbedoeling binnenkomt. Een tellerkolom kan gedeclareerd worden om te mergen door de deltas op te tellen die elke kant toepaste, het gedrag van een convergent gerepliceerd datatype, zodat twee gelijktijdige verhogingen correct optellen in plaats van botsen. Een laatst-bijgewerkt-tijdstempel kan mergen door de latere waarde te nemen. Een verzamelingsgewaardeerde relatie kan mergen door vereniging. Een natuurlijke-sleutelbotsing kan tot een onvoorwaardelijk conflict verklaard worden, omdat de betekenis van het schema zegt dat de twee rijen dezelfde entiteit zijn. Waar geen beleid van toepassing is en beide kanten dezelfde waarde aanraakten, doet het protocol precies wat git doet en stopt het voor een mens, en presenteert het conflict in termen van rijen en waarden in plaats van pagina’s. Een declaratie zou zo eenvoudig kunnen luiden als dit:

MERGE POLICY ON inventory (on_hand)
  USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
  USING conflict;  -- zelfde SKU, zelfde item

Dit is het stuk waarvan eerder werk aantoont dat het mogelijk is. Inhoudsgeadresseerde systemen met door de gebruiker gedefinieerde mergefuncties bestaan al buiten de relationele wereld: Irmin, de git-achtige opslag achter delen van het MirageOS-project, is opgebouwd rond precies dit idee van mergebare data met aangepaste mergelogica, en de literatuur over convergente en commutatieve gerepliceerde datatypes geeft een rigoureuze verantwoording van wanneer gelijktijdige wijzigingen gemergd kunnen worden zonder conflict. De theorie van invariant confluence, van Bailis en collega’s, gaat één stap verder en vertelt ons precies welke invarianten een merge kan behouden zonder coördinatie en welke, globale uniciteit en foreign keys daaronder, dat aantoonbaar niet kunnen. Dat is geen raadgeving van wanhoop; het is de reden waarom een natuurlijke-sleutelbotsing tot een conflict verklaard moet worden in plaats van weggewenst, en het vertelt een protocol precies waar een automatisch beleid veilig is en waar een mens moet beslissen. Wat niet gedaan is, is die semantische merge naar native, transactionele Postgres brengen, beheerst door de constraints van het schema zelf. Dat is het open probleem dat het waard is om op te lossen, en degene die de branchingproducten omzeild hebben in plaats van doorkruist.

5.4 Materialisatie als optimalisatie

Een terecht bezwaar is dat het opnieuw afspelen van logische wijzigingen om een branch te reconstrueren traag zou kunnen zijn voor een grote database. Het antwoord is de ontkoppeling zelf: hoe een branch fysiek gematerialiseerd wordt, is geen deel van het versiemodel, dus het kan vrij gekozen en later gewijzigd worden. Een branch kan opnieuw afgespeeld worden vanuit wijzigingssets wanneer hij klein of zelden gebruikt is, of opgezet worden als een copy-on-write-momentopname wanneer hij snel moet zijn, met behulp van bestandssysteemmomentopnamen zoals ZFS of de copy-on-write-opslag zelf die Neon en zijn soort gebouwd hebben. Met andere woorden, de uitstekende snel-forkende engines zijn geen concurrenten van dit protocol; zij zijn één mogelijke backend voor zijn materialisatie, met de merge en het overdraagbare versiemodel erboven geleverd. Het protocol zegt wat een branch en een merge betekenen; de opslaglaag is vrij om ze snel te maken.

5.5 Eerlijke grenzen

Wij beweren niet dat dit gemakkelijk is, en een opinieartikel dat anders deed voorkomen zou achterdocht verdienen. Semantische merge is werkelijk moeilijk: het schrijven van correct per-tabel-beleid vergt zorg, lang uiteengelopen branches stapelen conflicten op die geen beleid zonder oordeel kan oplossen, en zeer omvangrijke wijzigingsstromen roepen reële vragen op over opslag en doorvoer voor de commitlog. Een grote merge valideren tegen elke constraint heeft een kostprijs, en sommige invarianten, zoals de invariant-confluence-theorie bewijst, kunnen helemaal niet verzoend worden zonder coördinatie, dus een eerlijk protocol brengt die naar voren als conflicten in plaats van te doen alsof het ze oplost. Dit zijn de redenen waarom het probleem nog open is, geen redenen om het onoplosbaar te verklaren. Wat de protocolbenadering oplevert, is dat het moeilijke deel, merge, aangepakt wordt op de ene plek waar het goed aangepakt kan worden, op de logische laag met het schema bij de hand, in plaats van verlaten te worden op de opslaglaag of platgeslagen te worden tot een celgewijze regel. Het betekent ook dat het werk zich opstapelt: omdat het een protocol over standaard-Postgres is, blijft elke verbetering in de engine, elke extensie, elk operationeel gereedschap eronder werken.

6. Wat dit in de praktijk betekent

Voor een organisatie die vandaag kiest, volgt de eerlijke richtlijn de tabel. Als wat je nodig hebt goedkope, directe databases voor ontwikkeling, testen en pull-request-previews zijn, zijn de copy-on-write-branchinggereedschappen uitstekend en zou je ze moeten gebruiken, met heldere ogen dat een branch daar een wegwerpbare aftakking is, geen lijn van werk die je terug zult mergen. Als je vers begint en versiebeheer het punt van het systeem is, is Dolt een serieus en capabel gereedschap, mits je accepteert dat je een nieuwe engine kiest in plaats van Postgres uit te breiden. En als wat je wilt de volledige belofte is, branch en diff en merge over de productie-Postgres die je al draait en vertrouwt, is het eerlijke antwoord dat geen enkel product het nog levert, en dat het juiste om op in te zetten een protocol is gebouwd op de eigen primitieven van Postgres in plaats van weer een fork van de engine of de opslag.

Die laatste positie is degene die Nashua inneemt, en zij is van hetzelfde laken een pak als hoe wij dit hele landschap lezen. Wij geven de voorkeur aan best-of-breed gereedschappen en open standaarden boven platforms van één leverancier, en wij zijn wantrouwig jegens lock-in waar die zich ook verbergt, ook binnen een opslaglaag die wel kan branchen maar je data nooit op gelijke voorwaarden kan laten vertrekken. Een versiemodel dat puur protocol is, overdraagbaar over elke Postgres op elke infrastructuur, on-premises of cloud, houdt de keuze van waar en hoe te draaien stevig bij de organisatie. Cloud en on-premises zijn beide goede werkplekken voor data; een protocol dat zich er niet om bekommert welke, is precies het punt.

7. Conclusie

De database verdient het versiebeheer dat elk ander deel van software-engineering transformeerde, en de projecten die dat doel najagen hebben gelijk het na te jagen. Maar de prijs is merge, niet louter branch, en het veld is uiteengevallen in gereedschappen die mergen door Postgres te verlaten en gereedschappen die Postgres behouden door merge op te geven. Die splitsing is niet onvermijdelijk. Zij komt voort uit het versmelten van drie scheidbare zorgen, het versiemodel, de fysieke opslag en de conflictoplossing, tot één product. Scheid ze, bouw het versiemodel als een protocol op de write-ahead log, multiversion-opslag en logical decoding die Postgres al meelevert, en plaats een semantische, constraint-bewuste merge in het centrum ervan, en de valse keuze lost op. Git verdiende zijn plaats door het model van de machine te scheiden. Data verdient hetzelfde, en Postgres heeft, vrijwel uniek, al de onderdelen om het werkelijk te maken. Nashua helpt dat liever bouwen dan er een fork van te verkopen.

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