ग्रीनपीग डेटाबेस सहायक

1. प्रविष्टि
2. लाइब्रेरी कनेक्शन
3. कक्षा कहाँ
   
   • अनुरोध का परमाणु भाग
   • जटिल क्वेरी
4. कक्षा में शामिल हों
5. कक्षा की क्वेरी
   
   • नेस्टेड मापदंडों के साथ एक डेटाबेस से चयन
   • खोज के नाम पर अपने आप से कई मिलन

╔═══╗╔═══╗╔═══╗╔═══╗╔╗─╔╗────╔═══╗╔══╗╔═══╗ ║╔══╝║╔═╗║║╔══╝║╔══╝║╚═╝║────║╔═╗║╚╗╔╝║╔══╝ ║║╔═╗║╚═╝║║╚══╗║╚══╗║╔╗─║────║╚═╝║─║║─║║╔═╗ ║║╚╗║║╔╗╔╝║╔══╝║╔══╝║║╚╗║────║╔══╝─║║─║║╚╗║ ║╚═╝║║║║║─║╚══╗║╚══╗║║─║║────║║───╔╝╚╗║╚═╝║ ╚═══╝╚╝╚╝─╚═══╝╚═══╝╚╝─╚╝────╚╝───╚══╝╚═══╝ 5HHHG HH HHHHHHH 9HHHA HHHHHHHH5 HHHHHHHHHHHHHHHHHH 9HHHHH5 5HHHHHHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHHHHHHH ;HHHHHHHHHHHHHHHHHHHHHHHHHHA H2 HHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHHHH9 HHHHHHHHHHHHHHHHHHHHHHH AHHHHHHHHHHHHHHHHHHHHHH HHHHHHHHHHHHHHHHHHHHH9 iHS HHHHHHHHHHHHHHHHHHHHHHhh HHHHHHHHHHHHHHHHHH AA HHHHHHHHHHHHHH3 &H Hi HS Hr & H& H& Hi 

प्रविष्टि

मैं आपको php में अपनी छोटी सी लाइब्रेरी के विकास के बारे में बताना चाहता हूँ। वह किन कार्यों को हल करता है? मैंने इसे लिखने का फैसला क्यों किया और यह आपके लिए उपयोगी क्यों हो सकता है? खैर इन सवालों के जवाब देने की कोशिश करते हैं।

ग्रीनपीग (इसके बाद जीपी ) एक छोटा डेटाबेस सहायक है जो आपके द्वारा उपयोग किए जाने वाले किसी भी php ढांचे की कार्यक्षमता को पूरक कर सकता है।

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

लेकिन इस दृष्टिकोण के साथ, यह सवाल उठता है: उपयोगकर्ता द्वारा जानकारी के लिए खोज करने पर एसक्यूएल क्वेरी का हिस्सा कहाँ उत्पन्न होता है? जीपी का उद्देश्य है, सबसे पहले, php के माध्यम से सुविधाजनक संकलन पर, जहां किसी भी जटिलता का अनुरोध।

लेकिन क्या मुझे इस पुस्तकालय को लिखने के लिए प्रेरित किया (सिवाय, दिलचस्प अनुभव प्राप्त करने के लिए)? ये तीन चीजें हैं:

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

 [ [0] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [1] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [2] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ], [3] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [4] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [5] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [6] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [7] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [8] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [9] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 10 ['name'] => ' ' ['value'] => 5 ], [10] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 8 ['name'] => ' ()' ['value'] => 0.12 ], [11] => [ ['id'] => 4 ['type'] => 'phone' ['val_id'] => 9 ['name'] => '   ' ['value'] => 1 ], [12] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [13] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [14] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ], [15] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 1 ['name'] => ' ()' ['value'] => 790 ], [16] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 2 ['name'] => '   ' ['value'] => 24 ], [17] => [ ['id'] => 1 ['type'] => 'car' ['val_id'] => 3 ['name'] => ' ' ['value'] => 75 ] ] 

