november 2026
Version control for transactional data
En git-lignende protokol til PostgreSQL: hvorfor, hvad og hvordan; de open source-projekter, der allerede bygger den, hvor deres design kommer til kort, og en bedre vej bygget på det, Postgres allerede har.
Resumé
Softwareteams versionsstyrer deres kode med git og ville ikke drømme om at arbejde uden det, men databasen under den kode, den mest værdifulde og mindst reversible tilstand en organisation besidder, redigeres stadig på stedet uden forgrening, uden diff og uden fletning. Et livligt felt af open source-projekter lover at lukke det hul og bringe git til databasen, og denne artikel redegør for hvorfor, hvad og hvordan. Vi argumenterer for, at den virkelige gevinst ikke er forgrening, men fletning, evnen til at forene divergerende linjer af transaktionsdata, og vi viser, at feltet har delt sig i to lejre, der hver især opgiver halvdelen af problemet: Dolt og DoltgreSQL vinder ægte git-semantik ved at genimplementere databasemotoren og lade native Postgres bag sig, mens Neon og Supabase beholder Postgres, men tilbyder en forgrening, der kan dele sig og aldrig forene sig igen. Vi foreslår en bedre vej. Ikke en forgrenet motor og ikke et forgrenet lagerlag, men en versionsstyringsprotokol bygget på den write-ahead-log, flerversions-samtidighed og logiske afkodning, som Postgres allerede leverer, med semantisk, begrænsningsbevidst fletning som dens førsteklasses operation. Versionsstyring for data bør adskille versionsmodellen fra lagringen, på samme måde som git adskilte objektmodellen fra transporten.
Nøgleord: PostgreSQL; databaseversionsstyring; git for data; dataforgrening; skemamigrering; tre-vejs-fletning; konfliktløsning; write-ahead-log; logisk afkodning; flerversions-samtidighedskontrol; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; temporale tabeller; dataprovenans; digital suverænitet
1. Indledning
Bed en udvikler om at arbejde en dag uden git, og du får et blankt afslag. Forgrening, commit, diff og fletning er så vævet ind i den måde, software bygges på, at deres fravær er utænkeligt. Spørg nu den samme udvikler, hvordan de versionsstyrer produktionsdatabasen, skemaet og de data, som koden findes for at betjene, og svaret er næsten altid et flovt ingenting. Databasen redigeres på stedet. En migrering kører fremad, og hvis den går galt, er en hektisk gendannelse fra nattens backup den eneste vej tilbage. To ingeniører kan ikke udvikle mod divergerende kopier af dataene og forene dem senere; de skiftes, eller de overskriver hinanden. Den mest værdifulde og mindst reversible tilstand en organisation besidder, er det ene stykke af stakken helt uden versionsstyring.
Dette er et besynderligt hul, og et voksende felt af open source-projekter har sat sig for at lukke det under et banner, alle forstår: git til din database. Løftet er umiddelbart tiltalende. Forgren databasen for at prøve en risikabel ændring isoleret. Lav en diff mellem to versioner for at se præcis, hvad en migrering gjorde. Giv hver analytiker deres egen linje af data, og flet det gode arbejde tilbage. Rejs til enhver tidligere tilstand lige så let som git checkout. Hvis versionsstyring forvandlede måden, vi skriver kode på, lyder argumentet, kan den forvandle måden, vi forvalter data på.
Vi mener, at argumentet er rigtigt, og dette er en holdningsartikel om, hvordan man gør det sandt. Vi forklarer, hvorfor versionsstyrede data betyder noget (afsnit 2), hvad en git-lignende protokol faktisk skal levere, hvilket er mere og sværere, end det først ser ud (afsnit 3), og hvor nutidens projekter står, med anerkendelse hvor den er fortjent og en nøgtern redegørelse for, hvor deres design kommer til kort (afsnit 4). Derefter fremfører vi vores sag: at feltet har manøvreret sig ind i et falsk valg, og at den bedre vej for Postgres er en protokol bygget på de primitiver, den allerede leverer, frem for en ny motor eller en uflettbar forgrening (afsnit 5). Nashua anbefaler best-of-breed-værktøjer og sund praksis frem for ethvert enkelt produkt, og det er ånden her: ikke en reklame for ét projekt, men et argument om, hvordan dette bør bygges.
2. Hvorfor versionsstyre databasen
Sagen begynder med det arbejde, folk allerede gør dårligt i hånden. Skemamigreringer er det oplagte eksempel. Ethvert team, der driver en database, kører migreringer, og ethvert team har mærket den særlige gru ved en migrering, der ikke kan fortrydes rent. En versionsstyret database gør en migrering til en commit: reversibel, inspicerbar og testbar på en forgrening, før den rører produktion. Diffen er ikke et gæt ud fra migreringsskriptet; den er den faktiske ændring af skema og data, beregnet og gennemgåelig som enhver pull request.
Så er der udviklings- og testløkken. Moderne teams vil have en realistisk database til hver feature-branch og hver pull request-forhåndsvisning, seedet med produktionslignende data, rejst på sekunder og smidt væk, når branchen flettes. At gøre det ved at gendanne fulde kopier er langsomt og dyrt; at gøre det ved at dele én database inviterer til kollisioner. Billige, øjeblikkelige forgreninger løser et reelt og dagligt problem, hvilket er præcis derfor, forgreningsprodukterne har fundet et ivrigt marked.
Ud over den daglige løkke ligger de dybere grunde. Reproducerbarhed: en dataforsker, der kan fastlåse en analyse til en præcis committet tilstand af dataene, kan reproducere et resultat måneder senere, og det kan revisoren, der sætter spørgsmålstegn ved det, også. Provenans og revision: en database, hvis historik er en kæde af signerede commits, besvarer hvem der ændrede hvad, og hvornår, af konstruktion frem for ved en påbygget trigger. Dette er ikke en luksus i regulerede sektorer; Den Europæiske Unions DORA-regime og dets lige forventer, at finansielle enheder kan påvise integriteten og sporbarheden af deres data, og en versioneret historik er påviselig på en måde, som en foranderlig tabel ikke er. Gendannelse: point-in-time-gendannelse ophører med at være en backup-operation og bliver et checkout. Og samarbejde bliver endelig muligt om data på samme måde som om kode, med uafhængige arbejdslinjer, der konvergerer gennem gennemgang frem for gennem låsning.
Intet af dette er eksotisk. Det er softwareudviklingens almindelige maskineri, anvendt på det ene aktiv, der stædigt har modstået det. Spørgsmålet er ikke, om databasen fortjener versionsstyring. Det gør den tydeligvis. Spørgsmålet er, hvad der skal til for at give den den ægte vare.
3. Hvad en git-lignende protokol betyder
Det er værd at være præcis om, hvad git faktisk leverer, for den lette halvdel forveksles rutinemæssigt med helheden. Git er et indholdsadresseret objektlager: hver version af hver fil er en blob navngivet efter hashen af dens indhold, træer sammensætter blobs til et øjebliksbillede, og en commit navngiver et træ sammen med sine forældre og danner en uforanderlig rettet acyklisk graf af historik. Oven på det lager sidder to lag af bekvemmelighed: refs, som er menneskelige navne for punkter i grafen, så main og feature blot er etiketter på commits; og operationer, hvoraf diff og merge er dem, der betyder noget.
Den afgørende operation, den der gør git til et samarbejdsværktøj frem for en fin backup, er tre-vejs-fletningen. Når to branches divergerer, spørger git ikke, hvilken der vinder. Den finder deres fælles forfader, beregner hvad hver side ændrede i forhold til den forfader, og kombinerer ændringerne, idet den kun markerer de steder, hvor begge sider rørte det samme på uforenelige måder. Det er det, der lader hundrede mennesker arbejde parallelt og konvergere. Forgrening uden fletning er blot en billig kopi; forgrening med fletning er versionsstyring.
Før dette over til en database, og afbildningen er antydende, men ikke triviel, som figur 1 viser. En commit bør være et uforanderligt øjebliksbillede af hele databasen i et logisk øjeblik. En branch bør være en navngiven linje af sådanne øjebliksbilleder. En diff bør rapportere de rækker og skemaobjekter, der ændrede sig mellem to commits. Og en fletning bør forene to divergerende linjer af data til én. De første tre er i bund og grund et lager- og navngivningsproblem. Den fjerde er den svære, og det er dér, analogien til git holder op med at være behagelig.
Tekst fletter, fordi en kildefil er en linjeordnet sekvens uden regler for sit indhold; git kan sammenføje to sæt af linjeændringer, og resultatet er stadig en gyldig fil per definition. En database er ikke sådan. Dens indhold styres af invarianter: primærnøgler skal forblive unikke, fremmednøgler skal kunne opløses, check-begrænsninger skal holde, og frem for alt det skal dataene stadig betyde noget. To branches, der hver især indsætter en kunde med den samme naturlige nøgle, har ikke frembragt en fletningskonflikt i tekstlig forstand; de har frembragt en tilstand, som skemaet forbyder. To branches, der hver især nedskriver en kontosaldo med et forskelligt beløb, kan ikke begge simpelthen vinde. En fletning for data skal respektere dataenes regler, og undertiden hensigten bag dem. Det er det virkelige indhold i vendingen git til databasen, og det er den prøve, de eksisterende projekter bør måles imod.
4. Det aktuelle stade, og hvor det kommer til kort
Feltet deler sig rent i tre grupper, og delingen er lærerig, fordi hver gruppe er defineret af, hvad den opgiver. Tabel 1 stiller dem side om side.
Tabel 1. Hvor nutidens tilgange står. Native PG betyder den rigtige PostgreSQL-motor, med dens udvidelser og økosystem, frem for en genimplementering af dens wire-protokol. Mønstret er skarpt: det eneste projekt med ægte datafletning er det, der forlader Postgres, og ethvert værktøj, der beholder Postgres, opgiver fletning.
| Projekt | Tilgang | Native PG | Forgrening | Datadiff | Datafletning | Konfliktmodel |
|---|---|---|---|---|---|---|
| Dolt | ny motor, Merkle-DAG | nej | ja | ja | ja | cellevis, strukturel |
| DoltgreSQL | ny motor, PG-wire | nej | ja | ja | ja | cellevis, strukturel |
| Neon | copy-on-write-lager | ja | ja | nej | nej | ingen |
| Supabase-forgrening | instans pr. branch | ja | ja | kun skema | nej | ingen |
| Temporale/revisionsværktøjer | lineær historik | ja | nej | over tid | nej | ingen |
| En protokol (foreslået) | over WAL + MVCC | ja | ja | ja | ja | semantisk, begrænsningsbevidst |
4.1 Genimplementering af motoren: Dolt og DoltgreSQL
Dolt er den mest komplette realisering af idéen, og den fortjener ægte anerkendelse. Det er en open source SQL-database bygget fra grunden til at være versioneret: dens lagring er en indholdsadresseret Merkle-rettet acyklisk graf, struktureret med probabilistiske træer, ofte kaldet prolly trees, der giver den gits strukturelle deling og hurtige diffs, mens den forbliver en indekseret database, der kan forespørges. Branch, diff, merge, clone, push og pull er førsteklasses SQL- og kommandolinjeoperationer. Dolt er, ægte, git til data, og DoltgreSQL udvider den samme motor til at tale PostgreSQL-wire-protokollen, så Postgres-klienter kan forbinde.
Omkostningen er tydelig i den sætning: bygget fra grunden. Dolt er ikke Postgres. Det er en ny motor, der genimplementerer en database og, i DoltgreSQLs tilfælde, Postgres-protokollen oven på den. En organisation, der tager den i brug, tilføjer ikke versionering til den Postgres, den kører; den erstatter Postgres med noget andet og arver det andets ydelseskarakteristika og den lange hale af Postgres-udvidelser, den ikke reproducerer, PostGIS og pgvector og resten, som produktionssystemer læner sig op ad. DoltgreSQL nåede en 1.0-udgivelse i 2026 og er imponerende kompatibel, men kompatibel med Postgres-dialekten er ikke det samme som at være Postgres. For et greenfield-projekt, der værdsætter versionering over alt, kan det være en fair handel. For den enorme installerede base af produktions-Postgres er det at erstatte motoren for at opnå versionsstyring en meget stor hale, der logrer med en meget vigtig hund.
Der er en mere subtil begrænsning, og den betyder noget for argumentet, der kommer. Dolts fletning er modelleret efter gits: den arbejder en celle ad gangen, tager hver sides ændringer i forhold til den fælles forfader og kombinerer dem, og hvor begge sider ændrede den samme celle, registrerer den en konflikt, som et menneske skal løse. Dette er strukturel fletning, og det er den rigtige standard, men den er semantisk blind. Den ved ikke, at to samtidige forøgelser af et lagerniveau bør lægges sammen frem for at kollidere, eller at to indsættelser, der deler en naturlig nøgle, ikke er et sammentræf, men en modsigelse. Dolt opdager ganske vist begrænsningsovertrædelser, som en fletning indfører, og bringer dem frem til løsning frem for stiltiende at committe en ødelagt tilstand, hvilket er til dens ros, men opdagelse efter kendsgerningen er ikke det samme som en fletning, der forstår dataenes betydning. Den strukturelle model er loftet for, hvad cellevis fletning kan gøre.
4.2 Forgrening af lagringen: Neon og Supabase
Den anden gruppe beholder Postgres, præcis det Dolt opgiver, og køber sin forgrening længere nede i stakken. Neon omarkitekterer Postgres-lagringen og adskiller beregning fra en flerversions, logstruktureret lagringstjeneste, og forgrening falder ud af det design næsten gratis: en branch er en copy-on-write-forgrening af lagringen på et valgt punkt i loggen, oprettet på sekunder uanset hvor stor databasen er, fordi intet kopieres, før det skrives. Supabase tilbyder forgrening i en lignende ånd, rejser en separat Postgres-instans pr. branch og kobler den ind i et Git-drevet forhåndsvisningsarbejdsflow, og det samme copy-on-write-mønster løber lige igennem økosystemet, fra Xatas databærende branches til ZFS-tynde-klonerne hos Postgres.ai. Alle er ægte nyttige, og for udviklings- og testløkken i afsnit 2 er de tæt på ideelle.
Men se på tabellen igen. Dette er branches, der kan dele sig og aldrig forene sig igen. Neon kan oprette en branch i et øjeblik og divergere fra den; den kan ikke flette den branches dataændringer tilbage i sin forælder, fordi intet i en copy-on-write-lagerforgrening ved, hvordan man forener to sæt af divergerende sideskrivninger til én sammenhængende, begrænsningsrespekterende tilstand. Det er ikke en forglemmelse, der kan lappes; det er konsekvensen af at løse problemet i lagerlaget, hvor enheden er en uigennemsigtig side, frem for i det logiske lag, hvor enheden er en række med betydning. Supabases branches er rettet mod skemamigreringer til forhåndsvisningsmiljøer, ikke mod at flette data overhovedet. Resultatet er kraftfuld copy-on-write-kloning, hvilket er en reel og værdifuld ting, iført versionsstyringens ordforråd, mens den kun leverer dens lette halvdel. At kalde en forgrening uden en fletning for en branch låner et løfte, designet ikke kan holde.
4.3 Logføring af historik: temporale tabeller og revisionsspor
En tredje gruppe fejes undertiden ind i den samme samtale og bør skelnes. Systemversionerede temporale tabeller, som standardiseret i SQL:2011 og tilnærmet i Postgres af udvidelser såsom temporal_tables, og revisionsrammeværker såsom pgMemento, giver en tabel en historik: hver række bærer det tidsspænd, den var aktuel for, og man kan forespørge databasen, som den stod i ethvert tidligere øjeblik. Dette er værdifuldt, og det leverer den provenans og point-in-time-læsning, som afsnit 2 efterspurgte. Men det er en enkelt, lineær historik. Der er ingen branch og ingen fletning, ingen parallelle arbejdslinjer at forene. Tidsrejse er ikke versionsstyring; det er én akse af den, den der altid var den letteste at tilføje.
4.4 Tre bekymringer, fejlagtigt sammensmeltet
Træd tilbage, og mønstret er klart. Hvert projekt besvarer de samme tre spørgsmål på én gang og bundter svarene ind i et enkelt produkt: hvordan historik modelleres, hvordan en version lagres fysisk, og hvordan konflikter løses. Dolt sammensmelter en git-lignende versionsmodel med en skræddersyet lagermotor og en cellevis konfliktmodel, og for at få det første må man tage alle tre. Neon sammensmelter en tynd versionsmodel med en copy-on-write-lagermotor og slet ingen konfliktmodel. Fordi de tre er svejset sammen, kan man ikke beholde Postgres og stadig have fletning, og man kan ikke få semantisk fletning fra nogen, fordi konfliktmodellen er, hvad end lagermotoren nu gjorde let. Det falske valg, som feltet præsenterer, Postgres uden fletning eller fletning uden Postgres, er et biprodukt af at sammensmelte bekymringer, der er logisk adskilte. Træk dem fra hinanden, og et bedre design viser sig.
5. En bedre vej: en protokol, ikke en forgrening
Vores forslag er at holde op med at bygge versionsstyrede databaser og begynde at definere en versionsstyringsprotokol for den database, vi allerede har. Trækket er det samme, som git selv gjorde: gits geni var at adskille objektmodellen, commits og træer og refs, fra transporten, der flytter dem rundt, så modellen kunne overleve enhver bestemt implementering. Databaseversionsstyring bør adskille versionsmodellen, commits og branches og fletninger, fra den fysiske lagring, der materialiserer dem, så den kan køre på almindelig Postgres i stedet for at kræve en ny motor. Figur 2 viser formen på det.
5.1 Substratet Postgres allerede leverer
Det slående, og kernen i vores argument, er hvor meget af maskineriet Postgres allerede har. Dens flerversions-samtidighedskontrol holder flere versioner af hver række og giver hver transaktion et konsistent øjebliksbillede af databasen i et logisk øjeblik: det er en commit i alt andet end navn. Dens write-ahead-log er en ordnet, holdbar optegnelse over hver ændring, der nogensinde er anvendt, hvilket vil sige en reflog. Og logisk afkodning, den modne mekanisme, der allerede driver logisk replikering, forvandler den log til en ren, ordnet strøm af ændringer på rækkeniveau, som enhver klient kan forbruge. Tre af gits fire primitiver, uforanderlige øjebliksbilleder, en historiklog og en ændringsstrøm, sidder allerede inde i Postgres, som figur 1 viste. En protokol behøver ikke at genopbygge dem. Den behøver kun at tilføje de to ting, Postgres mangler: vedvarende navngivne refs over den historik, og en fletning, der forstår dataene.
At fange commits er altså et spørgsmål om at forbruge den logiske afkodningsstrøm og optegne hver transaktions ændringer som et indholdsadresseret ændringssæt, hashet efter sit indhold, så identiske ændringer deler lagring, og ethvert ændringssæt kan navngives og hentes efter sin hash. En slot oprettes én gang, og ændringerne tømmes og lagres:
SELECT pg_create_logical_replication_slot(
'vc', 'pgoutput');
-- hver transaktions ændringer, i rækkefølge,
-- hashet og lagret som et commit-objekt
SELECT * FROM pg_logical_slot_get_changes(
'vc', NULL, NULL);
Intet her forgrener motoren eller rækker ind under rækken. Protokollen læser, hvad Postgres allerede udsender, og bygger versionsgrafen ved siden af den.
5.2 Commits, refs og branches
Med ændringssæt som commits er resten af den lette halvdel bogføring. En commit optegner sin forælder eller sine forældre og indholdshashen af det ændringssæt, den indfører, og danner den samme uforanderlige rettede acykliske graf, som git bruger. En ref er et navn, der peger på en commit, og en branch er en ref, der bevæger sig, efterhånden som nye commits føjes til den. Disse metadata er små, det er almindelige relationsdata, og de kan bo i et skema inde i selve den database, de versionerer, eller i et følgelager. Fordi en commit er defineret af indholdsadresserede logiske ændringer frem for af fysiske sider, er den portabel: den betyder det samme på enhver Postgres, on-premises eller i enhver sky, hvilket er netop den egenskab, en copy-on-write-lagerforgrening ikke kan tilbyde. Versionsmodellen er ren protokol, og den bærer ingen indlåsning.
5.3 Semantisk, begrænsningsbevidst fletning
Her er den svære halvdel, og stedet hvor en protokol kan gøre, hvad intet nuværende værktøj gør. Fordi commits er logiske ændringssæt frem for uigennemsigtige sider, kan en tre-vejs-fletning operere, hvor betydningen bor. Givet to branches og deres fælles forfader beregner protokollen hver sides ændringer på rækkeniveau og kombinerer dem, og gør derefter de to ting, der adskiller en databasefletning fra en tekstfletning. For det første validerer den det foreslåede resultat mod det levende skema, enhver begrænsning, nøgle og fremmednøglerelation, så en fletning aldrig kan committe en tilstand, databasen ville afvise; en overtrædelse rejses som en konflikt, ikke skrevet som korruption. For det andet, og dette er det virkelige fremskridt, løser den overlap ved hjælp af politikker erklæret pr. tabel og pr. kolonne af de mennesker, der ejer dataenes betydning, frem for en enkelt blind cellevis regel.
Disse politikker er, hvor domænehensigt træder ind. En tællerkolonne kan erklæres at flette ved at summere de deltaer, hver side anvendte, adfærden for en konvergent replikeret datatype, så to samtidige forøgelser korrekt summeres i stedet for at kollidere. Et sidst-opdateret-tidsstempel kan flette ved at tage den senere værdi. En mængdeværdsat relation kan flette ved forening. En naturlig-nøgle-kollision kan erklæres en ubetinget konflikt, fordi skemaets betydning siger, at de to rækker er den samme entitet. Hvor ingen politik gælder, og begge sider rørte den samme værdi, gør protokollen præcis, hvad git gør, og standser for et menneske, idet den præsenterer konflikten i form af rækker og værdier frem for sider. En erklæring kan læses lige så ligefremt som dette:
MERGE POLICY ON inventory (on_hand)
USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
USING conflict; -- samme SKU, samme vare
Dette er det stykke, som tidligere arbejde viser er muligt. Indholdsadresserede systemer med brugerdefinerede fletningsfunktioner findes allerede uden for den relationelle verden: Irmin, det git-lignende lager bag dele af MirageOS-projektet, er bygget op omkring præcis denne idé om flettbare data med tilpasset fletningslogik, og litteraturen om konvergente og kommutative replikerede datatyper giver en stringent redegørelse for, hvornår samtidige ændringer kan flettes uden konflikt. Teorien om invariant-konfluens, fra Bailis og kolleger, går et skridt videre og fortæller os præcis, hvilke invarianter en fletning kan bevare uden koordinering, og hvilke, global unikhed og fremmednøgler iblandt dem, beviseligt ikke kan. Det er ikke et råd til fortvivlelse; det er grunden til, at en naturlig-nøgle-kollision må erklæres en konflikt frem for at ønskes væk, og det fortæller en protokol præcis, hvor en automatisk politik er sikker, og hvor et menneske må afgøre. Det, der ikke er gjort, er at bringe den semantiske fletning til native, transaktionel Postgres, styret af skemaets egne begrænsninger. Det er det åbne problem, der er værd at løse, og det, forgreningsprodukterne er gået uden om frem for igennem.
5.4 Materialisering som en optimering
En rimelig indvending er, at genafspilning af logiske ændringer for at rekonstruere en branch kunne være langsom for en stor database. Svaret er afkoblingen selv: hvordan en branch materialiseres fysisk er ikke en del af versionsmodellen, så den kan vælges frit og ændres senere. En branch kan genafspilles fra ændringssæt, når den er lille eller sjældent brugt, eller rejses som et copy-on-write-øjebliksbillede, når den skal være hurtig, ved hjælp af filsystem-øjebliksbilleder såsom ZFS eller netop den copy-on-write-lagring, som Neon og dens lige har bygget. Med andre ord er de fremragende hurtig-forgrenende motorer ikke konkurrenter til denne protokol; de er én mulig backend for dens materialisering, med fletningen og den portable versionsmodel leveret oven over dem. Protokollen siger, hvad en branch og en fletning betyder; lagerlaget er frit til at gøre dem hurtige.
5.5 Ærlige grænser
Vi hævder ikke, at dette er let, og en holdningsartikel, der lod som om andet, ville fortjene mistanke. Semantisk fletning er ægte svær: at skrive korrekte politikker pr. tabel kræver omhu, længe-divergerede branches ophober konflikter, som ingen politik kan løse uden dømmekraft, og meget højvolumen-ændringsstrømme rejser reelle spørgsmål om lagring og gennemløb for commit-loggen. At validere en stor fletning mod enhver begrænsning har en omkostning, og nogle invarianter kan, som invariant-konfluens-teorien beviser, slet ikke forenes uden koordinering, så en ærlig protokol bringer dem frem som konflikter frem for at lade som om den løser dem. Dette er grundene til, at problemet stadig er åbent, ikke grunde til at erklære det uløseligt. Det, protokoltilgangen køber, er, at den svære del, fletningen, tackles det ene sted, den kan tackles godt, i det logiske lag med skemaet i hånden, i stedet for at blive opgivet i lagerlaget eller fladet ud til en cellevis regel. Det betyder også, at arbejdet forrentes: fordi det er en protokol over almindelig Postgres, bliver enhver forbedring i motoren, enhver udvidelse, ethvert driftsværktøj ved med at virke under den.
6. Hvad dette betyder i praksis
For en organisation, der vælger i dag, følger den ærlige vejledning tabellen. Hvis det, du har brug for, er billige, øjeblikkelige databaser til udvikling, test og pull request-forhåndsvisninger, er copy-on-write-forgreningsværktøjerne fremragende, og du bør bruge dem, med klart blik for at en branch dér er en engangsforgrening, ikke en arbejdslinje, du vil flette tilbage. Hvis du starter på ny, og versionering er systemets pointe, er Dolt et seriøst og dygtigt værktøj, forudsat at du accepterer, at du vælger en ny motor frem for at udvide Postgres. Og hvis det, du ønsker, er det fulde løfte, branch og diff og fletning over den produktions-Postgres, du allerede kører og stoler på, er det ærlige svar, at intet produkt leverer det endnu, og det rigtige at satse på er en protokol bygget på Postgres’ egne primitiver frem for endnu en forgrening af motoren eller lagringen.
Den sidste holdning er den, Nashua indtager, og den hænger sammen med, hvordan vi læser hele dette landskab. Vi foretrækker best-of-breed-værktøjer og åbne standarder frem for enkeltleverandørplatforme, og vi er på vagt over for indlåsning, hvor end den gemmer sig, herunder inde i et lagerlag, der kan forgrene, men aldrig lade dine data forlade det på lige vilkår. En versionsmodel, der er ren protokol, portabel på tværs af enhver Postgres på enhver infrastruktur, on-premises eller sky, holder valget af hvor og hvordan der køres fast hos organisationen. Sky og on-premises er begge gode hjem for data; en protokol, der er ligeglad med hvilket, er netop pointen.
7. Konklusion
Databasen fortjener den versionsstyring, der forvandlede enhver anden del af softwareudvikling, og de projekter, der jager det mål, har ret i at jage det. Men gevinsten er fletning, ikke blot forgrening, og feltet har delt sig i værktøjer, der fletter ved at forlade Postgres, og værktøjer, der beholder Postgres ved at opgive fletning. Den deling er ikke uundgåelig. Den kommer af at sammensmelte tre adskillelige bekymringer, versionsmodellen, den fysiske lagring og konfliktløsningen, til ét produkt. Adskil dem, byg versionsmodellen som en protokol på den write-ahead-log, flerversionslagring og logiske afkodning, som Postgres allerede leverer, og sæt en semantisk, begrænsningsbevidst fletning i dens centrum, og det falske valg opløses. Git fortjente sin plads ved at adskille modellen fra maskinen. Data fortjener det samme, og Postgres har, næsten enestående, allerede delene til at gøre det virkeligt. Nashua vil hellere hjælpe med at bygge det end sælge en forgrening af det.
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
