novembre 2026

Version control for transactional data

Un protocollo in stile git per PostgreSQL: il perché, il cosa e il come; i progetti open-source che già lo costruiscono, dove il loro design non arriva, e una via migliore costruita su ciò che Postgres già offre.

Sommario

I team di sviluppo versionano il loro codice con git e non sognerebbero mai di lavorare senza, eppure il database sotto quel codice, lo stato più prezioso e meno reversibile che un’organizzazione possiede, viene ancora modificato sul posto senza branch, senza diff e senza merge. Un campo vivace di progetti open-source promette di colmare quel divario e portare git nel database, e questo articolo ne espone il perché, il cosa e il come. Sosteniamo che il vero premio non è il branching ma il merging, la capacità di riconciliare linee divergenti di dati transazionali, e mostriamo che il campo si è diviso in due schieramenti che rinunciano ciascuno a metà del problema: Dolt e DoltgreSQL ottengono una vera semantica git reimplementando il motore del database e lasciandosi alle spalle Postgres nativo, mentre Neon e Supabase mantengono Postgres ma offrono un branch che può biforcarsi e mai ricongiungersi. Proponiamo una via migliore. Non un motore forkato e non uno strato di storage forkato, ma un protocollo di controllo di versione costruito sul write-ahead log, sulla concorrenza multiversione e sul logical decoding che Postgres già fornisce, con un merge semantico e consapevole dei vincoli come operazione di prima classe. Il controllo di versione per i dati dovrebbe separare il modello di versione dallo storage, nel modo in cui git ha separato il modello a oggetti dal trasporto.

Parole chiave: PostgreSQL; controllo di versione del database; git per i dati; branching dei dati; migrazione dello schema; merge a tre vie; risoluzione dei conflitti; write-ahead log; logical decoding; controllo della concorrenza multiversione; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; tabelle temporali; provenienza dei dati; sovranità digitale

1. Introduzione

Chiedi a uno sviluppatore di lavorare per un giorno senza git e otterrai un rifiuto netto. Branching, commit, diff e merge sono così intrecciati nel modo in cui si costruisce il software che la loro assenza è impensabile. Ora chiedi allo stesso sviluppatore come versiona il database di produzione, lo schema e i dati che il codice esiste per servire, e la risposta è quasi sempre un imbarazzato niente. Il database viene modificato sul posto. Una migrazione va avanti e, se qualcosa va storto, un frenetico ripristino dal backup di ieri notte è l’unico modo per tornare indietro. Due ingegneri non possono sviluppare su copie divergenti dei dati e riconciliarle in seguito; fanno a turno, oppure si sovrascrivono a vicenda. Lo stato più prezioso e meno reversibile che un’organizzazione possiede è l’unico pezzo dello stack senza alcun controllo di versione.

È un divario strano, e un campo in crescita di progetti open-source si è messo in testa di colmarlo sotto un’insegna che tutti capiscono: git per il tuo database. La proposta è immediatamente allettante. Fai il branch del database per provare una modifica rischiosa in isolamento. Fai il diff di due versioni per vedere esattamente cosa ha fatto una migrazione. Dai a ogni analista la propria linea di dati e reincorpora con il merge il lavoro buono. Viaggia verso qualunque stato passato con la stessa facilità di git checkout. Se il controllo di versione ha trasformato il modo in cui scriviamo il codice, prosegue l’argomento, può trasformare il modo in cui gestiamo i dati.

Pensiamo che l’argomento sia giusto, e questo è un position paper su come renderlo vero. Spieghiamo perché i dati sotto controllo di versione contano (Sezione 2), cosa deve davvero fornire un protocollo in stile git, che è più e più difficile di quanto sembri a prima vista (Sezione 3), e a che punto sono i progetti di oggi, con il merito dove è dovuto e un resoconto lucido di dove i loro design non arrivano (Sezione 4). Poi presentiamo la nostra tesi: che il campo si è cacciato in una falsa scelta, e che la via migliore per Postgres è un protocollo costruito sulle primitive che già fornisce anziché un nuovo motore o un fork non mergeabile (Sezione 5). Nashua sostiene gli strumenti best-of-breed e la buona pratica più di qualunque singolo prodotto, ed è questo lo spirito qui: non la promozione di un progetto, ma un argomento su come questo dovrebbe essere costruito.

2. Perché versionare il database

