november 2026
Version control for transactional data
Ett git-likt protokoll för PostgreSQL: varför, vad och hur; projekten med öppen källkod som redan bygger det, var deras design brister, och en bättre väg byggd på det Postgres redan har.
Sammanfattning
Mjukvaruteam versionshanterar sin kod med git och skulle inte drömma om att arbeta utan det, men databasen under den koden, det mest värdefulla och minst återställbara tillstånd en organisation äger, redigeras fortfarande på plats utan gren, utan diff och utan merge. Ett livaktigt fält av projekt med öppen källkod lovar att överbrygga den klyftan och föra git till databasen, och detta dokument redogör för varför, vad och hur. Vi hävdar att det verkliga priset inte är förgrening utan merge, förmågan att förena divergerande linjer av transaktionsdata, och vi visar att fältet har delat sig i två läger som vart och ett ger upp halva problemet: Dolt och DoltgreSQL vinner äkta git-semantik genom att återimplementera databasmotorn och lämna inbyggt Postgres bakom sig, medan Neon och Supabase behåller Postgres men erbjuder en gren som kan förgrena sig och aldrig återförenas. Vi föreslår en bättre väg. Inte en förgrenad motor och inte ett förgrenat lagringslager, utan ett versionshanteringsprotokoll byggt på den write-ahead-logg, flerversions-samtidighet och logiska avkodning som Postgres redan levererar, med en semantisk, villkorsmedveten merge som sin förstklassiga operation. Versionshantering för data bör skilja versionsmodellen från lagringen, på samma sätt som git skilde objektmodellen från transporten.
Nyckelord: PostgreSQL; databasversionshantering; git för data; dataförgrening; schemamigrering; trevägs-merge; konfliktlösning; write-ahead-logg; logisk avkodning; flerversions-samtidighetskontroll; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; temporala tabeller; dataproveniens; digital suveränitet
1. Introduktion
Be en utvecklare att arbeta en dag utan git och du får ett blankt nej. Att förgrena, committa, diffa och merga är så sammanvävt med hur mjukvara byggs att deras frånvaro är otänkbar. Fråga sedan samma utvecklare hur de versionshanterar produktionsdatabasen, det schema och de data som koden finns till för att betjäna, och svaret är nästan alltid ett generat ingenting. Databasen redigeras på plats. En migrering körs framåt och, om den går fel, är en panikartad återställning från gårdagens säkerhetskopia den enda vägen tillbaka. Två ingenjörer kan inte utveckla mot divergerande kopior av data och förena dem senare; de turas om, eller så skriver de över varandra. Det mest värdefulla och minst återställbara tillstånd en organisation äger är den enda del av stacken som helt saknar versionshantering.
Detta är en egendomlig klyfta, och ett växande fält av projekt med öppen källkod har föresatt sig att överbrygga den under ett baner alla förstår: git för din databas. Löftet är omedelbart tilltalande. Förgrena databasen för att pröva en riskabel ändring i isolering. Diffa två versioner för att se exakt vad en migrering gjorde. Ge varje analytiker en egen linje av data och merga tillbaka det goda arbetet. Res till vilket tidigare tillstånd som helst lika enkelt som git checkout. Om versionshantering förvandlade hur vi skriver kod, lyder argumentet, kan den förvandla hur vi hanterar data.
Vi anser att argumentet är riktigt, och detta är ett ståndpunktsdokument om hur man gör det sant. Vi förklarar varför versionshanterad data har betydelse (sektion 2), vad ett git-likt protokoll faktiskt måste tillhandahålla, vilket är mer och svårare än det först förefaller (sektion 3), och var dagens projekt står, med erkännande där det är förtjänt och en klarögd redogörelse för var deras design brister (sektion 4). Sedan för vi vår talan: att fältet har målat in sig i ett falskt val, och att den bättre vägen för Postgres är ett protokoll byggt på de primitiver den redan levererar snarare än en ny motor eller en omergbar förgrening (sektion 5). Nashua förordar best-of-breed-verktyg och sund praxis framför någon enskild produkt, och det är andan här: inte en försäljning av ett projekt, utan ett argument om hur detta bör byggas.
2. Varför versionshantera databasen
Fallet börjar med det arbete människor redan gör illa för hand. Schemamigreringar är det uppenbara. Varje team som driver en databas kör migreringar, och varje team har känt den särskilda fasa som följer av en migrering som inte kan ångras rent. En versionshanterad databas gör en migrering till en commit: reversibel, inspekterbar och testbar på en gren innan den rör produktionen. Diffen är inte en gissning utifrån migreringsskriptet; den är den faktiska ändringen av schema och data, beräknad och granskningsbar som vilken pull request som helst.
Sedan har vi utvecklings- och testloopen. Moderna team vill ha en realistisk databas för varje funktionsgren och varje förhandsvisning av en pull request, fylld med produktionslik data, uppstartad på några sekunder och bortkastad när grenen mergas. Att göra det genom att återställa fullständiga kopior är långsamt och dyrt; att göra det genom att dela en enda databas inbjuder till kollisioner. Billiga, omedelbara grenar löser ett verkligt och dagligt problem, vilket är just därför förgreningsprodukterna har funnit en ivrig marknad.
Bortom den dagliga loopen ligger de djupare skälen. Reproducerbarhet: en dataforskare som kan förankra en analys vid ett exakt committat tillstånd av data kan återskapa ett resultat månader senare, och det kan också den revisor som ifrågasätter det. Proveniens och granskning: en databas vars historik är en kedja av signerade commits besvarar vem som ändrade vad, och när, genom sin konstruktion snarare än genom en påbyggd trigger. Detta är ingen lyx i reglerade sektorer; Europeiska unionens DORA-regelverk och dess släktingar förväntar sig att finansiella entiteter ska påvisa integriteten och spårbarheten i sina data, och en versionshanterad historik är påvisbar på ett sätt som en föränderlig tabell inte är. Återställning: point-in-time-återställning upphör att vara en säkerhetskopieringsåtgärd och blir en checkout. Och samarbete blir äntligen möjligt kring data på samma sätt som kring kod, med oberoende arbetslinjer som konvergerar genom granskning snarare än genom låsning.
Inget av detta är exotiskt. Det är mjukvaruteknikens vanliga maskineri, tillämpat på den enda tillgång som envist har stått emot det. Frågan är inte huruvida databasen förtjänar versionshantering. Det gör den uppenbart. Frågan är vad som skulle krävas för att ge den den äkta varan.
3. Vad ett git-likt protokoll innebär
Det är värt att vara precis om vad git faktiskt tillhandahåller, eftersom den enkla halvan rutinmässigt förväxlas med helheten. Git är ett innehållsadresserat objektlager: varje version av varje fil är en blob namngiven efter hashen av sitt innehåll, träd sätter samman blobar till en ögonblicksbild, och en commit namnger ett träd tillsammans med sina föräldrar, vilket bildar en oföränderlig riktad acyklisk graf av historik. Ovanpå det lagret ligger två lager av bekvämlighet: refs, som är mänskliga namn på punkter i grafen, så att main och feature bara är etiketter på commits; och operationer, av vilka diff och merge är de som har betydelse.
Den avgörande operationen, den som gör git till ett samarbetsverktyg snarare än en fin säkerhetskopia, är trevägs-mergen. När två grenar divergerar frågar git inte vilken som vinner. Den finner deras gemensamma förfader, beräknar vad varje sida ändrade i förhållande till den förfadern, och kombinerar ändringarna, och markerar endast de ställen där båda sidor rörde samma sak på oförenliga sätt. Det är det som låter hundra personer arbeta parallellt och konvergera. Förgrening utan merge är bara en billig kopia; förgrening med merge är versionshantering.
För över detta till en databas och avbildningen är suggestiv men inte trivial, som figur 1 lägger ut. En commit bör vara en oföränderlig ögonblicksbild av hela databasen i ett logiskt ögonblick. En gren bör vara en namngiven linje av sådana ögonblicksbilder. En diff bör rapportera de rader och schemaobjekt som ändrades mellan två commits. Och en merge bör förena två divergerande linjer av data till en. De tre första är i grunden ett lagrings- och namngivningsproblem. Den fjärde är den svåra, och det är där analogin med git upphör att vara bekväm.
Text mergar därför att en källfil är en radordnad sekvens utan regler om sitt innehåll; git kan foga samman två uppsättningar radändringar och resultatet är fortfarande per definition en giltig fil. En databas är inte sådan. Dess innehåll styrs av invarianter: primärnycklar måste förbli unika, främmande nycklar måste gå att slå upp, villkorskontroller måste hålla, och, framför allt detta, måste data fortfarande betyda något. Två grenar som var och en infogar en kund med samma naturliga nyckel har inte skapat en mergekonflikt i textuell mening; de har skapat ett tillstånd som schemat förbjuder. Två grenar som var och en minskar ett kontosaldo med ett olika belopp kan inte båda helt enkelt vinna. En merge för data måste respektera dataets regler, och ibland avsikten bakom det. Det är det verkliga innehållet i frasen git för databasen, och det är det prov mot vilket de befintliga projekten bör mätas.
4. Teknikens läge, och var det brister
Fältet delar sig rent i tre grupper, och indelningen är lärorik eftersom varje grupp definieras av vad den ger upp. Tabell 1 ställer dem sida vid sida.
Tabell 1. Var dagens angreppssätt står. Inbyggt PG avser den riktiga PostgreSQL-motorn, med dess utökningar och ekosystem, snarare än en återimplementering av dess trådprotokoll. Mönstret är skarpt: det enda projekt med äkta data-merge är det som lämnar Postgres, och varje verktyg som behåller Postgres ger upp merge.
| Projekt | Angreppssätt | Inbyggt PG | Gren | Data-diff | Data-merge | Konfliktmodell |
|---|---|---|---|---|---|---|
| Dolt | ny motor, Merkle-DAG | nej | ja | ja | ja | cellvis, strukturell |
| DoltgreSQL | ny motor, PG-tråd | nej | ja | ja | ja | cellvis, strukturell |
| Neon | copy-on-write-lagring | ja | ja | nej | nej | ingen |
| Supabase-förgrening | instans per gren | ja | ja | endast schema | nej | ingen |
| Temporala/granskningsverktyg | linjär historik | ja | nej | över tid | nej | ingen |
| Ett protokoll (föreslaget) | över WAL + MVCC | ja | ja | ja | ja | semantisk, villkorsmedveten |
4.1 Att återimplementera motorn: Dolt och DoltgreSQL
Dolt är det mest fullständiga förverkligandet av idén, och den förtjänar verkligt erkännande. Den är en SQL-databas med öppen källkod byggd från grunden för att vara versionshanterad: dess lagring är en innehållsadresserad riktad acyklisk Merkle-graf, strukturerad med probabilistiska träd, ofta kallade prolly trees, som ger den gits strukturella delning och snabba diffar samtidigt som den förblir en indexerad, frågbar databas. Branch, diff, merge, clone, push och pull är förstklassiga operationer i SQL och på kommandoraden. Dolt är, på riktigt, git för data, och DoltgreSQL utökar samma motor till att tala PostgreSQL:s trådprotokoll så att Postgres-klienter kan ansluta.
Kostnaden ligger i öppen dager i den meningen: byggd från grunden. Dolt är inte Postgres. Den är en ny motor som återimplementerar en databas och, i DoltgreSQL:s fall, Postgres-protokollet ovanpå den. En organisation som inför den lägger inte till versionshantering i det Postgres den driver; den ersätter Postgres med något annat och ärver det någots prestandaegenskaper och den långa svansen av Postgres-utökningar som den inte återskapar, PostGIS och pgvector och resten som produktionssystem lutar sig mot. DoltgreSQL nådde en 1.0-utgåva under 2026 och är imponerande kompatibel, men kompatibel med Postgres-dialekten är inte detsamma som att vara Postgres. För ett grönfältsprojekt som värderar versionshantering över allt kan det vara en rimlig byteshandel. För den väldiga installerade basen av produktions-Postgres är att ersätta motorn för att vinna versionshantering en mycket stor svans som viftar med en mycket viktig hund.
Det finns en mer subtil begränsning, och den har betydelse för argumentet som kommer. Dolts merge är modellerad efter gits: den arbetar en cell i taget, tar varje sidas ändringar i förhållande till den gemensamma förfadern och kombinerar dem, och där båda sidor ändrade samma cell registrerar den en konflikt för en människa att lösa. Detta är strukturell merge, och den är det rätta standardvalet, men den är semantiskt blind. Den vet inte att två samtidiga ökningar av en lagernivå bör summeras snarare än kollidera, eller att två infogningar som delar en naturlig nyckel inte är en tillfällighet utan en motsägelse. Dolt upptäcker visserligen de villkorsöverträdelser som en merge inför och lyfter fram dem för lösning snarare än att tyst committa ett trasigt tillstånd, vilket är till dess förtjänst, men upptäckt i efterhand är inte detsamma som en merge som förstår dataets mening. Den strukturella modellen är taket för vad cellvis merge kan göra.
4.2 Att förgrena lagringen: Neon och Supabase
Den andra gruppen behåller Postgres, precis det som Dolt ger upp, och köper sin förgrening längre ner i stacken. Neon omarkitekturerar Postgres lagring och skiljer beräkning från en flerversions, loggstrukturerad lagringstjänst, och förgrening faller ut ur den designen nästan gratis: en gren är en copy-on-write-förgrening av lagringen vid en vald punkt i loggen, skapad på några sekunder oavsett hur stor databasen är, eftersom ingenting kopieras förrän det skrivs. Supabase erbjuder förgrening i en liknande anda, genom att resa en separat Postgres-instans per gren och koppla in den i ett Git-drivet förhandsvisningsflöde, och samma copy-on-write-mönster löper rakt igenom ekosystemet, från Xatas databärande grenar till ZFS-tunnklonerna hos Postgres.ai. Alla är genuint användbara, och för utvecklings- och testloopen i sektion 2 är de nära idealet.
Men se på tabellen igen. Detta är grenar som kan förgrena sig och aldrig återförenas. Neon kan skapa en gren i ett ögonblick och divergera från den; den kan inte merga den grenens dataändringar tillbaka in i sin förälder, eftersom ingenting i en copy-on-write-lagringsförgrening vet hur man förenar två uppsättningar divergerande sidskrivningar till ett sammanhängande, villkorsrespekterande tillstånd. Det är inget förbiseende att lappa; det är följden av att lösa problemet i lagringslagret, där enheten är en ogenomskinlig sida, snarare än i det logiska lagret, där enheten är en rad med mening. Supabases grenar är inriktade på schemamigreringar för förhandsvisningsmiljöer, inte på att merga data alls. Resultatet är kraftfull copy-on-write-kloning, vilket är en verklig och värdefull sak, iförd versionshanteringens vokabulär men levererande endast dess enkla halva. Att kalla en förgrening utan merge för en gren lånar ett löfte som designen inte kan hålla.
4.3 Att logga historik: temporala tabeller och granskningsspår
En tredje grupp sveps ibland in i samma samtal och bör särskiljas. Systemversionerade temporala tabeller, som standardiserade i SQL:2011 och approximerade i Postgres av utökningar såsom temporal_tables, och granskningsramverk såsom pgMemento, ger en tabell en historik: varje rad bär det tidsspann under vilket den var aktuell, och du kan fråga databasen så som den stod vid vilket tidigare ögonblick som helst. Detta är värdefullt, och det tillhandahåller den proveniens och den point-in-time-läsning som sektion 2 efterfrågade. Men det är en enda, linjär historik. Det finns ingen gren och ingen merge, inga parallella arbetslinjer att förena. Tidsresa är inte versionshantering; det är en axel av den, den som alltid var enklast att lägga till.
4.4 Tre angelägenheter, felaktigt sammansmälta
Ta ett steg tillbaka och mönstret är tydligt. Varje projekt besvarar samma tre frågor på en gång, och buntar ihop svaren till en enda produkt: hur historik modelleras, hur en version lagras fysiskt, och hur konflikter löses. Dolt smälter samman en git-lik versionsmodell med en skräddarsydd lagringsmotor och en cellvis konfliktmodell, och för att få den första måste du ta alla tre. Neon smälter samman en tunn versionsmodell med en copy-on-write-lagringsmotor och ingen konfliktmodell alls. Eftersom de tre är svetsade samman kan du inte behålla Postgres och ändå ha merge, och du kan inte få semantisk merge från någon, eftersom konfliktmodellen är vad lagringsmotorn råkade göra enkelt. Det falska val som fältet presenterar, Postgres utan merge eller merge utan Postgres, är en artefakt av att smälta samman angelägenheter som är logiskt åtskilda. Dra isär dem och en bättre design framträder.
5. En bättre väg: ett protokoll, inte en förgrening
Vårt förslag är att sluta bygga versionshanterade databaser och börja definiera ett versionshanteringsprotokoll för den databas vi redan har. Steget är detsamma som git självt tog: gits genialitet var att skilja objektmodellen, commits och träd och refs, från den transport som flyttar runt dem, så att modellen kunde överleva vilken enskild implementering som helst. Databasversionshantering bör skilja versionsmodellen, commits och grenar och merger, från den fysiska lagring som materialiserar dem, så att den kan köras på vanligt Postgres i stället för att kräva en ny motor. Figur 2 visar dess form.
5.1 Substratet Postgres redan levererar
Det slående, och kärnan i vårt argument, är hur mycket av maskineriet Postgres redan har. Dess flerversions-samtidighetskontroll håller flera versioner av varje rad och ger varje transaktion en konsekvent ögonblicksbild av databasen i ett logiskt ögonblick: det är en commit så när som på namnet. Dess write-ahead-logg är en ordnad, beständig uppteckning av varje ändring som någonsin tillämpats, vilket vill säga en reflog. Och logisk avkodning, den mogna mekanism som redan driver logisk replikering, förvandlar den loggen till en ren, ordnad ström av radnivåändringar som vilken klient som helst kan konsumera. Tre av gits fyra primitiver, oföränderliga ögonblicksbilder, en historiklogg och en ändringsström, sitter redan inuti Postgres, som figur 1 visade. Ett protokoll behöver inte bygga om dem. Det behöver bara lägga till de två saker Postgres saknar: beständiga namngivna refs över den historiken, och en merge som förstår data.
Att fånga commits är då en fråga om att konsumera strömmen från logisk avkodning och teckna ned varje transaktions ändringar som en innehållsadresserad ändringsmängd, hashad efter sitt innehåll så att identiska ändringar delar lagring och vilken ändringsmängd som helst kan namnges och hämtas via sin hash. En slot skapas en gång, och ändringarna töms och lagras:
SELECT pg_create_logical_replication_slot(
'vc', 'pgoutput');
-- varje transaktions ändringar, i ordning,
-- hashade och lagrade som ett commit-objekt
SELECT * FROM pg_logical_slot_get_changes(
'vc', NULL, NULL);
Ingenting här förgrenar motorn eller sträcker sig under raden. Protokollet läser vad Postgres redan avger och bygger versionsgrafen vid sidan av den.
5.2 Commits, refs och grenar
Med ändringsmängder som commits är resten av den enkla halvan bokföring. En commit tecknar sin förälder eller sina föräldrar och innehållshashen för den ändringsmängd den inför, vilket bildar samma oföränderliga riktade acykliska graf som git använder. En ref är ett namn som pekar på en commit, och en gren är en ref som flyttar sig allteftersom nya commits läggs till den. Dessa metadata är små, de är vanlig relationsdata, och de kan bo i ett schema inuti själva den databas de versionshanterar eller i ett följeslagarlager. Eftersom en commit definieras av innehållsadresserade logiska ändringar snarare än av fysiska sidor är den portabel: den betyder samma sak på vilket Postgres som helst, on-premises eller i vilket moln som helst, vilket är precis den egenskap en copy-on-write-lagringsförgrening inte kan erbjuda. Versionsmodellen är rent protokoll, och den bär ingen inlåsning.
5.3 Semantisk, villkorsmedveten merge
Här är den svåra halvan, och platsen där ett protokoll kan göra vad inget nuvarande verktyg gör. Eftersom commits är logiska ändringsmängder snarare än ogenomskinliga sidor kan en trevägs-merge arbeta där meningen bor. Givet två grenar och deras gemensamma förfader beräknar protokollet varje sidas radnivåändringar och kombinerar dem, och gör sedan de två saker som skiljer en databas-merge från en text-merge. För det första validerar det det föreslagna resultatet mot det levande schemat, varje villkor, nyckel och relation av främmande nyckel, så att en merge aldrig kan committa ett tillstånd som databasen skulle avvisa; en överträdelse reses som en konflikt, inte skrivs som korruption. För det andra, och detta är det verkliga framsteget, löser det överlappningar med hjälp av policyer deklarerade per tabell och per kolumn av de människor som äger dataets mening, snarare än en enda blind cellvis regel.
Dessa policyer är där domänavsikten kommer in. En räknarkolumn kan deklareras att merga genom att summera de delta som varje sida tillämpade, beteendet hos en konvergent replikerad datatyp, så att två samtidiga ökningar korrekt summeras i stället för att kollidera. En senast-uppdaterad-tidsstämpel kan merga genom att ta det senare värdet. En mängdvärd relation kan merga genom union. En naturnyckelkollision kan deklareras som en ovillkorlig konflikt, eftersom schemats mening säger att de två raderna är samma entitet. Där ingen policy gäller och båda sidor rörde samma värde gör protokollet exakt vad git gör och stannar för en människa, och presenterar konflikten i termer av rader och värden snarare än sidor. En deklaration skulle kunna läsa så här enkelt:
MERGE POLICY ON inventory (on_hand)
USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
USING conflict; -- samma SKU, samma artikel
Detta är den del som tidigare arbete visar är möjlig. Innehållsadresserade system med användardefinierade mergefunktioner existerar redan utanför den relationella världen: Irmin, det git-lika lager som ligger bakom delar av MirageOS-projektet, är byggt kring just denna idé om mergbar data med anpassad mergelogik, och litteraturen om konvergenta och kommutativa replikerade datatyper ger en rigorös redogörelse för när samtidiga ändringar kan mergas utan konflikt. Teorin om invariant konfluens, från Bailis och kollegor, går ett steg längre och berättar för oss precis vilka invarianter en merge kan bevara utan koordinering och vilka, global unikhet och främmande nycklar bland dem, bevisligen inte kan. Det är ingen förtvivlans läxa; det är skälet till att en naturnyckelkollision måste deklareras som en konflikt snarare än önskas bort, och det säger ett protokoll exakt var en automatisk policy är säker och var en människa måste avgöra. Det som inte har gjorts är att föra den semantiska mergen till inbyggt, transaktionellt Postgres, styrt av schemats egna villkor. Det är det öppna problem som är värt att lösa, och det som förgreningsprodukterna har klivit runt snarare än igenom.
5.4 Materialisering som en optimering
En rimlig invändning är att återspela logiska ändringar för att rekonstruera en gren kan vara långsamt för en stor databas. Svaret är frikopplingen själv: hur en gren materialiseras fysiskt är ingen del av versionsmodellen, så den kan väljas fritt och ändras senare. En gren kan återspelas från ändringsmängder när den är liten eller sällan använd, eller resas som en copy-on-write-ögonblicksbild när den måste vara snabb, med filsystemsögonblicksbilder såsom ZFS eller just den copy-on-write-lagring som Neon och dess like har byggt. Med andra ord är de utmärkta snabbförgrenande motorerna inte konkurrenter till detta protokoll; de är en möjlig backend för dess materialisering, med mergen och den portabla versionsmodellen tillförda ovanför dem. Protokollet säger vad en gren och en merge betyder; lagringslagret är fritt att göra dem snabba.
5.5 Ärliga begränsningar
Vi påstår inte att detta är enkelt, och ett ståndpunktsdokument som låtsades annorlunda skulle förtjäna misstanke. Semantisk merge är genuint svår: att skriva korrekta policyer per tabell kräver omsorg, länge divergerade grenar ackumulerar konflikter som ingen policy kan lösa utan omdöme, och ändringsströmmar med mycket hög volym reser verkliga frågor om lagring och genomströmning för commit-loggen. Att validera en stor merge mot varje villkor har en kostnad, och vissa invarianter kan, som teorin om invariant konfluens bevisar, inte förenas utan koordinering alls, så ett ärligt protokoll lyfter fram dessa som konflikter snarare än att låtsas lösa dem. Dessa är skälen till att problemet fortfarande är öppet, inte skäl att förklara det olösbart. Vad protokollansatsen köper är att den svåra delen, merge, angrips på den enda plats där den kan angripas väl, i det logiska lagret med schemat i hand, i stället för att överges i lagringslagret eller plattas ut till en cellvis regel. Det betyder också att arbetet ackumuleras: eftersom det är ett protokoll över vanligt Postgres fortsätter varje förbättring i motorn, varje utökning, varje driftsverktyg att fungera under det.
6. Vad detta betyder i praktiken
För en organisation som väljer i dag följer den ärliga vägledningen tabellen. Om det du behöver är billiga, omedelbara databaser för utveckling, testning och förhandsvisningar av pull requests är de copy-on-write-förgrenande verktygen utmärkta och du bör använda dem, med klara ögon om att en gren där är en engångsförgrening, inte en arbetslinje du kommer att merga tillbaka. Om du börjar från nytt och versionshantering är systemets poäng är Dolt ett seriöst och dugligt verktyg, förutsatt att du accepterar att du väljer en ny motor snarare än utökar Postgres. Och om det du vill ha är hela löftet, gren och diff och merge över det produktions-Postgres du redan driver och litar på, är det ärliga svaret att ingen produkt levererar det ännu, och det rätta att satsa på är ett protokoll byggt på Postgres egna primitiver snarare än ännu en förgrening av motorn eller lagringen.
Den sista ståndpunkten är den Nashua håller, och den hänger samman med hur vi läser hela detta landskap. Vi föredrar best-of-breed-verktyg och öppna standarder framför plattformar från en enda leverantör, och vi är vaksamma på inlåsning var den än gömmer sig, inbegripet inuti ett lagringslager som kan förgrena sig men aldrig låta dina data lämna på lika villkor. En versionsmodell som är rent protokoll, portabel över vilket Postgres som helst på vilken infrastruktur som helst, on-premises eller moln, håller valet av var och hur man kör fast hos organisationen. Moln och on-premises är båda bra hem för data; ett protokoll som inte bryr sig om vilket är just poängen.
7. Slutsats
Databasen förtjänar den versionshantering som förvandlade varje annan del av mjukvarutekniken, och de projekt som jagar det målet har rätt att jaga det. Men priset är merge, inte bara gren, och fältet har delat sig i verktyg som mergar genom att lämna Postgres och verktyg som behåller Postgres genom att ge upp merge. Den klyvningen är inte oundviklig. Den kommer från att smälta samman tre åtskiljbara angelägenheter, versionsmodellen, den fysiska lagringen och konfliktlösningen, till en enda produkt. Skilj dem åt, bygg versionsmodellen som ett protokoll på den write-ahead-logg, flerversionslagring och logiska avkodning som Postgres redan levererar, och sätt en semantisk, villkorsmedveten merge i dess centrum, så upplöses det falska valet. Git förtjänade sin plats genom att skilja modellen från maskinen. Data förtjänar detsamma, och Postgres har, nästan unikt, redan delarna för att göra det verkligt. Nashua hjälper hellre till att bygga det än säljer en förgrening 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
