November 2026

Version control for transactional data

Ein git-artiges Protokoll für PostgreSQL: das Warum, das Was und das Wie; die quelloffenen Projekte, die es bereits bauen, wo ihr Entwurf zu kurz greift, und ein besserer Weg, aufgebaut auf dem, was Postgres schon mitbringt.

Zusammenfassung

Software-Teams versionieren ihren Code mit git und würden nicht im Traum daran denken, ohne es zu arbeiten, doch die Datenbank unter diesem Code, der wertvollste und am wenigsten umkehrbare Zustand, den eine Organisation besitzt, wird nach wie vor an Ort und Stelle bearbeitet, ohne Branch, ohne Diff und ohne Merge. Ein lebhaftes Feld quelloffener Projekte verspricht, diese Lücke zu schließen und git in die Datenbank zu bringen, und dieses Papier legt das Warum, das Was und das Wie dar. Wir argumentieren, dass der eigentliche Gewinn nicht das Branchen ist, sondern das Mergen, die Fähigkeit, divergierende Linien transaktionaler Daten zu versöhnen, und wir zeigen, dass sich das Feld in zwei Lager gespalten hat, die jedes die Hälfte des Problems preisgeben: Dolt und DoltgreSQL gewinnen echte git-Semantik, indem sie die Datenbank-Engine neu implementieren und das native Postgres hinter sich lassen, während Neon und Supabase Postgres behalten, aber einen Branch bieten, der sich abspalten und nie wieder zusammenführen kann. Wir schlagen einen besseren Weg vor. Keine geforkte Engine und keine geforkte Speicherschicht, sondern ein Versionskontroll-Protokoll, aufgebaut auf dem Write-Ahead-Log, der Multiversion-Nebenläufigkeit und dem Logical Decoding, die Postgres bereits mitbringt, mit semantischem, constraint-bewusstem Merge als erstklassiger Operation. Versionskontrolle für Daten sollte das Versionsmodell von der Speicherung trennen, so wie git das Objektmodell vom Transport getrennt hat.

Schlüsselwörter: PostgreSQL; Datenbank-Versionskontrolle; git für Daten; Daten-Branching; Schema-Migration; Drei-Wege-Merge; Konfliktlösung; Write-Ahead-Log; Logical Decoding; Multiversion Concurrency Control; MVCC; Copy-on-Write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; temporale Tabellen; Datenprovenienz; digitale Souveränität

1. Einleitung

Bitten Sie eine Entwicklerin, einen Tag lang ohne git zu arbeiten, und Sie ernten eine glatte Absage. Branchen, Committen, Diffen und Mergen sind so sehr damit verwoben, wie Software gebaut wird, dass ihr Fehlen undenkbar ist. Fragen Sie nun dieselbe Entwicklerin, wie sie die Produktionsdatenbank versioniert, das Schema und die Daten, zu deren Dienst der Code überhaupt existiert, und die Antwort ist fast immer ein verlegenes Nichts. Die Datenbank wird an Ort und Stelle bearbeitet. Eine Migration läuft vorwärts, und wenn sie schiefgeht, ist eine hektische Wiederherstellung aus dem Backup der letzten Nacht der einzige Weg zurück. Zwei Ingenieure können nicht gegen divergierende Kopien der Daten entwickeln und sie später versöhnen; sie wechseln sich ab, oder sie überschreiben einander. Der wertvollste und am wenigsten umkehrbare Zustand, den eine Organisation besitzt, ist das eine Stück des Stacks, das gar keine Versionskontrolle hat.

Dies ist eine seltsame Lücke, und ein wachsendes Feld quelloffener Projekte hat sich aufgemacht, sie unter einem Banner zu schließen, das jeder versteht: git für Ihre Datenbank. Das Versprechen ist unmittelbar einnehmend. Branchen Sie die Datenbank, um eine riskante Änderung isoliert auszuprobieren. Diffen Sie zwei Versionen, um genau zu sehen, was eine Migration getan hat. Geben Sie jeder Analystin ihre eigene Linie der Daten und mergen Sie die gute Arbeit zurück. Reisen Sie zu jedem vergangenen Zustand so leicht wie mit git checkout. Wenn Versionskontrolle verändert hat, wie wir Code schreiben, so das Argument, dann kann sie verändern, wie wir Daten verwalten.

