टारनटूल डीबीएमएस में उच्च स्तरीय प्रतिकृति

नमस्ते, मैं DBMS के लिए एप्लिकेशन बना रहा हूं टारनटूल Mail.ru ग्रुप द्वारा विकसित एक प्लेटफ़ॉर्म है जो उच्च-प्रदर्शन DBMS और लुआ भाषा में एक एप्लिकेशन सर्वर को जोड़ता है। टारनटूल पर आधारित समाधानों की उच्च गति, विशेष रूप से, डीबीएमएस के इन-मेमोरी मोड के लिए समर्थन और डेटा के साथ एकल एड्रेस स्पेस में एप्लिकेशन बिजनेस लॉजिक को निष्पादित करने की क्षमता के कारण हासिल की जाती है। उसी समय, ACID लेनदेन का उपयोग करके डेटा दृढ़ता सुनिश्चित की जाती है (डिस्क पर एक WAL लॉग बनाए रखा जाता है)। टारनटूल में प्रतिकृति और शार्डिंग के लिए अंतर्निहित समर्थन है। संस्करण 2.1 से प्रारंभ होकर, SQL भाषा में क्वेरीज़ समर्थित हैं। टारनटूल खुला स्रोत है और सरलीकृत बीएसडी लाइसेंस के तहत लाइसेंस प्राप्त है। इसका एक व्यावसायिक एंटरप्राइज़ संस्करण भी है।

शक्ति महसूस करें! (...उर्फ प्रदर्शन का आनंद लें)

उपरोक्त सभी टारनटूल को डेटाबेस के साथ काम करने वाले उच्च-लोड एप्लिकेशन बनाने के लिए एक आकर्षक मंच बनाते हैं। ऐसे अनुप्रयोगों में, अक्सर डेटा प्रतिकृति की आवश्यकता होती है।

जैसा कि ऊपर बताया गया है, टारनटूल में अंतर्निहित डेटा प्रतिकृति है। इसके संचालन का सिद्धांत मास्टर लॉग (वाल) में निहित सभी लेनदेन को प्रतिकृतियों पर क्रमिक रूप से निष्पादित करना है। आमतौर पर ऐसी प्रतिकृति (हम इसे आगे कहेंगे कम स्तर) का उपयोग एप्लिकेशन दोष सहनशीलता सुनिश्चित करने और/या क्लस्टर नोड्स के बीच रीडिंग लोड वितरित करने के लिए किया जाता है।

चावल। 1. एक क्लस्टर के भीतर प्रतिकृति

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

1. यातायात बचत:

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

2. HTTP एक्सचेंज को लागू करने में कोई कठिनाई नहीं है, जो आपको दूरस्थ डेटाबेस को सिंक्रनाइज़ करने की अनुमति देता है।

चावल। 2. HTTP पर प्रतिकृति

3. डेटाबेस संरचनाएं जिनके बीच डेटा स्थानांतरित किया जाता है, समान नहीं होनी चाहिए (इसके अलावा, सामान्य स्थिति में, विभिन्न डीबीएमएस, प्रोग्रामिंग भाषाओं, प्लेटफार्मों आदि का उपयोग करना भी संभव है)।

चावल। 3. विषमांगी प्रणालियों में प्रतिकृति

नकारात्मक पक्ष यह है कि, औसतन, प्रोग्रामिंग कॉन्फ़िगरेशन की तुलना में अधिक कठिन/महंगी है, और अंतर्निहित कार्यक्षमता को अनुकूलित करने के बजाय, आपको अपना स्वयं का कार्यान्वयन करना होगा।

यदि आपकी स्थिति में उपरोक्त लाभ महत्वपूर्ण हैं (या एक आवश्यक शर्त हैं), तो उच्च-स्तरीय प्रतिकृति का उपयोग करना समझ में आता है। आइए टारनटूल डीबीएमएस में उच्च-स्तरीय डेटा प्रतिकृति को लागू करने के कई तरीकों पर गौर करें।

यातायात न्यूनीकरण

