november 2026

Version control for transactional data

En git-lignende protokoll for PostgreSQL: hvorfor, hva og hvordan; prosjektene med åpen kildekode som allerede bygger det, hvor designet deres kommer til kort, og en bedre vei bygget på det Postgres allerede har.

Sammendrag

Programvareteam versjonerer koden sin med git og ville ikke drømt om å arbeide uten det, likevel er databasen under den koden, den mest verdifulle og minst reverserbare tilstanden en organisasjon har, fremdeles redigert på stedet uten gren, uten diff og uten fletting. Et livlig felt av prosjekter med åpen kildekode lover å tette det gapet og bringe git til databasen, og denne artikkelen legger frem hvorfor, hva og hvordan. Vi hevder at den egentlige gevinsten ikke er forgrening, men fletting, evnen til å forene divergerende linjer av transaksjonelle data, og vi viser at feltet har delt seg i to leire som hver gir fra seg halve problemet: Dolt og DoltgreSQL vinner ekte git-semantikk ved å reimplementere databasemotoren og legge innebygd Postgres bak seg, mens Neon og Supabase beholder Postgres, men tilbyr en gren som kan forgrene seg og aldri møtes igjen. Vi foreslår en bedre vei. Ikke en forgrenet motor og ikke et forgrenet lagringslag, men en versjonskontrollprotokoll bygget på write-ahead-loggen, flerversjons samtidighet og logisk dekoding som Postgres allerede leverer, med semantisk, begrensningsbevisst fletting som sin førsteklasses operasjon. Versjonskontroll for data bør skille versjonsmodellen fra lagringen, slik git skilte objektmodellen fra transporten.

Nøkkelord: PostgreSQL; databaseversjonskontroll; git for data; dataforgrening; skjemamigrasjon; treveis fletting; konfliktløsning; write-ahead log; logisk dekoding; flerversjons samtidighetskontroll; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; temporale tabeller; dataproveniens; digital suverenitet

1. Innledning

Be en utvikler om å arbeide en dag uten git, og du vil få et blankt avslag. Forgrening, committing, diffing og fletting er så vevd inn i hvordan programvare bygges at fraværet deres er utenkelig. Spør så den samme utvikleren hvordan de versjonerer produksjonsdatabasen, skjemaet og dataene som koden finnes for å betjene, og svaret er nesten alltid et skamfullt ingenting. Databasen redigeres på stedet. En migrasjon kjører forover, og hvis den går galt, er en frenetisk gjenoppretting fra nattens sikkerhetskopi den eneste veien tilbake. To ingeniører kan ikke utvikle mot divergerende kopier av dataene og forene dem senere; de bytter på, eller de overskriver hverandre. Den mest verdifulle og minst reverserbare tilstanden en organisasjon har, er den ene delen av stacken uten noen versjonskontroll i det hele tatt.

Dette er et underlig gap, og et voksende felt av prosjekter med åpen kildekode har satt seg fore å tette det under et banner alle forstår: git for databasen din. Salgsargumentet er umiddelbart tiltalende. Forgren databasen for å prøve en risikabel endring isolert. Diff to versjoner for å se nøyaktig hva en migrasjon gjorde. Gi hver analytiker sin egen linje med data, og flett det gode arbeidet tilbake. Reis til enhver tidligere tilstand like enkelt som git checkout. Hvis versjonskontroll forvandlet hvordan vi skriver kode, lyder argumentet, kan det forvandle hvordan vi forvalter data.

Vi mener argumentet er riktig, og dette er en posisjonsartikkel om hvordan man gjør det sant. Vi forklarer hvorfor versjonskontrollerte data betyr noe (avsnitt 2), hva en git-lignende protokoll faktisk må tilby, noe som er mer og vanskeligere enn det først ser ut (avsnitt 3), og hvor dagens prosjekter står, med anerkjennelse der den fortjenes og en klarøyd redegjørelse for hvor designene deres kommer til kort (avsnitt 4). Deretter fremfører vi saken vår: at feltet har manøvrert seg inn i et falskt valg, og at den bedre veien for Postgres er en protokoll bygget på primitivene det allerede leverer snarere enn en ny motor eller en uflettbar forgrening (avsnitt 5). Nashua slutter opp om best-of-breed-verktøy og sunn praksis fremfor ethvert enkelt produkt, og det er ånden her: ikke en reklame for ett prosjekt, men et argument om hvordan dette bør bygges.