Wir halten das Argument für richtig, und dies ist ein Positionspapier darüber, wie man es wahr macht. Wir erklären, warum versionskontrollierte Daten wichtig sind (Abschnitt 2), was ein git-artiges Protokoll tatsächlich bereitstellen muss, was mehr und schwieriger ist, als es zunächst aussieht (Abschnitt 3), und wo die heutigen Projekte stehen, mit Anerkennung, wo sie verdient ist, und einer klarsichtigen Darstellung dessen, wo ihre Entwürfe zu kurz greifen (Abschnitt 4). Dann führen wir unseren Fall: dass sich das Feld in eine falsche Wahl manövriert hat und dass der bessere Weg für Postgres ein Protokoll ist, aufgebaut auf den Primitiven, die es bereits mitbringt, statt einer neuen Engine oder eines nicht mergefähigen Forks (Abschnitt 5). Nashua befürwortet Best-of-Breed-Werkzeuge und solide Praxis gegenüber jedem einzelnen Produkt, und das ist hier der Geist: kein Werben für ein Projekt, sondern ein Argument darüber, wie dies gebaut werden sollte.

2. Warum die Datenbank versionieren

Der Fall beginnt mit der Arbeit, die Menschen ohnehin schon schlecht von Hand erledigen. Schema-Migrationen sind die offensichtliche. Jedes Team, das eine Datenbank betreibt, führt Migrationen aus, und jedes Team hat das besondere Grauen einer Migration gespürt, die sich nicht sauber rückgängig machen lässt. Eine versionskontrollierte Datenbank macht aus einer Migration einen Commit: umkehrbar, inspizierbar und auf einem Branch testbar, bevor sie die Produktion berührt. Der Diff ist keine Mutmaßung aus dem Migrationsskript; er ist die tatsächliche Änderung an Schema und Daten, berechnet und prüfbar wie jeder Pull Request.

Dann ist da die Entwicklungs- und Testschleife. Moderne Teams wollen eine realistische Datenbank für jeden Feature-Branch und jede Pull-Request-Vorschau, befüllt mit produktionsnahen Daten, in Sekunden hochgezogen und weggeworfen, wenn der Branch gemergt wird. Dies durch das Wiederherstellen vollständiger Kopien zu tun, ist langsam und teuer; es durch das Teilen einer einzigen Datenbank zu tun, lädt zu Kollisionen ein. Billige, sofortige Branches lösen ein echtes und tägliches Problem, was genau der Grund ist, warum die Branching-Produkte einen willigen Markt gefunden haben.

Jenseits der täglichen Schleife liegen die tieferen Gründe. Reproduzierbarkeit: Eine Datenwissenschaftlerin, die eine Analyse an einen exakten committeten Zustand der Daten heften kann, kann ein Ergebnis Monate später reproduzieren, und ebenso die Prüferin, die es infrage stellt. Provenienz und Audit: Eine Datenbank, deren Historie eine Kette signierter Commits ist, beantwortet, wer was wann geändert hat, von Bauart her statt durch einen angeschraubten Trigger. Das ist keine Nettigkeit in regulierten Branchen; das DORA-Regime der Europäischen Union und seinesgleichen erwarten von Finanzunternehmen, die Integrität und Nachvollziehbarkeit ihrer Daten nachzuweisen, und eine versionierte Historie ist nachweisbar auf eine Weise, wie eine veränderliche Tabelle es nicht ist. Wiederherstellung: Point-in-Time-Restore hört auf, eine Backup-Operation zu sein, und wird zu einem Checkout. Und Zusammenarbeit an Daten wird endlich so möglich, wie sie es an Code ist, mit unabhängigen Arbeitslinien, die durch Review statt durch Sperren zusammenlaufen.

Nichts davon ist exotisch. Es ist das gewöhnliche Maschinenwerk der Softwareentwicklung, angewandt auf das eine Gut, das sich ihm hartnäckig widersetzt hat. Die Frage ist nicht, ob die Datenbank Versionskontrolle verdient. Sie verdient sie offensichtlich. Die Frage ist, was es bräuchte, um ihr das Echte zu geben.

3. Was ein git-artiges Protokoll bedeutet

Es lohnt sich, präzise zu sein, was git tatsächlich bereitstellt, denn die leichte Hälfte wird routinemäßig für das Ganze gehalten. Git ist ein inhaltsadressierter Objektspeicher: Jede Version jeder Datei ist ein Blob, benannt nach dem Hash seines Inhalts, Trees setzen Blobs zu einem Snapshot zusammen, und ein Commit benennt einen Tree zusammen mit seinen Eltern und bildet so einen unveränderlichen gerichteten azyklischen Graphen der Historie. Auf diesem Speicher sitzen zwei Schichten der Bequemlichkeit: Refs, die menschliche Namen für Punkte im Graphen sind, sodass main und feature bloß Etiketten auf Commits sind; und Operationen, von denen diff und merge die sind, auf die es ankommt.

