हाय/लो एल्गोरिदम क्या है?

Question

हाय/लो एल्गोरिदम क्या है?

मुझे यह NHibernate प्रलेखन में मिला है (यह अनन्य कुंजी उत्पन्न करने का एक तरीका है, खंड 5.1.4.2), लेकिन मुझे यह कैसे काम करता है इसका एक अच्छा स्पष्टीकरण नहीं मिला है।

मुझे पता है कि निबर्ननेट इसे संभालता है, और मुझे अंदरूनी जानने की आवश्यकता नहीं है, लेकिन मैं सिर्फ उत्सुक हूं।

Answer 1

मूल विचार यह है कि आपके पास प्राथमिक कुंजी बनाने के लिए दो संख्याएं हैं- एक "उच्च" संख्या और "कम" संख्या। एक क्लाइंट मूल रूप से "उच्च" अनुक्रम को बढ़ा सकता है, यह जानकर कि यह "निम्न" मानों की विविधता के साथ पिछले "उच्च" मान की पूरी श्रृंखला से सुरक्षित रूप से कुंजी उत्पन्न कर सकता है।

उदाहरण के लिए, मान लीजिए कि आपके पास 35 के वर्तमान मूल्य के साथ "उच्च" अनुक्रम है, और "कम" संख्या 0-1023 की सीमा में है। फिर ग्राहक अनुक्रम को 36 तक बढ़ा सकता है (अन्य क्लाइंट के लिए 35 का उपयोग करते समय चाबियाँ उत्पन्न करने में सक्षम होने के लिए) और पता है कि चाबियाँ 35/0, 35/1, 35/2, 35/3 ... 35/1023 हैं सभी उपलब्ध।

यह प्राथमिक कुंजी के बिना मूल्य डालने और फिर उन्हें क्लाइंट पर लाने के बजाय क्लाइंट पक्ष पर प्राथमिक कुंजी सेट करने में सक्षम होने के लिए बहुत उपयोगी (विशेष रूप से ORMs के साथ) हो सकता है। किसी और चीज के अलावा, इसका मतलब है कि आप आसानी से माता-पिता/बच्चे के संबंध बना सकते हैं और प्रविष्टियों से पहले कुंजियां पूरी तरह से कर सकते हैं, जिससे उन्हें सरल बैचिंग मिलती है।

Answer 2

जॉन के जवाब के अलावा:

यह कट काम करने के लिए सक्षम होने के लिए प्रयोग किया जाता है। एक ग्राहक तब सर्वर को एक उच्च संख्या के लिए पूछ सकता है और लो संख्या को बढ़ाने वाली वस्तुओं को बना सकता है। जब तक लो रेंज का उपयोग नहीं किया जाता है तब तक सर्वर से संपर्क करने की आवश्यकता नहीं होती है।

Answer 3

हाय-लो आवंटक से बेहतर, "रैखिक चंक" आवंटक है। यह एक समान टेबल-आधारित सिद्धांत का उपयोग करता है लेकिन छोटे, आसानी से आकार वाले हिस्सों को आवंटित करता है & अच्छे मानव-अनुकूल मूल्य उत्पन्न करता है। करने के लिए

select NEXT from KEY_ALLOC where SEQ=?; 
update KEY_ALLOC set NEXT=(old value+20) where SEQ=? and NEXT=(old value); 

यह कि इस सौदे के लिए प्रतिबद्ध कर सकते हैं प्रदान करना (उपयोग पुनर्प्रयास:

create table KEY_ALLOC (
    SEQ varchar(32) not null, 
    NEXT bigint not null, 
    primary key (SEQ) 
); 

अगले, कहते हैं, 20 चाबियाँ (जो तब की जरूरत के रूप में इस्तेमाल सर्वर & में एक सीमा के रूप में आयोजित की जाती हैं) का आवंटन करने के लिए विवाद को संभालें), आपने आवंटित 20 कुंजी & आवश्यकतानुसार उन्हें वितरित कर सकते हैं।

केवल 20 के एक खंड के आकार के साथ, यह योजना ओरेकल अनुक्रम से आवंटित करने से 10x तेज है, और सभी डेटाबेस के बीच 100% पोर्टेबल है। आवंटन प्रदर्शन हाय-लो के बराबर है।

अंबालर के विचार के विपरीत, यह कुंजीपटल को एक संगत रैखिक संख्या रेखा के रूप में मानता है।

यह समग्र कुंजी (जो वास्तव में कभी भी एक अच्छा विचार नहीं था) के लिए प्रोत्साहन से बचाता है और जब सर्वर पुनरारंभ होता है तो पूरे लो-शब्द को बर्बाद करने से बचा जाता है। यह "दोस्ताना", मानव-स्तर के प्रमुख मूल्य उत्पन्न करता है।

तुलनात्मक रूप से श्री अंबलर का विचार उच्च 16- या 32-बिट्स आवंटित करता है, और बड़े मानव-असंगत रूपों को उच्च-शब्द वृद्धि के रूप में उत्पन्न करता है।

