नवंबर 2026

Version control for transactional data

PostgreSQL के लिए एक git-जैसा प्रोटोकॉल: क्यों, क्या और कैसे; वे ओपन-सोर्स परियोजनाएँ जो इसे पहले से बना रही हैं, जहाँ उनका डिज़ाइन कम पड़ता है, और एक बेहतर तरीका जो उसी पर बना है जो Postgres के पास पहले से मौजूद है।

सार

सॉफ्टवेयर टीमें अपने कोड का संस्करण git से रखती हैं और उसके बिना काम करने की कल्पना तक नहीं कर सकतीं, फिर भी उस कोड के नीचे का डेटाबेस, वह सबसे मूल्यवान और सबसे कम प्रतिवर्तनीय स्थिति जो कोई संगठन धारण करता है, अब भी बिना किसी ब्रांच, बिना किसी डिफ़ और बिना किसी मर्ज के यथास्थान संपादित किया जाता है। ओपन-सोर्स परियोजनाओं का एक जीवंत क्षेत्र उस खाई को पाटने और git को डेटाबेस तक लाने का वादा करता है, और यह शोध-पत्र क्यों, क्या और कैसे को प्रस्तुत करता है। हम तर्क देते हैं कि असली पुरस्कार ब्रांचिंग नहीं बल्कि मर्जिंग है, यानी लेन-देन संबंधी डेटा की विपथगामी धाराओं को समाधित करने की क्षमता, और हम दिखाते हैं कि यह क्षेत्र दो खेमों में बँट गया है जिनमें से प्रत्येक समस्या का आधा हिस्सा छोड़ देता है: Dolt और DoltgreSQL डेटाबेस इंजन को पुनः कार्यान्वित करके और मूल Postgres को पीछे छोड़कर सच्चे git सिमेंटिक्स जीतते हैं, जबकि Neon और Supabase Postgres को बनाए रखते हैं किंतु एक ऐसी ब्रांच देते हैं जो विभाजित तो हो सकती है पर कभी फिर नहीं जुड़ती। हम एक बेहतर तरीका प्रस्तावित करते हैं। कोई विभाजित इंजन नहीं और कोई विभाजित भंडारण परत नहीं, बल्कि एक संस्करण-नियंत्रण प्रोटोकॉल जो उसी write-ahead log, बहुसंस्करण संगामिती और logical decoding पर बना है जो Postgres पहले से प्रदान करता है, जिसमें सिमेंटिक, कंस्ट्रेंट-सजग मर्ज एक प्रथम-श्रेणी संक्रिया के रूप में है। डेटा के लिए संस्करण नियंत्रण को संस्करण मॉडल को भंडारण से उसी तरह अलग करना चाहिए, जिस तरह git ने ऑब्जेक्ट मॉडल को ट्रांसपोर्ट से अलग किया था।

मुख्य शब्द: PostgreSQL; डेटाबेस संस्करण नियंत्रण; डेटा के लिए git; डेटा ब्रांचिंग; स्कीमा माइग्रेशन; तीन-तरफ़ा मर्ज; संघर्ष समाधान; write-ahead log; logical decoding; बहुसंस्करण संगामिती नियंत्रण; MVCC; कॉपी-ऑन-राइट; CRDT; Dolt; DoltgreSQL; Neon; Supabase; टेम्पोरल तालिकाएँ; डेटा उद्गम; डिजिटल संप्रभुता

1. परिचय

किसी डेवलपर से git के बिना एक दिन काम करने को कहिए और आपको सीधा इनकार मिलेगा। ब्रांचिंग, कमिटिंग, डिफ़िंग और मर्जिंग इस बात में इतनी बुनी हुई हैं कि सॉफ्टवेयर कैसे बनता है, उनकी अनुपस्थिति अकल्पनीय है। अब उसी डेवलपर से पूछिए कि वे उत्पादन डेटाबेस का, यानी उस स्कीमा और उस डेटा का, जिसकी सेवा के लिए कोड का अस्तित्व है, संस्करण कैसे रखते हैं, और उत्तर लगभग हमेशा एक सकुचाया हुआ कुछ नहीं होता है। डेटाबेस यथास्थान संपादित होता है। एक माइग्रेशन आगे की ओर चलता है और, यदि वह गलत हो जाए, तो पिछली रात के बैकअप से एक व्याकुल पुनर्स्थापन ही वापसी का एकमात्र रास्ता होता है। दो इंजीनियर डेटा की विपथगामी प्रतियों के विरुद्ध विकास करके बाद में उन्हें समाधित नहीं कर सकते; वे बारी-बारी से करते हैं, या एक-दूसरे को कुचल देते हैं। कोई संगठन जो सबसे मूल्यवान और सबसे कम प्रतिवर्तनीय स्थिति धारण करता है, वह स्टैक का वही एक हिस्सा है जिसमें कोई संस्करण नियंत्रण है ही नहीं।

यह एक विचित्र खाई है, और ओपन-सोर्स परियोजनाओं का एक बढ़ता हुआ क्षेत्र इसे एक ऐसे झंडे तले पाटने निकला है जिसे हर कोई समझता है: आपके डेटाबेस के लिए git। यह प्रस्ताव तत्काल आकर्षक है। किसी जोखिम भरे परिवर्तन को अलगाव में आज़माने के लिए डेटाबेस को ब्रांच कीजिए। यह देखने के लिए कि किसी माइग्रेशन ने वास्तव में क्या किया, दो संस्करणों का डिफ़ लीजिए। हर विश्लेषक को डेटा की अपनी स्वयं की धारा दीजिए और अच्छे काम को वापस मर्ज कीजिए। किसी भी बीती हुई स्थिति तक उतनी ही आसानी से यात्रा कीजिए जितनी आसानी से git checkout। यदि संस्करण नियंत्रण ने यह बदल दिया कि हम कोड कैसे लिखते हैं, तो तर्क यह है कि यह यह भी बदल सकता है कि हम डेटा का प्रबंधन कैसे करते हैं।