Die entscheidende Operation, jene, die git zu einem Werkzeug der Zusammenarbeit macht statt zu einem aufgehübschten Backup, ist der Drei-Wege-Merge. Wenn zwei Branches divergieren, fragt git nicht, welcher gewinnt. Es findet ihren gemeinsamen Vorfahren, berechnet, was jede Seite relativ zu diesem Vorfahren geändert hat, und kombiniert die Änderungen, wobei es nur die Stellen markiert, an denen beide Seiten dasselbe auf unvereinbare Weise berührt haben. Das ist es, was hundert Menschen parallel arbeiten und dennoch zusammenlaufen lässt. Branchen ohne Mergen ist bloß eine billige Kopie; Branchen mit Mergen ist Versionskontrolle.

Überträgt man dies auf eine Datenbank, ist die Abbildung suggestiv, aber nicht trivial, wie Abbildung 1 darlegt. Ein Commit sollte ein unveränderlicher Snapshot der gesamten Datenbank in einem logischen Augenblick sein. Ein Branch sollte eine benannte Linie solcher Snapshots sein. Ein Diff sollte die Zeilen und Schemaobjekte melden, die sich zwischen zwei Commits geändert haben. Und ein Merge sollte zwei divergierende Linien von Daten zu einer versöhnen. Die ersten drei sind im Wesentlichen ein Speicher- und Benennungsproblem. Das vierte ist das schwierige, und dort hört die Analogie zu git auf, bequem zu sein.

Abbildung 1. Das git-Objektmodell, abgebildet auf Postgres. Drei der vier Bausteine von git existieren bereits innerhalb von Postgres als der MVCC-Snapshot, das Write-Ahead-Log und Logical Decoding; was fehlt, ist ein persistenter Branch-Ref und, vor allem, ein Merge, der die Daten versteht. Ein Protokoll muss nur die zwei warmen Kästen liefern, nicht die drei blauen neu bauen.
Abbildung 1. Das git-Objektmodell, abgebildet auf Postgres. Drei der vier Bausteine von git existieren bereits innerhalb von Postgres als der MVCC-Snapshot, das Write-Ahead-Log und Logical Decoding; was fehlt, ist ein persistenter Branch-Ref und, vor allem, ein Merge, der die Daten versteht. Ein Protokoll muss nur die zwei warmen Kästen liefern, nicht die drei blauen neu bauen.

Text lässt sich mergen, weil eine Quelldatei eine zeilengeordnete Sequenz ohne Regeln über ihren Inhalt ist; git kann zwei Mengen von Zeilenänderungen zusammenfügen, und das Ergebnis ist per Definition noch immer eine gültige Datei. Eine Datenbank ist nicht so. Ihr Inhalt wird von Invarianten regiert: Primärschlüssel müssen eindeutig bleiben, Fremdschlüssel müssen auflösen, Check-Constraints müssen gelten, und über all dem müssen die Daten noch etwas bedeuten. Zwei Branches, die jeweils einen Kunden mit demselben natürlichen Schlüssel einfügen, haben keinen Merge-Konflikt im textuellen Sinne erzeugt; sie haben einen Zustand erzeugt, den das Schema verbietet. Zwei Branches, die einen Kontostand jeweils um einen anderen Betrag verringern, können nicht beide einfach gewinnen. Ein Merge für Daten muss die Regeln der Daten achten und bisweilen die Absicht dahinter. Das ist der eigentliche Gehalt der Wendung git für die Datenbank, und das ist der Prüfstein, an dem die bestehenden Projekte gemessen werden sollten.

4. Der Stand der Technik und wo er zu kurz greift

Das Feld teilt sich sauber in drei Gruppen, und die Teilung ist lehrreich, weil jede Gruppe durch das definiert ist, was sie aufgibt. Tabelle 1 stellt sie nebeneinander.

Tabelle 1. Wo die heutigen Ansätze stehen. Natives PG meint die echte PostgreSQL-Engine, mit ihren Erweiterungen und ihrem Ökosystem, statt einer Neuimplementierung ihres Wire-Protokolls. Das Muster ist deutlich: Das einzige Projekt mit echtem Daten-Merge ist jenes, das Postgres verlässt, und jedes Werkzeug, das Postgres behält, gibt den Merge auf.

Projekt Ansatz Natives PG Branch Daten-Diff Daten-Merge Konfliktmodell
Dolt neue Engine, Merkle-DAG nein ja ja ja zellenweise, strukturell
DoltgreSQL neue Engine, PG-Wire nein ja ja ja zellenweise, strukturell
Neon Copy-on-Write-Speicher ja ja nein nein keines
Supabase-Branching Instanz pro Branch ja ja nur Schema nein keines
Temporale / Audit-Werkzeuge lineare Historie ja nein über die Zeit nein keines
Ein Protokoll (vorgeschlagen) über WAL + MVCC ja ja ja ja semantisch, constraint-bewusst