La tesi comincia dal lavoro che le persone già fanno male a mano. Le migrazioni dello schema sono quello più ovvio. Ogni team che gestisce un database esegue migrazioni, e ogni team ha provato il particolare timore di una migrazione che non si può annullare in modo pulito. Un database sotto controllo di versione rende una migrazione un commit: reversibile, ispezionabile e testabile su un branch prima che tocchi la produzione. Il diff non è una congettura ricavata dallo script di migrazione; è la modifica effettiva a schema e dati, calcolata e rivedibile come qualunque pull request.

Poi c’è il ciclo di sviluppo e test. I team moderni vogliono un database realistico per ogni feature branch e per ogni preview di pull request, popolato con dati simili a quelli di produzione, creato in pochi secondi e buttato via quando il branch viene mergiato. Farlo ripristinando copie complete è lento e costoso; farlo condividendo un unico database invita alle collisioni. Branch economici e istantanei risolvono un problema reale e quotidiano, ed è esattamente per questo che i prodotti di branching hanno trovato un mercato impaziente.

Oltre il ciclo quotidiano stanno le ragioni più profonde. Riproducibilità: un data scientist che può ancorare un’analisi a uno stato esatto e committato dei dati può riprodurre un risultato mesi dopo, e così può l’auditor che lo mette in discussione. Provenienza e audit: un database la cui storia è una catena di commit firmati risponde a chi ha cambiato cosa, e quando, per costruzione anziché tramite un trigger aggiunto a posteriori. Non è un dettaglio piacevole nei settori regolamentati; il regime DORA dell’Unione Europea e i suoi affini si aspettano che le entità finanziarie dimostrino l’integrità e la tracciabilità dei loro dati, e una storia versionata è dimostrabile in un modo in cui una tabella mutabile non lo è. Recupero: il ripristino a un istante nel tempo smette di essere un’operazione di backup e diventa un checkout. E la collaborazione diventa finalmente possibile sui dati nel modo in cui lo è sul codice, con linee di lavoro indipendenti che convergono attraverso la revisione anziché attraverso il locking.

Niente di tutto questo è esotico. È l’ordinaria macchina dell’ingegneria del software, applicata all’unico asset che le ha ostinatamente resistito. La domanda non è se il database meriti il controllo di versione. Chiaramente lo merita. La domanda è cosa ci vorrebbe per dargliene uno vero.

3. Cosa significa un protocollo in stile git

Vale la pena essere precisi su cosa git fornisca davvero, perché la metà facile viene regolarmente scambiata per il tutto. Git è un object store indirizzato per contenuto: ogni versione di ogni file è un blob chiamato con l’hash del suo contenuto, i tree compongono i blob in uno snapshot, e un commit nomina un tree insieme ai suoi genitori, formando un grafo aciclico diretto e immutabile della storia. Sopra quell’archivio stanno due strati di comodità: i ref, che sono nomi umani per punti nel grafo, così che main e feature siano semplici etichette sui commit; e le operazioni, di cui diff e merge sono quelle che contano.

L’operazione decisiva, quella che rende git uno strumento di collaborazione anziché un backup elegante, è il merge a tre vie. Quando due branch divergono, git non chiede quale dei due vinca. Trova il loro antenato comune, calcola cosa ciascun lato ha cambiato rispetto a quell’antenato, e combina le modifiche, segnalando solo i punti in cui entrambi i lati hanno toccato la stessa cosa in modi incompatibili. È questo che permette a cento persone di lavorare in parallelo e convergere. Il branching senza il merging è solo una copia economica; il branching con il merging è controllo di versione.

Portalo a un database e la mappatura è suggestiva ma non banale, come illustra la Figura 1. Un commit dovrebbe essere uno snapshot immutabile dell’intero database in un istante logico. Un branch dovrebbe essere una linea nominata di tali snapshot. Un diff dovrebbe riportare le righe e gli oggetti di schema che sono cambiati tra due commit. E un merge dovrebbe riconciliare due linee divergenti di dati in una sola. I primi tre sono, in sostanza, un problema di storage e di denominazione. Il quarto è quello difficile, ed è dove l’analogia con git smette di essere comoda.

