noviembre de 2026
Version control for transactional data
Un protocolo al estilo de git para PostgreSQL: el porqué, el qué y el cómo; los proyectos de código abierto que ya lo construyen, dónde falla su diseño, y una vía mejor construida sobre lo que Postgres ya tiene.
Resumen
Los equipos de software versionan su código con git y no concebirían trabajar sin él, y sin embargo la base de datos que hay bajo ese código, el estado más valioso y menos reversible que una organización posee, se sigue editando en el sitio sin rama, sin diff y sin merge. Un campo animado de proyectos de código abierto promete cerrar esa brecha y llevar git a la base de datos, y este artículo expone el porqué, el qué y el cómo. Sostenemos que el verdadero premio no es ramificar sino fusionar, la capacidad de reconciliar líneas divergentes de datos transaccionales, y mostramos que el campo se ha dividido en dos bandos que cada uno renuncia a la mitad del problema: Dolt y DoltgreSQL obtienen una verdadera semántica de git reimplementando el motor de base de datos y dejando atrás el Postgres nativo, mientras que Neon y Supabase conservan Postgres pero ofrecen una rama que puede bifurcarse y nunca reunirse. Proponemos una vía mejor. No un motor bifurcado ni una capa de almacenamiento bifurcada, sino un protocolo de control de versiones construido sobre el registro de escritura anticipada, la concurrencia multiversión y la decodificación lógica que Postgres ya incluye, con un merge semántico y consciente de restricciones como su operación de primera clase. El control de versiones para datos debería separar el modelo de versiones del almacenamiento, del mismo modo que git separó el modelo de objetos del transporte.
Palabras clave: PostgreSQL; control de versiones de bases de datos; git para datos; ramificación de datos; migración de esquemas; merge a tres vías; resolución de conflictos; registro de escritura anticipada; decodificación lógica; control de concurrencia multiversión; MVCC; copy-on-write; CRDT; Dolt; DoltgreSQL; Neon; Supabase; tablas temporales; procedencia de datos; soberanía digital
1. Introducción
Pide a una persona que desarrolla que trabaje un día sin git y obtendrás una negativa rotunda. Ramificar, hacer commit, comparar y fusionar están tan entretejidos en cómo se construye el software que su ausencia resulta impensable. Ahora pregúntale a esa misma persona cómo versiona la base de datos de producción, el esquema y los datos a los que el código existe para servir, y la respuesta es casi siempre una nada avergonzada. La base de datos se edita en el sitio. Una migración avanza y, si sale mal, una restauración frenética desde la copia de seguridad de anoche es la única vuelta atrás. Dos ingenieros no pueden desarrollar contra copias divergentes de los datos y reconciliarlas después; se turnan, o se pisan el uno al otro. El estado más valioso y menos reversible que una organización posee es la única pieza del stack sin ningún control de versiones.
Es una brecha extraña, y un campo creciente de proyectos de código abierto se ha propuesto cerrarla bajo un lema que todos entienden: git para tu base de datos. La propuesta resulta atractiva de inmediato. Ramifica la base de datos para probar un cambio arriesgado de forma aislada. Compara dos versiones para ver exactamente qué hizo una migración. Dale a cada analista su propia línea de datos y fusiona de vuelta el buen trabajo. Viaja a cualquier estado pasado con la misma facilidad que git checkout. Si el control de versiones transformó cómo escribimos código, reza el argumento, puede transformar cómo gestionamos los datos.
Creemos que el argumento es acertado, y este es un artículo de posición sobre cómo hacerlo realidad. Explicamos por qué importan los datos versionados (Sección 2), qué tiene que ofrecer realmente un protocolo al estilo de git, que es más y más difícil de lo que parece a primera vista (Sección 3), y dónde se encuentran los proyectos de hoy, con reconocimiento donde es merecido y un relato lúcido de dónde falla su diseño (Sección 4). Luego exponemos nuestra tesis: que el campo se ha metido él solo en una falsa elección, y que el mejor camino para Postgres es un protocolo construido sobre las primitivas que ya incluye en lugar de un motor nuevo o una bifurcación que no se puede fusionar (Sección 5). Nashua respalda las herramientas de lo mejor de su clase y la buena práctica por encima de cualquier producto único, y ese es el espíritu aquí: no una propuesta a favor de un proyecto, sino un argumento sobre cómo debería construirse esto.
2. Por qué versionar la base de datos
El argumento comienza con el trabajo que la gente ya hace mal a mano. Las migraciones de esquema son el caso obvio. Todo equipo que opera una base de datos ejecuta migraciones, y todo equipo ha sentido el pavor particular de una migración que no puede deshacerse limpiamente. Una base de datos versionada convierte una migración en un commit: reversible, inspeccionable y comprobable en una rama antes de que toque producción. El diff no es una conjetura a partir del script de migración; es el cambio real al esquema y a los datos, calculado y revisable como cualquier pull request.
Luego está el bucle de desarrollo y prueba. Los equipos modernos quieren una base de datos realista para cada rama de funcionalidad y cada vista previa de pull request, sembrada con datos parecidos a los de producción, levantada en segundos y desechada cuando la rama se fusiona. Hacerlo restaurando copias completas es lento y caro; hacerlo compartiendo una sola base de datos invita a las colisiones. Las ramas baratas e instantáneas resuelven un problema real y cotidiano, que es precisamente por lo que los productos de ramificación han encontrado un mercado ávido.
Más allá del bucle cotidiano yacen las razones más profundas. Reproducibilidad: una persona que analiza datos y puede fijar un análisis a un estado exacto y confirmado de los datos puede reproducir un resultado meses después, y también puede hacerlo el auditor que lo cuestiona. Procedencia y auditoría: una base de datos cuya historia es una cadena de commits firmados responde quién cambió qué, y cuándo, por construcción en lugar de por un disparador atornillado. Esto no es un capricho en los sectores regulados; el régimen DORA de la Unión Europea y sus semejantes esperan que las entidades financieras demuestren la integridad y la trazabilidad de sus datos, y una historia versionada es demostrable de un modo que una tabla mutable no lo es. Recuperación: la restauración a un punto en el tiempo deja de ser una operación de copia de seguridad y se convierte en un checkout. Y la colaboración por fin se hace posible sobre los datos como lo es sobre el código, con líneas de trabajo independientes que convergen mediante la revisión en lugar de mediante el bloqueo.
Nada de esto es exótico. Es la maquinaria ordinaria de la ingeniería de software, aplicada al único activo que se le ha resistido con tozudez. La cuestión no es si la base de datos merece control de versiones. Claramente lo merece. La cuestión es qué haría falta para darle lo auténtico.
3. Qué significa un protocolo al estilo de git
Vale la pena ser preciso sobre lo que git ofrece en realidad, porque la mitad fácil se confunde habitualmente con el todo. Git es un almacén de objetos direccionado por contenido: cada versión de cada archivo es un blob nombrado por el hash de su contenido, los árboles componen blobs en una instantánea, y un commit nombra un árbol junto con sus padres, formando un grafo acíclico dirigido e inmutable de la historia. Sobre ese almacén se asientan dos capas de comodidad: las refs, que son nombres humanos para puntos del grafo, de modo que main y feature no son más que etiquetas sobre commits; y las operaciones, de las cuales diff y merge son las que importan.
La operación decisiva, la que hace de git una herramienta de colaboración en lugar de una copia de seguridad elegante, es el merge a tres vías. Cuando dos ramas divergen, git no pregunta cuál gana. Encuentra su ancestro común, calcula lo que cada lado cambió respecto de ese ancestro, y combina los cambios, señalando solo los lugares donde ambos lados tocaron lo mismo de maneras incompatibles. Eso es lo que permite que cien personas trabajen en paralelo y converjan. Ramificar sin fusionar no es más que una copia barata; ramificar con fusión es control de versiones.
Lleva esto a una base de datos y el mapeo es sugerente pero no trivial, como expone la Figura 1. Un commit debería ser una instantánea inmutable de toda la base de datos en un instante lógico. Una rama debería ser una línea nombrada de tales instantáneas. Un diff debería informar de las filas y los objetos de esquema que cambiaron entre dos commits. Y un merge debería reconciliar dos líneas divergentes de datos en una. Los tres primeros son, en esencia, un problema de almacenamiento y de nomenclatura. El cuarto es el difícil, y es donde la analogía con git deja de ser cómoda.
El texto se fusiona porque un archivo fuente es una secuencia ordenada por líneas sin reglas sobre su contenido; git puede empalmar dos conjuntos de cambios de líneas y el resultado sigue siendo un archivo válido por definición. Una base de datos no es así. Su contenido se rige por invariantes: las claves primarias deben seguir siendo únicas, las claves foráneas deben resolverse, las restricciones de verificación deben cumplirse y, por encima de todas ellas, los datos deben seguir significando algo. Dos ramas que cada una inserta un cliente con la misma clave natural no han producido un conflicto de merge en el sentido textual; han producido un estado que el esquema prohíbe. Dos ramas que cada una decrementa el saldo de una cuenta en una cantidad distinta no pueden ganar ambas sin más. Un merge para datos tiene que respetar las reglas de los datos, y a veces la intención tras ellos. Ese es el contenido real de la frase git para la base de datos, y es la prueba frente a la cual deberían medirse los proyectos existentes.
4. El estado del arte, y dónde falla
El campo se divide limpiamente en tres grupos, y la división es instructiva porque cada grupo se define por aquello a lo que renuncia. La Tabla 1 los pone uno junto a otro.
Tabla 1. Dónde se sitúan los enfoques de hoy. PG nativo significa el motor PostgreSQL real, con sus extensiones y su ecosistema, en lugar de una reimplementación de su protocolo de cable. El patrón es tajante: el único proyecto con verdadero merge de datos es el que abandona Postgres, y toda herramienta que conserva Postgres renuncia al merge.
| Proyecto | Enfoque | PG nativo | Rama | Diff de datos | Merge de datos | Modelo de conflictos |
|---|---|---|---|---|---|---|
| Dolt | motor nuevo, DAG Merkle | no | sí | sí | sí | por celda, estructural |
| DoltgreSQL | motor nuevo, cable PG | no | sí | sí | sí | por celda, estructural |
| Neon | almacenamiento copy-on-write | sí | sí | no | no | ninguno |
| Ramas de Supabase | instancia por rama | sí | sí | solo esquema | no | ninguno |
| Herramientas temporales / de auditoría | historia lineal | sí | no | en el tiempo | no | ninguno |
| Un protocolo (propuesto) | sobre WAL + MVCC | sí | sí | sí | sí | semántico, consciente de restricciones |
4.1 Reimplementar el motor: Dolt y DoltgreSQL
Dolt es la realización más completa de la idea, y merece verdadero reconocimiento. Es una base de datos SQL de código abierto construida desde cero para ser versionada: su almacenamiento es un grafo acíclico dirigido de Merkle direccionado por contenido, estructurado con árboles probabilísticos, a menudo llamados prolly trees, que le dan la compartición estructural y los diffs rápidos de git sin dejar de ser una base de datos indexada y consultable. Branch, diff, merge, clone, push y pull son operaciones de primera clase en SQL y en la línea de comandos. Dolt es, genuinamente, git para datos, y DoltgreSQL extiende el mismo motor para hablar el protocolo de cable de PostgreSQL de modo que los clientes de Postgres puedan conectarse.
El coste está a la vista en esa frase: construida desde cero. Dolt no es Postgres. Es un motor nuevo que reimplementa una base de datos y, en el caso de DoltgreSQL, el protocolo de Postgres por encima de él. Una organización que lo adopta no añade versionado al Postgres que ejecuta; reemplaza Postgres por otra cosa y hereda las características de rendimiento de esa cosa y la larga cola de extensiones de Postgres que no reproduce, PostGIS y pgvector y las demás en las que se apoyan los sistemas de producción. DoltgreSQL alcanzó una versión 1.0 en 2026 y es impresionantemente compatible, pero ser compatible con el dialecto de Postgres no es lo mismo que ser Postgres. Para un proyecto nuevo que valora el versionado por encima de todo, puede ser un intercambio justo. Para la vasta base instalada de Postgres de producción, reemplazar el motor para ganar control de versiones es una cola muy grande meneando a un perro muy importante.
Hay una limitación más sutil, y importa para el argumento que viene. El merge de Dolt está modelado sobre el de git: trabaja una celda cada vez, tomando los cambios de cada lado respecto del ancestro común y combinándolos, y donde ambos lados cambiaron la misma celda registra un conflicto para que una persona lo resuelva. Esto es merge estructural, y es el valor por defecto correcto, pero es semánticamente ciego. No sabe que dos incrementos concurrentes a un nivel de existencias deberían sumarse en lugar de colisionar, ni que dos inserciones que comparten una clave natural no son una coincidencia sino una contradicción. Dolt sí detecta las violaciones de restricciones que un merge introduce y las expone para su resolución en lugar de confirmar en silencio un estado roto, lo que es de agradecer, pero detectar después del hecho no es lo mismo que un merge que entiende el significado de los datos. El modelo estructural es el techo de lo que puede lograr el merge por celda.
4.2 Ramificar el almacenamiento: Neon y Supabase
El segundo grupo conserva Postgres, justo lo que Dolt abandona, y compra su ramificación más abajo en el stack. Neon rearquitecta el almacenamiento de Postgres, separando el cómputo de un servicio de almacenamiento multiversión y estructurado por registro, y la ramificación surge de ese diseño casi gratis: una rama es una bifurcación copy-on-write del almacenamiento en un punto elegido del registro, creada en segundos por grande que sea la base de datos, porque nada se copia hasta que se escribe. Supabase ofrece ramificación con un espíritu similar, levantando una instancia separada de Postgres por rama y cableándola a un flujo de vista previa dirigido por Git, y el mismo patrón copy-on-write recorre todo el ecosistema, desde las ramas portadoras de datos de Xata hasta los clones ligeros sobre ZFS de Postgres.ai. Todos son genuinamente útiles, y para el bucle de desarrollo y prueba de la Sección 2 están cerca de lo ideal.
Pero mira la tabla de nuevo. Estas son ramas que pueden bifurcarse y nunca reunirse. Neon puede crear una rama en un instante y divergir de ella; no puede fusionar los cambios de datos de esa rama de vuelta en su padre, porque nada en una bifurcación de almacenamiento copy-on-write sabe cómo reconciliar dos conjuntos de escrituras de páginas divergentes en un único estado coherente y respetuoso con las restricciones. Eso no es un descuido que haya que parchear; es la consecuencia de resolver el problema en la capa de almacenamiento, donde la unidad es una página opaca, en lugar de en la capa lógica, donde la unidad es una fila con significado. Las ramas de Supabase están orientadas a migraciones de esquema para entornos de vista previa, no a fusionar datos en absoluto. El resultado es una potente clonación copy-on-write, que es algo real y valioso, vistiendo el vocabulario del control de versiones mientras entrega solo su mitad fácil. Llamar rama a una bifurcación sin merge toma prestada una promesa que el diseño no puede cumplir.
4.3 Registrar la historia: tablas temporales y rastros de auditoría
Un tercer grupo se arrastra a veces a la misma conversación y conviene distinguirlo. Las tablas temporales versionadas por el sistema, tal como se estandarizan en SQL:2011 y se aproximan en Postgres mediante extensiones como temporal_tables, y los marcos de auditoría como pgMemento, dan a una tabla una historia: cada fila lleva el intervalo de tiempo durante el cual estuvo vigente, y puedes consultar la base de datos tal como estaba en cualquier instante pasado. Esto es valioso, y aporta la procedencia y la lectura a un punto en el tiempo que la Sección 2 pedía. Pero es una única historia lineal. No hay rama ni merge, ni líneas de trabajo paralelas que reconciliar. El viaje en el tiempo no es control de versiones; es un eje de él, el que siempre fue el más fácil de añadir.
4.4 Tres preocupaciones, mal fusionadas
Da un paso atrás y el patrón queda claro. Cada proyecto responde las mismas tres preguntas a la vez, y agrupa las respuestas en un único producto: cómo se modela la historia, cómo se almacena físicamente una versión y cómo se resuelven los conflictos. Dolt fusiona un modelo de versiones al estilo de git con un motor de almacenamiento a medida y un modelo de conflictos por celda, y para obtener el primero debes tomar los tres. Neon fusiona un modelo de versiones delgado con un motor de almacenamiento copy-on-write y ningún modelo de conflictos en absoluto. Como los tres están soldados entre sí, no puedes conservar Postgres y aun así tener merge, y no puedes obtener merge semántico de nadie, porque el modelo de conflictos es lo que el motor de almacenamiento resultara hacer fácil. La falsa elección que el campo presenta, Postgres sin merge o merge sin Postgres, es un artefacto de fusionar preocupaciones que son lógicamente separadas. Sepáralas y aparece un mejor diseño.
5. Una vía mejor: un protocolo, no una bifurcación
Nuestra propuesta es dejar de construir bases de datos versionadas y empezar a definir un protocolo de control de versiones para la base de datos que ya tenemos. El movimiento es el mismo que hizo el propio git: el genio de git fue separar el modelo de objetos, commits y árboles y refs, del transporte que los mueve de un lado a otro, de modo que el modelo pudiera sobrevivir a cualquier implementación particular. El control de versiones de bases de datos debería separar el modelo de versiones, commits y ramas y merges, del almacenamiento físico que los materializa, de modo que pueda ejecutarse sobre un Postgres de serie en lugar de requerir un motor nuevo. La Figura 2 muestra su forma.
5.1 El sustrato que Postgres ya incluye
Lo llamativo, y el corazón de nuestro argumento, es cuánta de la maquinaria tiene Postgres ya. Su control de concurrencia multiversión mantiene múltiples versiones de cada fila y entrega a cada transacción una instantánea consistente de la base de datos en un instante lógico: eso es un commit en todo salvo en el nombre. Su registro de escritura anticipada es un registro ordenado y duradero de cada cambio jamás aplicado, es decir, un reflog. Y la decodificación lógica, el mecanismo maduro que ya impulsa la replicación lógica, convierte ese registro en un flujo limpio y ordenado de cambios a nivel de fila que cualquier cliente puede consumir. Tres de las cuatro primitivas de git, las instantáneas inmutables, un registro de historia y un flujo de cambios, ya están dentro de Postgres, como mostró la Figura 1. Un protocolo no necesita reconstruirlas. Solo necesita añadir las dos cosas que a Postgres le faltan: refs nombradas persistentes sobre esa historia, y un merge que entienda los datos.
Capturar commits, entonces, es cuestión de consumir el flujo de decodificación lógica y registrar los cambios de cada transacción como un conjunto de cambios direccionado por contenido, con hash por su contenido de modo que los cambios idénticos compartan almacenamiento y cualquier conjunto de cambios pueda nombrarse y recuperarse por su hash. Un slot se crea una vez, y los cambios se drenan y se almacenan:
SELECT pg_create_logical_replication_slot(
'vc', 'pgoutput');
-- los cambios de cada transacción, en orden,
-- con hash y almacenados como objeto commit
SELECT * FROM pg_logical_slot_get_changes(
'vc', NULL, NULL);
Nada aquí bifurca el motor ni llega por debajo de la fila. El protocolo lee lo que Postgres ya emite y construye el grafo de versiones junto a él.
5.2 Commits, refs y ramas
Con los conjuntos de cambios como commits, el resto de la mitad fácil es contabilidad. Un commit registra su padre o sus padres y el hash de contenido del conjunto de cambios que introduce, formando el mismo grafo acíclico dirigido e inmutable que usa git. Una ref es un nombre que apunta a un commit, y una rama es una ref que se mueve a medida que se le añaden nuevos commits. Estos metadatos son pequeños, son datos relacionales corrientes, y pueden vivir en un esquema dentro de la propia base de datos que versionan o en un almacén acompañante. Como un commit se define por cambios lógicos direccionados por contenido en lugar de por páginas físicas, es portable: significa lo mismo en cualquier Postgres, en instalaciones propias o en cualquier nube, que es precisamente la propiedad que una bifurcación de almacenamiento copy-on-write no puede ofrecer. El modelo de versiones es puro protocolo, y no acarrea ninguna cautividad.
5.3 Merge semántico y consciente de restricciones
Aquí está la mitad difícil, y el lugar donde un protocolo puede hacer lo que ninguna herramienta actual hace. Como los commits son conjuntos de cambios lógicos en lugar de páginas opacas, un merge a tres vías puede operar donde reside el significado. Dadas dos ramas y su ancestro común, el protocolo calcula los cambios a nivel de fila de cada lado y los combina, y luego hace las dos cosas que distinguen un merge de base de datos de un merge de texto. Primero, valida el resultado propuesto contra el esquema en vivo, cada restricción, clave y relación de clave foránea, de modo que un merge nunca pueda confirmar un estado que la base de datos rechazaría; una violación se eleva como un conflicto, no se escribe como corrupción. Segundo, y este es el verdadero avance, resuelve los solapamientos usando políticas declaradas por tabla y por columna por las personas que son dueñas del significado de los datos, en lugar de una única regla ciega por celda.
Esas políticas son donde entra la intención del dominio. Una columna contador puede declararse para fusionarse sumando los deltas que cada lado aplicó, el comportamiento de un tipo de dato replicado convergente, de modo que dos incrementos concurrentes sumen correctamente en lugar de colisionar. Una marca de tiempo de última actualización puede fusionarse tomando el valor más reciente. Una relación de valor conjunto puede fusionarse por unión. Una colisión de clave natural puede declararse un conflicto incondicional, porque el significado del esquema dice que las dos filas son la misma entidad. Donde ninguna política aplica y ambos lados tocaron el mismo valor, el protocolo hace exactamente lo que hace git y se detiene para una persona, presentando el conflicto en términos de filas y valores en lugar de páginas. Una declaración podría leerse tan llanamente como esto:
MERGE POLICY ON inventory (on_hand)
USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
USING conflict; -- mismo SKU, mismo artículo
Esta es la pieza que el estado previo del arte muestra que es posible. Los sistemas direccionados por contenido con funciones de merge definidas por el usuario ya existen fuera del mundo relacional: Irmin, el almacén al estilo de git tras partes del proyecto MirageOS, está construido en torno a exactamente esta idea de datos fusionables con lógica de merge personalizada, y la literatura sobre los tipos de datos replicados convergentes y conmutativos da un relato riguroso de cuándo los cambios concurrentes pueden fusionarse sin conflicto. La teoría de la confluencia de invariantes, de Bailis y colegas, va un paso más allá y nos dice con precisión qué invariantes puede preservar un merge sin coordinación y cuáles, la unicidad global y las claves foráneas entre ellas, demostrablemente no puede. Eso no es un consejo de desesperación; es la razón por la que una colisión de clave natural tiene que declararse un conflicto en lugar de desearse ausente, y le dice a un protocolo exactamente dónde una política automática es segura y dónde una persona debe decidir. Lo que no se ha hecho es llevar ese merge semántico al Postgres nativo y transaccional, gobernado por las propias restricciones del esquema. Ese es el problema abierto que vale la pena resolver, y el que los productos de ramificación han rodeado en lugar de atravesar.
5.4 La materialización como optimización
Una objeción justa es que reproducir cambios lógicos para reconstruir una rama podría ser lento para una base de datos grande. La respuesta es el propio desacoplamiento: cómo se materializa físicamente una rama no es parte del modelo de versiones, así que puede elegirse libremente y cambiarse después. Una rama puede reproducirse desde conjuntos de cambios cuando es pequeña o se usa poco, o levantarse como una instantánea copy-on-write cuando debe ser rápida, usando instantáneas de sistema de archivos como ZFS o el propio almacenamiento copy-on-write que Neon y los suyos han construido. En otras palabras, los excelentes motores de bifurcación rápida no son competidores de este protocolo; son un posible backend para su materialización, con el merge y el modelo de versiones portable suministrados por encima de ellos. El protocolo dice qué significan una rama y un merge; la capa de almacenamiento es libre de hacerlos rápidos.
5.5 Límites honestos
No afirmamos que esto sea fácil, y un artículo de posición que fingiera lo contrario merecería sospecha. El merge semántico es genuinamente difícil: escribir políticas por tabla correctas requiere cuidado, las ramas largamente divergidas acumulan conflictos que ninguna política puede resolver sin criterio, y los flujos de cambios de muy alto volumen plantean cuestiones reales de almacenamiento y rendimiento para el registro de commits. Validar un merge grande contra cada restricción tiene un coste, y algunos invariantes, como demuestra la teoría de la confluencia de invariantes, no pueden reconciliarse sin coordinación en absoluto, así que un protocolo honesto expone esos como conflictos en lugar de fingir resolverlos. Estas son las razones por las que el problema sigue abierto, no razones para declararlo irresoluble. Lo que el enfoque de protocolo compra es que la parte difícil, el merge, se aborda en el único lugar donde puede abordarse bien, en la capa lógica con el esquema en mano, en lugar de abandonarse en la capa de almacenamiento o aplanarse en una regla por celda. También significa que el trabajo se acumula: como es un protocolo sobre un Postgres de serie, cada mejora en el motor, cada extensión, cada herramienta operativa sigue funcionando por debajo de él.
6. Qué significa esto en la práctica
Para una organización que elige hoy, la orientación honesta sigue la tabla. Si lo que necesitas son bases de datos baratas e instantáneas para desarrollo, pruebas y vistas previas de pull request, las herramientas de ramificación copy-on-write son excelentes y deberías usarlas, con la claridad de que una rama allí es una bifurcación desechable, no una línea de trabajo que fusionarás de vuelta. Si empiezas de cero y el versionado es el propósito del sistema, Dolt es una herramienta seria y capaz, siempre que aceptes que estás eligiendo un motor nuevo en lugar de extender Postgres. Y si lo que quieres es la promesa completa, ramificar y comparar y fusionar sobre el Postgres de producción que ya ejecutas y en el que confías, la respuesta honesta es que ningún producto lo entrega todavía, y lo correcto por lo que apostar es un protocolo construido sobre las propias primitivas de Postgres en lugar de otra bifurcación del motor o del almacenamiento.
Esa última posición es la que Nashua sostiene, y es de una pieza con cómo leemos todo este panorama. Favorecemos las herramientas de lo mejor de su clase y los estándares abiertos por encima de las plataformas de un solo proveedor, y desconfiamos de la cautividad dondequiera que se esconda, incluido dentro de una capa de almacenamiento que puede ramificar pero nunca deja a tus datos marcharse en igualdad de condiciones. Un modelo de versiones que es puro protocolo, portable a través de cualquier Postgres sobre cualquier infraestructura, en instalaciones propias o en la nube, mantiene la elección de dónde y cómo ejecutar firmemente en manos de la organización. La nube y las instalaciones propias son ambos buenos hogares para los datos; un protocolo al que no le importa cuál es exactamente el punto.
7. Conclusión
La base de datos merece el control de versiones que transformó todas las demás partes de la ingeniería de software, y los proyectos que persiguen esa meta hacen bien en perseguirla. Pero el premio es el merge, no solo la rama, y el campo se ha dividido en herramientas que fusionan dejando Postgres y herramientas que conservan Postgres renunciando al merge. Esa división no es inevitable. Procede de fusionar tres preocupaciones separables, el modelo de versiones, el almacenamiento físico y la resolución de conflictos, en un solo producto. Sepáralas, construye el modelo de versiones como un protocolo sobre el registro de escritura anticipada, el almacenamiento multiversión y la decodificación lógica que Postgres ya incluye, y pon un merge semántico y consciente de restricciones en su centro, y la falsa elección se disuelve. Git se ganó su lugar separando el modelo de la máquina. Los datos merecen lo mismo, y Postgres, de forma casi única, ya tiene las partes para hacerlo realidad. Nashua preferiría ayudar a construir eso que vender una bifurcación de ello.
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