आवंटित कुंजी की तुलना:

Linear_Chunk  Hi_Lo 
100    65536 
101    65537 
102    65538 
.. server restart 
120    131072 
121    131073 
122    131073 
.. server restart 
140    196608 

मैं वास्तव में 90 के दशक में वापस श्री Ambler साथ पत्राचार किया उसे करने के लिए इस सुधार योजना का सुझाव देना है, लेकिन वह भी फंस गया था & फायदे का उपयोग करने का & स्पष्ट सादगी स्वीकार करने के लिए जिद्दी एक रैखिक संख्या रेखा।

डिजाइन-वार, कोई समाधान तुलनात्मक लाभ प्राप्त करते समय Linear_Chunk की तुलना में उनका समाधान मूल रूप से संख्या-रेखा (समग्र कुंजी, बड़े hi_word उत्पादों) पर अधिक जटिल है। इस प्रकार उनका डिजाइन गणितीय साबित हुआ है।

Answer 4

हाय/लो एल्गोरिदम अनुक्रम डोमेन को "हाय" समूहों में विभाजित करता है। एक "हाय" मान तुल्यकालिक रूप से असाइन किया जाता है। प्रत्येक "हाय" समूह को "लो" प्रविष्टियों की अधिकतम संख्या दी जाती है, जो समवर्ती डुप्लिकेट प्रविष्टियों के बारे में चिंता किए बिना ऑफ-लाइन असाइन कर सकते हैं।

1. "हाय" टोकन डेटाबेस द्वारा असाइन किया गया है, और दो समवर्ती कॉल लगातार अनन्य मानों
2. एक बार एक "हाय" टोकन लिया गया है कि हम केवल "incrementSize" की जरूरत है (की संख्या को देखने के लिए गारंटी दी जाती है "लो" प्रविष्टियों)

3. पहचानकर्ता रेंज निम्नलिखित सूत्र द्वारा दिया जाता है:

   [(hi -1) * incrementSize) + 1, (hi * incrementSize) + 1) 
   

   और "लो" मूल्य रेंज में हो जाएगा:

   [0, incrementSize) 
   

   के शुरू होने से मूल्य से लागू किया जा रहा:

   [(hi -1) * incrementSize) + 1) 
   

4. जब सब "लो" मूल्यों उपयोग किया जाता है, एक नया "हाय" मूल्य प्राप्त किए गए है और चक्र जारी

आप this article में अधिक विस्तृत स्पष्टीकरण पा सकते हैं:

और यह दृश्य प्रस्तुति भी अनुसरण करना आसान है:

जबकि हाय/लो अनुकूलक पहचानकर्ता पीढ़ी के अनुकूलन के लिए ठीक है, यह अन्य प्रणालियों हमारे डेटाबेस में पंक्तियों डालने, हमारे पहचानकर्ता रणनीति के बारे में कुछ भी जानने के बिना साथ अच्छी तरह से नहीं चलता है।

हाइबरनेट pooled-lo ऑप्टिमाइज़र प्रदान करता है, जो इंटरऑपरेबिलिटी अनुक्रम आवंटन तंत्र के साथ एक हाय/लो जनरेटर रणनीति को जोड़ता है। यह ऑप्टिमाइज़र अन्य सिस्टम के साथ कुशल और अंतःक्रियाशील दोनों है, जो पिछले विरासत हाय/लो पहचानकर्ता रणनीति की तुलना में बेहतर उम्मीदवार है।

Answer 5

मैंने पाया कि हाय/लो एल्गोरिदम मेरे डेटाबेस में प्रतिकृति परिदृश्यों के साथ कई डेटाबेस के लिए एकदम सही है। इसकी कल्पना करें। आपके पास न्यूयॉर्क (एलियास 01) और लॉस एंजिल्स (उर्फ 02) में एक अन्य सर्वर है, तो आपके पास एक व्यक्तिगत तालिका है ... इसलिए न्यूयॉर्क में जब कोई व्यक्ति बना रहता है ... आप हमेशा HI के रूप में 01 का उपयोग करते हैं मूल्य और LO मान अगले संवादात्मक है। उदाहरण उदाहरण के लिए।

• 010000010 जेसन
• 010000011 डेविड
• 010000012 थियो

लॉस एंजिल्स में आप हमेशा उदाहरण के लिए HI 02 का उपयोग करें:

• 020000045 रूपर्ट
• 020000046 ओसवाल्ड
• 020,000,047 मारियो

तो, आप डुप्लिकेट प्राथमिक कुंजी, collissions, आदि

इस बारे में चिंता करने के बिना (कोई बात नहीं क्या ब्रांड) सभी प्राथमिक कुंजी और डेटा को आसानी से और स्वाभाविक रूप से गठबंधन डेटाबेस प्रतिकृति का उपयोग करते हैं इस परिदृश्य में जाने का सबसे अच्छा तरीका है।