क्या git या मर्क्यूरियल की तुलना में svn में विलय के बीच अंतर है?

Question

मेरी समझ से एसवीएन 'शाखा में आसान है। मर्ज करना मुश्किल ’। ऐसा क्यों है? वहाँ एक अंतर है कि वे कैसे विलय करते हैं?

Answer 1

कृपया एक बहुत ही ठोस स्थिति के लिए मेरा स्टैक ओवरफ्लो उत्तर देखें जहां मर्क्यूरियल (और गिट) बिना समस्याओं के विलीन हो जाता है और जहां तोड़फोड़ आपको एक संगीन संघर्ष के साथ प्रस्तुत करता है। स्थिति उस शाखा पर की गई एक सरल रीफैक्टरिंग है जहां आप कुछ फ़ाइलों का नाम बदलते हैं।

Tdammers जवाब देने के संबंध में, फिर वहाँ गलतफहमी की संख्या है:

• सबवर्सन, मर्क्यूरियल, और Git प्रोजेक्ट के सभी रिपॉजिटरी-वाइड स्नैपशॉट ट्रैक करता है। उन्हें संस्करण , संशोधन , या परिवर्तन कॉल करने से कोई फर्क नहीं पड़ता। वे सभी तार्किक रूप से एक फाइल के सेट के परमाणु स्नैपशॉट हैं।

• जब विलय की बात आती है तो आपके कमिट्स के आकार पर कोई फर्क नहीं पड़ता है । सभी तीन प्रणालियाँ मानक थ्री-वे मर्ज एल्गोरिथम के साथ विलय करती हैं और उस एल्गोरिथ्म के इनपुट हैं

  • सबसे बड़ा सामान्य पूर्वज संस्करण
  • एक शाखा पर संस्करण
  • अन्य शाखा पर संस्करण

  इससे कोई फर्क नहीं पड़ता कि दो शाखा संस्करण कैसे बनाए गए थे। आपने पूर्वज संस्करण के बाद से 1000 छोटे कमिट्स का उपयोग किया है, या आपने 1 कमिट का उपयोग किया है। वह सब मामला फाइलों का अंतिम संस्करण है। (हां, यह आश्चर्य की बात है! हां, बहुत सारे डीवीसीएस गाइडों को यह बुरी तरह से गलत लगता है।)

वह मतभेदों के बारे में कुछ अच्छे बिंदु भी उठाता है:

• तोड़फोड़ में कुछ "वूडू" हैं जहां से आप मर्ज कर सकते हैं /trunk, कह सकते हैं /branches/foo। मर्क्यूरियल और गिट इस मॉडल का उपयोग नहीं करते हैं - शाखाओं को इतिहास में सीधे मॉडल किया जाता है। इसलिए इतिहास रेखीय होने के बजाय एक निर्देशित चक्रीय ग्राफ बन जाता है । यह सबवर्सन द्वारा उपयोग किए जाने वाले मॉडल की तुलना में बहुत सरल मॉडल है और यह कई कोने के मामलों को काट देता है।

• आप आसानी से एक मर्ज में देरी कर सकते हैं या किसी और को इसे संभालने दे सकते हैं। यदि hg mergeआप एक टन संघर्ष करते हैं, तो आप अपने सहकर्मी से आपसे पूछ सकते हैं hg pullऔर फिर उसके पास वही स्थिति है। तो वह कर सकता है hg mergeऔर शायद वह संघर्षों को सुलझाने में आपसे बेहतर है।

  यह तोड़फोड़ के साथ बहुत मुश्किल है, जहां आपको अपडेट करने से पहले आवश्यक है । आप सर्वर पर होने वाले परिवर्तनों को अनदेखा नहीं कर सकते हैं और अपनी अनाम शाखा पर प्रतिबद्ध रह सकते हैं। सामान्य तौर पर, तोड़फोड़ आपको जब आप एक गंदा काम की नकल के साथ खेलने के लिए मजबूर करता है svn update। यह उस तरह का जोखिम भरा है जब से आपने अपने परिवर्तनों को कहीं भी सुरक्षित नहीं रखा है। Git और Mercurial आपको पहले प्रतिबद्ध करने देता है, और फिर आवश्यक रूप से अपडेट और मर्ज करता है।

वास्तविक कारण Git और Mercurial विलय से बेहतर है जो कि तोड़फोड़ कार्यान्वयन का विषय है। नाम बदलने के विवाद हैं कि तोड़फोड़ बस यह भी नहीं सोच सकती कि यह स्पष्ट है कि सही उत्तर क्या है। मर्क्यूरियल और गिट आसानी से संभालते हैं। लेकिन वहाँ कोई कारण नहीं है कि तोड़फोड़ के रूप में अच्छी तरह से उन लोगों को संभाल नहीं सकता - केंद्रीकृत किया जा रहा है निश्चित रूप से कारण नहीं है।

Comments