तो, उच्च-स्तरीय प्रतिकृति के फायदों में से एक ट्रैफ़िक बचत है। इस लाभ को पूरी तरह से महसूस करने के लिए, प्रत्येक विनिमय सत्र के दौरान स्थानांतरित किए गए डेटा की मात्रा को कम करना आवश्यक है। बेशक, हमें यह नहीं भूलना चाहिए कि सत्र के अंत में, डेटा रिसीवर को स्रोत के साथ सिंक्रनाइज़ किया जाना चाहिए (कम से कम डेटा के उस हिस्से के लिए जो प्रतिकृति में शामिल है)।

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

एक अन्य समाधान, कार्यान्वयन की दृष्टि से अधिक जटिल, डेटा की प्राप्ति को स्वीकार करना है। इस मामले में, प्रत्येक विनिमय सत्र के दौरान, सभी डेटा प्रसारित किया जाता है, जिसकी प्राप्ति की पुष्टि प्राप्तकर्ता द्वारा नहीं की गई है। इसे लागू करने के लिए, आपको स्रोत तालिका में एक बूलियन कॉलम जोड़ना होगा (उदाहरण के लिए, is_transferred). यदि प्राप्तकर्ता रिकॉर्ड की प्राप्ति की पुष्टि करता है, तो संबंधित फ़ील्ड मान लेता है true, जिसके बाद प्रविष्टि अब एक्सचेंजों में शामिल नहीं है। इस कार्यान्वयन विकल्प के निम्नलिखित नुकसान हैं. सबसे पहले, स्थानांतरित किए गए प्रत्येक रिकॉर्ड के लिए, एक पावती तैयार की जानी चाहिए और भेजी जानी चाहिए। मोटे तौर पर कहें तो, यह स्थानांतरित किए गए डेटा की मात्रा को दोगुना करने और राउंडट्रिप की संख्या को दोगुना करने के बराबर हो सकता है। दूसरे, एक ही रिकॉर्ड को कई प्राप्तकर्ताओं को भेजने की कोई संभावना नहीं है (प्राप्त करने वाला पहला रिसीवर अपने लिए और अन्य सभी के लिए रसीद की पुष्टि करेगा)।

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

आप पिछले दृष्टिकोण में थोड़ा सुधार करके डेटा स्थानांतरण की दक्षता में सुधार कर सकते हैं। ऐसा करने के लिए, हम परिवर्तनों को ट्रैक करने के लिए कॉलम फ़ील्ड मान के रूप में पूर्णांक प्रकार (लंबे पूर्णांक) का उपयोग करेंगे। आइए कॉलम को नाम दें row_ver. जब भी कोई रिकॉर्ड बनाया/संशोधित किया जाता है, तब भी इस कॉलम का फ़ील्ड मान सेट/अपडेट किया जाना चाहिए। लेकिन इस मामले में, फ़ील्ड को वर्तमान दिनांक-समय नहीं सौंपा जाएगा, बल्कि कुछ काउंटर का मान, एक से बढ़ा दिया जाएगा। परिणामस्वरूप, स्तंभ row_ver इसमें अद्वितीय मान शामिल होंगे और इसका उपयोग न केवल "डेल्टा" डेटा (पिछले विनिमय सत्र के अंत के बाद से जोड़ा/बदला गया डेटा) प्रदर्शित करने के लिए किया जा सकता है, बल्कि इसे आसानी से और प्रभावी ढंग से पृष्ठों में विभाजित करने के लिए भी किया जा सकता है।

उच्च-स्तरीय प्रतिकृति के ढांचे के भीतर स्थानांतरित डेटा की मात्रा को कम करने की अंतिम प्रस्तावित विधि मुझे सबसे इष्टतम और सार्वभौमिक लगती है। आइए इसे और अधिक विस्तार से देखें।

पंक्ति संस्करण काउंटर का उपयोग करके डेटा पास करना

सर्वर/मास्टर भाग का कार्यान्वयन