2. Hvorfor versjonskontrollere databasen

Saken begynner med arbeidet folk allerede gjør dårlig for hånd. Skjemamigrasjoner er det åpenbare eksempelet. Ethvert team som drifter en database kjører migrasjoner, og ethvert team har kjent den særegne angsten ved en migrasjon som ikke kan angres rent. En versjonskontrollert database gjør en migrasjon til en commit: reverserbar, inspiserbar og testbar på en gren før den rører produksjon. Diffen er ikke en gjetning fra migrasjonsskriptet; den er den faktiske endringen av skjema og data, beregnet og gjennomgåbar som enhver pull request.

Så er det utviklings- og testsløyfen. Moderne team ønsker en realistisk database for hver funksjonsgren og hver pull request-forhåndsvisning, fylt med produksjonslignende data, startet opp på sekunder og kastet når grenen flettes. Å gjøre det ved å gjenopprette fulle kopier er tregt og dyrt; å gjøre det ved å dele én database inviterer til kollisjoner. Billige, umiddelbare grener løser et reelt og daglig problem, som er nettopp derfor forgreningsproduktene har funnet et ivrig marked.

Bortenfor den daglige sløyfen ligger de dypere grunnene. Reproduserbarhet: en dataforsker som kan feste en analyse til en nøyaktig committet tilstand av dataene, kan reprodusere et resultat måneder senere, og det kan også revisoren som stiller spørsmål ved det. Proveniens og revisjon: en database hvis historie er en kjede av signerte commits besvarer hvem som endret hva, og når, ved konstruksjon snarere enn ved en påmontert utløser. Dette er ikke en luksus i regulerte sektorer; Den europeiske unionens DORA-regime og dets slektninger forventer at finansielle enheter kan dokumentere integriteten og sporbarheten til dataene sine, og en versjonert historie er dokumenterbar på en måte en muterbar tabell ikke er. Gjenoppretting: gjenoppretting til et tidspunkt slutter å være en sikkerhetskopieringsoperasjon og blir en checkout. Og samarbeid blir endelig mulig på data slik det er på kode, med uavhengige arbeidslinjer som konvergerer gjennom gjennomgang snarere enn gjennom låsing.

Ingenting av dette er eksotisk. Det er det alminnelige maskineriet i programvareutvikling, anvendt på det ene aktivumet som hardnakket har motstått det. Spørsmålet er ikke om databasen fortjener versjonskontroll. Det gjør den åpenbart. Spørsmålet er hva som skulle til for å gi den den ekte varen.

3. Hva en git-lignende protokoll betyr

Det er verdt å være presis om hva git faktisk tilbyr, fordi den enkle halvdelen rutinemessig forveksles med det hele. Git er et innholdsadressert objektlager: hver versjon av hver fil er en blob navngitt av hashen av innholdet sitt, trær setter sammen blober til et øyeblikksbilde, og en commit navngir et tre sammen med foreldrene sine, og danner en uforanderlig rettet asyklisk graf av historie. Oppå det lageret hviler to lag med bekvemmelighet: refs, som er menneskelige navn på punkter i grafen, slik at main og feature bare er etiketter på commits; og operasjoner, hvorav diff og merge er de som betyr noe.

Den avgjørende operasjonen, den som gjør git til et samarbeidsverktøy snarere enn en fancy sikkerhetskopi, er treveis fletting. Når to grener divergerer, spør ikke git hvilken som vinner. Den finner deres felles forfar, beregner hva hver side endret relativt til den forfaren, og kombinerer endringene, og flagger bare stedene der begge sider rørte det samme på uforenlige måter. Det er det som lar hundre personer arbeide parallelt og konvergere. Forgrening uten fletting er bare en billig kopi; forgrening med fletting er versjonskontroll.

Før dette over til en database, og avbildningen er antydende, men ikke triviell, slik figur 1 viser. En commit bør være et uforanderlig øyeblikksbilde av hele databasen i et logisk øyeblikk. En gren bør være en navngitt linje av slike øyeblikksbilder. En diff bør rapportere radene og skjemaobjektene som endret seg mellom to commits. Og en fletting bør forene to divergerende datalinjer til én. De tre første er i hovedsak et lagrings- og navngivingsproblem. Den fjerde er den vanskelige, og det er der analogien til git slutter å være behagelig.