बहुत बढ़िया जवाब! अगर मैं कर सकता था मैं दो बार upvote। :) मैं उस एसवीएन पुस्तक को भी जोड़ता हूँ जो आप एसओ उत्तर में संदर्भित करते हैं , स्पष्ट रूप से स्वीकार करते हैं कि "सबवर्सन के मर्ज-ट्रैकिंग फ़ीचर में एक अत्यंत जटिल आंतरिक कार्यान्वयन है ..." - यह अकेला एक बहुत अच्छा संकेत है कि यह सुविधा अविश्वसनीय है

— ज्ञान

... और यहां तक ​​कि उस अत्यंत जटिल कार्यान्वयन से सामान्य पूर्वज किसी भी, लेकिन सरल मामलों में सही तरीके से पता नहीं लगा सकते हैं।

— जन हडेक

विलम्बित विलय के बारे में - यह नहीं मिलता है - एसवीएन के साथ मेरा सहकर्मी / चेकआउट ट्रंक को अपडेट कर सकता है, और फिर मेरी शाखा से इसमें विलीन हो सकता है।

— गिल बेट्स

@ गिलबेट्स: मैं एक ऐसी स्थिति के बारे में बात कर रहा हूँ जहाँ आपने अपने काम के लिए एक शाखा शुरू नहीं की है - जब आप trunkएसवीएन में काम कर रहे हों । डीवीसीएस के साथ आप साझा किए बिना कर सकते हैं, लेकिन एसवीएन में आपके svn commitसीधे उसी शाखा पर काम करने वाले अन्य लोगों को प्रभावित करेगा। यहां तक ​​कि अगर हम दोनों एसवीएन में एक शाखा पर काम करते हैं, तो मैं आपके काम को तुरंत आपके काम के साथ विलय किए बिना अपना काम नहीं कर सकता। यह कुछ हद तक डरावना बनाता है - जो एक संस्करण नियंत्रण प्रणाली के लिए एक डरावनी संपत्ति है! :-)

— मार्टिन गेइस्लर

Answer 2

मुख्य समस्या यह है कि ये सिस्टम किस प्रकार एक संस्करणित निर्देशिका संरचना का प्रतिनिधित्व करते हैं।

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

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

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

और फिर अच्छा विवरण है जो चीजों को और भी आसान बनाते हैं:

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

Comments

मुझे कुछ सुधारों का उल्लेख करना होगा और उत्तर देने के लिए जोड़ना होगा: 1. एसवीएन संशोधन वैश्विक प्रति-रिपॉजिटरी हैं , पुनरीक्षण कुछ क्षणों में रेपो में सभी फाइलों का प्रतिनिधित्व करता है। मर्ज तकनीक मूल रूप से एसवीएन और डीवीसीएस में आम है - यदि मर्ज की गई फाइल में फाइल बदल गई है इसी तरह , मर्ज एसवीएन और डीवीसीएस के लिए समान मात्रा में संघर्ष का उत्पादन करेगा - सभी एससीएम अभी भी स्ट्रिंग-स्तर पर काम करते हैं, न कि एक तार्किक ब्लॉक 3. एसवीएन में बड़े हिट वास्तुशिल्प कमजोरी का परिणाम नहीं है, लेकिन क्योंकि उपयोगकर्ता अक्सर अजीब बेवकूफ होते हैं - वे बुनियादी पैटर्न की अनदेखी करते हैं। शाखा | SVN में मर्ज का काम करता है, अगर / dev / मस्तिष्क और / देव / हाथ काम करते हैं

— आलसी बेजर

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

— आलसी बेजर

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

— Jan Hudec

@JanHudec - क्षमा करें, SVN हैंडल नहीं चलता है। परमाणु एक क्रिया (DVCS तरीका - "नाम") पर नाम बदल जाता है, लेकिन "हटाएं + ..." के रूप में, इस प्रकार - वृक्ष संघर्षों का उत्पादन करता है, जहां यह DVCS में नहीं होता है ( असली नाम )। मर्क्यूरियल ट्रैक का नाम स्पष्ट रूप से ( hg mvया hg addremove --similarity...) है, जबकि गिट हेयुरिस्टिक का उपयोग करता है, लेकिन दोनों ही नाम बदल देते हैं । मर्ज किए गए फ़ाइलों में 1 स्ट्रिंग अंतर के साथ भी मुझे पेड़ का संघर्ष मिल सकता है ! आपको कुछ तोड़फोड़ पहलुओं को फिर से सीखना होगा, क्षमा करें।

— आलसी बेजर

अब हम काफी तकनीकी हो रहे हैं :-) दोनों तोड़फोड़ और मर्क्यूरियल ट्रैक प्रतियां , नाम नहीं। दोनों प्रणाली के rename a bरूप में ट्रैक copy a b; remove aऔर दोनों एक परमाणु प्रतिबद्ध में करते हैं। मर्ज व्यवहार में अंतर कोने के मामलों की अलग-अलग हैंडलिंग से और उपविभाजन से मर्क्यूरियल और गिट की तुलना में अधिक मर्ज की अनुमति देता है। अंत में, Git मर्ज और लॉग टाइम में नाम का पता लगाता है - हम इसे Mercurial में भी जोड़ने की सोच रहे हैं।

— मार्टिन गेइस्लर