Figura 1. Il modello a oggetti di git mappato su Postgres. Tre dei quattro mattoni di git esistono già dentro Postgres come lo snapshot MVCC, il write-ahead log e il logical decoding; ciò che manca è un ref di branch persistente e, soprattutto, un merge che comprende i dati. Un protocollo deve solo fornire i due riquadri caldi, non ricostruire i tre blu.
Figura 1. Il modello a oggetti di git mappato su Postgres. Tre dei quattro mattoni di git esistono già dentro Postgres come lo snapshot MVCC, il write-ahead log e il logical decoding; ciò che manca è un ref di branch persistente e, soprattutto, un merge che comprende i dati. Un protocollo deve solo fornire i due riquadri caldi, non ricostruire i tre blu.

Il testo si fonde perché un file sorgente è una sequenza ordinata per righe senza regole sul suo contenuto; git può innestare due insiemi di modifiche di righe e il risultato è per definizione ancora un file valido. Un database non è così. Il suo contenuto è governato da invarianti: le chiavi primarie devono restare uniche, le chiavi esterne devono risolversi, i vincoli di check devono valere e, al di sopra di tutto questo, i dati devono comunque significare qualcosa. Due branch che inseriscono ciascuno un cliente con la stessa chiave naturale non hanno prodotto un conflitto di merge nel senso testuale; hanno prodotto uno stato che lo schema vieta. Due branch che decrementano ciascuno il saldo di un conto di un importo diverso non possono vincere entrambi semplicemente. Un merge per i dati deve rispettare le regole dei dati, e a volte l’intento che vi sta dietro. È questo il vero contenuto della frase git per il database, ed è la prova con cui andrebbero misurati i progetti esistenti.

4. Lo stato dell’arte, e dove non arriva

Il campo si divide nettamente in tre gruppi, e la divisione è istruttiva perché ciascun gruppo è definito da ciò a cui rinuncia. La Tabella 1 li mette fianco a fianco.

Tabella 1. A che punto sono gli approcci di oggi. PG nativo indica il vero motore PostgreSQL, con le sue estensioni e il suo ecosistema, anziché una reimplementazione del suo protocollo di comunicazione. Lo schema è netto: l’unico progetto con un vero merge dei dati è quello che abbandona Postgres, e ogni strumento che mantiene Postgres rinuncia al merge.

Progetto Approccio PG nativo Branch Diff dei dati Merge dei dati Modello di conflitto
Dolt nuovo motore, DAG di Merkle no sì sì sì a livello di cella, strutturale
DoltgreSQL nuovo motore, protocollo PG no sì sì sì a livello di cella, strutturale
Neon storage copy-on-write sì sì no no nessuno
Supabase branching istanza per branch sì sì solo schema no nessuno
Strumenti temporali / di audit storia lineare sì no nel tempo no nessuno
Un protocollo (proposto) su WAL + MVCC sì sì sì sì semantico, consapevole dei vincoli

4.1 Reimplementare il motore: Dolt e DoltgreSQL

Dolt è la realizzazione più completa dell’idea, e merita un vero riconoscimento. È un database SQL open-source costruito da zero per essere versionato: il suo storage è un grafo aciclico diretto di Merkle indirizzato per contenuto, strutturato con alberi probabilistici, spesso chiamati prolly tree, che gli danno la condivisione strutturale e i diff veloci di git pur restando un database indicizzato e interrogabile. Branch, diff, merge, clone, push e pull sono operazioni di prima classe in SQL e da riga di comando. Dolt è, genuinamente, git per i dati, e DoltgreSQL estende lo stesso motore perché parli il protocollo di comunicazione di PostgreSQL, così che i client Postgres possano connettersi.

Il costo è bene in vista in quella frase: costruito da zero. Dolt non è Postgres. È un nuovo motore che reimplementa un database e, nel caso di DoltgreSQL, il protocollo Postgres sopra di esso. Un’organizzazione che lo adotta non aggiunge il versionamento al Postgres che esegue; sostituisce Postgres con qualcos’altro ed eredita le caratteristiche prestazionali di quel qualcosa e la lunga coda di estensioni Postgres che non riproduce, PostGIS e pgvector e il resto su cui i sistemi di produzione si appoggiano. DoltgreSQL ha raggiunto una release 1.0 nel 2026 ed è compatibile in modo impressionante, ma essere compatibile con il dialetto Postgres non è la stessa cosa che essere Postgres. Per un progetto greenfield che valorizza il versionamento sopra ogni cosa, può essere uno scambio equo. Per la vasta base installata di Postgres in produzione, sostituire il motore per ottenere il controllo di versione è una coda molto grande che agita un cane molto importante.

