PostgreSQL में विभिन्न तालिकाओं से डेटा को संयोजित करने के लिए जॉइन का उपयोग करना

परिचय

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

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

जॉइन क्या होते हैं?

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

जॉइन का मूल सिंटैक्स इस तरह दिखता है:

SELECT    *FROM    <first_table><join_type> <second_table>    <join_condition>;
 

एक जॉइन में, प्रत्येक परिणामी पंक्ति का निर्माण पहली तालिका के सभी स्तंभों के बाद दूसरी तालिका के सभी स्तंभों को शामिल करके किया जाता है। SELECT क्वेरी के भाग का उपयोग सटीक कॉलम निर्दिष्ट करने के लिए किया जा सकता है जिसे आप प्रदर्शित करना चाहते हैं।

यदि तुलना के लिए उपयोग किए गए कॉलम में मान अद्वितीय नहीं हैं, तो मूल तालिकाओं से कई पंक्तियों का निर्माण किया जा सकता है। उदाहरण के लिए, कल्पना करें कि आपके पास पहली तालिका से एक कॉलम की तुलना की जा रही है जिसमें "लाल" के मान के साथ दो रिकॉर्ड हैं। इसके साथ मिलान दूसरी तालिका का एक स्तंभ है जिसमें उस मान के साथ तीन पंक्तियाँ हैं। जॉइन उस मूल्य के लिए छह अलग-अलग पंक्तियों का उत्पादन करेगा जो विभिन्न संयोजनों का प्रतिनिधित्व करते हैं जिन्हें प्राप्त किया जा सकता है।

शामिल होने का प्रकार और जुड़ने की शर्तें निर्धारित करती हैं कि प्रदर्शित होने वाली प्रत्येक पंक्ति का निर्माण कैसे किया जाता है। यह प्रभावित करता है कि प्रत्येक तालिका की पंक्तियों का क्या होता है जो नहीं करती और करती हैं जॉइन कंडीशन पर मैच करें।

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

विभिन्न प्रकार के जोड़

विभिन्न प्रकार के जॉइन उपलब्ध हैं, जिनमें से प्रत्येक संभावित रूप से अलग-अलग परिणाम देगा। प्रत्येक प्रकार के निर्माण के तरीके को समझने से आपको यह निर्धारित करने में मदद मिलेगी कि विभिन्न परिदृश्यों के लिए कौन सा उपयुक्त है।

आंतरिक जुड़ाव

डिफ़ॉल्ट जुड़ाव को आंतरिक जुड़ाव . कहा जाता है . PostgreSQL में, इसे INNER JOIN . का उपयोग करके निर्दिष्ट किया जा सकता है या बस बस JOIN ।

यहाँ एक विशिष्ट उदाहरण है जो आंतरिक जुड़ाव के सिंटैक्स को प्रदर्शित करता है:

SELECT    *FROM    table_1[INNER] JOIN table_2    ON table_1.id = table_2.table_1_id;
 

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

यदि आप घटक तालिकाओं के वेन आरेख के रूप में परिणामों का प्रतिनिधित्व करते हैं, तो एक आंतरिक जुड़ाव आपको दो मंडलियों के अतिव्यापी क्षेत्र का प्रतिनिधित्व करने की अनुमति देता है। केवल एक तालिका में मौजूद कोई भी मान प्रदर्शित नहीं होता है।

लेफ्ट जॉइन

लेफ्ट जॉइन एक जॉइन होता है जो इनर जॉइन में पाए गए सभी रिकॉर्ड और साथ ही सभी बेमेल को दिखाता है। पहली तालिका से पंक्तियाँ। PostgreSQL में, इसे LEFT OUTER JOIN . के रूप में निर्दिष्ट किया जा सकता है या सिर्फ एक LEFT JOIN . के रूप में ।

लेफ्ट जॉइन का मूल सिंटैक्स इस पैटर्न का अनुसरण करता है:

SELECT    *FROM    table_1LEFT JOIN table_2    ON table_1.id = table_2.table_1_id;
 

दोनों तालिकाओं में सभी मिलान रिकॉर्ड से पंक्तियों का निर्माण करने के लिए पहले एक आंतरिक जुड़ाव का प्रदर्शन करके एक बायाँ जुड़ाव का निर्माण किया जाता है। बाद में, पहली तालिका से बेजोड़ रिकॉर्ड भी शामिल किए गए हैं। चूंकि जॉइन की प्रत्येक पंक्ति में दोनों तालिकाओं के कॉलम शामिल होते हैं, बेजोड़ कॉलम NULL . का उपयोग करते हैं दूसरी तालिका के सभी स्तंभों के मान के रूप में।

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

