Jooq - जावा के लिए "LINQ", जावा कोड में एक प्रकार का सुरक्षित SQL क्वेरी बिल्डर

हाल ही में, JDBC और ORM के बीच एक मध्य मैदान की तलाश में , मैं एक दिलचस्प ओपन सोर्स लाइब्रेरी ( अपाचे सॉफ्टवेयर लाइसेंस ) के साथ आया, जिसके साथ आप SQL कोड को सीधे जावा कोड में काफी आसानी से और सुरक्षित रूप से बना सकते हैं। पुस्तकालय को जूक कहा जाता है। जूक में एक कोड जनरेटर शामिल है जो आपके डेटाबेस की संरचना को पार्स करता है और आवश्यक जावा कक्षाएं बनाता है। वास्तव में, आपको इस कोड जैसा कुछ मिलता है:

Integer taskId = sqlFactory.select(ID).from(TASK).where(STATUS.equal(TaskStatus.QUEUED)). orderBy(LAST_UPDATED).limit(1).fetchOne(ID); 

जैसा कि आप देख सकते हैं, एक क्वेरी का निर्माण करना और इसे सरल प्रकारों के लिए निष्पादित करना एक पंक्ति लेता है। Jooq के बारे में थोड़ा सा:

हमारे साथ क्या अच्छा है?

• MySQL 5.1.41 / 5.5.8, Oracle XE 10.2.0.1.0, DB2 9.7, PostGreSQL 9.0, H2 1.3.154, HSQLDB 2.1.0, SQLite, डर्बी 10.7 का समर्थन करें
• समर्थन Sybase, MSSQL, Ingres, Firebird के लिए योजना बनाई है
• न केवल तालिकाओं / क्षेत्रों के लिए, बल्कि विचारों, संग्रहीत कार्यविधियों, UDF, MySQL में ENUM जैसे जटिल प्रकारों के लिए कोड बनाने के लिए समर्थन, बूँद (आप नियमित बाइट के रूप में उनका प्रतिनिधित्व कर सकते हैं]]
• चूँकि संपूर्ण डेटाबेस स्कीमा को वर्गों द्वारा दर्शाया जाता है, भाषा IDE में स्वतः पूर्ण का निर्माण करती है
• कोई SQL इंजेक्शन भेद्यता जब ठीक से उपयोग किया जाता है - jooq प्रश्नों में पैरामीटर टेम्पलेट का उपयोग करता है
• अधिकांश भाग डेटाबेस के लिए स्वतंत्र वाक्यविन्यास
• जेनेरिक प्रकारों का उपयोग कोड संकलित करते समय भी पर्याप्त संख्या में चेक प्रदान करता है। साथ ही, यदि आपने डेटाबेस तालिका में किसी कॉलम का नाम बदल दिया है, तो किसी भी कोड को ठीक करना भूलना असंभव है। डेटाबेस के बार-बार पार्स करने के बाद, गलत कोड बस संकलन नहीं करता है
• मूल ActiveRecord समर्थन (डेटाबेस से प्राप्त रिकॉर्ड को बदला जा सकता है और एक या दो पंक्तियों में वापस लिखा जा सकता है)
• न केवल चयनित प्रश्नों का समर्थन करें, बल्कि INSERT, UPDATE का भी समर्थन करें।
• नेस्टेड प्रश्नों, मनमाने फ़ील्ड्स, कुल फ़ंक्शंस, UNION क्वेरीज़, अंकगणित और अन्य कार्यों के लिए समर्थन
• क्वेरी निष्पादन के परिणाम प्राप्त करने के लिए सुविधाजनक तरीके हैं- fetch (), fetchAny (), fetchLazy (), fetchMap () और अन्य।
• आंतरिक Jooq डिवाइस की रूपरेखा सहित, अच्छा SLF4J समर्थन।
• बहुत सारी चीजों की योजना बनाई
• लेखक इंटरनेट पर लगातार है, बहुत जल्दी jooq Google समूह में और बग ट्रैकर में टिकट पर सवालों के जवाब देता है।
• मावेन का समर्थन। Jooq वितरण Maven Central के माध्यम से उपलब्ध हैं।
• दोनों डीएसएल सिंटैक्स (चयन) (से।) (कहां) () कहां निर्माण और ओओपी (एक = नई एरी (), a.addSelect (); a.addFrom ()) के लिए समर्थन।
• क्वेरी परिणाम और क्वेरी ऑब्जेक्ट स्वयं सीरियल करने योग्य हैं।

इसमें हमारा क्या कसूर है?

• जबकि कुछ विशिष्ट भाषा सुविधाओं के लिए कोई सीधा समर्थन नहीं है, जैसे "UPDATE" या "अनुक्रमणिका उपयोग संकेत" का चयन SELECT में करता है। लेकिन वर्कअराउंड है ।
• यदि आप एक ही कक्षा में एक से अधिक टेबल के साथ काम करते हैं, तो स्थैतिक आयात करना कुछ मामलों में उपयोग करना मुश्किल है, जो क्वेरी उपस्थिति की कुछ जटिलता की ओर जाता है (ऊपर दिए गए एक के संबंध में उदाहरण)

 Integer taskId = sqlFactory.select(Task.ID).from(Task.TASK).where(Task.STATUS.equal(TaskStatus.QUEUED)). orderBy(Task.LAST_UPDATED).limit(1).fetchOne(Task.ID); 