MS SQL सर्वर में, इस दृष्टिकोण को लागू करने के लिए एक विशेष कॉलम प्रकार है - rowversion. प्रत्येक डेटाबेस में एक काउंटर होता है जो हर बार एक कॉलम वाली तालिका में कोई रिकॉर्ड जोड़ने/बदलने पर एक काउंटर बढ़ जाता है rowversion. इस काउंटर का मान स्वचालित रूप से जोड़े गए/परिवर्तित रिकॉर्ड में इस कॉलम के फ़ील्ड को असाइन किया गया है। टारनटूल डीबीएमएस में समान अंतर्निहित तंत्र नहीं है। हालाँकि, टारनटूल में इसे मैन्युअल रूप से लागू करना मुश्किल नहीं है। आइए देखें कि यह कैसे किया जाता है।

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

टारनटूल में कोई भी डेटाबेस ऑपरेशन करने से पहले, आपको निम्नलिखित कमांड चलाने की आवश्यकता है:

box.cfg{}

परिणामस्वरूप, टारनटूल वर्तमान निर्देशिका में डेटाबेस स्नैपशॉट और लेनदेन लॉग लिखना शुरू कर देगा।

चलिए एक क्रम बनाते हैं row_version:

box.schema.sequence.create('row_version',
    { if_not_exists = true })

विकल्प if_not_exists निर्माण स्क्रिप्ट को कई बार निष्पादित करने की अनुमति देता है: यदि ऑब्जेक्ट मौजूद है, तो टारनटूल इसे दोबारा बनाने का प्रयास नहीं करेगा। इस विकल्प का उपयोग बाद के सभी DDL कमांड में किया जाएगा।