एक पेड़ के समान सरणी प्राप्त करने के लिए, हमें परिणाम को वांछित रूप में स्वयं लाने की आवश्यकता है, या प्रत्येक उत्पाद के लिए एन डेटाबेस प्रश्न बनाएं। और अगर हमें छँटाई की जरूरत है, और छँटाई के साथ भी? जीपी इन समस्याओं को हल करने में सक्षम है। यहाँ जीपी के साथ नमूने का एक उदाहरण है:

 [ [1] => [ ['prod_type'] => 'car' ['properties'] => [ [1] => [ ['name'] => ' ()' ['value'] => 790 ] [2] => [ ['name'] => '   ' ['value'] => 24 ] [3] => [ ['name'] => ' ' ['value'] => 75 ] ] ] [4] => [ ['prod_type'] => 'phone' ['properties'] => [ [10] => [ ['name'] => ' ' ['value'] => 5 ] [8] => [ ['name'] => ' ()' ['value'] => 0.12 ] [9] => [ ['name'] => '   ' ['value'] => 1 ] ] ] ] 

और निश्चित रूप से एक ही समय में सुविधाजनक पेजेशन और सॉर्टिंग: ->pagination(1, 10)->sort('id') ।

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

और अंत में, यह सब Oracle डेटाबेस और mySql दोनों के लिए काम करना चाहिए। प्रलेखन में वर्णित कई विशेषताएं भी हैं।

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

स्वयं पुस्तकालय और उदाहरणों की एक परीक्षा के लिए सीधे आगे बढ़ने से पहले, मैं कहूंगा कि विस्तृत विवरण के बिना केवल सार होगा। यदि आप रुचि रखते हैं कि जीपी कैसे काम करता है, तो आप प्रलेखन को देख सकते हैं, इसमें मैंने सब कुछ विस्तार से समझाने की कोशिश की।

लाइब्रेरी कनेक्शन

संगीतकार के माध्यम से पुस्तकालय स्थापित किया जा सकता है: composer require falbin/green-pig-dao

फिर आपको एक कारखाना लिखने की आवश्यकता है जिसके माध्यम से आप इस पुस्तकालय का उपयोग करेंगे।

कक्षा कहाँ

इस वर्ग का उपयोग करते हुए, आप किसी भी जटिलता के sql क्वेरी के भाग का संकलन कर सकते हैं।

अनुरोध का परमाणु भाग

किसी क्वेरी के सबसे छोटे, परमाणु भाग पर विचार करें। यह एक सरणी द्वारा वर्णित है: [, , ]
उदाहरण: ['name', 'like', '%%']

• सरणी का पहला तत्व सिर्फ एक स्ट्रिंग है, जिसे बदलाव के बिना sql क्वेरी में डाला गया है, और इसलिए, आप इसमें sql फ़ंक्शन लिख सकते हैं। उदाहरण: ['LOWER(name)', 'like', '%%']
• दूसरा तत्व भी दो ऑपरेंड के बीच बदलाव के बिना एसक्यूएल में डाला गया एक स्ट्रिंग है। यह निम्नलिखित मान ले सकता है: =,>, <,> =, <=, <>, जैसे, बीच में नहीं, बीच में नहीं, जैसे, में नहीं ।
• सरणी का तीसरा तत्व या तो संख्यात्मक या स्ट्रिंग प्रकार हो सकता है। जहाँ वर्ग स्वतः उत्पन्न उपनाम को sql क्वेरी में स्थानापन्न कर देगा।
• Sql कुंजी के साथ ऐरे तत्व। कभी-कभी यह आवश्यक होता है कि मूल्य परिवर्तन के बिना sql कोड में डाला जाता है। उदाहरण के लिए, कार्यों को लागू करने के लिए। इसे 'sql' को कुंजी (3 तत्व के लिए) के रूप में निर्दिष्ट करके प्राप्त किया जा सकता है। उदाहरण: ['LOWER(name)', 'like', 'sql' => "LOWER('$name')"]
• बाँध कुंजी के साथ एक सरणी तत्व बाँध के भंडारण के लिए एक सरणी है। उपरोक्त उदाहरण सुरक्षा के दृष्टिकोण से गलत है। आप चर में वर्ग को सम्मिलित नहीं कर सकते - यह बहुत अधिक इंजेक्शन है। इसलिए, इस मामले में, आपको अपने आप को उपनाम निर्दिष्ट करने की आवश्यकता होगी, उदाहरण के लिए: ['LOWER(name)', 'like', 'sql' => "LOWER(:name)", 'bind'=> ['name' => $name] ]
• ऑपरेटर को इस तरह लिखा जा सकता है: ['curse', 'not in', [1, 3, 5]] । द क्लास ने इस तरह के प्रवेश को निम्नलिखित एसक्यूएल कोड में बदल दिया है: curse not in (:al_where_jCgWfr95kh, :al_where_mCqefr95kh, :al_where_jCfgfr9Gkh)
• इस कथन को इस तरह लिखा जा सकता है: ['curse', ' between', 1, 5] । निम्न वर्ग कोड में इस तरह के प्रवेश को कहां वर्ग परिवर्तित करता है: के curse between :al_where_Pi4CRr4xNn and :al_where_WiPPS4NKiG
  लेकिन सावधान रहें, यदि सरणी के तीसरे और चौथे तत्व तार हैं, तो विशेष तर्क लागू किया जाता है। इस मामले में, यह माना जाता है कि चयन एक तिथि सीमा से होता है और, इसलिए, स्ट्रिंग को किसी दिनांक में कास्टिंग करने के sql फ़ंक्शन का उपयोग किया जाता है। किसी दिनांक (mySql और Oracle में अलग-अलग वाले) को परिवर्तित करने का कार्य और इसके मापदंडों को सेटिंग्स की एक सरणी (प्रलेखन में अधिक) से लिया गया है। सरणी ['build_date', 'between', '01.01.2016', '01.01.2019'] को sql में परिवर्तित किया जाएगा: build_date between TO_DATE(:al_where_fkD7nZg5lU, 'dd.mm.yyyy hh24:mi::ss') and TO_DATE(:al_where_LdyVRznPF8, 'dd.mm.yyyy hh24:mi::ss')