4.1 Die Engine neu implementieren: Dolt und DoltgreSQL

Dolt ist die vollständigste Verwirklichung der Idee, und es verdient echte Anerkennung. Es ist eine quelloffene SQL-Datenbank, von Grund auf dafür gebaut, versioniert zu werden: Ihr Speicher ist ein inhaltsadressierter gerichteter azyklischer Merkle-Graph, strukturiert mit probabilistischen Bäumen, oft Prolly Trees genannt, die ihr das strukturelle Teilen von git und schnelle Diffs geben, während sie eine indizierte, abfragbare Datenbank bleibt. Branch, Diff, Merge, Clone, Push und Pull sind erstklassige SQL- und Kommandozeilen-Operationen. Dolt ist, ganz ehrlich, git für Daten, und DoltgreSQL erweitert dieselbe Engine darum, das PostgreSQL-Wire-Protokoll zu sprechen, sodass Postgres-Clients sich verbinden können.

Der Preis liegt in jenem Satz offen zutage: von Grund auf gebaut. Dolt ist nicht Postgres. Es ist eine neue Engine, die eine Datenbank neu implementiert und, im Fall von DoltgreSQL, das Postgres-Protokoll obendrauf. Eine Organisation, die es übernimmt, fügt dem Postgres, das sie betreibt, keine Versionierung hinzu; sie ersetzt Postgres durch etwas anderes und erbt die Performance-Eigenschaften dieses anderen und den langen Schwanz an Postgres-Erweiterungen, die es nicht nachbildet, PostGIS und pgvector und den Rest, auf den sich Produktionssysteme stützen. DoltgreSQL erreichte 2026 ein 1.0-Release und ist beeindruckend kompatibel, aber mit dem Postgres-Dialekt kompatibel zu sein, ist nicht dasselbe, wie Postgres zu sein. Für ein Greenfield-Projekt, das Versionierung über alles schätzt, kann das ein fairer Tausch sein. Für die riesige installierte Basis an Produktions-Postgres ist das Ersetzen der Engine, um Versionskontrolle zu gewinnen, ein sehr großer Schwanz, der mit einem sehr wichtigen Hund wedelt.

Es gibt eine feinere Einschränkung, und sie ist für das kommende Argument von Bedeutung. Dolts Merge ist dem von git nachempfunden: Er arbeitet eine Zelle nach der anderen, nimmt die Änderungen jeder Seite relativ zum gemeinsamen Vorfahren und kombiniert sie, und wo beide Seiten dieselbe Zelle geändert haben, verzeichnet er einen Konflikt, den ein Mensch auflösen muss. Dies ist struktureller Merge, und er ist der richtige Standard, aber er ist semantisch blind. Er weiß nicht, dass zwei nebenläufige Erhöhungen eines Lagerbestands sich summieren sollten statt zu kollidieren, oder dass zwei Inserts, die sich einen natürlichen Schlüssel teilen, kein Zufall sind, sondern ein Widerspruch. Dolt erkennt durchaus Constraint-Verletzungen, die ein Merge einführt, und bringt sie zur Auflösung an die Oberfläche, statt stillschweigend einen kaputten Zustand zu committen, was ihm zugutezuhalten ist, aber das Erkennen im Nachhinein ist nicht dasselbe wie ein Merge, der die Bedeutung der Daten versteht. Das strukturelle Modell ist die Decke dessen, was zellenweiser Merge leisten kann.

4.2 Den Speicher branchen: Neon und Supabase

Die zweite Gruppe behält Postgres, genau das, was Dolt aufgibt, und erkauft ihr Branching tiefer im Stack. Neon gestaltet den Postgres-Speicher neu, trennt die Compute-Schicht von einem mehrversionigen, log-strukturierten Speicherdienst, und Branching fällt aus diesem Entwurf beinahe kostenlos ab: Ein Branch ist ein Copy-on-Write-Fork des Speichers an einem gewählten Punkt im Log, in Sekunden erstellt, egal wie groß die Datenbank ist, weil nichts kopiert wird, bis es geschrieben wird. Supabase bietet Branching in ähnlichem Geist, stellt eine eigene Postgres-Instanz pro Branch bereit und verdrahtet sie in einen Git-getriebenen Vorschau-Workflow, und dasselbe Copy-on-Write-Muster zieht sich quer durch das Ökosystem, von Xatas datentragenden Branches bis zu den ZFS-Thin-Clones von Postgres.ai. Alle sind wahrhaft nützlich, und für die Entwicklungs- und Testschleife aus Abschnitt 2 sind sie nahezu ideal.