C’è una limitazione più sottile, e conta per l’argomento che verrà. Il merge di Dolt è modellato su quello di git: lavora una cella alla volta, prendendo le modifiche di ciascun lato rispetto all’antenato comune e combinandole, e dove entrambi i lati hanno cambiato la stessa cella registra un conflitto perché un essere umano lo risolva. Questo è il merge strutturale, ed è il default giusto, ma è semanticamente cieco. Non sa che due incrementi concorrenti a un livello di stock dovrebbero sommarsi anziché scontrarsi, o che due inserimenti che condividono una chiave naturale non sono una coincidenza ma una contraddizione. Dolt rileva effettivamente le violazioni di vincoli che un merge introduce e le fa emergere per la risoluzione anziché committare in silenzio uno stato rotto, il che è a suo merito, ma rilevare a posteriori non è la stessa cosa di un merge che comprende il significato dei dati. Il modello strutturale è il tetto di ciò che un merge a livello di cella può fare.

4.2 Branching dello storage: Neon e Supabase

Il secondo gruppo mantiene Postgres, esattamente la cosa a cui Dolt rinuncia, e compra il proprio branching più in basso nello stack. Neon riprogetta lo storage di Postgres, separando il calcolo da un servizio di storage multiversione e strutturato a log, e il branching deriva da quel design quasi gratuitamente: un branch è un fork copy-on-write dello storage a un punto scelto nel log, creato in pochi secondi per quanto grande sia il database, perché nulla viene copiato finché non viene scritto. Supabase offre il branching in uno spirito simile, mettendo in piedi un’istanza Postgres separata per branch e collegandola a un flusso di preview guidato da Git, e lo stesso pattern copy-on-write attraversa tutto l’ecosistema, dai branch di Xata che trasportano i dati ai thin clone ZFS di Postgres.ai. Sono tutti genuinamente utili, e per il ciclo di sviluppo e test della Sezione 2 sono vicini all’ideale.

Ma guarda di nuovo la tabella. Questi sono branch che possono biforcarsi e mai ricongiungersi. Neon può creare un branch in un istante e divergere da esso; non può reincorporare con il merge le modifiche ai dati di quel branch nel suo genitore, perché nulla in un fork di storage copy-on-write sa come riconciliare due insiemi di scritture di pagina divergenti in un unico stato coerente e rispettoso dei vincoli. Non è una svista da correggere con una patch; è la conseguenza del risolvere il problema allo strato di storage, dove l’unità è una pagina opaca, anziché allo strato logico, dove l’unità è una riga dotata di significato. I branch di Supabase sono orientati alle migrazioni dello schema per gli ambienti di preview, non affatto al merge dei dati. Il risultato è una potente clonazione copy-on-write, che è una cosa reale e di valore, che indossa il vocabolario del controllo di versione pur consegnandone solo la metà facile. Chiamare branch un fork senza merge prende in prestito una promessa che il design non può mantenere.

4.3 Registrare la storia: tabelle temporali e audit trail

Un terzo gruppo viene a volte trascinato nella stessa conversazione e andrebbe distinto. Le tabelle temporali versionate dal sistema, come standardizzate in SQL:2011 e approssimate in Postgres da estensioni come temporal_tables, e i framework di audit come pgMemento, danno a una tabella una storia: ogni riga porta con sé l’arco di tempo per cui era corrente, e puoi interrogare il database com’era in qualunque istante passato. Questo è di valore, e fornisce la provenienza e la lettura a un istante nel tempo che la Sezione 2 chiedeva. Ma è una storia unica e lineare. Non c’è branch e non c’è merge, non ci sono linee di lavoro parallele da riconciliare. Il viaggio nel tempo non è controllo di versione; ne è un asse, quello che è sempre stato il più facile da aggiungere.

4.4 Tre preoccupazioni, fuse erroneamente