जटिल क्वेरी

चलो कारखाने के माध्यम से वर्ग का एक उदाहरण बनाते हैं: $wh = GP::where();

अनुरोध के "परमाणु भागों" के बीच तार्किक कनेक्शन को इंगित करने के लिए, आपको linkAnd() या linkOr() फ़ंक्शन का उपयोग करना होगा। एक उदाहरण:

 // sql: (old > 18 and old < 50) $wh->linkAnd([ ['old', '<', 18], ['old', '>', 50] ]); // sql: (old < 18 or old > 50) $wh->linkOr([ ['old', '<', 18], ['old', '>', 50] ]); 

जब linkAnd / linkOr फ़ंक्शंस का उपयोग कर रहे हों, तो सभी डेटा को जहाँ - $ wh वर्ग की आवृत्ति के अंदर संग्रहीत किया जाता है। साथ ही, फ़ंक्शन में इंगित सभी "परमाणु भागों" को ब्रैकेट किया गया है ।

किसी भी जटिलता के Sql को तीन कार्यों द्वारा वर्णित किया जा सकता है: linkAnd(), linkOr(), getRaw() । एक उदाहरण पर विचार करें:

 // sql: curse = 1 and (old < 18 or old > 50) $wh->linkAnd([ ['curse', '=', 1], $wh->linkOr([ ['old', '<', 18], ['old', '>', 50] ])->getRaw() ]); 

जहाँ कक्षा में एक निजी चर होता है जो कच्ची अभिव्यक्ति को संग्रहीत करता है। linkAnd() और linkOr() विधियाँ इस चर को अधिलेखित करती हैं, इसलिए, एक तार्किक अभिव्यक्ति का निर्माण करते समय, विधियों को एक साथ linkOr() बनाया जाता है और चर के साथ चर में अंतिम निष्पादित विधि से प्राप्त डेटा होता है।

जॉय क्लास

ज्वाइन एक वर्ग है जो sql कोड के एक संयुक्त टुकड़े को उत्पन्न करता है। चलो कारखाने के माध्यम से कक्षा का एक उदाहरण बनाते हैं: $jn = GP::leftJoin('coursework', 'student_id', 's.id') , जहाँ:

• coursework वह तालिका है जिसमें हम शामिल होंगे।
• student_id - coursework टेबल से एक विदेशी कुंजी वाला एक कॉलम।
• s.id - तालिका के स्तंभ जिसके साथ जुड़ना चाहिए, तालिका के उपनाम के साथ लिखा जाना चाहिए (इस मामले में, तालिका का उपनाम s है)।