Doch schauen Sie noch einmal auf die Tabelle. Dies sind Branches, die sich abspalten und nie wieder zusammenführen können. Neon kann in einem Augenblick einen Branch erstellen und von ihm divergieren; es kann die Datenänderungen dieses Branches nicht zurück in seinen Elternteil mergen, weil nichts in einem Copy-on-Write-Speicherfork weiß, wie man zwei Mengen divergierender Seitenschreibungen in einen kohärenten, constraint-achtenden Zustand versöhnt. Das ist kein Versehen, das sich flicken ließe; es ist die Folge davon, das Problem auf der Speicherschicht zu lösen, wo die Einheit eine opake Seite ist, statt auf der logischen Schicht, wo die Einheit eine Zeile mit Bedeutung ist. Supabases Branches sind auf Schema-Migrationen für Vorschauumgebungen ausgerichtet, überhaupt nicht auf das Mergen von Daten. Das Ergebnis ist mächtiges Copy-on-Write-Klonen, was eine reale und wertvolle Sache ist, das das Vokabular der Versionskontrolle trägt und doch nur ihre leichte Hälfte liefert. Einen Fork ohne Merge einen Branch zu nennen, borgt sich ein Versprechen, das der Entwurf nicht halten kann.

4.3 Historie protokollieren: temporale Tabellen und Audit-Trails

Eine dritte Gruppe wird manchmal in dasselbe Gespräch gezogen und sollte unterschieden werden. System-versionierte temporale Tabellen, wie in SQL:2011 standardisiert und in Postgres durch Erweiterungen wie temporal_tables angenähert, sowie Audit-Frameworks wie pgMemento geben einer Tabelle eine Historie: Jede Zeile trägt die Zeitspanne, für die sie aktuell war, und man kann die Datenbank so abfragen, wie sie in irgendeinem vergangenen Augenblick dastand. Das ist wertvoll, und es liefert die Provenienz und das Point-in-Time-Lesen, nach denen Abschnitt 2 verlangt hat. Aber es ist eine einzelne, lineare Historie. Es gibt keinen Branch und keinen Merge, keine parallelen Arbeitslinien, die zu versöhnen wären. Zeitreise ist keine Versionskontrolle; sie ist eine Achse davon, jene, die stets am leichtesten hinzuzufügen war.

4.4 Drei Belange, fälschlich verschmolzen

Tritt man zurück, ist das Muster klar. Jedes Projekt beantwortet dieselben drei Fragen auf einmal und bündelt die Antworten in ein einziges Produkt: wie Historie modelliert wird, wie eine Version physisch gespeichert wird und wie Konflikte aufgelöst werden. Dolt verschmilzt ein git-artiges Versionsmodell mit einer maßgeschneiderten Speicher-Engine und einem zellenweisen Konfliktmodell, und um das Erste zu bekommen, muss man alle drei nehmen. Neon verschmilzt ein dünnes Versionsmodell mit einer Copy-on-Write-Speicher-Engine und gar keinem Konfliktmodell. Weil die drei zusammengeschweißt sind, kann man Postgres nicht behalten und dennoch Merge haben, und man kann von niemandem semantischen Merge bekommen, weil das Konfliktmodell das ist, was die Speicher-Engine zufällig leicht gemacht hat. Die falsche Wahl, die das Feld präsentiert, Postgres ohne Merge oder Merge ohne Postgres, ist ein Artefakt des Verschmelzens von Belangen, die logisch getrennt sind. Zieht man sie auseinander, erscheint ein besserer Entwurf.

5. Ein besserer Weg: ein Protokoll, kein Fork

Unser Vorschlag ist, aufzuhören, versionskontrollierte Datenbanken zu bauen, und zu beginnen, ein Versionskontroll-Protokoll für die Datenbank zu definieren, die wir bereits haben. Der Schritt ist derselbe, den git selbst gemacht hat: Die Genialität von git bestand darin, das Objektmodell, Commits und Trees und Refs, vom Transport zu trennen, der sie umherbewegt, sodass das Modell jede einzelne Implementierung überdauern konnte. Datenbank-Versionskontrolle sollte das Versionsmodell, Commits und Branches und Merges, von der physischen Speicherung trennen, die sie materialisiert, sodass sie auf gewöhnlichem Postgres laufen kann, statt eine neue Engine zu verlangen. Abbildung 2 zeigt die Gestalt davon.