Figur 1. Git-objektmodellen avbildet på Postgres. Tre av gits fire byggeklosser finnes allerede inne i Postgres som MVCC-øyeblikksbildet, write-ahead-loggen og logisk dekoding; det som mangler er en persistent gren-ref og, fremfor alt, en fletting som forstår dataene. En protokoll trenger bare å levere de to varme boksene, ikke å bygge opp igjen de tre blå.
Figur 1. Git-objektmodellen avbildet på Postgres. Tre av gits fire byggeklosser finnes allerede inne i Postgres som MVCC-øyeblikksbildet, write-ahead-loggen og logisk dekoding; det som mangler er en persistent gren-ref og, fremfor alt, en fletting som forstår dataene. En protokoll trenger bare å levere de to varme boksene, ikke å bygge opp igjen de tre blå.

Tekst flettes fordi en kildefil er en linjeordnet sekvens uten regler om innholdet sitt; git kan spleise to sett med linjeendringer, og resultatet er fremdeles en gyldig fil per definisjon. En database er ikke slik. Innholdet dens styres av invarianter: primærnøkler må forbli unike, fremmednøkler må la seg oppløse, sjekkbegrensninger må holde, og over alle disse må dataene fremdeles bety noe. To grener som hver setter inn en kunde med samme naturlige nøkkel, har ikke produsert en flettekonflikt i tekstlig forstand; de har produsert en tilstand skjemaet forbyr. To grener som hver reduserer en kontosaldo med et ulikt beløp, kan ikke begge bare vinne. En fletting for data må respektere dataenes regler, og noen ganger intensjonen bak dem. Det er det egentlige innholdet i uttrykket git for databasen, og det er prøven de eksisterende prosjektene bør måles mot.

4. Dagens teknikk, og hvor den kommer til kort

Feltet deler seg rent inn i tre grupper, og delingen er lærerik fordi hver gruppe defineres av det den gir fra seg. Tabell 1 stiller dem side ved side.

Tabell 1. Hvor dagens tilnærminger står. Innebygd PG betyr den ekte PostgreSQL-motoren, med sine utvidelser og sitt økosystem, snarere enn en reimplementasjon av dens wire-protokoll. Mønsteret er skarpt: det eneste prosjektet med ekte datafletting er det som forlater Postgres, og ethvert verktøy som beholder Postgres gir fletting fra seg.

Prosjekt Tilnærming Innebygd PG Gren Datadiff Datafletting Konfliktmodell
Dolt ny motor, Merkle-DAG nei ja ja ja cellevis, strukturell
DoltgreSQL ny motor, PG-wire nei ja ja ja cellevis, strukturell
Neon copy-on-write-lagring ja ja nei nei ingen
Supabase-forgrening instans per gren ja ja kun skjema nei ingen
Temporale / revisjonsverktøy lineær historie ja nei over tid nei ingen
En protokoll (foreslått) over WAL + MVCC ja ja ja ja semantisk, begrensningsbevisst

4.1 Å reimplementere motoren: Dolt og DoltgreSQL

Dolt er den mest fullstendige realiseringen av idéen, og den fortjener reell anerkjennelse. Det er en SQL-database med åpen kildekode bygget fra grunnen av for å være versjonert: lagringen dens er en innholdsadressert, rettet asyklisk Merkle-graf, strukturert med probabilistiske trær, ofte kalt prolly-trær, som gir den gits strukturelle deling og raske differ samtidig som den forblir en indeksert, spørrbar database. Branch, diff, merge, clone, push og pull er førsteklasses SQL- og kommandolinjeoperasjoner. Dolt er, genuint, git for data, og DoltgreSQL utvider den samme motoren til å snakke PostgreSQLs wire-protokoll slik at Postgres-klienter kan koble til.

Kostnaden ligger i åpent lys i den setningen: bygget fra grunnen av. Dolt er ikke Postgres. Det er en ny motor som reimplementerer en database og, i DoltgreSQLs tilfelle, Postgres-protokollen oppå den. En organisasjon som tar den i bruk legger ikke versjonering til den Postgres den kjører; den erstatter Postgres med noe annet og arver det noes ytelsesegenskaper og den lange halen av Postgres-utvidelser den ikke reproduserer, PostGIS og pgvector og resten som produksjonssystemer lener seg på. DoltgreSQL nådde en 1.0-utgivelse i 2026 og er imponerende kompatibel, men kompatibel med Postgres-dialekten er ikke det samme som å være Postgres. For et greenfield-prosjekt som verdsetter versjonering over alt, kan det være en rimelig byttehandel. For den enorme installerte basen av produksjons-Postgres er det å erstatte motoren for å oppnå versjonskontroll en svært stor hale som logrer med en svært viktig hund.