राइट जॉइन करें

राइट जॉइन एक जॉइन है जो एक इनर जॉइन में पाए गए सभी रिकॉर्ड्स को दिखाता है, साथ ही सभी बेमेल दूसरी तालिका से पंक्तियाँ। PostgreSQL में, इसे RIGHT OUTER JOIN . के रूप में निर्दिष्ट किया जा सकता है या सिर्फ एक RIGHT JOIN . के रूप में ।

राइट जॉइन का मूल सिंटैक्स इस पैटर्न का अनुसरण करता है:

SELECT    *FROM    table_1RIGHT JOIN table_2    ON table_1.id = table_2.table_1_id;
 

दोनों तालिकाओं में सभी मिलान रिकॉर्ड से पंक्तियों का निर्माण करने के लिए पहले एक आंतरिक जुड़ाव का प्रदर्शन करके एक सही जुड़ाव का निर्माण किया जाता है। बाद में, दूसरी तालिका से बेजोड़ रिकॉर्ड भी शामिल हैं। चूंकि जॉइन की प्रत्येक पंक्ति में दोनों तालिकाओं के कॉलम शामिल होते हैं, बेजोड़ कॉलम NULL . का उपयोग करते हैं पहली तालिका के सभी स्तंभों के मान के रूप में।

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

पूर्ण जुड़ाव

एक पूर्ण जुड़ाव एक जुड़ाव है जो एक आंतरिक जुड़ाव में पाए गए सभी रिकॉर्ड दिखाता है, साथ ही सभी बेमेल दोनों घटक तालिकाओं से पंक्तियाँ। PostgreSQL में, इसे FULL OUTER JOIN . के रूप में निर्दिष्ट किया जा सकता है या सिर्फ एक FULL JOIN . के रूप में ।

पूर्ण जुड़ाव का मूल सिंटैक्स इस पैटर्न का अनुसरण करता है:

SELECT    *FROM    table_1FULL JOIN table_2    ON table_1.id = table_2.table_1_id;
 

दोनों तालिकाओं में सभी मिलान रिकॉर्ड से पंक्तियों का निर्माण करने के लिए पहले एक आंतरिक जुड़ाव का प्रदर्शन करके एक पूर्ण जुड़ाव का निर्माण किया जाता है। बाद में, दोनों तालिकाओं के बेजोड़ रिकॉर्ड भी शामिल किए गए हैं। चूंकि जॉइन की प्रत्येक पंक्ति में दोनों तालिकाओं के कॉलम शामिल होते हैं, बेजोड़ कॉलम NULL . का उपयोग करते हैं बेजोड़ अन्य तालिका के सभी स्तंभों के मान के रूप में।

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

क्रॉस जॉइन

एक विशेष जुड़ाव जिसे CROSS JOIN . कहा जाता है भी उपलब्ध है। क्रॉस जॉइन किसी भी तुलना का उपयोग यह निर्धारित करने के लिए नहीं करता है कि प्रत्येक तालिका में पंक्तियाँ एक दूसरे से मेल खाती हैं या नहीं। इसके बजाय, परिणाम केवल पहली तालिका की प्रत्येक पंक्ति को दूसरी तालिका की प्रत्येक पंक्ति में जोड़कर बनाया जाता है।

यह दो या दो से अधिक तालिकाओं में पंक्तियों के कार्टेशियन उत्पाद का उत्पादन करता है। वास्तव में, जुड़ने की यह शैली प्रत्येक तालिका से बिना शर्त पंक्तियों को जोड़ती है। इसलिए, यदि प्रत्येक तालिका में तीन पंक्तियाँ हैं, तो परिणामी तालिका में नौ पंक्तियाँ होंगी जिनमें दोनों तालिकाओं के सभी स्तंभ होंगे।

उदाहरण के लिए, यदि आपके पास t1 . नामक तालिका है t2 . नामक तालिका के साथ संयुक्त , प्रत्येक पंक्तियों के साथ r1 , r2 , और r3 , परिणाम इस प्रकार संयुक्त रूप से नौ पंक्तियाँ होंगी:

t1.r1 + t2.r1t1.r1 + t2.r2t1.r1 + t2.r3t1.r2 + t2.r1t1.r2 + t2.r2t1.r2 + t2.r3t1.r3 + t2.r1t1.r3 + t2.r2t1.r3 + t2.r3
 

स्वयं शामिल हों

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

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

चूंकि स्वयं एक ही तालिका को दो बार संदर्भित करता है, संदर्भों को स्पष्ट करने के लिए तालिका उपनामों की आवश्यकता होती है। उदाहरण के लिए, ऊपर के उदाहरण में, आप people . के दो उदाहरणों में शामिल हो सकते हैं उपनामों का उपयोग कर तालिका people AS children और people AS mothers . इस तरह, आप निर्दिष्ट कर सकते हैं कि शामिल होने की शर्तों को परिभाषित करते समय आप किस तालिका का उल्लेख कर रहे हैं।

यहां एक और उदाहरण दिया गया है, जो इस बार कर्मचारियों और प्रबंधकों के बीच संबंधों का प्रतिनिधित्व करता है:

SELECT    *FROM    people AS employeeJOIN people AS manager    ON employee.manager_id = manager.id;
 

शर्तों में शामिल हों

तालिकाओं का संयोजन करते समय, सम्मिलित होने की स्थिति निर्धारित करती है कि समग्र परिणाम बनाने के लिए पंक्तियों का एक साथ कैसे मिलान किया जाएगा। मूल आधार प्रत्येक तालिका में कॉलम को परिभाषित करना है जो उस पंक्ति में शामिल होने के लिए मेल खाना चाहिए।

ON खंड

टेबल जॉइन के लिए शर्तों को परिभाषित करने का सबसे मानक तरीका है ON खंड। ON क्लॉज प्रत्येक तालिका से सटीक कॉलम निर्दिष्ट करने के लिए एक समान चिह्न का उपयोग करता है, जिसकी तुलना यह निर्धारित करने के लिए की जाएगी कि कोई जुड़ाव कब हो सकता है। PostgreSQL प्रत्येक तालिका से पंक्तियों को एक साथ जोड़ने के लिए दिए गए कॉलम का उपयोग करता है।

ON क्लॉज सबसे वर्बोज़ है, लेकिन उपलब्ध जॉइन शर्तों में सबसे लचीला भी है। यह इस बात पर ध्यान दिए बिना कि प्रत्येक तालिका के कॉलम नाम कितने मानकीकृत हैं, यह विशिष्टता की अनुमति देता है।

ON . का मूल सिंटैक्स क्लॉज इस तरह दिखता है:

SELECT    *FROM    table1JOIN    table2ON    table1.id = table2.ident;
 

यहाँ, table1 . से पंक्तियाँ और table2 जब भी id table1 . से कॉलम ident . से मेल खाता है table2 . से कॉलम . क्योंकि एक आंतरिक जुड़ाव का उपयोग किया जाता है, परिणाम केवल उन पंक्तियों को दिखाएंगे जो शामिल हुई थीं। चूंकि क्वेरी वाइल्डकार्ड का उपयोग करती है * वर्ण, दोनों तालिकाओं के सभी स्तंभ प्रदर्शित होंगे।

इसका मतलब है कि दोनों id table1 . से कॉलम और ident table2 . से कॉलम प्रदर्शित किया जाएगा, भले ही उनके पास शामिल होने की स्थिति को संतुष्ट करने के आधार पर समान सटीक मूल्य हो। SELECT . में आप जो सटीक कॉलम दिखाना चाहते हैं, उन्हें कॉल करके आप इस दोहराव से बच सकते हैं कॉलम सूची।

USING खंड

USING क्लॉज एक ON . की शर्तों को निर्दिष्ट करने के लिए एक शॉर्टहैंड है क्लॉज जिसका उपयोग तब किया जा सकता है जब कॉलम की तुलना दोनों तालिकाओं में समान नाम हो। USING क्लॉज साझा किए गए कॉलम नामों की कोष्ठक में संलग्न एक सूची लेता है, जिसकी तुलना की जानी चाहिए।

USING . का सामान्य सिंटैक्स खंड इस प्रारूप का उपयोग करता है:

SELECT    *FROM    table1JOIN    table2USING    (id, state);
 

यह जुड़ाव table1 . को जोड़ती है table2 . के साथ जब दो कॉलम जो दोनों टेबल साझा करते हैं (id और state ) प्रत्येक के मेल खाने वाले मान हैं।