जनरेटेड sql: left JOIN coursework coursework_joM9YuTTfW ON coursework_joM9YuTTfW.student_id = s.id

कक्षा का एक उदाहरण बनाते समय, हमने पहले से ही तालिकाओं में शामिल होने के लिए स्थिति का वर्णन किया था, लेकिन स्थिति को स्पष्ट और विस्तारित करने के लिए आवश्यक हो सकता है। LinkAnd / linkOr फ़ंक्शंस आपको ऐसा करने में मदद करेगी: $jn->linkAnd(['semester_number', '>', 2])

उत्पन्न inner JOIN coursework coursework_Nd1n5T7c0r ON coursework_Nd1n5T7c0r.student_id = s.id and (semester_number > :al_where_M1kEcHzZyy) : inner JOIN coursework coursework_Nd1n5T7c0r ON coursework_Nd1n5T7c0r.student_id = s.id and (semester_number > :al_where_M1kEcHzZyy)

यदि इसमें शामिल होने के लिए कई टेबल हैं, तो आप उन्हें एक कक्षा में जोड़ सकते हैं: CollectionJoin ।

कक्षा की क्वेरी

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

एक विशिष्ट उदाहरण पर विचार करें।

चलो कारखाने के माध्यम से वर्ग का एक उदाहरण बनाते हैं: $qr = GP::query();

अब हम sql टेम्पलेट सेट करेंगे, दिए गए परिदृश्य के लिए आवश्यक मानों को sql टेम्पलेट में स्थानापन्न करेंगे और कहेंगे कि हम एक रिकॉर्ड प्राप्त करना चाहते हैं, और विशेष रूप से औसत_मार्क कॉलम से डेटा।

 $rez = $qr->sql("select /*select*/ from student s inner join mark m on s.id = m.student_id inner join lesson l on l.id = m.lesson_id /*where*/ /*group*/") ->sqlPart('/*select*/', 's.name, avg(m.mark) average_mark', []) ->whereAnd('/*where*/', ['s.id', '=', 1]) ->sqlPart('/*group*/', 'group by s.name', []) ->one('average_mark'); 

परिणाम: 3,16666666666666666666666666666666666667

नेस्टेड मापदंडों के साथ एक डेटाबेस से चयन

सबसे अधिक, मेरे पास डेटाबेस से ट्री व्यू में संलग्न गुणों के साथ चयन करने का अवसर नहीं था। इसलिए, जीपी लाइब्रेरी में ऐसा अवसर है, और घोंसले की गहराई सीमित नहीं है।

ऑपरेशन के सिद्धांत पर विचार करने का सबसे आसान तरीका एक उदाहरण पर आधारित है। विचार के लिए, हम निम्नलिखित डेटाबेस स्कीमा लेते हैं :

तालिका सामग्री:

अक्सर, जब एक डेटाबेस को क्वेरी करते हैं, तो आप एक पेड़ की तरह प्राप्त करना चाहते हैं, एक सपाट जवाब नहीं। उदाहरण के लिए, इस क्वेरी को चलाकर:

 SELECT s.id, s.name, c.id title_id, c.title FROM student s INNER JOIN coursework c ON c. student_id = s.id WHERE s.id = 3 

हमें एक सपाट परिणाम मिलता है:

 [ 0 => [ 'id' => 3, 'name' => '', 'title_id' => 6, 'title' => '«»    ', ], 1=> [ 'id' => 3, 'name' => '', 'title_id' => 7, 'title' => '  ' ] ] 

जीपी का उपयोग करके, आप यह परिणाम प्राप्त कर सकते हैं:

 [ 3 => [ 'name' => '', 'courseworks' => [ 6 => ['title' => '«»    '], 7 => ['title' => '  '] ] ] ] 

इस परिणाम को प्राप्त करने के लिए, आपको all फ़ंक्शन के विकल्प के साथ एक सरणी पास करनी होगी (फ़ंक्शन सभी क्वेरी लाइनों को लौटाता है):

 all([ 'id'=> 'pk', 'name' => 'name', 'courseworks' => [ 'title_id' => 'pk', 'title' => 'title' ] ]) 