आइए उदाहरण के तौर पर एक स्थान बनाएं।

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        },
        {
            name = 'row_ver',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

यहां हमने स्पेस का नाम सेट किया है (goods), फ़ील्ड नाम और उनके प्रकार।

टारनटूल में ऑटो-इंक्रीमेंटिंग फ़ील्ड भी अनुक्रमों का उपयोग करके बनाई जाती हैं। आइए फ़ील्ड के अनुसार एक स्वत: वृद्धिशील प्राथमिक कुंजी बनाएं id:

box.schema.sequence.create('goods_id',
    { if_not_exists = true })
box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

टारनटूल कई प्रकार के इंडेक्स का समर्थन करता है। सबसे अधिक उपयोग किए जाने वाले सूचकांक TREE और HASH प्रकार हैं, जो नाम के अनुरूप संरचनाओं पर आधारित होते हैं। TREE सबसे बहुमुखी सूचकांक प्रकार है। यह आपको व्यवस्थित तरीके से डेटा पुनर्प्राप्त करने की अनुमति देता है। लेकिन समानता चयन के लिए, HASH अधिक उपयुक्त है। तदनुसार, प्राथमिक कुंजी के लिए HASH का उपयोग करना उचित है (हमने यही किया)।

कॉलम का उपयोग करने के लिए row_ver परिवर्तित डेटा को स्थानांतरित करने के लिए, आपको अनुक्रम मानों को इस कॉलम के फ़ील्ड से बांधना होगा row_ver. लेकिन प्राथमिक कुंजी के विपरीत, कॉलम फ़ील्ड मान row_ver न केवल नए रिकॉर्ड जोड़ते समय, बल्कि मौजूदा रिकॉर्ड बदलते समय भी एक की वृद्धि होनी चाहिए। इसके लिए आप ट्रिगर्स का उपयोग कर सकते हैं। टारनटूल में दो प्रकार के स्पेस ट्रिगर हैं: before_replace и on_replace. जब भी अंतरिक्ष में डेटा बदलता है तो ट्रिगर सक्रिय हो जाते हैं (परिवर्तनों से प्रभावित प्रत्येक टुपल के लिए, एक ट्रिगर फ़ंक्शन लॉन्च किया जाता है)। भिन्न on_replace, before_replace-ट्रिगर आपको उस टुपल के डेटा को संशोधित करने की अनुमति देते हैं जिसके लिए ट्रिगर निष्पादित किया गया है। तदनुसार, अंतिम प्रकार के ट्रिगर्स हमारे लिए उपयुक्त हैं।

box.space.goods:before_replace(function(old, new)
    return box.tuple.new({new[1], new[2], new[3],
        box.sequence.row_version:next()})
end)

निम्नलिखित ट्रिगर फ़ील्ड मान को प्रतिस्थापित करता है row_ver अनुक्रम के अगले मान के लिए संग्रहीत टुपल row_version.

अंतरिक्ष से डेटा निकालने में सक्षम होने के लिए goods कॉलम द्वारा row_verआइए एक इंडेक्स बनाएं:

box.space.goods:create_index('row_ver', {
    parts = { 'row_ver' },
    unique = true,
    type = 'TREE',
    if_not_exists = true
})

सूचकांक प्रकार - वृक्ष (TREE), क्योंकि हमें कॉलम में मानों के आरोही क्रम में डेटा निकालने की आवश्यकता होगी row_ver.

आइए अंतरिक्ष में कुछ डेटा जोड़ें:

box.space.goods:insert{nil, 'pen', 123}
box.space.goods:insert{nil, 'pencil', 321}
box.space.goods:insert{nil, 'brush', 100}
box.space.goods:insert{nil, 'watercolour', 456}
box.space.goods:insert{nil, 'album', 101}
box.space.goods:insert{nil, 'notebook', 800}
box.space.goods:insert{nil, 'rubber', 531}
box.space.goods:insert{nil, 'ruler', 135}

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

आइए सम्मिलन परिणाम की जाँच करें:

tarantool> box.space.goods:select()
---
- - [1, 'pen', 123, 1]
  - [2, 'pencil', 321, 2]
  - [3, 'brush', 100, 3]
  - [4, 'watercolour', 456, 4]
  - [5, 'album', 101, 5]
  - [6, 'notebook', 800, 6]
  - [7, 'rubber', 531, 7]
  - [8, 'ruler', 135, 8]
...

जैसा कि आप देख सकते हैं, पहला और आखिरी फ़ील्ड स्वचालित रूप से भर जाता है। अब पेज-दर-पेज स्थान परिवर्तन अपलोड करने के लिए फ़ंक्शन लिखना आसान हो जाएगा goods:

local page_size = 5
local function get_goods(row_ver)
    local index = box.space.goods.index.row_ver
    local goods = {}
    local counter = 0
    for _, tuple in index:pairs(row_ver, {
        iterator = 'GT' }) do
        local obj = tuple:tomap({ names_only = true })
        table.insert(goods, obj)
        counter = counter + 1
        if counter >= page_size then
            break
        end
    end
    return goods
end

फ़ंक्शन एक पैरामीटर के रूप में मान लेता है row_ver, जहां से परिवर्तनों को अनलोड करना आवश्यक है, और बदले हुए डेटा का एक हिस्सा लौटाता है।

टारनटूल में डेटा सैंपलिंग इंडेक्स के माध्यम से की जाती है। समारोह get_goods सूचकांक द्वारा एक पुनरावर्तक का उपयोग करता है row_ver परिवर्तित डेटा प्राप्त करने के लिए. इटरेटर प्रकार जीटी (ग्रेटर दैन, ग्रेटर दैन) है। इसका मतलब यह है कि पुनरावर्तक क्रमिक रूप से पारित कुंजी (फ़ील्ड मान) से शुरू होने वाले सूचकांक मानों को पार करेगा row_ver).

पुनरावर्तक टुपल्स लौटाता है। बाद में HTTP के माध्यम से डेटा स्थानांतरित करने में सक्षम होने के लिए, टुपल्स को बाद के क्रमांकन के लिए सुविधाजनक संरचना में परिवर्तित करना आवश्यक है। उदाहरण इसके लिए मानक फ़ंक्शन का उपयोग करता है tomap. के बजाय का उपयोग करने का tomap आप अपना स्वयं का फ़ंक्शन लिख सकते हैं. उदाहरण के लिए, हम किसी फ़ील्ड का नाम बदलना चाह सकते हैं name, मैदान से न गुजरें code और एक फ़ील्ड जोड़ें comment:

local function unflatten_goods(tuple)
    local obj = {}
    obj.id = tuple.id
    obj.goods_name = tuple.name
    obj.comment = 'some comment'
    obj.row_ver = tuple.row_ver
    return obj
end

आउटपुट डेटा का पृष्ठ आकार (एक भाग में रिकॉर्ड की संख्या) चर द्वारा निर्धारित किया जाता है page_size. उदाहरण में मान page_size 5 है। एक वास्तविक कार्यक्रम में, पृष्ठ का आकार आमतौर पर अधिक मायने रखता है। यह स्पेस टुपल के औसत आकार पर निर्भर करता है। डेटा स्थानांतरण समय को मापकर इष्टतम पृष्ठ आकार अनुभवजन्य रूप से निर्धारित किया जा सकता है। पृष्ठ का आकार जितना बड़ा होगा, भेजने और प्राप्त करने वाले पक्षों के बीच राउंडट्रिप की संख्या उतनी ही कम होगी। इस तरह आप परिवर्तनों को डाउनलोड करने का कुल समय कम कर सकते हैं। हालाँकि, यदि पृष्ठ का आकार बहुत बड़ा है, तो हम नमूने को क्रमबद्ध करने वाले सर्वर पर बहुत अधिक समय व्यतीत करेंगे। परिणामस्वरूप, सर्वर पर आने वाले अन्य अनुरोधों को संसाधित करने में देरी हो सकती है। पैरामीटर page_size कॉन्फ़िगरेशन फ़ाइल से लोड किया जा सकता है. प्रत्येक संचरित स्थान के लिए, आप अपना स्वयं का मान निर्धारित कर सकते हैं। हालाँकि, अधिकांश स्थानों के लिए डिफ़ॉल्ट मान (उदाहरण के लिए, 100) उपयुक्त हो सकता है।

आइए फ़ंक्शन निष्पादित करें get_goods:

tarantool> get_goods(0)

---
- - row_ver: 1
    code: 123
    name: pen
    id: 1
  - row_ver: 2
    code: 321
    name: pencil
    id: 2
  - row_ver: 3
    code: 100
    name: brush
    id: 3
  - row_ver: 4
    code: 456
    name: watercolour
    id: 4
  - row_ver: 5
    code: 101
    name: album
    id: 5
...

आइए फ़ील्ड मान लें row_ver अंतिम पंक्ति से और फ़ंक्शन को दोबारा कॉल करें:

tarantool> get_goods(5)

---
- - row_ver: 6
    code: 800
    name: notebook
    id: 6
  - row_ver: 7
    code: 531
    name: rubber
    id: 7
  - row_ver: 8
    code: 135
    name: ruler
    id: 8
...

एक बार फिर:

tarantool> get_goods(8)
---
- []
...

जैसा कि आप देख सकते हैं, जब इस तरह से उपयोग किया जाता है, तो फ़ंक्शन सभी स्पेस रिकॉर्ड पेज दर पेज लौटाता है goods. अंतिम पृष्ठ के बाद एक खाली चयन है।

आइए अंतरिक्ष में परिवर्तन करें:

box.space.goods:update(4, {{'=', 6, 'copybook'}})
box.space.goods:insert{nil, 'clip', 234}
box.space.goods:insert{nil, 'folder', 432}

हमने फ़ील्ड मान बदल दिया है name एक प्रविष्टि के लिए और दो नई प्रविष्टियाँ जोड़ी गईं।

आइए अंतिम फ़ंक्शन कॉल को दोहराएं:

tarantool> get_goods(8)
---



- - row_ver: 9
    code: 800
    name: copybook
    id: 6
  - row_ver: 10
    code: 234
    name: clip
    id: 9
  - row_ver: 11
    code: 432
    name: folder
    id: 10
...