Fai un passo indietro e lo schema è chiaro. Ogni progetto risponde alle stesse tre domande in una volta sola, e raggruppa le risposte in un unico prodotto: come viene modellata la storia, come una versione viene fisicamente memorizzata, e come i conflitti vengono risolti. Dolt fonde un modello di versione in stile git a un motore di storage su misura e a un modello di conflitto a livello di cella, e per ottenere il primo devi prenderti tutti e tre. Neon fonde un modello di versione sottile a un motore di storage copy-on-write e a nessun modello di conflitto. Poiché i tre sono saldati insieme, non puoi mantenere Postgres e avere comunque il merge, e non puoi avere un merge semantico da nessuno, perché il modello di conflitto è qualunque cosa sia capitato fosse facile per il motore di storage. La falsa scelta che il campo presenta, Postgres senza merge o merge senza Postgres, è un artefatto del fondere preoccupazioni che sono logicamente separate. Separale e appare un design migliore.

5. Una via migliore: un protocollo, non un fork

La nostra proposta è smettere di costruire database sotto controllo di versione e cominciare a definire un protocollo di controllo di versione per il database che già abbiamo. La mossa è la stessa che git stesso ha fatto: il genio di git è stato separare il modello a oggetti, commit e tree e ref, dal trasporto che li sposta in giro, così che il modello potesse sopravvivere a qualunque implementazione particolare. Il controllo di versione del database dovrebbe separare il modello di versione, commit e branch e merge, dallo storage fisico che li materializza, così da poter girare su Postgres standard anziché richiedere un nuovo motore. La Figura 2 ne mostra la forma.

Figura 2. Un protocollo di controllo di versione sopra Postgres nativo. Il motore alla base è invariato, Postgres standard con i suoi vincoli e le sue estensioni intatti. Sopra di esso, il logical decoding cattura le modifiche come commit indirizzati per contenuto, un sottile strato di modello fornisce branch e ref, e il merge semantico, l'unica parte davvero difficile, riconcilia la divergenza validando rispetto allo schema vivo e applicando politiche per tabella. Come un branch viene fisicamente materializzato è un'ottimizzazione sostituibile, non parte del contratto.
Figura 2. Un protocollo di controllo di versione sopra Postgres nativo. Il motore alla base è invariato, Postgres standard con i suoi vincoli e le sue estensioni intatti. Sopra di esso, il logical decoding cattura le modifiche come commit indirizzati per contenuto, un sottile strato di modello fornisce branch e ref, e il merge semantico, l'unica parte davvero difficile, riconcilia la divergenza validando rispetto allo schema vivo e applicando politiche per tabella. Come un branch viene fisicamente materializzato è un'ottimizzazione sostituibile, non parte del contratto.

5.1 Il substrato che Postgres già fornisce

La cosa sorprendente, e il cuore del nostro argomento, è quanta di questa macchina Postgres abbia già. Il suo controllo della concorrenza multiversione mantiene più versioni di ogni riga e consegna a ciascuna transazione uno snapshot coerente del database in un istante logico: è un commit in tutto tranne che nel nome. Il suo write-ahead log è un registro ordinato e durevole di ogni modifica mai applicata, vale a dire un reflog. E il logical decoding, il meccanismo maturo che già alimenta la replica logica, trasforma quel log in un flusso pulito e ordinato di modifiche a livello di riga che qualunque client può consumare. Tre delle quattro primitive di git, snapshot immutabili, un log della storia e un flusso di modifiche, si trovano già dentro Postgres, come mostrava la Figura 1. Un protocollo non ha bisogno di ricostruirle. Deve solo aggiungere le due cose che a Postgres mancano: ref nominati e persistenti su quella storia, e un merge che comprende i dati.

Catturare i commit, dunque, è una questione di consumare il flusso di logical decoding e registrare le modifiche di ciascuna transazione come un change set indirizzato per contenuto, con hash calcolato dal suo contenuto così che modifiche identiche condividano lo storage e qualunque change set possa essere nominato e recuperato tramite il suo hash. Uno slot viene creato una volta sola, e le modifiche vengono drenate e memorizzate:

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

-- le modifiche di ogni transazione, in ordine,
-- con hash e salvate come oggetto commit
SELECT * FROM pg_logical_slot_get_changes(
  'vc', NULL, NULL);

Niente qui forka il motore o si spinge sotto la riga. Il protocollo legge ciò che Postgres già emette e costruisce il grafo di versione accanto ad esso.

5.2 Commit, ref e branch