फ़ंक्शंस एग्रीगेटर में $option सरणी ( $option , $ रॉडेटा) और सभी ( $options ) निम्न कार्यों के अनुसार बनाया गया है:

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

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

 SELECT s.id student_id, s.name student_name, s.semester_number, c.id coursework_id, c.semester_number coursework_semester, c.title coursework_title, l.id lesson_id, l.name lesson, m.id mark_id, m.mark FROM student s LEFT JOIN coursework c ON c.student_id = s.id LEFT JOIN mark m ON m.student_id = s.id LEFT JOIN lesson l ON l.id = m.lesson_id ORDER BY s.id, c.id, l.id, m.id 

परिणाम हमें शोभा नहीं देता:

कार्य को प्राप्त करने के लिए, आपको निम्नलिखित $option सारणी लिखने की आवश्यकता है:

 $option = [ 'student_id' => 'pk', 'student_name' => 'name', 'courseworks' => [ 'coursework_semester' => 'pk', 'coursework_title' => 'title' ], 'lessons' => [ 'lesson_id' => 'pk', 'lesson' => 'lesson', 'marks' => [ 'mark_id' => 'pk', 'mark' => 'mark' ] ] ]; 

डेटाबेस क्वेरी:

 //    Query   .       // (    yii2) $qr = Yii::$app->gp->query( "SELECT s.id student_id, s.name student_name, s.semester_number, c.id coursework_id, c.semester_number coursework_semester, c.title coursework_title, l.id lesson_id, l.name lesson, m.id mark_id, m.mark FROM student s LEFT JOIN coursework c ON c.student_id = s.id LEFT JOIN mark m ON m.student_id = s.id LEFT JOIN lesson l ON l.id = m.lesson_id ORDER BY s.id, c.id, l.id, m.id"); //   1,  2   3  //  1 $result = $qr->all($option); //  2 $result = $qr->aggregator($option, $qr->all()); //  3 $qr->all(); $result = $qr->aggregator($option, $qr->rawData()); 

aggregator फ़ंक्शन किसी भी सरणी को डेटाबेस क्वेरी के परिणाम के समान संरचना के साथ संसाधित कर सकता है, $option में वर्णित नियमों के अनुसार।

$result चर में निम्नलिखित डेटा शामिल हैं:

 [ 1 => [ 'name' => '', 'courseworks' => [ 1 => ['title' => '    '], ], 'lessons' => [ 1 => [ 'lesson' => '', 'marks' => [ 1 => ['mark' => 3], 2 => ['mark' => 4] ] ], 2 => [ 'lesson' => '', 'marks' => [ 3 => ['mark' => 2], 4 => ['mark' => 2], 5 => ['mark' => 3] ] ], 4 => [ 'lesson' => '', 'marks' => [ 6 => ['mark' => 5] ] ] ] ], 3 => [ 'name' => '', 'courseworks' => [ 1 => ['title' => '«»    '], 2 => ['title' => '  '] ], 'lessons' => [ 1 => [ 'lesson' => '', 'marks' => [ 17 => ['mark' => 5] ] ], 2 => [ 'lesson' => '', 'marks' => [ 18 => ['mark' => 2] ] ], 3 => [ 'lesson' => '-', 'marks' => [ 20 => ['mark' => 4] ] ], 4 => [ 'lesson' => '', 'marks' => [ 16 => ['mark' => 2], 19 => ['mark' => 3] ] ], ] ] ] 

वैसे, समग्र क्वेरी के साथ पृष्ठांकन के साथ, केवल शीर्ष, सबसे बुनियादी डेटा माना जाता है। उपर्युक्त उदाहरण में, पृष्ठन के लिए केवल 2 रेखाएँ होंगी।

खोज के नाम पर अपने आप से कई मिलन

जैसा कि मैंने पहले लिखा था, मेरी लाइब्रेरी का मुख्य कार्य चुनिंदा प्रश्नों के लिए भागों की पीढ़ी को सरल बनाना है। तो जिस स्थिति में हमें उस क्वेरी के लिए बार-बार एक ही तालिका में शामिल होने की आवश्यकता हो सकती है? विकल्पों में से एक तब होता है जब हमारे पास एक निश्चित उत्पाद होता है, जिसके गुण पहले से ज्ञात नहीं होते हैं और उन्हें उपयोगकर्ताओं द्वारा जोड़ा जाएगा, और हमें इन गतिशील गुणों द्वारा उत्पादों की खोज करने का अवसर दिया जाना चाहिए। एक सरल उदाहरण के साथ समझाने का सबसे आसान तरीका।