• प्रश्नों को निष्पादित करते समय और परिणाम को क्रॉल करते समय एक छोटा ओवरहेड (मुझे लगता है कि यह छोटा है, दसियों से सैकड़ों माइक्रोसेकंड, शायद)?
• MySQL में LAST_INSERT_ID () के लिए कोई तत्काल समर्थन नहीं है । लेकिन वर्कअराउंड है । अनुक्रम समर्थित हैं ।

आत्मीयता

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

 Field<Integer> jobTypeCountField = Job.JOBTYPE_ID.count().as("JOBTYPE_ID_COUNT"); Result<Record> jobTypeCountRecord = null; jobTypeCountRecord = sqlFactory.select(Job.JOBTYPE_ID, jobTypeCountField).from(Job.JOB) .where(Job.STATUS.equal(JobStatus.EXECUTING)).groupBy(Job.JOBTYPE_ID).fetch(); for (Record record : jobTypeCountRecord) { System.out.println(record.getValue(Job.JOBTYPE_ID) + " - " - record.getValue(jobTypeCountField)); } 

हालाँकि, इस विषय पर राय अलग हो सकती है। ऐसा कोड किसी को अधिक समझ में आएगा।

• संस्करण 2.0 में, बहुत दिलचस्प बन्स की योजना बनाई गई है।
• नॉन-विकी डॉक्यूमेंटेशन (Trac) और उस पर सुविधाजनक नेविगेशन भी नहीं। हालांकि, Ctrl-Q द्वारा सब कुछ समझने के लिए javadoc कोड में पर्याप्त है। हालाँकि, मुझे लगता है कि Trac बहुत सुविधाजनक नहीं है, इसलिए मुझे गलती लगती है ...
• अब तक, उपयोगकर्ताओं की अपेक्षाकृत कम संख्या।

जौक एनालॉग्स

• Querydsl
• SQL निर्माण किट (इसके लिए कोई दस्तावेज नहीं मिला)

अधिक एनालॉग, थोड़ी अलग योजना

• JPQL
• JaQu
• HQL

संपर्क विवरण:

• परियोजना की वेबसाइट - http://www.jooq.org
• मैनुअल: http://sourceforge.net/apps/trac/jooq/wiki/Manual
• फोरम - http://groups.google.com/group/jooq-user
• SVN जानकारी: https://sourceforge.net/scm/?type=svn&group_id=283484

जूक स्रोत से कुछ उदाहरण (MySQL में info_schema डेटाबेस के साथ काम करना)

शायद Geshi से वाक्य रचना हाइलाइटिंग के साथ यहां के उदाहरणों को देखना बेहतर है।

  select(KeyColumnUsage.CONSTRAINT_NAME, KeyColumnUsage.TABLE_NAME, KeyColumnUsage.COLUMN_NAME) .from(KEY_COLUMN_USAGE).join(TABLE_CONSTRAINTS) .on(KeyColumnUsage.TABLE_SCHEMA.equal(TableConstraints.TABLE_SCHEMA)) .and(KeyColumnUsage.TABLE_NAME.equal(TableConstraints.TABLE_NAME)) .and(KeyColumnUsage.CONSTRAINT_NAME.equal(TableConstraints.CONSTRAINT_NAME)) .where(TableConstraints.CONSTRAINT_TYPE.equal(constraintType)) .and(KeyColumnUsage.TABLE_SCHEMA.equal(getSchemaName())) .orderBy(KeyColumnUsage.TABLE_NAME.ascending(), KeyColumnUsage.ORDINAL_POSITION.ascending()).fetch() 

  for (Record record : create().select( ReferentialConstraints.CONSTRAINT_NAME, ReferentialConstraints.TABLE_NAME, ReferentialConstraints.REFERENCED_TABLE_NAME, ReferentialConstraints.UNIQUE_CONSTRAINT_NAME, KeyColumnUsage.COLUMN_NAME) .from(REFERENTIAL_CONSTRAINTS) .join(KEY_COLUMN_USAGE) .on(ReferentialConstraints.CONSTRAINT_SCHEMA.equal(KeyColumnUsage.CONSTRAINT_SCHEMA)) .and(ReferentialConstraints.CONSTRAINT_NAME.equal(KeyColumnUsage.CONSTRAINT_NAME)) .where(ReferentialConstraints.CONSTRAINT_SCHEMA.equal(getSchemaName())) .orderBy( KeyColumnUsage.CONSTRAINT_NAME.ascending(), KeyColumnUsage.ORDINAL_POSITION.ascending()) .fetch()) { String foreignKey = record.getValue(ReferentialConstraints.CONSTRAINT_NAME); String foreignKeyColumn = record.getValue(KeyColumnUsage.COLUMN_NAME); String foreignKeyTableName = record.getValue(ReferentialConstraints.TABLE_NAME); String referencedKey = record.getValue(ReferentialConstraints.UNIQUE_CONSTRAINT_NAME); String referencedTableName = record.getValue(ReferentialConstraints.REFERENCED_TABLE_NAME); TableDefinition foreignKeyTable = getTable(foreignKeyTableName); if (foreignKeyTable != null) { ColumnDefinition column = foreignKeyTable.getColumn(foreignKeyColumn); String key = getKeyName(referencedTableName, referencedKey); relations.addForeignKey(foreignKey, key, column); } }