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

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

वास्तविक विश्व उपयोग का मामला

वॉंट में, हमने हाल ही में कॉकरोचडीबी से टीआईडीबी में डेटाबेस माइग्रेशन किया है। जबकि कॉकरोचडीबी प्रदर्शनशील और विश्वसनीय था, हमें अंततः OLAP डेटाबेस का समर्थन करने के लिए अपने टेकस्टैक में जोड़ने के निर्णय का सामना करना पड़ा। इसकी आवश्यकता हमारे ओपन सोर्स सामुदायिक अंतर्दृष्टि उत्पाद पर हमारे विश्लेषणात्मक कार्यभार का समर्थन करने के लिए थी। अपनी प्रौद्योगिकी पदचिह्न को छोटा रखने के लिए, हमने TiDB के साथ आगे बढ़ने और डेटाबेस के HTAP आर्किटेक्चर का लाभ उठाने का निर्णय लिया। 

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

प्रदर्शन

स्क्विरल के रीडमी में, एक उदाहरण है कि आप वैकल्पिक फ़िल्टर के साथ कथनों को अद्यतन करने के लिए सशर्त क्वेरी बिल्डिंग का उपयोग कैसे कर सकते हैं:

if len(q) > 0 {
    users = users.Where("name LIKE ?", fmt.Sprint("%", q, "%"))
}

यहां एक वास्तविक, लेकिन सरलीकृत उदाहरण है कि कैसे हमने अपनी एक क्वेरी को सशर्त रूप से तालिकाओं में शामिल करने और एक वैकल्पिक फ़िल्टर जोड़ने के लिए अपडेट किया:

psql := squirrel.StatementBuilder.PlaceholderFormat(squirrel.Question)

statementBuilder := psql.Select(`i.id`).
From("vaunt.installations i").
Where(`entity_name = ?`, name)

if len(provider) > 0 {
    statementBuilder.Where(`provider = ?`, provider)
}

if len(repo) > 0 {
    statementBuilder.Join(`repositories as r on JSON_CONTAINS(i.repositories, CONCAT('["', r.id, '"]'))`)
    statementBuilder.Where(`r.name = ?`, repo)
}

क्या आप कोड के साथ समस्या का पता लगा सकते हैं? यदि नहीं, तो चिंता न करें—यह कुछ ऐसा है जो हमारे अपने कोड समीक्षाओं में भी तब तक फिसलता रहा जब तक हमने अपना परीक्षण नहीं चलाया। 

यहाँ मुद्दा यह है कि हम स्टेटमेंट बिल्डर को बिल्डर फ़ंक्शंस के परिणाम के साथ अपडेट करना भूल गए हैं। उदाहरण के लिए, प्रदाता स्थिति फ़िल्टर को इसके बजाय पढ़ना चाहिए:

if len(provider) > 0 {
    statementBuilder = statementBuilder.Where(`provider = ?`, provider)
}

यह एक अपेक्षाकृत सरल गलती है और इसे पर्याप्त परीक्षण मामलों में आसानी से पकड़ा जा सकता है, लेकिन क्योंकि यह तकनीकी रूप से अमान्य कोड नहीं है, इसलिए तुरंत यह समझने में थोड़ा समय लग सकता है कि क्या हो रहा है।

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

टीक्यूएलए का उपयोग करना

स्क्विरल का उपयोग करते हुए उपरोक्त प्रदर्शन को फिर से लिखा गया है, और tqla में समतुल्य इस तरह दिखता है:

t, err := tqla.New(tqla.WithPlaceHolder(tqla.Question))
if err != nil {
    return nil, err
}

query, args, err := t.Compile(`
    SELECT i.id
    FROM vaunt.installations as i
    {{ if .Repo }}
    JOIN vaunt.repositories as r on JSON_CONTAINS(i.repositories, CONCAT('["', r.id, '"]'), '$')
    {{ end }}
    WHERE entity_name = {{ .Name}}
    {{ if .Provider }}
    AND i.provider = {{ .Provider }}
    {{ end }}
    {{ if .Repo }}
    AND r.name = {{ .Repo }}
    {{ end }}
    `, data)
