लेन-देन

1. सौदा और डेटा संरचना की परिचय

सौदा डेटाबेस प्रबंधन प्रणाली की क्रियान्वयन प्रक्रिया में एक तार्किक इकाई है, जिसमें कई कार्यों की श्रृंखला होती है। ये कार्य सभी या पूर्णत: सफल होते हैं या सभी विफल होते हैं और इन्हें एक अविभाज्य पूरे के रूप में संज्ञान में लिया जाता है। सौदे की मुख्य विशेषताएँ ACID के रूप में संक्षेपित की जा सकती हैं:

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

डेटा संरचितता एक डेटाबेस में एक श्रृंखला के बाद सही और वैध डेटा स्थिति की रखरखाव को संदर्भित करती है। समकालिक पहुंच या सिस्टम विफलताओं के संदर्भ में, डेटा संरचनाता विशेषता से महत्वपूर्ण है, और सौदे की मदद से सुनिश्चित करता है कि डेटा संरचना को वादानियता पर गंभीर प्रभाव नहीं पड़ते हैं, विफलता या संघर्ष के संदर्भ में भी।

2. ent फ्रेमवर्क का अवलोकन

ent एक एंटिटी फ्रेमवर्क है जो गो प्रोग्रामिंग भाषा में कोड जनरेशन के माध्यम से, डेटाबेस को ऑपरेट करने के लिए एक टाइप सेफ API प्रदान करता है। इससे डेटाबेस के कार्यों को और सूजी और सुरक्षित बनाने में सक्षम होता है, जो सुरक्षा संबंधित मुद्दों जैसे SQL इंजेक्शन से बच सकता है। सौदे प्रसंस्करण के संदर्भ में, ent फ्रेमवर्क मजबूत समर्थन प्रदान करता है, जो विकसकों को संक्षेपित कोड के साथ जटिल सौदों के प्रसंस्करण को करने और सुनिश्चित करने की अनुमति देता है कि सौदा की ACID विशेषताएँ पाए जाते हैं।

3. सौदा प्रारंभ करना

3.1 ent में सौदा कैसे शुरू करें

ent फ्रेमवर्क में, दिए गए संरचना में client.Tx विधि का उपयोग करके आसानी से एक नया सौदा प्रारंभ किया जा सकता है, जो Tx सौदा ऑब्ज

5. ट्रांजैक्शनल क्लाइंट का उपयोग

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

// इस उदाहरण में, हम मूल Gen फ़ंक्शन को एक लेन-देन के भीतर आवरण करते हैं।
func WrapGen(ctx context.Context, client *ent.Client) error {
    // पहले, एक लेन-देन बनाएं
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // लेन-देन से लेन-देन वाली क्लाइंट प्राप्त करें
    txClient := tx.Client()
    // मूल जेन फ़ंक्शन को लेन-देन वाले क्लाइंट का उपयोग करके निष्पादित करें, मूल जेन कोड को बदलाव किए बिना
    if err := Gen(ctx, txClient); err != nil {
        // यदि कोई त्रुटि होती है, तो लेन-देन को वापस ले लें
        return rollback(tx, err)
    }
    // सफल होने पर, लेन-देन को कमिट करें
    return tx.Commit()
}

ऊपर के कोड में, ट्रांजैक्शनल क्लाइंट tx.Client() का उपयोग किया गया है, जिससे मूल Gen फ़ंक्शन को लेन-देन की गारंटी के तहत निष्पादित किया जा सकता है। यह उपाय हमें मूल तार्किक परिणाम पर न्यूनतम प्रभाव डालते हुए मौजूदा बिना लेन-देन वाले कोड को आसानी से लेन-देन वाले कोड में बदलने में सहायक होता है।

6. लेन-देन के लिए सर्वोत्तम प्रथाएँ

6.1 कॉलबैक फ़ंक्शन के साथ लेन-देन का प्रबंधन

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

func WithTx(ctx context.Context, client *ent.Client, fn func(tx *ent.Tx) error) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    // पन्नी और रिकवर का उपयोग करके संभावित पैनिक स्थितियों को संभालने के लिए
    defer func() {
        if v := recover(); v != nil {
            tx.Rollback()
            panic(v)
        }
    }()
    // अनुपलब्ध कॉलबैक फ़ंक्शन को बुलाने के लिए प्रदत्त कॉलबैक फ़ंक्शन को कॉल करें ताकि व्यावसायिक तार्किकता निष्पादित की जा सके
    if err := fn(tx); err != nil {
        // त्रुटि के मामले में, लेन-देन को वापस ले लें
        if rerr := tx.Rollback(); rerr != nil {
            err = fmt.Errorf("%w: rolling back transaction: %v", err, rerr)
        }
        return err
    }
    // यदि व्यावसायिक तार्किकता में कोई त्रुटि ना हो, तो लेन-देन को कमिट करें
    return tx.Commit()
}

WithTx फ़ंक्शन का उपयोग व्यावसायिक तार्किकता को आवरणित करने के लिए करके, हम सुनिश्चित कर सकते हैं कि यदि व्यावसायिक तार्किकता के भीतर त्रुटियाँ या अप्रत्याशित परिस्थितियाँ होती हैं, तो लेन-देन सही ढंग से संभाला जाएगा (संशोधित या वापस लिया जाएगा)।

6.2 लेन-देन हुक्स का उपयोग

स्कीमा हुक्स और रनटाइम हुक्स की तरह, हम सक्रिय लेन-देन (Tx) के भीतर हुक्स पंजीकृत कर सकते हैं जो Tx.Commit या Tx.Rollback पर क्रियाशील होंगे।

func Do(ctx context.Context, client *ent.Client) error {
    tx, err := client.Tx(ctx)
    if err != nil {
        return err
    }
    tx.OnCommit(func(next ent.Committer) ent.Committer {
        return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
            // लेन-देन को कमिट करने से पहले तार्किकता
            err := next.Commit(ctx, tx)
            // लेन-देन को कमिट करने के बाद तार्किकता
            return err
        })
    })
    tx.OnRollback(func(next ent.Rollbacker) ent.Rollbacker {
        return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
            // लेन-देन को रोलबैक करने से पहले तार्किकता
            err := next.Rollback(ctx, tx)
            // लेन-देन को रोलबैक करने के बाद तार्किकता
            return err
        })
    })
    // अन्य व्यावसायिक तार्किकता निष्पादित करें
    //
    // 
    //
    return err
}

लेन-देन को कमिट और रोलबैक के दौरान हुक्स जोड़कर, हम अतिरिक्त तार्किकता जैसे की लॉगिंग या संसाधन सफाई जैसी क्रियाएँ संभाल सकते हैं।

7. विभिन्न लेनदार विचलन स्तरों को समझना

डेटाबेस सिस्टम में, लेनदार विचलन स्तर सेट करना विभिन्न समक्रमण समस्याओं (जैसे कि गंदा पढ़ाई, गैर-पुनरावृत्ति पढ़ाई और प्रतिभूत पढ़ाई) से बचने के लिए महत्वपूर्ण है। यहां कुछ मानक विचलन स्तर हैं और उन्हें ent फ्रेमवर्क में कैसे सेट किया जाए, इसके बारे में:

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

ent में, अगर डेटाबेस ड्राइवर ट्रांजैक्शन विचलन स्तर सेट करने का समर्थन करता है, तो इसे निम्नलिखित रूप में सेट किया जा सकता है:

// लेनदार विचलन स्तर को पुनरावृत्ति समर्थित पढ़ाई पर सेट करें
tx, err := client.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelRepeatableRead})

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