हम मानते हैं कि यह तर्क सही है, और यह एक नीति-पत्र है कि इसे सच कैसे किया जाए। हम समझाते हैं कि संस्करण-नियंत्रित डेटा क्यों मायने रखता है (खंड 2), एक git-जैसे प्रोटोकॉल को वास्तव में क्या प्रदान करना होता है, जो पहली नज़र में दिखने से अधिक और कठिन है (खंड 3), और आज की परियोजनाएँ कहाँ खड़ी हैं, जहाँ श्रेय देय है वहाँ श्रेय देते हुए और इस बात का एक स्पष्ट-दृष्टि विवरण देते हुए कि उनके डिज़ाइन कहाँ कम पड़ते हैं (खंड 4)। फिर हम अपना पक्ष रखते हैं: कि यह क्षेत्र स्वयं को एक झूठे चुनाव में धकेल बैठा है, और कि Postgres के लिए बेहतर मार्ग एक नए इंजन या एक अमर्जनीय फ़ोर्क के बजाय उन्हीं आदिम तत्वों पर बना एक प्रोटोकॉल है जिन्हें वह पहले से प्रदान करता है (खंड 5)। Nashua किसी एकल उत्पाद के बजाय सर्वश्रेष्ठ-नस्ल उपकरणों और सुदृढ़ व्यवहार का समर्थन करता है, और यहाँ भी वही भावना है: किसी एक परियोजना के लिए कोई प्रचार नहीं, बल्कि इस बारे में एक तर्क कि इसे कैसे बनाया जाना चाहिए।

2. डेटाबेस का संस्करण-नियंत्रण क्यों करें

यह मामला उस काम से शुरू होता है जिसे लोग पहले से ही हाथ से बुरी तरह करते हैं। स्कीमा माइग्रेशन इसका स्पष्ट उदाहरण है। हर टीम जो कोई डेटाबेस चलाती है माइग्रेशन चलाती है, और हर टीम ने ऐसे माइग्रेशन का वह विशेष भय महसूस किया है जिसे स्वच्छता से पलटा नहीं जा सकता। एक संस्करण-नियंत्रित डेटाबेस किसी माइग्रेशन को एक कमिट बना देता है: प्रतिवर्तनीय, निरीक्षण-योग्य, और उत्पादन को छूने से पहले एक ब्रांच पर परीक्षण-योग्य। यह डिफ़ माइग्रेशन स्क्रिप्ट से लगाया गया कोई अनुमान नहीं है; यह स्कीमा और डेटा का वास्तविक परिवर्तन है, जो किसी भी पुल अनुरोध की तरह अभिकलित और समीक्षा-योग्य है।

फिर विकास और परीक्षण का लूप है। आधुनिक टीमें हर फ़ीचर ब्रांच और हर पुल-अनुरोध प्रीव्यू के लिए एक यथार्थवादी डेटाबेस चाहती हैं, जो उत्पादन-सदृश डेटा से भरा हो, कुछ ही सेकंडों में खड़ा हो जाए और ब्रांच के मर्ज होने पर फेंक दिया जाए। पूरी प्रतियाँ पुनर्स्थापित करके ऐसा करना धीमा और महँगा है; एक ही डेटाबेस साझा करके ऐसा करना टकरावों को न्योता देता है। सस्ती, तात्क्षणिक ब्रांचें एक वास्तविक और दैनिक समस्या को हल करती हैं, और ठीक इसीलिए ब्रांचिंग उत्पादों को एक उत्सुक बाज़ार मिला है।

दैनिक लूप से परे गहरे कारण छिपे हैं। पुनरुत्पाद्यता: एक डेटा वैज्ञानिक जो किसी विश्लेषण को डेटा की एक ठीक-ठीक कमिट की गई स्थिति से बाँध सकता है, वह किसी परिणाम को महीनों बाद पुनरुत्पन्न कर सकता है, और वही वह अंकेक्षक भी कर सकता है जो उस पर प्रश्न उठाता है। उद्गम और अंकेक्षण: एक डेटाबेस जिसका इतिहास हस्ताक्षरित कमिटों की एक शृंखला है, किसी जड़े हुए ट्रिगर के बजाय अपनी संरचना से ही यह उत्तर देता है कि किसने क्या बदला, और कब। विनियमित क्षेत्रों में यह कोई सुविधा-मात्र नहीं है; यूरोपीय संघ का DORA तंत्र और उसके सजातीय वित्तीय संस्थाओं से अपेक्षा करते हैं कि वे अपने डेटा की अखंडता और अनुरेखणीयता प्रदर्शित करें, और एक संस्करणित इतिहास उस तरह प्रदर्शनीय है जैसे कोई परिवर्तनीय तालिका नहीं है। पुनर्प्राप्ति: पॉइंट-इन-टाइम पुनर्स्थापन एक बैकअप संक्रिया होना बंद कर देता है और एक चेकआउट बन जाता है। और सहयोग अंततः डेटा पर उसी तरह संभव हो जाता है जैसे वह कोड पर है, काम की स्वतंत्र धाराओं के साथ जो लॉकिंग के बजाय समीक्षा के माध्यम से अभिसरित होती हैं।

इसमें से कुछ भी विदेशी-विचित्र नहीं है। यह सॉफ्टवेयर इंजीनियरिंग की साधारण मशीनरी है, जो उस एक परिसंपत्ति पर लागू होती है जिसने हठपूर्वक इसका प्रतिरोध किया है। प्रश्न यह नहीं है कि क्या डेटाबेस संस्करण नियंत्रण का हक़दार है। वह स्पष्ट रूप से है। प्रश्न यह है कि उसे असली चीज़ देने में क्या लगेगा।

3. एक git-जैसे प्रोटोकॉल का अर्थ क्या है

इस बारे में सटीक होना सार्थक है कि git वास्तव में क्या प्रदान करता है, क्योंकि आसान आधे को नियमित रूप से पूरा समझ लिया जाता है। git एक सामग्री-संबोधित (content-addressed) ऑब्जेक्ट भंडार है: हर फ़ाइल का हर संस्करण एक ब्लॉब है जिसका नाम उसकी सामग्री के हैश से रखा जाता है, वृक्ष (trees) ब्लॉबों को एक स्नैपशॉट में संयोजित करते हैं, और एक कमिट एक वृक्ष को उसके जनकों के साथ नामांकित करती है, जिससे इतिहास का एक अपरिवर्तनीय निर्देशित अचक्रीय ग्राफ़ बनता है। उस भंडार के ऊपर सुविधा की दो परतें बैठती हैं: refs, जो ग्राफ़ में बिंदुओं के लिए मानवीय नाम हैं, ताकि main और feature बस कमिटों पर लगे लेबल हों; और संक्रियाएँ, जिनमें से diff और merge ही मायने रखती हैं।