मान लीजिए कि हमारे पास कंप्यूटर घटकों की बिक्री करने वाला एक ऑनलाइन स्टोर है, और हमारे पास एक सख्त वर्गीकरण नहीं है, और हम समय-समय पर एक घटक या किसी अन्य को खरीदेंगे। लेकिन हम अपने सभी उत्पादों को एक इकाई के रूप में वर्णित करना चाहते हैं और सभी उत्पादों की खोज करना चाहते हैं। तो, व्यावसायिक तर्क के दृष्टिकोण से किन संस्थाओं को अलग किया जा सकता है:

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

ऊपर वर्णित व्यापार तर्क के सभी नीचे की छवि में विस्तार से परिलक्षित होता है।

उदाहरण के लिए, हमारे पास एक उत्पाद है: 16 जीबी डीडीआर 3 रैम । आरेख पर इसे इस तरह प्रदर्शित किया जा सकता है:

डेटाबेस की संरचना और डेटा निम्नलिखित आंकड़ों में स्पष्ट रूप से दिखाई देते हैं:

जैसा कि हम आरेख से देखते हैं, सभी गुणों के सभी मूल्य एक वैल टेबल में संग्रहीत किए जाते हैं (वैसे, हमारे सरलीकृत संस्करण में, सभी गुणों में संख्यात्मक मान हैं)। इसलिए, अगर हम AND के एक समूह के साथ कई गुणों के लिए एक साथ खोजना चाहते हैं, तो हमें एक खाली चयन मिलता है।

उदाहरण के लिए, एक खरीदार ऐसे अनुरोध के लिए उपयुक्त उत्पादों की तलाश में है: मेमोरी की मात्रा 10 जीबी से अधिक होनी चाहिए और फॉर्म फैक्टर 2.5 इंच होना चाहिए । यदि हम नीचे दिखाए अनुसार sql लिखते हैं, तो हमें एक खाली चयन मिलता है:

 select * from product p inner join val v on v.product_id = p.id where (v.property_id = 1 and v.value > 10) AND (v.property_id = 3 and v.value = 2.5) 

चूंकि सभी गुणों के मूल्यों को एक तालिका में संग्रहीत किया जाता है, कई गुणों की खोज करने के लिए, आपको प्रत्येक संपत्ति के लिए तालिका घाटी में शामिल होना चाहिए जिसे खोजा जाएगा। लेकिन एक अति सूक्ष्म अंतर है, जॉइन टेबल "क्षैतिज" से जुड़ें (शब्द संघ में सभी "लंबवत" जुड़ते हैं), निम्नलिखित एक उदाहरण है:

यह परिणाम हमें शोभा नहीं देता, हम सभी मूल्यों को एक कॉलम में देखना चाहेंगे। ऐसा करने के लिए, आपको उन संपत्तियों से 1 गुना अधिक तालिका तालिका में शामिल होना होगा, जिसके द्वारा खोज की जाती है।

हम स्वचालित रूप से sql क्वेरी उत्पन्न करने के करीब हैं। आइए फ़ंक्शन को देखें
whereWithJoin ($aliasJoin, $options, $aliasWhere, $where) , जो सभी काम करेंगे:

• $ aliasJoin - आधार टेम्पलेट में एक उपनाम, जिसके बजाय जॉइन के साथ sql भाग प्रतिस्थापित किया जाता है।
• $ विकल्प - एक हिस्सा शामिल होने के लिए नियमों के विवरण के साथ एक सरणी।
• $ aliasWhere - बेस टेम्पलेट में एक उपनाम, जो बदले में जहां sql भाग को प्रतिस्थापित करता है।
• $ जहां जहां वर्ग का एक उदाहरण है।

आइए एक उदाहरण देखें: whereWithJoin('/*join*/', $options, '/*where*/', $wh) ।

सबसे पहले, $ विकल्प चर बनाएं: $options = ['v' => ['val', 'product_id', 'p.id']];