फ़ंक्शन ने बदले हुए और जोड़े गए रिकॉर्ड लौटा दिए। तो समारोह get_goods आपको वह डेटा प्राप्त करने की अनुमति देता है जो उसकी अंतिम कॉल के बाद से बदल गया है, जो कि विचाराधीन प्रतिकृति पद्धति का आधार है।

हम इस लेख के दायरे से बाहर JSON के रूप में HTTP के माध्यम से परिणाम जारी करना छोड़ देंगे। आप इसके बारे में यहां पढ़ सकते हैं: https://habr.com/ru/company/mailru/blog/272141/

ग्राहक/दास भाग का कार्यान्वयन

आइए देखें कि प्राप्तकर्ता पक्ष का कार्यान्वयन कैसा दिखता है। आइए डाउनलोड किए गए डेटा को संग्रहीत करने के लिए प्राप्तकर्ता पक्ष पर एक स्थान बनाएं:

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

स्थान की संरचना स्रोत में स्थान की संरचना से मिलती जुलती है। लेकिन चूंकि हम प्राप्त डेटा को कहीं और नहीं भेजने जा रहे हैं, इसलिए कॉलम row_ver प्राप्तकर्ता के स्थान में नहीं है. खेत मेँ id स्रोत पहचानकर्ताओं को रिकॉर्ड किया जाएगा. इसलिए, रिसीवर की ओर से इसे ऑटो-इंक्रीमेंट करने की कोई आवश्यकता नहीं है।

इसके अतिरिक्त, हमें मूल्यों को सहेजने के लिए एक स्थान की आवश्यकता है row_ver:

box.schema.space.create('row_ver', {
    format = {
        {
            name = 'space_name',
            type = 'string'

        },
        {
            name = 'value',
            type = 'string'

        }
    },
    if_not_exists = true
})