निर्णायक संक्रिया, वह जो git को किसी शानदार बैकअप के बजाय एक सहयोग उपकरण बनाती है, तीन-तरफ़ा मर्ज है। जब दो ब्रांचें विपथगामी होती हैं, तो git यह नहीं पूछता कि कौन-सी जीतती है। वह उनके साझा पूर्वज को ढूँढता है, अभिकलित करता है कि प्रत्येक पक्ष ने उस पूर्वज के सापेक्ष क्या बदला, और परिवर्तनों को संयोजित करता है, केवल उन्हीं स्थानों को चिह्नित करते हुए जहाँ दोनों पक्षों ने एक ही चीज़ को असंगत तरीकों से छुआ। यही वह है जो सौ लोगों को समानांतर रूप से काम करने और अभिसरित होने देता है। मर्जिंग के बिना ब्रांचिंग बस एक सस्ती प्रति है; मर्जिंग के साथ ब्रांचिंग संस्करण नियंत्रण है।

इसे किसी डेटाबेस तक ले जाइए और यह मानचित्रण सूचक तो है पर तुच्छ नहीं, जैसा कि चित्र 1 दर्शाता है। एक कमिट को किसी तार्किक क्षण पर समूचे डेटाबेस का एक अपरिवर्तनीय स्नैपशॉट होना चाहिए। एक ब्रांच को ऐसे स्नैपशॉटों की एक नामांकित धारा होनी चाहिए। एक डिफ़ को उन पंक्तियों और स्कीमा वस्तुओं की रिपोर्ट देनी चाहिए जो दो कमिटों के बीच बदलीं। और एक मर्ज को डेटा की दो विपथगामी धाराओं को एक में समाधित करना चाहिए। पहली तीन, सार में, एक भंडारण और नामकरण की समस्या हैं। चौथी कठिन वाली है, और यहीं git से की जाने वाली उपमा सहज होना बंद कर देती है।

चित्र 1. git ऑब्जेक्ट मॉडल को Postgres पर मानचित्रित किया गया। git के चार निर्माण-खंडों में से तीन Postgres के भीतर पहले से मौजूद हैं, MVCC स्नैपशॉट, write-ahead log और logical decoding के रूप में; जो अनुपस्थित है वह एक स्थायी ब्रांच ref और, सबसे बढ़कर, एक ऐसा मर्ज है जो डेटा को समझता हो। एक प्रोटोकॉल को केवल दो गर्म बक्से प्रदान करने हैं, तीन नीले बक्सों को फिर से बनाना नहीं।
चित्र 1. git ऑब्जेक्ट मॉडल को Postgres पर मानचित्रित किया गया। git के चार निर्माण-खंडों में से तीन Postgres के भीतर पहले से मौजूद हैं, MVCC स्नैपशॉट, write-ahead log और logical decoding के रूप में; जो अनुपस्थित है वह एक स्थायी ब्रांच ref और, सबसे बढ़कर, एक ऐसा मर्ज है जो डेटा को समझता हो। एक प्रोटोकॉल को केवल दो गर्म बक्से प्रदान करने हैं, तीन नीले बक्सों को फिर से बनाना नहीं।

पाठ (text) इसलिए मर्ज होता है क्योंकि एक स्रोत फ़ाइल एक पंक्ति-क्रमित अनुक्रम है जिसकी सामग्री के बारे में कोई नियम नहीं; git पंक्ति-परिवर्तनों के दो समुच्चयों को जोड़ सकता है और परिणाम परिभाषा के अनुसार अब भी एक वैध फ़ाइल रहती है। एक डेटाबेस वैसा नहीं है। उसकी सामग्री अचरों (invariants) द्वारा शासित होती है: प्राथमिक कुंजियाँ अद्वितीय रहनी चाहिए, विदेशी कुंजियाँ हल होनी चाहिए, जाँच-कंस्ट्रेंट कायम रहने चाहिए, और इन सबसे बढ़कर, डेटा का अब भी कुछ अर्थ होना चाहिए। दो ब्रांचें जो प्रत्येक एक ही प्राकृतिक कुंजी वाला ग्राहक सम्मिलित करती हैं, उन्होंने पाठगत अर्थ में कोई मर्ज संघर्ष उत्पन्न नहीं किया है; उन्होंने एक ऐसी स्थिति उत्पन्न की है जिसे स्कीमा निषिद्ध करता है। दो ब्रांचें जो प्रत्येक किसी खाता शेष को एक भिन्न राशि से घटाती हैं, दोनों बस जीत नहीं सकतीं। डेटा के लिए एक मर्ज को डेटा के नियमों का, और कभी-कभी उसके पीछे के आशय का भी, सम्मान करना होता है। यही ‘डेटाबेस के लिए git’ वाक्यांश की असली अंतर्वस्तु है, और यही वह कसौटी है जिस पर मौजूदा परियोजनाओं को परखा जाना चाहिए।

4. कला की वर्तमान स्थिति, और जहाँ वह कम पड़ती है

यह क्षेत्र स्वच्छता से तीन समूहों में बँटता है, और यह विभाजन शिक्षाप्रद है क्योंकि प्रत्येक समूह इसी से परिभाषित होता है कि वह क्या छोड़ देता है। तालिका 1 उन्हें अगल-बगल रखती है।

तालिका 1. आज के तरीके कहाँ खड़े हैं। मूल PG का अर्थ है असली PostgreSQL इंजन, अपने एक्सटेंशनों और पारितंत्र के साथ, न कि उसके वायर प्रोटोकॉल का कोई पुनःकार्यान्वयन। पैटर्न स्पष्ट है: सच्चे डेटा मर्ज वाली एकमात्र परियोजना वही है जो Postgres को छोड़ देती है, और हर वह उपकरण जो Postgres को बनाए रखता है मर्ज छोड़ देता है।

परियोजना तरीका मूल PG ब्रांच डेटा डिफ़ डेटा मर्ज संघर्ष मॉडल
Dolt नया इंजन, Merkle DAG नहीं हाँ हाँ हाँ कोष्ठ-वार, संरचनात्मक
DoltgreSQL नया इंजन, PG वायर नहीं हाँ हाँ हाँ कोष्ठ-वार, संरचनात्मक
Neon कॉपी-ऑन-राइट भंडारण हाँ हाँ नहीं नहीं कोई नहीं
Supabase ब्रांचिंग प्रति-ब्रांच इंस्टेंस हाँ हाँ केवल स्कीमा नहीं कोई नहीं
टेम्पोरल / अंकेक्षण उपकरण रैखिक इतिहास हाँ नहीं समय के साथ नहीं कोई नहीं
एक प्रोटोकॉल (प्रस्तावित) WAL + MVCC के ऊपर हाँ हाँ हाँ हाँ सिमेंटिक, कंस्ट्रेंट-सजग