Det finnes en mer subtil begrensning, og den betyr noe for argumentet som kommer. Dolts fletting er modellert på gits: den arbeider én celle om gangen, tar hver sides endringer relativt til den felles forfaren og kombinerer dem, og der begge sider endret den samme cellen registrerer den en konflikt som et menneske skal løse. Dette er strukturell fletting, og det er den rette standarden, men den er semantisk blind. Den vet ikke at to samtidige inkrementer til et lagernivå bør summeres snarere enn å kollidere, eller at to innsettinger som deler en naturlig nøkkel ikke er en tilfeldighet, men en selvmotsigelse. Dolt oppdager riktignok begrensningsbrudd som en fletting innfører og løfter dem frem for løsning snarere enn å stille committe en ødelagt tilstand, noe som er til dens ære, men å oppdage i etterkant er ikke det samme som en fletting som forstår dataenes mening. Den strukturelle modellen er taket for hva cellevis fletting kan gjøre.

4.2 Å forgrene lagringen: Neon og Supabase

Den andre gruppen beholder Postgres, nettopp det Dolt gir fra seg, og kjøper forgreningen sin lenger ned i stacken. Neon omarkitekterer Postgres-lagringen, skiller beregning fra en flerversjons, loggstrukturert lagringstjeneste, og forgrening faller ut av det designet nesten gratis: en gren er en copy-on-write-forgrening av lagringen ved et valgt punkt i loggen, opprettet på sekunder uansett hvor stor databasen er, fordi ingenting kopieres før det skrives. Supabase tilbyr forgrening i en lignende ånd, setter opp en egen Postgres-instans per gren og kobler den inn i en Git-drevet forhåndsvisningsarbeidsflyt, og det samme copy-on-write-mønsteret løper gjennom hele økosystemet, fra Xatas databærende grener til ZFS-tynnklonene til Postgres.ai. Alle er genuint nyttige, og for utviklings- og testsløyfen i avsnitt 2 er de nær ideelle.

Men se på tabellen igjen. Dette er grener som kan forgrene seg og aldri møtes igjen. Neon kan opprette en gren i et øyeblikk og divergere fra den; den kan ikke flette den grenens dataendringer tilbake inn i forelderen, fordi ingenting i en copy-on-write-lagringsforgrening vet hvordan man forener to sett med divergerende sideskrivinger til én sammenhengende, begrensningsrespekterende tilstand. Det er ikke en forglemmelse som skal lappes; det er konsekvensen av å løse problemet på lagringslaget, der enheten er en ugjennomsiktig side, snarere enn på det logiske laget, der enheten er en rad med mening. Supabases grener er rettet mot skjemamigrasjoner for forhåndsvisningsmiljøer, ikke mot å flette data i det hele tatt. Resultatet er kraftig copy-on-write-kloning, som er en reell og verdifull ting, iført versjonskontrollens vokabular mens den bare leverer den enkle halvdelen. Å kalle en forgrening uten en fletting for en gren låner et løfte designet ikke kan holde.

4.3 Å logge historie: temporale tabeller og revisjonsspor

En tredje gruppe feies noen ganger inn i den samme samtalen og bør skilles ut. Systemversjonerte temporale tabeller, som standardisert i SQL:2011 og tilnærmet i Postgres av utvidelser som temporal_tables, og revisjonsrammeverk som pgMemento, gir en tabell en historie: hver rad bærer tidsrommet den var gjeldende for, og du kan spørre databasen slik den sto på et hvilket som helst tidligere øyeblikk. Dette er verdifullt, og det leverer provenienen og tidspunktlesningen som avsnitt 2 ba om. Men det er én enkelt, lineær historie. Det finnes ingen gren og ingen fletting, ingen parallelle arbeidslinjer å forene. Tidsreise er ikke versjonskontroll; det er én akse av den, den som alltid var enklest å legge til.

4.4 Tre bekymringer, feilaktig sammensmeltet