Abbildung 2. Ein Versionskontroll-Protokoll über nativem Postgres. Die Engine am Fundament ist unverändert, gewöhnliches Postgres mit seinen Constraints und Erweiterungen intakt. Darüber erfasst Logical Decoding Änderungen als inhaltsadressierte Commits, eine dünne Modellschicht liefert Branches und Refs, und semantischer Merge, der eine wahrhaft schwierige Teil, versöhnt Divergenz, indem er gegen das lebende Schema validiert und Richtlinien pro Tabelle anwendet. Wie ein Branch physisch materialisiert wird, ist eine austauschbare Optimierung, kein Teil des Vertrags.
Abbildung 2. Ein Versionskontroll-Protokoll über nativem Postgres. Die Engine am Fundament ist unverändert, gewöhnliches Postgres mit seinen Constraints und Erweiterungen intakt. Darüber erfasst Logical Decoding Änderungen als inhaltsadressierte Commits, eine dünne Modellschicht liefert Branches und Refs, und semantischer Merge, der eine wahrhaft schwierige Teil, versöhnt Divergenz, indem er gegen das lebende Schema validiert und Richtlinien pro Tabelle anwendet. Wie ein Branch physisch materialisiert wird, ist eine austauschbare Optimierung, kein Teil des Vertrags.

5.1 Das Substrat, das Postgres bereits mitbringt

Das Auffällige, und das Herz unseres Arguments, ist, wie viel von der Maschinerie Postgres bereits besitzt. Seine Multiversion Concurrency Control hält mehrere Versionen jeder Zeile und reicht jeder Transaktion einen konsistenten Snapshot der Datenbank in einem logischen Augenblick: Das ist ein Commit in allem außer dem Namen. Sein Write-Ahead-Log ist eine geordnete, dauerhafte Aufzeichnung jeder je angewandten Änderung, was heißt, ein Reflog. Und Logical Decoding, der ausgereifte Mechanismus, der bereits die logische Replikation antreibt, verwandelt dieses Log in einen sauberen, geordneten Strom von Änderungen auf Zeilenebene, den jeder Client konsumieren kann. Drei der vier Primitive von git, unveränderliche Snapshots, ein Historien-Log und ein Änderungsstrom, sitzen bereits in Postgres, wie Abbildung 1 zeigte. Ein Protokoll muss sie nicht neu bauen. Es muss nur die zwei Dinge hinzufügen, die Postgres fehlen: persistente benannte Refs über dieser Historie und einen Merge, der die Daten versteht.

Commits zu erfassen, ist dann eine Sache des Konsumierens des Logical-Decoding-Stroms und des Aufzeichnens der Änderungen jeder Transaktion als inhaltsadressiertes Change-Set, gehasht nach seinem Inhalt, sodass identische Änderungen Speicher teilen und jedes Change-Set nach seinem Hash benannt und abgerufen werden kann. Ein Slot wird einmal erstellt, und die Änderungen werden abgezogen und gespeichert:

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

-- Änderungen jeder Transaktion, in Reihenfolge,
-- gehasht und als Commit-Objekt gespeichert
SELECT * FROM pg_logical_slot_get_changes(
  'vc', NULL, NULL);

Nichts hier forkt die Engine oder greift unter die Zeile. Das Protokoll liest, was Postgres bereits ausgibt, und baut den Versionsgraphen daneben auf.

5.2 Commits, Refs und Branches

Mit Change-Sets als Commits ist der Rest der leichten Hälfte Buchführung. Ein Commit verzeichnet seinen Elternteil oder seine Eltern und den Inhalts-Hash des Change-Sets, das es einführt, und bildet denselben unveränderlichen gerichteten azyklischen Graphen, den git nutzt. Ein Ref ist ein Name, der auf einen Commit zeigt, und ein Branch ist ein Ref, das sich bewegt, während neue Commits zu ihm hinzugefügt werden. Diese Metadaten sind klein, sie sind gewöhnliche relationale Daten, und sie können in einem Schema innerhalb genau der Datenbank leben, die sie versioniert, oder in einem begleitenden Speicher. Weil ein Commit durch inhaltsadressierte logische Änderungen definiert ist und nicht durch physische Seiten, ist er portabel: Er bedeutet dasselbe auf jedem Postgres, On-Premises oder in jeder Cloud, was genau die Eigenschaft ist, die ein Copy-on-Write-Speicherfork nicht bieten kann. Das Versionsmodell ist reines Protokoll, und es trägt kein Lock-in.

5.3 Semantischer, constraint-bewusster Merge

Hier ist die schwierige Hälfte, und die Stelle, an der ein Protokoll tun kann, was kein heutiges Werkzeug tut. Weil Commits logische Change-Sets sind statt opaker Seiten, kann ein Drei-Wege-Merge dort arbeiten, wo die Bedeutung wohnt. Gegeben zwei Branches und ihr gemeinsamer Vorfahr, berechnet das Protokoll die Änderungen jeder Seite auf Zeilenebene und kombiniert sie, und tut dann die zwei Dinge, die einen Datenbank-Merge von einem Text-Merge unterscheiden. Erstens validiert es das vorgeschlagene Ergebnis gegen das lebende Schema, jeden Constraint, jeden Schlüssel und jede Fremdschlüsselbeziehung, sodass ein Merge niemals einen Zustand committen kann, den die Datenbank ablehnen würde; eine Verletzung wird als Konflikt erhoben, nicht als Korruption geschrieben. Zweitens, und das ist der eigentliche Fortschritt, löst es Überlappungen mithilfe von Richtlinien auf, die pro Tabelle und pro Spalte von den Menschen deklariert werden, denen die Bedeutung der Daten gehört, statt mit einer einzigen blinden zellenweisen Regel.