4.1 इंजन को पुनः कार्यान्वित करना: Dolt और DoltgreSQL

Dolt इस विचार का सबसे संपूर्ण साकार रूप है, और यह वास्तविक श्रेय का हक़दार है। यह एक ओपन-सोर्स SQL डेटाबेस है जो आधार से ही संस्करणित होने के लिए बनाया गया है: इसका भंडारण एक सामग्री-संबोधित Merkle निर्देशित अचक्रीय ग्राफ़ है, जो प्रायिकतावादी वृक्षों से संरचित है, जिन्हें अक्सर prolly trees कहा जाता है, जो इसे git का संरचनात्मक साझाकरण और तेज़ डिफ़ देते हैं, जबकि यह एक अनुक्रमित, क्वेरी-योग्य डेटाबेस बना रहता है। ब्रांच, डिफ़, मर्ज, क्लोन, पुश और पुल प्रथम-श्रेणी SQL और कमांड-लाइन संक्रियाएँ हैं। Dolt वास्तव में डेटा के लिए git है, और DoltgreSQL उसी इंजन का विस्तार करके PostgreSQL वायर प्रोटोकॉल बोलता है, ताकि Postgres क्लाइंट जुड़ सकें।

लागत उस वाक्य में साफ़ दिखाई देती है: आधार से ही बनाया गया। Dolt, Postgres नहीं है। यह एक नया इंजन है जो एक डेटाबेस को, और DoltgreSQL के मामले में उसके ऊपर Postgres प्रोटोकॉल को, पुनः कार्यान्वित करता है। इसे अपनाने वाला कोई संगठन अपने चलाए जा रहे Postgres में संस्करणन नहीं जोड़ता; वह Postgres को किसी और चीज़ से बदल देता है और उस किसी और चीज़ के प्रदर्शन-लक्षणों तथा Postgres एक्सटेंशनों की उस लंबी पूँछ को विरासत में पाता है जिसे वह पुनरुत्पन्न नहीं करता, PostGIS और pgvector और बाक़ी सब जिन पर उत्पादन प्रणालियाँ टिकी रहती हैं। DoltgreSQL 2026 में एक 1.0 रिलीज़ तक पहुँचा और प्रभावशाली रूप से संगत है, किंतु Postgres बोली के साथ संगत होना Postgres होने के समान नहीं है। किसी ग्रीनफ़ील्ड परियोजना के लिए जो संस्करणन को सबसे ऊपर महत्व देती है, वह एक उचित सौदा हो सकता है। उत्पादन Postgres के विशाल स्थापित आधार के लिए, संस्करण नियंत्रण पाने के वास्ते इंजन को बदल देना एक बहुत बड़ी पूँछ का एक बहुत महत्वपूर्ण कुत्ते को हिलाना है।

एक सूक्ष्मतर सीमा है, और वह आगे आने वाले तर्क के लिए मायने रखती है। Dolt का मर्ज git के अनुरूप बना है: यह एक बार में एक कोष्ठ (cell) पर काम करता है, प्रत्येक पक्ष के परिवर्तनों को साझा पूर्वज के सापेक्ष लेकर उन्हें संयोजित करता है, और जहाँ दोनों पक्षों ने एक ही कोष्ठ को बदला वहाँ किसी मनुष्य द्वारा समाधान के लिए एक संघर्ष दर्ज कर लेता है। यह संरचनात्मक मर्ज है, और यह सही डिफ़ॉल्ट है, किंतु यह सिमेंटिक रूप से अंधा है। यह नहीं जानता कि किसी स्टॉक स्तर पर दो समवर्ती वृद्धियों को टकराने के बजाय जुड़ना चाहिए, या कि एक ही प्राकृतिक कुंजी साझा करने वाले दो सम्मिलन कोई संयोग नहीं बल्कि एक विरोधाभास हैं। Dolt उन कंस्ट्रेंट-उल्लंघनों का पता तो लगाता है जिन्हें कोई मर्ज प्रस्तुत करता है और किसी टूटी हुई स्थिति को चुपचाप कमिट करने के बजाय उन्हें समाधान के लिए सामने लाता है, जो इसका श्रेय है, किंतु तथ्य के बाद पता लगाना उस मर्ज के समान नहीं है जो डेटा का अर्थ समझता हो। संरचनात्मक मॉडल वह अधिकतम सीमा है जो कोष्ठ-वार मर्ज कर सकता है।

4.2 भंडारण को ब्रांच करना: Neon और Supabase

दूसरा समूह Postgres को बनाए रखता है, ठीक वही चीज़ जिसे Dolt छोड़ देता है, और अपनी ब्रांचिंग को स्टैक में नीचे ख़रीदता है। Neon, Postgres भंडारण की पुनर्रचना करता है, कंप्यूट को एक बहुसंस्करण, लॉग-संरचित भंडारण सेवा से अलग करते हुए, और ब्रांचिंग उस डिज़ाइन से लगभग मुफ़्त में निकल आती है: एक ब्रांच लॉग में किसी चुने हुए बिंदु पर भंडारण का एक कॉपी-ऑन-राइट फ़ोर्क है, जो डेटाबेस कितना भी बड़ा हो कुछ ही सेकंडों में बन जाता है, क्योंकि जब तक कुछ लिखा न जाए तब तक कुछ भी कॉपी नहीं होता। Supabase एक समान भावना में ब्रांचिंग प्रदान करता है, प्रति ब्रांच एक अलग Postgres इंस्टेंस खड़ा करते हुए और उसे एक Git-चालित प्रीव्यू वर्कफ़्लो में जोड़ते हुए, और वही कॉपी-ऑन-राइट पैटर्न पूरे पारितंत्र में चलता है, Xata की डेटा-वाहक ब्रांचों से लेकर Postgres.ai के ZFS पतले क्लोनों तक। सभी वास्तव में उपयोगी हैं, और खंड 2 के विकास और परीक्षण लूप के लिए वे आदर्श के निकट हैं।