इसी जुड़ाव को ON . का उपयोग करके अधिक मौखिक रूप से व्यक्त किया जा सकता है इस तरह:

SELECT    *FROM    table1JOIN    table2ON    table1.id = table2.id AND table1.state = table2.state;
 

जबकि उपरोक्त दोनों जॉइन के परिणामस्वरूप समान डेटा के साथ समान पंक्तियों का निर्माण किया जाएगा, वे थोड़े अलग प्रदर्शित होंगे। जबकि ON खंड में दोनों तालिकाओं के सभी स्तंभ शामिल हैं, USING क्लॉज डुप्लिकेट कॉलम को दबा देता है। तो दो अलग id . होने के बजाय कॉलम और दो अलग state कॉलम (प्रत्येक तालिका के लिए एक), परिणामों में साझा किए गए प्रत्येक कॉलम में से केवल एक होगा, उसके बाद table1 द्वारा प्रदान किए गए अन्य सभी कॉलम होंगे। और table2 ।

NATURAL खंड

NATURAL क्लॉज अभी तक एक और शॉर्टहैंड है जो USING . की वाचालता को और कम कर सकता है खंड। एक NATURAL शामिल हों कोई निर्दिष्ट नहीं करता है मिलान करने के लिए कॉलम। इसके बजाय, PostgreSQL स्वचालित रूप से उन सभी स्तंभों के आधार पर तालिकाओं में शामिल हो जाएगा, जिनमें प्रत्येक डेटाबेस में मेल खाने वाले स्तंभ हैं।

NATURAL . का सामान्य सिंटैक्स जॉइन क्लॉज इस तरह दिखता है:

SELECT    *FROM    table1NATURAL JOIN    table2;
 

मान लें कि table1 और table2 दोनों में id . नाम के कॉलम हैं , state , और company , उपरोक्त क्वेरी ON . का उपयोग करके इस क्वेरी के बराबर होगी खंड:

SELECT    *FROM    table1JOIN    table2ON    table1.id = table2.id AND table1.state = table2.state AND table1.company = table2.company;
 

और यह क्वेरी USING . का उपयोग कर रही है खंड:

SELECT    *FROM    table1JOIN    table2USING    (id, state, company);
 

जैसे USING खंड, NATURAL क्लॉज डुप्लीकेट कॉलम को दबा देता है, इसलिए परिणामों में शामिल प्रत्येक कॉलम का केवल एक ही इंस्टेंस होगा।

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

जॉइन कंडीशन्स और WHERE खंड

शामिल होने की शर्तें WHERE . का उपयोग करके डेटा की पंक्तियों को फ़िल्टर करने के लिए उपयोग की जाने वाली तुलनाओं के साथ कई विशेषताओं को साझा करती हैं खंड। दोनों संरचनाएं उन भावों को परिभाषित करती हैं जिन पर विचार की जाने वाली पंक्ति के लिए सत्य का मूल्यांकन करना चाहिए। इस वजह से, WHERE में अतिरिक्त तुलनाओं को शामिल करने के बीच अंतर क्या है, यह हमेशा सहज नहीं होता है निर्माण बनाम उन्हें जॉइन क्लॉज के भीतर ही परिभाषित करना।

परिणाम के अंतर को समझने के लिए, हमें उस क्रम पर एक नज़र डालनी होगी जिसमें PostgreSQL क्वेरी के विभिन्न भागों को संसाधित करता है। इस मामले में, जॉइन कंडीशन में विधेय को पहले मेमोरी में वर्चुअल जॉइन टेबल बनाने के लिए प्रोसेस किया जाता है। इस चरण के बाद, WHERE . के भीतर के भाव परिणामी पंक्तियों को फ़िल्टर करने के लिए क्लॉज का मूल्यांकन किया जाता है।

उदाहरण के तौर पर, मान लें कि हमारे पास customer . नामक दो टेबल हैं और order कि हमें एक साथ जुड़ने की जरूरत है। हम customer.id . का मिलान करके दो तालिकाओं में शामिल होना चाहते हैं order.customer_id . के साथ कॉलम कॉलम। इसके अतिरिक्त, हम order . में पंक्तियों में रुचि रखते हैं तालिका जिसमें product_id है 12345 का।

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

सबसे पहले, आइए दोनों का उपयोग LEFT JOIN . के लिए शामिल होने की शर्तों के रूप में करें :