In diesen Richtlinien tritt die Domänenabsicht ein. Eine Zählerspalte kann so deklariert werden, dass sie durch Summieren der Deltas mergt, die jede Seite angewandt hat, das Verhalten eines konvergenten replizierten Datentyps, sodass zwei nebenläufige Erhöhungen sich korrekt summieren statt zu kollidieren. Ein Zuletzt-aktualisiert-Zeitstempel kann mergen, indem er den späteren Wert nimmt. Eine mengenwertige Beziehung kann durch Vereinigung mergen. Eine Kollision natürlicher Schlüssel kann zu einem bedingungslosen Konflikt erklärt werden, weil die Bedeutung des Schemas sagt, dass die zwei Zeilen dieselbe Entität sind. Wo keine Richtlinie greift und beide Seiten denselben Wert berührt haben, tut das Protokoll genau das, was git tut, und hält für einen Menschen an, wobei es den Konflikt in Begriffen von Zeilen und Werten darstellt statt von Seiten. Eine Deklaration könnte sich so schlicht lesen wie diese:

MERGE POLICY ON inventory (on_hand)
  USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
  USING conflict;  -- gleiche SKU, gleicher Artikel

Dies ist das Stück, von dem der Stand der Kunst zeigt, dass es möglich ist. Inhaltsadressierte Systeme mit benutzerdefinierten Merge-Funktionen existieren bereits außerhalb der relationalen Welt: Irmin, der git-artige Speicher hinter Teilen des MirageOS-Projekts, ist genau um diese Idee mergefähiger Daten mit eigener Merge-Logik herum gebaut, und die Literatur über konvergente und kommutative replizierte Datentypen gibt eine strenge Darstellung davon, wann nebenläufige Änderungen ohne Konflikt gemergt werden können. Die Theorie der invarianten Konfluenz, von Bailis und Kolleginnen, geht einen Schritt weiter und sagt uns genau, welche Invarianten ein Merge ohne Koordination bewahren kann und welche, globale Eindeutigkeit und Fremdschlüssel darunter, beweisbar nicht. Das ist kein Rat der Verzweiflung; es ist der Grund, warum eine Kollision natürlicher Schlüssel zu einem Konflikt erklärt werden muss, statt sie wegzuwünschen, und es sagt einem Protokoll genau, wo eine automatische Richtlinie sicher ist und wo ein Mensch entscheiden muss. Was nicht getan worden ist, ist, diesen semantischen Merge zu nativem, transaktionalem Postgres zu bringen, regiert von den eigenen Constraints des Schemas. Das ist das offene Problem, das zu lösen sich lohnt, und jenes, um das die Branching-Produkte herumgegangen sind, statt hindurch.

5.4 Materialisierung als Optimierung

Ein fairer Einwand ist, dass das Wiederabspielen logischer Änderungen zur Rekonstruktion eines Branches für eine große Datenbank langsam sein könnte. Die Antwort ist die Entkopplung selbst: Wie ein Branch physisch materialisiert wird, ist nicht Teil des Versionsmodells, also kann es frei gewählt und später geändert werden. Ein Branch kann aus Change-Sets wiederabgespielt werden, wenn er klein oder selten genutzt ist, oder als Copy-on-Write-Snapshot aufgestellt werden, wenn er schnell sein muss, mithilfe von Dateisystem-Snapshots wie ZFS oder genau des Copy-on-Write-Speichers, den Neon und seinesgleichen gebaut haben. Mit anderen Worten, die exzellenten Fork-schnellen Engines sind keine Konkurrenten dieses Protokolls; sie sind ein mögliches Backend für seine Materialisierung, mit dem Merge und dem portablen Versionsmodell darüber geliefert. Das Protokoll sagt, was ein Branch und ein Merge bedeuten; die Speicherschicht ist frei, sie schnell zu machen.

5.5 Ehrliche Grenzen