किंतु तालिका को फिर देखिए। ये ऐसी ब्रांचें हैं जो विभाजित तो हो सकती हैं पर कभी फिर नहीं जुड़तीं। Neon किसी क्षण पर एक ब्रांच बना सकता है और उससे विपथ हो सकता है; वह उस ब्रांच के डेटा परिवर्तनों को वापस उसके जनक में मर्ज नहीं कर सकता, क्योंकि किसी कॉपी-ऑन-राइट भंडारण फ़ोर्क में कुछ भी यह नहीं जानता कि विपथगामी पृष्ठ-लेखनों के दो समुच्चयों को एक सुसंगत, कंस्ट्रेंट-सम्मानी स्थिति में कैसे समाधित किया जाए। यह कोई चूक नहीं है जिसे पैच किया जाए; यह समस्या को भंडारण परत पर हल करने का परिणाम है, जहाँ इकाई एक अपारदर्शी पृष्ठ है, न कि तार्किक परत पर, जहाँ इकाई अर्थ-युक्त एक पंक्ति है। Supabase की ब्रांचें प्रीव्यू परिवेशों के लिए स्कीमा माइग्रेशन की ओर उन्मुख हैं, डेटा को मर्ज करने की ओर बिल्कुल नहीं। परिणाम एक शक्तिशाली कॉपी-ऑन-राइट क्लोनिंग है, जो एक वास्तविक और मूल्यवान चीज़ है, जो संस्करण नियंत्रण की शब्दावली पहने हुए केवल उसका आसान आधा ही देती है। किसी ऐसे फ़ोर्क को, जिसमें मर्ज न हो, ब्रांच कहना एक ऐसा वादा उधार लेना है जिसे डिज़ाइन निभा नहीं सकता।

4.3 इतिहास लॉग करना: टेम्पोरल तालिकाएँ और अंकेक्षण-अनुरेख

एक तीसरा समूह कभी-कभी इसी बातचीत में समेट लिया जाता है और इसे अलग किया जाना चाहिए। सिस्टम-संस्करणित टेम्पोरल तालिकाएँ, जैसा कि SQL:2011 में मानकीकृत हैं और Postgres में temporal_tables जैसे एक्सटेंशनों द्वारा सन्निकटित की जाती हैं, और pgMemento जैसे अंकेक्षण ढाँचे, किसी तालिका को एक इतिहास देते हैं: हर पंक्ति समय की वह अवधि धारण करती है जिसके लिए वह वर्तमान थी, और आप डेटाबेस को वैसे ही क्वेरी कर सकते हैं जैसा वह किसी भी बीते हुए क्षण पर खड़ा था। यह मूल्यवान है, और यह वही उद्गम तथा पॉइंट-इन-टाइम पठन प्रदान करता है जिसकी खंड 2 ने माँग की थी। किंतु यह एक एकल, रैखिक इतिहास है। यहाँ कोई ब्रांच नहीं और कोई मर्ज नहीं, समाधित करने के लिए काम की कोई समानांतर धाराएँ नहीं। समय-यात्रा संस्करण नियंत्रण नहीं है; यह उसका एक अक्ष है, वही जिसे जोड़ना हमेशा सबसे आसान था।

4.4 तीन सरोकार, गलत तरीके से एकीकृत

पीछे हटिए और पैटर्न स्पष्ट है। हर परियोजना एक ही बार में वही तीन प्रश्न हल करती है, और उत्तरों को एक एकल उत्पाद में बाँध देती है: इतिहास को कैसे मॉडल किया जाए, किसी संस्करण को भौतिक रूप से कैसे संग्रहीत किया जाए, और संघर्षों को कैसे सुलझाया जाए। Dolt एक git-जैसे संस्करण मॉडल को एक विशेष-निर्मित भंडारण इंजन और एक कोष्ठ-वार संघर्ष मॉडल से एकीकृत करता है, और पहले को पाने के लिए आपको तीनों लेने होते हैं। Neon एक पतले संस्करण मॉडल को एक कॉपी-ऑन-राइट भंडारण इंजन से एकीकृत करता है और किसी संघर्ष मॉडल से बिल्कुल नहीं। चूँकि तीनों एक साथ वेल्ड किए गए हैं, आप Postgres को बनाए रखते हुए भी मर्ज नहीं पा सकते, और आप किसी से भी सिमेंटिक मर्ज नहीं पा सकते, क्योंकि संघर्ष मॉडल वही है जिसे भंडारण इंजन ने संयोगवश आसान बना दिया। यह क्षेत्र जो झूठा चुनाव प्रस्तुत करता है, मर्ज के बिना Postgres या Postgres के बिना मर्ज, वह तार्किक रूप से अलग सरोकारों को एकीकृत करने की एक कलाकृति है। उन्हें अलग खींचिए और एक बेहतर डिज़ाइन प्रकट होता है।

5. एक बेहतर तरीका: एक प्रोटोकॉल, न कि एक फ़ोर्क

हमारा प्रस्ताव यह है कि संस्करण-नियंत्रित डेटाबेस बनाना बंद करें और उस डेटाबेस के लिए एक संस्करण-नियंत्रण प्रोटोकॉल परिभाषित करना शुरू करें जो हमारे पास पहले से है। यह क़दम वही है जो स्वयं git ने उठाया था: git की प्रतिभा यह थी कि उसने ऑब्जेक्ट मॉडल, यानी कमिट और वृक्ष और refs, को उस ट्रांसपोर्ट से अलग किया जो उन्हें इधर-उधर ले जाता है, ताकि मॉडल किसी विशेष कार्यान्वयन से अधिक जी सके। डेटाबेस संस्करण नियंत्रण को संस्करण मॉडल, यानी कमिट और ब्रांच और मर्ज, को उस भौतिक भंडारण से अलग करना चाहिए जो उन्हें साकार करता है, ताकि यह किसी नए इंजन की माँग करने के बजाय स्टॉक Postgres पर चल सके। चित्र 2 इसकी आकृति दिखाता है।