SELECT    customer.id AS customer_id,    customer.name,    order.id AS order_id,    order.product_idFROM    customerLEFT JOIN    orderON    customer.id = order.customer_id AND order.product_id = 12345;
 

परिणाम संभावित रूप से कुछ इस तरह दिख सकते हैं:

 customer_id |   name   | order_id | product_id ------------+----------+----------+------------        4380 | Acme Co  |      480 |      12345        4380 | Acme Co  |      182 |      12345         320 | Other Co |      680 |      12345        4380 | Acme Co  |          |         320 | Other Co |          |          20 | Early Co |          |        8033 | Big Co   |          |(7 rows)
 

पोस्टग्रेएसक्यूएल निम्नलिखित ऑपरेशन करके इस परिणाम पर पहुंचा:

1. customer में किसी भी पंक्ति को संयोजित करें order . के साथ तालिका तालिका जहां:
   • customer.id order.customer_id . से मेल खाता है ।
   • order.product_id 12345 से मेल खाता है
2. चूंकि हम लेफ्ट जॉइन का उपयोग कर रहे हैं, किसी भी बेमेल . को शामिल करें बाईं तालिका से पंक्तियाँ (customer ), दाएँ तालिका से स्तंभों को बाहर निकालना (order ) NULL . के साथ मान।
3. केवल SELECT में सूचीबद्ध कॉलम प्रदर्शित करें कॉलम विनिर्देश।

परिणाम यह है कि हमारी सभी सम्मिलित पंक्तियाँ उन दोनों स्थितियों से मेल खाती हैं जिनकी हम तलाश कर रहे हैं। हालाँकि, लेफ्ट जॉइन के कारण PostgreSQL में पहली टेबल की कोई भी पंक्तियाँ शामिल हो जाती हैं जो जॉइन कंडीशन को पूरा नहीं करती हैं। इसका परिणाम "बचे हुए" पंक्तियों में होता है जो क्वेरी के स्पष्ट इरादे का पालन नहीं करते हैं।

अगर हम दूसरी क्वेरी को आगे बढ़ाते हैं (order.product_id =12345) से WHERE क्लॉज, इसे एक जॉइन कंडीशन के रूप में शामिल करने के बजाय, हमें अलग-अलग परिणाम मिलते हैं:

SELECT    customer.id AS customer_id,    customer.name,    order.id AS order_id,    order.product_idFROM    customerLEFT JOIN    orderON    customer.id = order.customer_idWHERE    order.product_id = 12345;
 

इस बार, केवल तीन पंक्तियाँ प्रदर्शित हैं:

 customer_id |   name   | order_id | product_id ------------+----------+----------+------------        4380 | Acme Co  |      480 |      12345        4380 | Acme Co  |      182 |      12345         320 | Other Co |      680 |      12345(3 rows)
 

जिस क्रम में तुलना की जाती है, वह इन अंतरों का कारण है। इस बार, PostgreSQL क्वेरी को इस तरह से प्रोसेस करता है:

1. customer में किसी भी पंक्ति को संयोजित करें order . के साथ तालिका तालिका जहां customer.id order.customer_id . से मेल खाता है ।
2. चूंकि हम लेफ्ट जॉइन का उपयोग कर रहे हैं, किसी भी बेमेल . को शामिल करें बाईं तालिका से पंक्तियाँ (customer ), दाएँ तालिका से स्तंभों को बाहर निकालना (order ) NULL . के साथ मान।
3. WHERE का मूल्यांकन करें किसी भी पंक्ति को हटाने के लिए खंड जिसमें order.product_id के मान के रूप में 12345 नहीं है कॉलम।
4. केवल SELECT में सूचीबद्ध कॉलम प्रदर्शित करें कॉलम विनिर्देश।

इस बार, भले ही हम लेफ्ट जॉइन का उपयोग कर रहे हों, WHERE क्लॉज सही product_id . के बिना सभी पंक्तियों को फ़िल्टर करके परिणामों को छोटा कर देता है . क्योंकि किसी भी बेजोड़ पंक्तियों में product_id होगा NULL पर सेट करें , यह उन सभी बेजोड़ पंक्तियों को हटा देता है जो लेफ्ट जॉइन द्वारा पॉप्युलेट की गई थीं। यह उन सभी पंक्तियों को भी हटा देता है जो शामिल होने की स्थिति से मेल खाती थीं, जो इस दूसरे दौर की जांच में उत्तीर्ण नहीं हुई थीं।

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

निष्कर्ष

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

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