Ta et skritt tilbake, og mønsteret er klart. Hvert prosjekt besvarer de samme tre spørsmålene på én gang, og bunter svarene inn i ett enkelt produkt: hvordan historie modelleres, hvordan en versjon lagres fysisk, og hvordan konflikter løses. Dolt smelter en git-lignende versjonsmodell sammen med en spesialbygd lagringsmotor og en cellevis konfliktmodell, og for å få den første må du ta alle tre. Neon smelter en tynn versjonsmodell sammen med en copy-on-write-lagringsmotor og ingen konfliktmodell i det hele tatt. Fordi de tre er sveiset sammen, kan du ikke beholde Postgres og likevel ha fletting, og du kan ikke få semantisk fletting fra noen, fordi konfliktmodellen er hva enn lagringsmotoren tilfeldigvis gjorde enkelt. Det falske valget feltet presenterer, Postgres uten fletting eller fletting uten Postgres, er et artefakt av å smelte sammen bekymringer som er logisk atskilte. Trekk dem fra hverandre, og et bedre design dukker opp.

5. En bedre vei: en protokoll, ikke en forgrening

Vårt forslag er å slutte å bygge versjonskontrollerte databaser og begynne å definere en versjonskontrollprotokoll for databasen vi allerede har. Grepet er det samme som git selv gjorde: gits geni var å skille objektmodellen, commits og trær og refs, fra transporten som flytter dem omkring, slik at modellen kunne overleve enhver bestemt implementasjon. Databaseversjonskontroll bør skille versjonsmodellen, commits og grener og flettinger, fra den fysiske lagringen som materialiserer dem, slik at den kan kjøre på standard Postgres i stedet for å kreve en ny motor. Figur 2 viser formen på det.

Figur 2. En versjonskontrollprotokoll over innebygd Postgres. Motoren i bunnen er uendret, standard Postgres med sine begrensninger og utvidelser intakt. Over den fanger logisk dekoding endringer som innholdsadresserte commits, et tynt modellag leverer grener og refs, og semantisk fletting, den ene genuint vanskelige delen, forener divergens ved å validere mot det levende skjemaet og anvende retningslinjer per tabell. Hvordan en gren materialiseres fysisk er en utskiftbar optimalisering, ikke en del av kontrakten.
Figur 2. En versjonskontrollprotokoll over innebygd Postgres. Motoren i bunnen er uendret, standard Postgres med sine begrensninger og utvidelser intakt. Over den fanger logisk dekoding endringer som innholdsadresserte commits, et tynt modellag leverer grener og refs, og semantisk fletting, den ene genuint vanskelige delen, forener divergens ved å validere mot det levende skjemaet og anvende retningslinjer per tabell. Hvordan en gren materialiseres fysisk er en utskiftbar optimalisering, ikke en del av kontrakten.

5.1 Substratet Postgres allerede leverer

Det slående, og kjernen i argumentet vårt, er hvor mye av maskineriet Postgres allerede har. Dens flerversjons samtidighetskontroll holder flere versjoner av hver rad og gir hver transaksjon et konsistent øyeblikksbilde av databasen i et logisk øyeblikk: det er en commit i alt annet enn navn. Dens write-ahead-logg er en ordnet, varig oversikt over hver endring som noensinne er anvendt, det vil si en reflog. Og logisk dekoding, den modne mekanismen som allerede driver logisk replikering, gjør den loggen om til en ren, ordnet strøm av radnivåendringer som enhver klient kan konsumere. Tre av gits fire primitiver, uforanderlige øyeblikksbilder, en historielogg og en endringsstrøm, sitter allerede inne i Postgres, slik figur 1 viste. En protokoll trenger ikke å bygge dem opp igjen. Den trenger bare å legge til de to tingene Postgres mangler: persistente navngitte refs over den historien, og en fletting som forstår dataene.

Å fange commits er da et spørsmål om å konsumere den logiske dekodingsstrømmen og registrere hver transaksjons endringer som et innholdsadressert endringssett, hashet av innholdet sitt slik at identiske endringer deler lagring og ethvert endringssett kan navngis og hentes ved hashen sin. En slot opprettes én gang, og endringene tappes og lagres:

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

-- hver transaksjons endringer, i rekkefølge,
-- hashet og lagret som et commit-objekt
SELECT * FROM pg_logical_slot_get_changes(
  'vc', NULL, NULL);

Ingenting her forgrener motoren eller når under raden. Protokollen leser det Postgres allerede sender ut og bygger versjonsgrafen ved siden av den.

5.2 Commits, refs og grener