चित्र 2. मूल Postgres के ऊपर एक संस्करण-नियंत्रण प्रोटोकॉल। आधार पर इंजन अपरिवर्तित है, स्टॉक Postgres अपने कंस्ट्रेंटों और एक्सटेंशनों के साथ अक्षुण्ण। उसके ऊपर, logical decoding परिवर्तनों को सामग्री-संबोधित कमिटों के रूप में पकड़ता है, एक पतली मॉडल परत ब्रांच और refs प्रदान करती है, और सिमेंटिक मर्ज, वह एकमात्र सचमुच कठिन हिस्सा, जीवंत स्कीमा के विरुद्ध सत्यापन करके और प्रति-तालिका नीतियाँ लागू करके विपथन को समाधित करता है। किसी ब्रांच को भौतिक रूप से कैसे साकार किया जाता है, यह एक अदला-बदली-योग्य अनुकूलन है, अनुबंध का हिस्सा नहीं।
चित्र 2. मूल Postgres के ऊपर एक संस्करण-नियंत्रण प्रोटोकॉल। आधार पर इंजन अपरिवर्तित है, स्टॉक Postgres अपने कंस्ट्रेंटों और एक्सटेंशनों के साथ अक्षुण्ण। उसके ऊपर, logical decoding परिवर्तनों को सामग्री-संबोधित कमिटों के रूप में पकड़ता है, एक पतली मॉडल परत ब्रांच और refs प्रदान करती है, और सिमेंटिक मर्ज, वह एकमात्र सचमुच कठिन हिस्सा, जीवंत स्कीमा के विरुद्ध सत्यापन करके और प्रति-तालिका नीतियाँ लागू करके विपथन को समाधित करता है। किसी ब्रांच को भौतिक रूप से कैसे साकार किया जाता है, यह एक अदला-बदली-योग्य अनुकूलन है, अनुबंध का हिस्सा नहीं।

5.1 वह सब्सट्रेट जो Postgres पहले से प्रदान करता है

चौंकाने वाली बात, और हमारे तर्क का हृदय, यह है कि इस मशीनरी का कितना हिस्सा Postgres के पास पहले से है। इसका बहुसंस्करण संगामिती नियंत्रण हर पंक्ति के अनेक संस्करण रखता है और हर लेन-देन को किसी तार्किक क्षण पर डेटाबेस का एक सुसंगत स्नैपशॉट सौंपता है: वह नाम के अलावा हर तरह से एक कमिट है। इसका write-ahead log कभी भी लागू किए गए हर परिवर्तन का एक क्रमित, टिकाऊ अभिलेख है, यानी एक reflog। और logical decoding, वह परिपक्व तंत्र जो पहले से ही logical replication को शक्ति देता है, उस लॉग को पंक्ति-स्तरीय परिवर्तनों की एक स्वच्छ, क्रमित धारा में बदल देता है जिसे कोई भी क्लाइंट उपभोग कर सकता है। git के चार आदिम तत्वों में से तीन, यानी अपरिवर्तनीय स्नैपशॉट, एक इतिहास लॉग और एक परिवर्तन-धारा, Postgres के भीतर पहले से बैठे हैं, जैसा कि चित्र 1 ने दिखाया। एक प्रोटोकॉल को उन्हें फिर से बनाने की आवश्यकता नहीं। उसे केवल वे दो चीज़ें जोड़नी हैं जिनका Postgres में अभाव है: उस इतिहास के ऊपर स्थायी नामांकित refs, और एक ऐसा मर्ज जो डेटा को समझता हो।

तो फिर, कमिटों को पकड़ना logical-decoding धारा को उपभोग करने और हर लेन-देन के परिवर्तनों को एक सामग्री-संबोधित परिवर्तन-समुच्चय (change set) के रूप में अभिलिखित करने का मामला है, जो अपनी सामग्री से हैश किया जाता है ताकि समरूप परिवर्तन भंडारण साझा करें और किसी भी परिवर्तन-समुच्चय को उसके हैश से नामांकित और प्राप्त किया जा सके। एक स्लॉट एक बार बनाया जाता है, और परिवर्तन निथारे और संग्रहीत किए जाते हैं:

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

-- हर लेन-देन के परिवर्तन, क्रम में,
-- हैश करके एक कमिट ऑब्जेक्ट के रूप में संग्रहीत
SELECT * FROM pg_logical_slot_get_changes(
  'vc', NULL, NULL);

यहाँ कुछ भी न तो इंजन को फ़ोर्क करता है और न ही पंक्ति के नीचे पहुँचता है। प्रोटोकॉल वही पढ़ता है जो Postgres पहले से उत्सर्जित करता है और उसके बगल में संस्करण ग्राफ़ बनाता है।

5.2 कमिट, refs और ब्रांच

कमिटों के रूप में परिवर्तन-समुच्चयों के साथ, आसान आधे का शेष भाग बहीखाता रखना है। एक कमिट अपने जनक या जनकों और उस परिवर्तन-समुच्चय के सामग्री-हैश को अभिलिखित करती है जिसे वह प्रस्तुत करती है, जिससे वही अपरिवर्तनीय निर्देशित अचक्रीय ग्राफ़ बनता है जिसका git उपयोग करता है। एक ref एक नाम है जो किसी कमिट की ओर संकेत करता है, और एक ब्रांच एक ऐसा ref है जो उसमें नई कमिट जुड़ने के साथ आगे बढ़ता है। यह मेटाडेटा छोटा है, यह साधारण संबंधपरक डेटा है, और यह उसी डेटाबेस के भीतर एक स्कीमा में रह सकता है जिसका यह संस्करण रखता है, या किसी सहयोगी भंडार में। चूँकि एक कमिट भौतिक पृष्ठों के बजाय सामग्री-संबोधित तार्किक परिवर्तनों से परिभाषित होती है, यह पोर्टेबल है: इसका अर्थ किसी भी Postgres पर वही रहता है, ऑन-प्रिमाइसेस हो या किसी भी क्लाउड में, जो ठीक वही गुण है जो एक कॉपी-ऑन-राइट भंडारण फ़ोर्क नहीं दे सकता। संस्करण मॉडल शुद्ध प्रोटोकॉल है, और इसमें कोई लॉक-इन नहीं है।

5.3 सिमेंटिक, कंस्ट्रेंट-सजग मर्ज

यहाँ कठिन आधा है, और वह स्थान जहाँ एक प्रोटोकॉल वह कर सकता है जो कोई वर्तमान उपकरण नहीं करता। चूँकि कमिट अपारदर्शी पृष्ठों के बजाय तार्किक परिवर्तन-समुच्चय हैं, एक तीन-तरफ़ा मर्ज वहाँ संचालित हो सकता है जहाँ अर्थ बसता है। दो ब्रांचें और उनका साझा पूर्वज दिए जाने पर, प्रोटोकॉल प्रत्येक पक्ष के पंक्ति-स्तरीय परिवर्तनों को अभिकलित करके उन्हें संयोजित करता है, और फिर वे दो चीज़ें करता है जो एक डेटाबेस मर्ज को एक पाठ मर्ज से अलग करती हैं। पहला, यह प्रस्तावित परिणाम को जीवंत स्कीमा के, यानी हर कंस्ट्रेंट, कुंजी और विदेशी-कुंजी संबंध के, विरुद्ध सत्यापित करता है, ताकि कोई मर्ज कभी भी ऐसी स्थिति कमिट न कर सके जिसे डेटाबेस अस्वीकार करता; किसी उल्लंघन को भ्रष्टाचार के रूप में लिखे जाने के बजाय एक संघर्ष के रूप में उठाया जाता है। दूसरा, और यही असली प्रगति है, यह अतिव्यापनों (overlaps) को उन नीतियों का उपयोग करके सुलझाता है जिन्हें डेटा का अर्थ रखने वाले लोगों द्वारा प्रति तालिका और प्रति स्तंभ घोषित किया जाता है, न कि किसी एकल अंधे कोष्ठ-वार नियम से।