if err != nil {
    return nil, err
}

जैसा कि आप देख सकते हैं, tqla के लिए टेम्पलेट सिंटैक्स सशर्त खंडों को शामिल करना बहुत सरल बनाता है। Tqla स्वचालित रूप से हमारे द्वारा सेट किए जा रहे वेरिएबल्स को हमारे निर्दिष्ट प्लेसहोल्डर्स के साथ बदल देता है और वे तर्क प्रदान करता है जिनका उपयोग हम स्टेटमेंट को निष्पादित करने के लिए अपने sql ड्राइवर के साथ कर सकते हैं।

स्क्विरल के समान, इस स्टेटमेंट बिल्डिंग दृष्टिकोण का परीक्षण करना आसान है, क्योंकि हम टेम्पलेट बिल्डर को पास करने और आउटपुट को मान्य करने के लिए डेटा ऑब्जेक्ट के विभिन्न सेट बना सकते हैं।

आप देख सकते हैं कि हम आसानी से क्वेरी के सशर्त टुकड़े जोड़ने में सक्षम हैं जहां वे सबसे उपयुक्त होंगे। उदाहरण के लिए, यहां हमारे पास FROM स्टेटमेंट के ठीक बाद एक सशर्त JOIN है - और हालांकि हमारे पास अभी भी कई कंडीशन चेक हैं, यह टेम्पलेट को अधिक जटिल नहीं बनाता है।

कस्टम कार्य

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

यहां एक उदाहरण दिया गया है कि कैसे हमने गोलांग के समय को परिवर्तित करने के लिए एक फ़ंक्शन का उपयोग किया। समय मान को एक sql.NullTime में परिवर्तित करने के लिए हमें अपने डेटा ऑब्जेक्ट के साथ इसे पहले से परिवर्तित करने की आवश्यकता के बिना सम्मिलित करने की अनुमति दी गई है:

funcs := template.FuncMap{
    "time": func(t time.Time) sql.NullTime {
        if t.IsZero() {
            return sql.NullTime{Valid: false}
        }
        return sql.NullTime{Time: t, Valid: true}
    },
}

t, err := tqla.New(tqla.WithPlaceHolder(tqla.Question), tqla.WithFuncMap(funcs))
if err != nil {
    return err
}

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

यहां एक सरलीकृत उदाहरण दिया गया है:

statement, args, err := t.Compile(`
    INSERT INTO events
        (name, created_at, merged_at, closed_at)
    VALUES ( 
        {{ .Name }},
        {{ time .CreatedAt }},
        {{ time .MergedAt }},
        {{ time .ClosedAt }}
    )`, eventData)

निष्कर्ष

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

हमने इस लाइब्रेरी को साझा करने के लिए tqla ओपन सोर्स बनाया है, इस उम्मीद में कि यह कई अलग-अलग प्रकार के अनुप्रयोगों में एसक्यूएल क्वेरीज़ बनाने का एक सरल, रखरखाव योग्य और सुरक्षित तरीका चाहने वाले अन्य उपयोगकर्ताओं के लिए एक अच्छा विकल्प प्रदान करता है।

यदि आप रुचि रखते हैं, तो कृपया रिपॉजिटरी की जांच करें और अगर यह किसी भी तरह से आपकी मदद करता है तो इसे एक स्टार दें। कोई भी सुविधा अनुरोध या बग रिपोर्ट करने के लिए स्वतंत्र महसूस करें!

हम फीडबैक और योगदान प्राप्त करने के लिए हमेशा खुले हैं।

भविष्य के विकास से जुड़े रहने के लिए, हमें एक्स पर फ़ॉलो करें या हमारे डिस्कोर्ड में शामिल हों!