box.space.row_ver:create_index('primary', {
    parts = { 'space_name' },
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

प्रत्येक लोड किए गए स्थान के लिए (फ़ील्ड space_name) हम यहां अंतिम लोड किए गए मान को सहेजेंगे row_ver (मैदान value). कॉलम प्राथमिक कुंजी के रूप में कार्य करता है space_name.

आइए स्पेस डेटा लोड करने के लिए एक फ़ंक्शन बनाएं goods HTTP के माध्यम से. ऐसा करने के लिए, हमें एक लाइब्रेरी की आवश्यकता है जो HTTP क्लाइंट को लागू करे। निम्न पंक्ति लाइब्रेरी को लोड करती है और HTTP क्लाइंट को इंस्टेंट करती है:

local http_client = require('http.client').new()

हमें json डिसेरिएलाइज़ेशन के लिए एक लाइब्रेरी की भी आवश्यकता है:

local json = require('json')

यह डेटा लोडिंग फ़ंक्शन बनाने के लिए पर्याप्त है:

local function load_data(url, row_ver)
    local url = ('%s?rowVer=%s'):format(url,
        tostring(row_ver))
    local body = nil
    local data = http_client:request('GET', url, body, {
        keepalive_idle =  1,
        keepalive_interval = 1
    })
    return json.decode(data.body)
end

फ़ंक्शन यूआरएल पते पर एक HTTP अनुरोध निष्पादित करता है और इसे भेजता है row_ver एक पैरामीटर के रूप में और अनुरोध का डिसेरिएलाइज़्ड परिणाम लौटाता है।

प्राप्त डेटा को सहेजने का फ़ंक्शन इस तरह दिखता है:

local function save_goods(goods)
    local n = #goods
    box.atomic(function()
        for i = 1, n do
            local obj = goods[i]
            box.space.goods:put(
                obj.id, obj.name, obj.code)
        end
    end)
end

अंतरिक्ष में डेटा सहेजने का चक्र goods लेन-देन में रखा गया (इसके लिए फ़ंक्शन का उपयोग किया जाता है box.atomic) डिस्क संचालन की संख्या को कम करने के लिए।

अंत में, स्थानीय स्थान सिंक्रनाइज़ेशन फ़ंक्शन goods किसी स्रोत के साथ आप इसे इस प्रकार कार्यान्वित कर सकते हैं:

local function sync_goods()
    local tuple = box.space.row_ver:get('goods')
    local row_ver = tuple and tuple.value or 0

    —— set your url here:
    local url = 'http://127.0.0.1:81/test/goods/list'

    while true do
        local goods = load_goods(url, row_ver)

        local count = #goods
        if count == 0 then
            return
        end

        save_goods(goods)

        row_ver = goods[count].rowVer
        box.space.row_ver:put({'goods', row_ver})
    end
end

सबसे पहले हम पहले से सहेजे गए मान को पढ़ते हैं row_ver जगह के लिए goods. यदि यह गायब है (पहला विनिमय सत्र), तो हम इसे मान लेते हैं row_ver शून्य। अगले चक्र में हम निर्दिष्ट यूआरएल पर स्रोत से परिवर्तित डेटा का पृष्ठ-दर-पृष्ठ डाउनलोड करते हैं। प्रत्येक पुनरावृत्ति पर, हम प्राप्त डेटा को उचित स्थानीय स्थान पर सहेजते हैं और मान को अपडेट करते हैं row_ver (अंतरिक्ष में row_ver और चर में row_ver) - मान लें row_ver लोड किए गए डेटा की अंतिम पंक्ति से.

आकस्मिक लूपिंग (प्रोग्राम में त्रुटि के मामले में) से बचाने के लिए, लूप while से बदला जा सकता है for:

for _ = 1, max_req do ...

फ़ंक्शन निष्पादित करने के परिणामस्वरूप sync_goods अंतरिक्ष goods रिसीवर में सभी अंतरिक्ष रिकॉर्ड के नवीनतम संस्करण होंगे goods स्रोत में.

जाहिर है, डेटा डिलीट को इस तरह प्रसारित नहीं किया जा सकता। यदि ऐसी कोई आवश्यकता मौजूद है, तो आप विलोपन चिह्न का उपयोग कर सकते हैं। स्थान में जोड़ें goods बूलियन फ़ील्ड is_deleted और किसी रिकॉर्ड को भौतिक रूप से हटाने के बजाय, हम तार्किक विलोपन का उपयोग करते हैं - हम फ़ील्ड मान निर्धारित करते हैं is_deleted अर्थ में true. कभी-कभी बूलियन फ़ील्ड के बजाय is_deleted फ़ील्ड का उपयोग करना अधिक सुविधाजनक है deleted, जो रिकॉर्ड के तार्किक विलोपन की तारीख-समय को संग्रहीत करता है। तार्किक विलोपन करने के बाद, विलोपन के लिए चिह्नित रिकॉर्ड को स्रोत से गंतव्य तक स्थानांतरित कर दिया जाएगा (ऊपर चर्चा किए गए तर्क के अनुसार)।

अनुक्रम row_ver अन्य स्थानों से डेटा संचारित करने के लिए उपयोग किया जा सकता है: प्रत्येक प्रेषित स्थान के लिए एक अलग अनुक्रम बनाने की कोई आवश्यकता नहीं है।

हमने टारनटूल डीबीएमएस का उपयोग करके अनुप्रयोगों में उच्च-स्तरीय डेटा प्रतिकृति का एक प्रभावी तरीका देखा।

निष्कर्ष

1. टारनटूल डीबीएमएस उच्च-लोड एप्लिकेशन बनाने के लिए एक आकर्षक, आशाजनक उत्पाद है।
2. निम्न-स्तरीय प्रतिकृति की तुलना में उच्च-स्तरीय डेटा प्रतिकृति के कई फायदे हैं।
3. लेख में चर्चा की गई उच्च-स्तरीय प्रतिकृति विधि आपको केवल उन रिकॉर्डों को स्थानांतरित करके स्थानांतरित डेटा की मात्रा को कम करने की अनुमति देती है जो पिछले विनिमय सत्र के बाद से बदल गए हैं।

स्रोत: www.habr.com