Con i change set come commit, il resto della metà facile è contabilità. Un commit registra il suo genitore o i suoi genitori e l’hash del contenuto del change set che introduce, formando lo stesso grafo aciclico diretto e immutabile che usa git. Un ref è un nome che punta a un commit, e un branch è un ref che si sposta man mano che nuovi commit gli vengono aggiunti. Questi metadati sono piccoli, sono ordinari dati relazionali, e possono vivere in uno schema dentro il database stesso che versionano o in un archivio di accompagnamento. Poiché un commit è definito da modifiche logiche indirizzate per contenuto anziché da pagine fisiche, è portabile: significa la stessa cosa su qualunque Postgres, on-premises o in qualunque cloud, che è precisamente la proprietà che un fork di storage copy-on-write non può offrire. Il modello di versione è puro protocollo, e non porta con sé alcun lock-in.

5.3 Merge semantico e consapevole dei vincoli

Ecco la metà difficile, e il punto in cui un protocollo può fare ciò che nessuno strumento attuale fa. Poiché i commit sono change set logici anziché pagine opache, un merge a tre vie può operare dove risiede il significato. Dati due branch e il loro antenato comune, il protocollo calcola le modifiche a livello di riga di ciascun lato e le combina, e poi fa le due cose che distinguono un merge di database da un merge di testo. Primo, valida il risultato proposto rispetto allo schema vivo, ogni vincolo, chiave e relazione di chiave esterna, così che un merge non possa mai committare uno stato che il database rifiuterebbe; una violazione viene sollevata come conflitto, non scritta come corruzione. Secondo, e questo è il vero progresso, risolve le sovrapposizioni usando politiche dichiarate per tabella e per colonna dalle persone che possiedono il significato dei dati, anziché un’unica regola cieca a livello di cella.

Quelle politiche sono dove entra l’intento del dominio. Una colonna contatore può essere dichiarata per fare il merge sommando i delta che ciascun lato ha applicato, il comportamento di un tipo di dato replicato convergente, così che due incrementi concorrenti si sommino correttamente invece di scontrarsi. Un timestamp di ultimo aggiornamento può fare il merge prendendo il valore più recente. Una relazione a valori d’insieme può fare il merge per unione. Una collisione di chiave naturale può essere dichiarata un conflitto incondizionato, perché il significato dello schema dice che le due righe sono la stessa entità. Dove nessuna politica si applica ed entrambi i lati hanno toccato lo stesso valore, il protocollo fa esattamente ciò che fa git e si ferma per un essere umano, presentando il conflitto in termini di righe e valori anziché di pagine. Una dichiarazione potrebbe leggersi con la stessa semplicità di questa:

MERGE POLICY ON inventory (on_hand)
  USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
  USING conflict;  -- stesso SKU, stesso articolo

È questo il pezzo che l’arte anteriore mostra essere possibile. Sistemi indirizzati per contenuto con funzioni di merge definite dall’utente esistono già fuori dal mondo relazionale: Irmin, l’archivio in stile git dietro parti del progetto MirageOS, è costruito esattamente attorno a questa idea di dati mergeabili con logica di merge personalizzata, e la letteratura sui tipi di dato replicati convergenti e commutativi offre un resoconto rigoroso di quando le modifiche concorrenti possono essere mergiate senza conflitto. La teoria della confluenza invariante, di Bailis e colleghi, va un passo oltre e ci dice con precisione quali invarianti un merge può preservare senza coordinamento e quali, tra cui l’unicità globale e le chiavi esterne, dimostrabilmente non può. Non è un consiglio di disperazione; è la ragione per cui una collisione di chiave naturale deve essere dichiarata un conflitto anziché essere scongiurata con un desiderio, e dice a un protocollo esattamente dove una politica automatica è sicura e dove un essere umano deve decidere. Ciò che non è stato fatto è portare quel merge semantico a un Postgres nativo e transazionale, governato dai vincoli dello schema stesso. È questo il problema aperto che vale la pena risolvere, e quello che i prodotti di branching hanno aggirato anziché attraversato.

5.4 La materializzazione come ottimizzazione

Un’obiezione legittima è che riprodurre le modifiche logiche per ricostruire un branch potrebbe essere lento per un database grande. La risposta è il disaccoppiamento stesso: come un branch viene fisicamente materializzato non è parte del modello di versione, perciò può essere scelto liberamente e cambiato in seguito. Un branch può essere riprodotto dai change set quando è piccolo o usato di rado, oppure messo in piedi come snapshot copy-on-write quando deve essere veloce, usando snapshot del filesystem come ZFS o lo stesso storage copy-on-write che Neon e i suoi simili hanno costruito. In altre parole, gli eccellenti motori che forkano in fretta non sono concorrenti di questo protocollo; sono un possibile backend per la sua materializzazione, con il merge e il modello di versione portabile forniti al di sopra di essi. Il protocollo dice cosa significano un branch e un merge; lo strato di storage è libero di renderli veloci.