वे नीतियाँ ही वह जगह हैं जहाँ डोमेन का आशय प्रवेश करता है। एक काउंटर स्तंभ को इस तरह घोषित किया जा सकता है कि वह प्रत्येक पक्ष द्वारा लागू किए गए डेल्टाओं को जोड़कर मर्ज हो, जो किसी अभिसारी प्रतिकृत डेटा प्रकार (convergent replicated data type) का व्यवहार है, ताकि दो समवर्ती वृद्धियाँ टकराने के बजाय सही ढंग से जुड़ जाएँ। एक अंतिम-अद्यतन टाइमस्टैम्प बाद वाले मान को लेकर मर्ज हो सकता है। एक समुच्चय-मान वाला संबंध संघ (union) द्वारा मर्ज हो सकता है। एक प्राकृतिक-कुंजी टकराव को एक बिना-शर्त संघर्ष घोषित किया जा सकता है, क्योंकि स्कीमा का अर्थ कहता है कि दोनों पंक्तियाँ एक ही सत्ता हैं। जहाँ कोई नीति लागू न हो और दोनों पक्षों ने एक ही मान को छुआ हो, वहाँ प्रोटोकॉल ठीक वही करता है जो git करता है और किसी मनुष्य के लिए रुक जाता है, संघर्ष को पृष्ठों के बजाय पंक्तियों और मानों के रूप में प्रस्तुत करते हुए। एक घोषणा उतनी ही सादगी से पढ़ी जा सकती है, जितनी यह:

MERGE POLICY ON inventory (on_hand)
  USING sum_of_deltas;
MERGE POLICY ON inventory (sku)
  USING conflict;  -- वही SKU, वही आइटम

यही वह अंश है जिसे पूर्व-कला संभव दिखाती है। उपयोगकर्ता-परिभाषित मर्ज फलनों वाली सामग्री-संबोधित प्रणालियाँ संबंधपरक दुनिया के बाहर पहले से मौजूद हैं: Irmin, वह git-जैसा भंडार जो MirageOS परियोजना के हिस्सों के पीछे है, ठीक इसी विचार के इर्द-गिर्द बना है, यानी कस्टम मर्ज तर्क वाले मर्ज-योग्य डेटा के, और अभिसारी तथा क्रमविनिमेय प्रतिकृत डेटा प्रकारों पर का साहित्य इसका एक कठोर विवरण देता है कि समवर्ती परिवर्तन कब बिना संघर्ष के मर्ज किए जा सकते हैं। अचर-अभिसरण (invariant confluence) का सिद्धांत, जो Bailis और सहयोगियों से आता है, एक क़दम और आगे जाता है और हमें ठीक-ठीक बताता है कि कोई मर्ज किन अचरों को बिना समन्वय के संरक्षित रख सकता है और किन्हें, जिनमें वैश्विक अद्वितीयता और विदेशी कुंजियाँ शामिल हैं, प्रमाणित रूप से नहीं रख सकता। यह निराशा की सलाह नहीं है; यही वह कारण है कि किसी प्राकृतिक-कुंजी टकराव को इच्छा से टाल देने के बजाय एक संघर्ष घोषित करना पड़ता है, और यह एक प्रोटोकॉल को ठीक-ठीक बताता है कि कहाँ एक स्वचालित नीति सुरक्षित है और कहाँ किसी मनुष्य को निर्णय करना चाहिए। जो नहीं किया गया है वह उस सिमेंटिक मर्ज को मूल, लेन-देन संबंधी Postgres तक लाना है, जो स्कीमा के अपने कंस्ट्रेंटों द्वारा शासित हो। यही वह खुली समस्या है जो हल करने योग्य है, और वही जिसके आर-पार जाने के बजाय ब्रांचिंग उत्पाद उसके इर्द-गिर्द से निकल गए हैं।

5.4 साकारीकरण एक अनुकूलन के रूप में

एक उचित आपत्ति यह है कि किसी ब्रांच को पुनर्निर्मित करने के लिए तार्किक परिवर्तनों को फिर से चलाना किसी बड़े डेटाबेस के लिए धीमा हो सकता है। उत्तर स्वयं यह विघटन (decoupling) है: किसी ब्रांच को भौतिक रूप से कैसे साकार किया जाता है, यह संस्करण मॉडल का हिस्सा नहीं है, इसलिए इसे स्वतंत्र रूप से चुना और बाद में बदला जा सकता है। किसी ब्रांच को परिवर्तन-समुच्चयों से तब फिर से चलाया जा सकता है जब वह छोटी हो या विरले उपयोग की हो, या जब उसे तेज़ होना हो तब एक कॉपी-ऑन-राइट स्नैपशॉट के रूप में खड़ा किया जा सकता है, ZFS जैसे फ़ाइलसिस्टम स्नैपशॉटों या ठीक उसी कॉपी-ऑन-राइट भंडारण का उपयोग करते हुए जिसे Neon और उसके जैसों ने बनाया है। दूसरे शब्दों में, वे उत्कृष्ट तेज़-फ़ोर्क इंजन इस प्रोटोकॉल के प्रतिस्पर्धी नहीं हैं; वे इसके साकारीकरण के लिए एक संभावित बैकएंड हैं, जिनके ऊपर मर्ज और पोर्टेबल संस्करण मॉडल प्रदान किए जाते हैं। प्रोटोकॉल कहता है कि एक ब्रांच और एक मर्ज का क्या अर्थ है; भंडारण परत उन्हें तेज़ बनाने के लिए स्वतंत्र है।

5.5 ईमानदार सीमाएँ