Wir behaupten nicht, dass dies leicht ist, und ein Positionspapier, das anderes vorgäbe, verdiente Misstrauen. Semantischer Merge ist wahrhaft schwer: Korrekte Richtlinien pro Tabelle zu schreiben erfordert Sorgfalt, lange divergierte Branches sammeln Konflikte an, die keine Richtlinie ohne Urteilsvermögen auflösen kann, und sehr volumenstarke Änderungsströme werfen echte Fragen der Speicherung und des Durchsatzes für das Commit-Log auf. Einen großen Merge gegen jeden Constraint zu validieren hat einen Preis, und manche Invarianten können, wie die Theorie der invarianten Konfluenz beweist, überhaupt nicht ohne Koordination versöhnt werden, also bringt ein ehrliches Protokoll jene als Konflikte an die Oberfläche, statt vorzugeben, sie aufzulösen. Dies sind die Gründe, warum das Problem noch offen ist, nicht Gründe, es für unlösbar zu erklären. Was der Protokollansatz einbringt, ist, dass der schwierige Teil, der Merge, an dem einen Ort angegangen wird, an dem er sich gut angehen lässt, auf der logischen Schicht mit dem Schema in der Hand, statt auf der Speicherschicht aufgegeben oder zu einer zellenweisen Regel plattgedrückt zu werden. Es bedeutet auch, dass sich die Arbeit summiert: Weil es ein Protokoll über gewöhnlichem Postgres ist, arbeitet jede Verbesserung in der Engine, jede Erweiterung, jedes Betriebswerkzeug darunter weiter.

6. Was dies in der Praxis bedeutet

Für eine Organisation, die heute wählt, folgt die ehrliche Orientierung der Tabelle. Wenn Sie billige, sofortige Datenbanken für Entwicklung, Test und Pull-Request-Vorschauen brauchen, sind die Copy-on-Write-Branching-Werkzeuge exzellent und Sie sollten sie nutzen, mit klarem Blick darauf, dass ein Branch dort ein wegwerfbarer Fork ist, keine Arbeitslinie, die Sie zurückmergen werden. Wenn Sie frisch beginnen und die Versionierung der Zweck des Systems ist, ist Dolt ein ernstes und fähiges Werkzeug, vorausgesetzt, Sie akzeptieren, dass Sie eine neue Engine wählen, statt Postgres zu erweitern. Und wenn Sie das volle Versprechen wollen, Branch und Diff und Merge über dem Produktions-Postgres, das Sie bereits betreiben und dem Sie vertrauen, ist die ehrliche Antwort, dass noch kein Produkt es liefert, und das Richtige, worauf zu setzen ist, ist ein Protokoll, aufgebaut auf Postgres’ eigenen Primitiven, statt eines weiteren Forks der Engine oder des Speichers.

Diese letzte Position ist jene, die Nashua vertritt, und sie ist aus einem Guss mit dem, wie wir diese ganze Landschaft lesen. Wir bevorzugen Best-of-Breed-Werkzeuge und offene Standards gegenüber Single-Vendor-Plattformen, und wir sind misstrauisch gegenüber Lock-in, wo immer es sich verbirgt, auch innerhalb einer Speicherschicht, die branchen kann, aber Ihre Daten nie zu gleichen Bedingungen gehen lässt. Ein Versionsmodell, das reines Protokoll ist, portabel über jedes Postgres auf jeder Infrastruktur, On-Premises oder Cloud, hält die Wahl, wo und wie betrieben wird, fest bei der Organisation. Cloud und On-Premises sind beide ein gutes Zuhause für Daten; ein Protokoll, dem es gleichgültig ist, welches, ist genau der Punkt.

7. Fazit

Die Datenbank verdient die Versionskontrolle, die jeden anderen Teil der Softwareentwicklung verwandelt hat, und die Projekte, die diesem Ziel nachjagen, tun recht daran. Aber der Gewinn ist der Merge, nicht bloß der Branch, und das Feld hat sich in Werkzeuge gespalten, die mergen, indem sie Postgres verlassen, und Werkzeuge, die Postgres behalten, indem sie den Merge aufgeben. Diese Spaltung ist nicht unausweichlich. Sie kommt vom Verschmelzen dreier trennbarer Belange, des Versionsmodells, der physischen Speicherung und der Konfliktlösung, in ein Produkt. Trennen Sie sie, bauen Sie das Versionsmodell als Protokoll auf dem Write-Ahead-Log, der Mehrversionsspeicherung und dem Logical Decoding, die Postgres bereits mitbringt, und setzen Sie einen semantischen, constraint-bewussten Merge in sein Zentrum, und die falsche Wahl löst sich auf. Git hat sich seinen Platz verdient, indem es das Modell von der Maschine trennte. Daten verdienen dasselbe, und Postgres hat, fast einzigartig, bereits die Teile, um es wahr zu machen. Nashua würde lieber helfen, das zu bauen, als einen Fork davon zu verkaufen.

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