v तालिका का उपनाम है। यदि दिए गए उपनाम $ क में पाए जाते हैं , तो एक नई वैल टेबल को ज्वाइन करके जोड़ा जाएगा (जहां product_id वैल टेबल की विदेशी कुंजी है, और p.id एलीस पी के साथ टेबल के लिए प्राथमिक कुंजी है), एक नया उपनाम और यह उपनाम इसके लिए उत्पन्न होता है। कहाँ में v की जगह लेगा।

$ व्ह कहाँ कक्षा का एक उदाहरण है। हम एक ही अनुरोध बनाते हैं: मेमोरी 10 जीबी से अधिक होनी चाहिए और फॉर्म फैक्टर 2.5 इंच होना चाहिए।

 $wh->linkAnd([ $wh->linkAnd([ ['v.property_id', '=', 1], ['v.value', '>', 10] ])->getRaw(), //    $wh->linkAnd([ ['v.property_id', '=', 3], ['v.value', '=', 2.5] ])->getRaw(),//    ]); 

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

 $qr->sql("select p.id, t.name type_name, pr.id prop_id, pr.name prop_name, v.id val_id, v.value from product p inner join type t on t.id = p.type_id inner join val v on v.product_id = p.id inner join properties pr on pr.id = v.property_id /*join*/ /*where*/") ->whereWithJoin('/*join*/', $options, '/*where*/', $wh) //     . ->all([ 'id' => 'pk', 'type_name' => 'type', 'properties' => [ 'prop_id' => 'pk', 'prop_name' => 'name', 'values' => [ 'val_id' => 'pk', 'value' => 'val' ] ] ]); 

हम उत्पन्न sql, बाइंड और क्वेरी निष्पादन समय के माध्यम से देखते हैं: $qr->debugInfo() :

 [ [ 'type' => 'info', 'sql' => 'select p.id, t.name type_name, pr.id prop_id, pr.name prop_name, v.id val_id, v.value from product p inner join type t on t.id = p.type_id inner join val v on v.product_id = p.id inner join properties pr on pr.id = v.property_id inner JOIN val val_mIQWpnHhdQ ON val_mIQWpnHhdQ.product_id = p.id inner JOIN val val_J0uveMpwEM ON val_J0uveMpwEM.product_id = p.id WHERE ( val_mIQWpnHhdQ.property_id = :al_where_leV5QlmOZN and val_mIQWpnHhdQ.value > :al_where_ycleYAswIw ) and ( val_J0uveMpwEM.property_id = :al_where_dinxDraTOE and val_J0uveMpwEM.value = :al_where_wZJhUqs74i )', 'binds' => [ 'al_where_leV5QlmOZN' => 1, 'al_where_ycleYAswIw' => 10, 'al_where_dinxDraTOE' => 3, 'al_where_wZJhUqs74i' => 2.5 ], 'timeQuery' => 0.0384588241577 ] ] 

$qr->rawData() :

 [ [ 'id' => 3, 'type_name' => 'SSD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 5, 'value' => 512 ], [ 'id' => 3, 'type_name' => 'SSD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 6, 'value' => 2.5 ], [ 'id' => 4, 'type_name' => 'SSD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 7, 'value' => 256 ], [ 'id' => 4, 'type_name' => 'SSD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 8, 'value' => 2.5 ], [ 'id' => 6, 'type_name' => 'HDD', 'prop_id' => 1, 'prop_name' => ' ', 'val_id' => 11, 'value' => 1024 ], [ 'id' => 6, 'type_name' => 'HDD', 'prop_id' => 3, 'prop_name' => '-', 'val_id' => 12, 'value' => 2.5 ] ] 

$qr->aggregateData() :

 [ 3 => [ 'type' => 'SSD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 5 => ['val' => 512] ] ], 3 => [ 'name' => '-', 'values' => [ 6 => ['val' => 2.5] ] ] ] ], 4 => [ 'type' => 'SSD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 7 => ['val' => 256] ] ], 3 => [ 'name' => '-', 'values' => [ 8 => ['val' => 2.5] ] ] ] ], 6 => [ 'type' => 'HDD', 'properties' => [ 1 => [ 'name' => ' ', 'values' => [ 11 => ['val' => 1024] ] ], 3 => [ 'name' => '-', 'values' => [ 12 => ['val' => 2.5] ] ] ] ] ] 

, , whereWithJoin() , .

whereWithJoin() , , n , m . n m 1 id . , AND .

GitHub .