5.5 Limiti onesti

Non stiamo sostenendo che questo sia facile, e un position paper che fingesse il contrario meriterebbe sospetto. Il merge semantico è genuinamente difficile: scrivere politiche per tabella corrette richiede attenzione, branch divergenti da lungo tempo accumulano conflitti che nessuna politica può risolvere senza giudizio, e flussi di modifiche di volume molto elevato sollevano reali questioni di storage e throughput per il log dei commit. Validare un merge grande rispetto a ogni vincolo ha un costo, e alcune invarianti, come dimostra la teoria della confluenza invariante, non possono affatto essere riconciliate senza coordinamento, perciò un protocollo onesto le fa emergere come conflitti anziché fingere di risolverle. Sono queste le ragioni per cui il problema è ancora aperto, non ragioni per dichiararlo irrisolvibile. Ciò che l’approccio a protocollo compra è che la parte difficile, il merge, viene affrontata nell’unico posto dove può essere affrontata bene, allo strato logico con lo schema a disposizione, invece di essere abbandonata allo strato di storage o appiattita in una regola a livello di cella. Significa anche che il lavoro si cumula: poiché è un protocollo sopra Postgres standard, ogni miglioramento nel motore, ogni estensione, ogni strumento operativo continua a funzionare al di sotto di esso.

6. Cosa significa in pratica

Per un’organizzazione che sceglie oggi, l’indicazione onesta segue la tabella. Se ciò di cui hai bisogno sono database economici e istantanei per sviluppo, test e preview di pull request, gli strumenti di branching copy-on-write sono eccellenti e dovresti usarli, con la piena consapevolezza che lì un branch è un fork usa e getta, non una linea di lavoro che reincorporerai con il merge. Se parti da zero e il versionamento è il punto del sistema, Dolt è uno strumento serio e capace, a patto che tu accetti di star scegliendo un nuovo motore anziché estendere Postgres. E se ciò che vuoi è la promessa completa, branch e diff e merge sul Postgres di produzione che già esegui e di cui ti fidi, la risposta onesta è che nessun prodotto la consegna ancora, e la cosa giusta su cui scommettere è un protocollo costruito sulle primitive di Postgres stesso anziché un ennesimo fork del motore o dello storage.

Quest’ultima posizione è quella che Nashua tiene, ed è coerente con il modo in cui leggiamo l’intero panorama. Prediligiamo gli strumenti best-of-breed e gli standard aperti rispetto alle piattaforme di un singolo vendor, e diffidiamo del lock-in ovunque si nasconda, anche dentro uno strato di storage che può fare branch ma mai lasciare che i tuoi dati se ne vadano a condizioni paritarie. Un modello di versione che è puro protocollo, portabile su qualunque Postgres su qualunque infrastruttura, on-premises o cloud, mantiene la scelta di dove e come eseguire saldamente in mano all’organizzazione. Il cloud e l’on-premises sono entrambi buoni luoghi per i dati; un protocollo a cui non importa quale sia è esattamente il punto.

7. Conclusione

Il database merita il controllo di versione che ha trasformato ogni altra parte dell’ingegneria del software, e i progetti che inseguono quell’obiettivo hanno ragione a inseguirlo. Ma il premio è il merge, non solo il branch, e il campo si è diviso in strumenti che fanno merge abbandonando Postgres e strumenti che mantengono Postgres rinunciando al merge. Quella divisione non è inevitabile. Nasce dal fondere tre preoccupazioni separabili, il modello di versione, lo storage fisico e la risoluzione dei conflitti, in un unico prodotto. Separale, costruisci il modello di versione come un protocollo sul write-ahead log, sullo storage multiversione e sul logical decoding che Postgres già fornisce, e metti al suo centro un merge semantico e consapevole dei vincoli, e la falsa scelta si dissolve. Git si è guadagnato il suo posto separando il modello dalla macchina. I dati meritano lo stesso, e Postgres, quasi unicamente, ha già le parti per renderlo reale. Nashua preferirebbe aiutare a costruirlo piuttosto che venderne un fork.

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