Med endringssett som commits er resten av den enkle halvdelen bokføring. En commit registrerer forelderen eller foreldrene sine og innholdshashen til endringssettet den innfører, og danner den samme uforanderlige rettede asykliske grafen git bruker. En ref er et navn som peker på en commit, og en gren er en ref som flytter seg etter hvert som nye commits legges til den. Disse metadataene er små, de er alminnelige relasjonelle data, og de kan bo i et skjema inne i selve databasen de versjonerer eller i et følgelager. Fordi en commit defineres av innholdsadresserte logiske endringer snarere enn av fysiske sider, er den portabel: den betyr det samme på enhver Postgres, lokalt eller i enhver sky, noe som er nettopp egenskapen en copy-on-write-lagringsforgrening ikke kan tilby. Versjonsmodellen er ren protokoll, og den bærer ingen innlåsing.

5.3 Semantisk, begrensningsbevisst fletting

Her er den vanskelige halvdelen, og stedet der en protokoll kan gjøre det ingen nåværende verktøy gjør. Fordi commits er logiske endringssett snarere enn ugjennomsiktige sider, kan en treveis fletting operere der meningen bor. Gitt to grener og deres felles forfar, beregner protokollen hver sides radnivåendringer og kombinerer dem, og gjør så de to tingene som skiller en databasefletting fra en tekstfletting. For det første validerer den det foreslåtte resultatet mot det levende skjemaet, hver begrensning, nøkkel og fremmednøkkelrelasjon, slik at en fletting aldri kan committe en tilstand databasen ville avvist; et brudd reises som en konflikt, ikke skrevet som korrupsjon. For det andre, og dette er det egentlige fremskrittet, løser den overlappinger ved hjelp av retningslinjer erklært per tabell og per kolonne av de som eier dataenes mening, snarere enn en enkelt blind cellevis regel.

Disse retningslinjene er der domeneintensjonen kommer inn. En tellerkolonne kan erklæres å flette ved å summere deltaene hver side anvendte, oppførselen til en konvergent replikert datatype, slik at to samtidige inkrementer korrekt summeres i stedet for å kollidere. Et sist-oppdatert-tidsstempel kan flette ved å ta den senere verdien. En mengdeverdiet relasjon kan flette ved union. En naturlig-nøkkel-kollisjon kan erklæres en ubetinget konflikt, fordi skjemaets mening sier at de to radene er den samme entiteten. Der ingen retningslinje gjelder og begge sider rørte den samme verdien, gjør protokollen nøyaktig det git gjør og stopper for et menneske, og presenterer konflikten i form av rader og verdier snarere enn sider. En erklæring kan lyde så enkelt 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 delen som tidligere arbeid viser er mulig. Innholdsadresserte systemer med brukerdefinerte flettefunksjoner finnes allerede utenfor den relasjonelle verdenen: Irmin, det git-lignende lageret bak deler av MirageOS-prosjektet, er bygget rundt nettopp denne idéen om flettbare data med egendefinert flettelogikk, og litteraturen om konvergente og kommutative replikerte datatyper gir en stringent redegjørelse for når samtidige endringer kan flettes uten konflikt. Teorien om invariant konfluens, fra Bailis og kolleger, går ett skritt videre og forteller oss nøyaktig hvilke invarianter en fletting kan bevare uten koordinering og hvilke, global unikhet og fremmednøkler blant dem, beviselig ikke kan. Det er ikke et råd i fortvilelse; det er grunnen til at en naturlig-nøkkel-kollisjon må erklæres en konflikt snarere enn å ønskes bort, og det forteller en protokoll nøyaktig hvor en automatisk retningslinje er trygg og hvor et menneske må avgjøre. Det som ikke er gjort, er å bringe den semantiske flettingen til innebygd, transaksjonell Postgres, styrt av skjemaets egne begrensninger. Det er det åpne problemet verdt å løse, og det de forgreningsproduktene har gått rundt snarere enn gjennom.

5.4 Materialisering som en optimalisering

En rimelig innvending er at det å spille av logiske endringer for å rekonstruere en gren kan være tregt for en stor database. Svaret er selve frakoblingen: hvordan en gren materialiseres fysisk er ikke en del av versjonsmodellen, så den kan velges fritt og endres senere. En gren kan spilles av fra endringssett når den er liten eller sjelden brukt, eller settes opp som et copy-on-write-øyeblikksbilde når den må være rask, ved hjelp av filsystemøyeblikksbilder som ZFS eller selve den copy-on-write-lagringen som Neon og dens like har bygget. Med andre ord er de utmerkede raskt-forgrenende motorene ikke konkurrenter til denne protokollen; de er én mulig backend for materialiseringen dens, med flettingen og den portable versjonsmodellen levert over dem. Protokollen sier hva en gren og en fletting betyr; lagringslaget står fritt til å gjøre dem raske.