हम यह दावा नहीं कर रहे कि यह आसान है, और एक नीति-पत्र जो इसके विपरीत का दिखावा करता, संदेह का पात्र होता। सिमेंटिक मर्ज सचमुच कठिन है: सही प्रति-तालिका नीतियाँ लिखने में सावधानी लगती है, लंबे समय से विपथ ब्रांचें ऐसे संघर्ष जमा कर लेती हैं जिन्हें कोई नीति बिना विवेक के नहीं सुलझा सकती, और बहुत उच्च-आयतन वाली परिवर्तन-धाराएँ कमिट लॉग के लिए भंडारण और थ्रूपुट के वास्तविक प्रश्न उठाती हैं। किसी बड़े मर्ज को हर कंस्ट्रेंट के विरुद्ध सत्यापित करने की एक लागत है, और कुछ अचर, जैसा कि अचर-अभिसरण सिद्धांत प्रमाणित करता है, बिना समन्वय के बिल्कुल भी समाधित नहीं किए जा सकते, इसलिए एक ईमानदार प्रोटोकॉल उन्हें सुलझाने का दिखावा करने के बजाय संघर्षों के रूप में सामने लाता है। ये वे कारण हैं कि समस्या अब भी खुली है, न कि इसे अघुलनशील घोषित करने के कारण। प्रोटोकॉल दृष्टिकोण जो ख़रीदता है वह यह है कि कठिन हिस्सा, यानी मर्ज, उसी एकमात्र जगह सुलझाया जाता है जहाँ उसे अच्छी तरह सुलझाया जा सकता है, तार्किक परत पर स्कीमा हाथ में लेकर, न कि भंडारण परत पर छोड़ दिया जाता है या किसी कोष्ठ-वार नियम में चपटा कर दिया जाता है। इसका यह भी अर्थ है कि काम चक्रवृद्धि होता है: चूँकि यह स्टॉक Postgres के ऊपर एक प्रोटोकॉल है, इंजन में हर सुधार, हर एक्सटेंशन, हर परिचालन उपकरण इसके नीचे काम करता रहता है।

6. इसका व्यवहार में क्या अर्थ है

आज चुनाव करने वाले किसी संगठन के लिए, ईमानदार मार्गदर्शन तालिका का अनुसरण करता है। यदि आपको जो चाहिए वह विकास, परीक्षण और पुल-अनुरोध प्रीव्यू के लिए सस्ते, तात्क्षणिक डेटाबेस हैं, तो कॉपी-ऑन-राइट ब्रांचिंग उपकरण उत्कृष्ट हैं और आपको उनका उपयोग करना चाहिए, इस स्पष्ट दृष्टि के साथ कि वहाँ एक ब्रांच एक फेंकने-योग्य फ़ोर्क है, काम की कोई ऐसी धारा नहीं जिसे आप वापस मर्ज करेंगे। यदि आप नए सिरे से शुरू कर रहे हैं और संस्करणन ही प्रणाली का उद्देश्य है, तो Dolt एक गंभीर और सक्षम उपकरण है, बशर्ते आप यह स्वीकार करें कि आप Postgres का विस्तार करने के बजाय एक नया इंजन चुन रहे हैं। और यदि आप जो चाहते हैं वह पूरा वादा है, यानी उस उत्पादन Postgres के ऊपर ब्रांच और डिफ़ और मर्ज जिसे आप पहले से चलाते और भरोसा करते हैं, तो ईमानदार उत्तर यह है कि कोई उत्पाद अभी तक इसे नहीं देता, और दाँव लगाने के लिए सही चीज़ इंजन या भंडारण के एक और फ़ोर्क के बजाय Postgres के अपने आदिम तत्वों पर बना एक प्रोटोकॉल है।

वह अंतिम स्थिति वही है जिसे Nashua धारण करता है, और यह इस बात के अनुरूप है कि हम इस समूचे परिदृश्य को कैसे पढ़ते हैं। हम एकल-विक्रेता प्लेटफ़ॉर्मों के बजाय सर्वश्रेष्ठ-नस्ल उपकरणों और खुले मानकों को तरजीह देते हैं, और लॉक-इन जहाँ कहीं छिपता है उससे सतर्क रहते हैं, उस भंडारण परत के भीतर भी जो ब्रांच तो कर सकती है पर आपके डेटा को कभी समान शर्तों पर जाने नहीं देती। एक संस्करण मॉडल जो शुद्ध प्रोटोकॉल है, किसी भी इन्फ्रास्ट्रक्चर पर किसी भी Postgres के आर-पार पोर्टेबल, ऑन-प्रिमाइसेस हो या क्लाउड, यह चुनाव कि कहाँ और कैसे चलाना है, दृढ़ता से संगठन के पास रखता है। क्लाउड और ऑन-प्रिमाइसेस दोनों डेटा के लिए अच्छे घर हैं; एक प्रोटोकॉल जो इसकी परवाह नहीं करता कि कौन-सा, यही तो मुद्दा है।

7. निष्कर्ष

डेटाबेस उस संस्करण नियंत्रण का हक़दार है जिसने सॉफ्टवेयर इंजीनियरिंग के हर दूसरे हिस्से को बदल दिया, और वे परियोजनाएँ जो उस लक्ष्य का पीछा कर रही हैं, उसका पीछा करने में सही हैं। किंतु पुरस्कार मर्ज है, केवल ब्रांच नहीं, और यह क्षेत्र ऐसे उपकरणों में बँट गया है जो Postgres को छोड़कर मर्ज करते हैं और ऐसे उपकरणों में जो मर्ज छोड़कर Postgres को बनाए रखते हैं। वह विभाजन अनिवार्य नहीं है। यह तीन अलग करने योग्य सरोकारों को, यानी संस्करण मॉडल, भौतिक भंडारण और संघर्ष समाधान को, एक उत्पाद में एकीकृत करने से आता है। उन्हें अलग कीजिए, संस्करण मॉडल को उसी write-ahead log, बहुसंस्करण भंडारण और logical decoding पर एक प्रोटोकॉल के रूप में बनाइए जो Postgres पहले से प्रदान करता है, और उसके केंद्र में एक सिमेंटिक, कंस्ट्रेंट-सजग मर्ज रखिए, और वह झूठा चुनाव घुल जाता है। git ने मॉडल को मशीन से अलग करके अपना स्थान अर्जित किया। डेटा वही हक़दार है, और Postgres, लगभग अनन्य रूप से, इसे वास्तविक बनाने के पुर्ज़े पहले से रखता है। Nashua इसका एक फ़ोर्क बेचने के बजाय इसे बनाने में मदद करना अधिक पसंद करेगा।

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