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

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

अधीर के लिए GitHub लिंक

हमारा लक्ष्य प्रोग्रामर को संकलन चरण में त्रुटियों के एक विशिष्ट सबसेट को पकड़ने में मदद करना है। कोटलिन, एक दृढ़ता से टाइप की गई भाषा होने के नाते, हमें SQL क्वेरी की संरचना में अमान्य भावों से छुटकारा पाने में मदद करेगी। एक बोनस के रूप में, हमें अनुरोध लिखने में IDE से अधिक टाइपोस सुरक्षा मिलेगी और मदद मिलेगी। SQL दोषों को पूरी तरह से ठीक करना संभव नहीं है, लेकिन कुछ समस्या क्षेत्रों को ठीक करना काफी संभव है।

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

सिद्धांत की बिट

SQL स्ट्रक्चर्ड क्वेरी लैंग्वेज के लिए है, अर्थात प्रश्नों की संरचना मौजूद है, हालांकि वाक्य रचना खराब है - भाषा बनाई गई थी ताकि इसका उपयोग किसी भी उपयोगकर्ता द्वारा किया जा सके, जिसके पास प्रोग्रामिंग कौशल भी नहीं है।

हालांकि, एसक्यूएल के तहत संबंधपरक डेटाबेस के सिद्धांत के रूप में एक बल्कि शक्तिशाली नींव निहित है - वहां सब कुछ बहुत तार्किक है। प्रश्नों की संरचना को समझने के लिए, हम एक सरल चयन की ओर मुड़ते हैं:

SELECT id, name --  (projection), π(id, name) FROM employees --  (table) WHERE organization_id = 1 --    (predicate), σ(organization_id = 1) 

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

कोटलिन के लिए पोर्टिंग

इसलिए, FROM किसी अन्य क्वेरी भाषा के निर्माण के संबंध में प्राथमिक है। यह इस अभिव्यक्ति से है कि क्वेरी जारी रखने के लिए सभी संभव विकल्प उत्पन्न होते हैं। कोटलिन में, हम इसे (टी) फ़ंक्शन के माध्यम से दर्शाते हैं, जो एक इनपुट ऑब्जेक्ट लेगा, जो एक टेबल है जिसमें कॉलम का एक सेट है।

 object Employees : Table("employees") { val id = Column("id") val name = Column("name") val organizationId = Column("organization_id") } 

फ़ंक्शन एक ऑब्जेक्ट लौटाएगा जिसमें ऐसे तरीके शामिल हैं जो अनुरोध के संभावित निरंतरता को दर्शाते हैं। निर्माण से हमेशा किसी भी अन्य अभिव्यक्तियों से पहले पहले आता है, इसलिए इसमें अंतिम चयन (SQL के विपरीत, जहां SELECT हमेशा FROM से पहले आता है) सहित बड़ी संख्या में एक्सटेंशन शामिल हैं। ऊपर SQL क्वेरी के बराबर कोड इस तरह दिखेगा:

 from(Employees) .where { e -> e.organizationId eq 1 } .select { e -> e.id .. e.name } 

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

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

 fun where(predicate: (T) -> Predicate): WhereClause<T> fun select(projection: (T) -> Iterable<Projection>): SelectStatement<T> 

शामिल हों

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

 fun <T2: Table> join(table2: T2): JoinClause<T, T2> 

JOIN, इस मामले में, FROM अभिव्यक्ति द्वारा प्रदान की गई विधियों के समान तरीके होंगे, एकमात्र अंतर यह होगा कि प्रक्षेपण और विधेय लैम्ब्डा दोनों तालिकाओं के स्तंभों का उपयोग करने में सक्षम होने के लिए दो पैरामीटर लेंगे।

 from(Employees) .join(Organizations).on { e, o -> o.id eq e.organizationId } .where { e, o -> e.organizationId eq 1 } .select { e, o -> e.id .. e.name .. o.name } 

डेटा प्रबंधन

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

 from(Employees) .where { e -> e.id eq 1 } .update { e -> e.name("John Doe") } from(Employees) .where { e -> e.id eq 0 } .delete() into(Employees) .insert { e -> e.name("John Doe") .. e.organizationId(1) } 

डेटा विवरण

SQL तालिकाओं के रूप में संरचित डेटा के साथ काम करता है। उनके साथ काम करने से पहले तालिकाओं को एक विवरण की आवश्यकता होती है। भाषा के इस भाग को डेटा परिभाषा भाषा कहा जाता है।

क्रिएट टेबल और ड्रॉप टेबल स्टेटमेंट को समान रूप से लागू किया जाता है - ओवर फंक्शन शुरुआती बिंदु के रूप में काम करेगा।

 over(Employees) .create { integer(it.id).primaryKey(autoIncrement = true).. text(it.name).unique().notNull().. integer(it.organizationId).foreignKey(references = Organizations.id) } 

 over(Employees).drop() 

• कोड और प्रलेखन