5.5 Ærlige grenser

Vi påstår ikke at dette er enkelt, og en posisjonsartikkel som lot som noe annet ville fortjent mistanke. Semantisk fletting er genuint vanskelig: å skrive korrekte retningslinjer per tabell krever omtanke, lenge divergerte grener akkumulerer konflikter som ingen retningslinje kan løse uten skjønn, og svært høyvolums endringsstrømmer reiser reelle spørsmål om lagring og gjennomstrømning for commit-loggen. Å validere en stor fletting mot hver begrensning har en kostnad, og noen invarianter kan, slik teorien om invariant konfluens beviser, ikke forenes uten koordinering i det hele tatt, så en ærlig protokoll løfter dem frem som konflikter snarere enn å late som den løser dem. Dette er grunnene til at problemet fremdeles er åpent, ikke grunner til å erklære det uløselig. Det protokolltilnærmingen kjøper, er at den vanskelige delen, fletting, angripes på det ene stedet den kan angripes godt, på det logiske laget med skjemaet for hånden, i stedet for å bli forlatt på lagringslaget eller flatet ut til en cellevis regel. Det betyr også at arbeidet forsterker seg: fordi det er en protokoll over standard Postgres, fortsetter hver forbedring i motoren, hver utvidelse, hvert driftsverktøy å virke under den.

6. Hva dette betyr i praksis

For en organisasjon som velger i dag følger den ærlige veiledningen tabellen. Hvis det du trenger er billige, umiddelbare databaser for utvikling, testing og pull request-forhåndsvisninger, er copy-on-write-forgreningsverktøyene utmerkede og du bør bruke dem, med klare øyne for at en gren der er en kastbar forgrening, ikke en arbeidslinje du vil flette tilbake. Hvis du starter på nytt og versjonering er poenget med systemet, er Dolt et seriøst og dyktig verktøy, forutsatt at du godtar at du velger en ny motor snarere enn å utvide Postgres. Og hvis det du vil ha er hele løftet, forgren og diff og flett over den produksjons-Postgres du allerede kjører og stoler på, er det ærlige svaret at ingen produkt leverer det ennå, og det rette å satse på er en protokoll bygget på Postgres’ egne primitiver snarere enn enda en forgrening av motoren eller lagringen.

Den siste posisjonen er den Nashua holder, og den henger sammen med hvordan vi leser hele dette landskapet. Vi foretrekker best-of-breed-verktøy og åpne standarder fremfor enleverandørplattformer, og vi er på vakt mot innlåsing hvor enn den skjuler seg, inkludert inne i et lagringslag som kan forgrene seg, men aldri la dataene dine forlate på like vilkår. En versjonsmodell som er ren protokoll, portabel på tvers av enhver Postgres på enhver infrastruktur, lokal eller sky, holder valget av hvor og hvordan man kjører fast hos organisasjonen. Sky og lokal drift er begge gode hjem for data; en protokoll som er likegyldig til hvilket er nettopp poenget.

7. Konklusjon

Databasen fortjener den versjonskontrollen som forvandlet enhver annen del av programvareutvikling, og prosjektene som jager det målet har rett i å jage det. Men gevinsten er fletting, ikke bare forgrening, og feltet har delt seg i verktøy som fletter ved å forlate Postgres og verktøy som beholder Postgres ved å gi fra seg fletting. Den delingen er ikke uunngåelig. Den kommer av å smelte sammen tre atskillbare bekymringer, versjonsmodellen, den fysiske lagringen og konfliktløsningen, til ett produkt. Skill dem, bygg versjonsmodellen som en protokoll på write-ahead-loggen, flerversjonslagringen og den logiske dekodingen som Postgres allerede leverer, og sett en semantisk, begrensningsbevisst fletting i sentrum, og det falske valget oppløses. Git gjorde seg fortjent til sin plass ved å skille modellen fra maskinen. Data fortjener det samme, og Postgres har, nesten enestående, allerede delene til å gjøre det virkelig. Nashua vil heller hjelpe til med å bygge det enn å selge en forgrening av 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