सेल्फ जॉइन बनाम इनर जॉइन

मुझे एक सेलेक्ट स्टेटमेंट में सभी टेबल्स को उनके अपने डेटा सेट का प्रतिनिधित्व करने के रूप में सोचने में मदद मिलती है।

इससे पहले कि आप कोई भी शर्त लागू करें, आप सोच सकते हैं कि प्रत्येक डेटा सेट पूरा हो गया है (उदाहरण के लिए, पूरी तालिका)।

जो जानकारी आप वास्तव में चाहते हैं उसे खोजने के लिए उन डेटा सेट को परिष्कृत करना शुरू करने के कई तरीकों में शामिल होना सिर्फ एक तरीका है।

हालांकि एक डेटाबेस स्कीमा को कुछ रिश्तों को ध्यान में रखकर तैयार किया जा सकता है (प्राथमिक कुंजी <-> विदेशी कुंजी) ये संबंध वास्तव में केवल एक विशेष क्वेरी के संदर्भ में मौजूद हैं। क्वेरी लेखक जो कुछ भी वे चाहते हैं उससे संबंधित कर सकते हैं। मैं इसका उदाहरण बाद में दूंगा...

एक इनर जॉइन दो तालिकाओं को एक दूसरे से जोड़ता है। एक क्वेरी में कई तालिकाओं को एक साथ जोड़ने के लिए अक्सर कई जॉइन ऑपरेशन होते हैं। यह उतना ही जटिल हो सकता है जितना इसकी आवश्यकता है। एक साधारण उदाहरण के लिए, निम्नलिखित तीन तालिकाओं पर विचार करें...

STUDENT

| STUDENTID | LASTNAME | FIRSTNAME |
------------------------------------
      1     |  Smith   |   John
      2     |  Patel   |  Sanjay
      3     |   Lee    |  Kevin
      4     |  Jackson |  Steven

ENROLLMENT

| ENROLLMENT ID | STUDENTID | CLASSID |
---------------------------------------
        1       |     2     |    3
        2       |     3     |    1
        3       |     4     |    2

CLASS

| CLASSID | COURSE | PROFESSOR |
--------------------------------
     1    | CS 101 |   Smith
     2    | CS 201 |  Ghandi
     3    | CS 301 |  McDavid
     4    | CS 401 |  Martinez

छात्र तालिका और कक्षा तालिका को नामांकन तालिका के माध्यम से एक दूसरे से संबंधित करने के लिए डिज़ाइन किया गया था। इस तरह की टेबल को जंक्शन टेबल . कहा जाता है ।

सभी छात्रों और जिन कक्षाओं में वे नामांकित हैं, उन्हें प्रदर्शित करने के लिए एक प्रश्न लिखने के लिए दो . का उपयोग किया जाएगा इनर जॉइन...

SELECT stud.LASTNAME, stud.FIRSTNAME, class.COURSE, class.PROFESSOR
FROM STUDENT stud
INNER JOIN ENROLLMENT enr
    ON stud.STUDENTID = enr.STUDENTID
INNER JOIN CLASS class
    ON class.CLASSID = enr.CLASSID;

उपरोक्त को ध्यान से पढ़ें और आपको देखना चाहिए कि क्या हो रहा है। बदले में आपको जो मिलेगा वह निम्नलिखित डेटा सेट है...

 | LASTNAME | FIRSTNAME | COURSE | PROFESSOR |
 ---------------------------------------------
     Patel  |   Sanjay  | CS 301 |  McDavid
      Lee   |   Kevin   | CS 101 |   Smith
    Jackson |  Steven   | CS 201 |  Ghandi

जॉइन क्लॉज का उपयोग करके हमने तीनों तालिकाओं के डेटा सेट को केवल एक दूसरे से मेल खाने वाले डेटा तक सीमित कर दिया है। "मिलान" को चालू . का उपयोग करके परिभाषित किया गया है खंड। ध्यान दें कि यदि आप इस क्वेरी को चलाते हैं तो आप नहीं कक्षा तालिका से कक्षा 4 पंक्ति या छात्र तालिका से छात्र 1 पंक्ति देखें क्योंकि वे आईडी मैचों में मौजूद नहीं हैं (इस मामले में नामांकन तालिका)। उस काम को थोड़ा अलग तरीके से कैसे बनाया जाए, इस बारे में अधिक पढ़ने के लिए "बाएं"/"दाएं"/"पूर्ण बाहरी" जॉइन देखें।

कृपया ध्यान दें, पहले "रिश्ते" पर मेरी टिप्पणियों के अनुसार, कोई कारण नहीं . है आप सीधे LASTNAME और PROFESSOR कॉलम पर छात्र तालिका और कक्षा तालिका से संबंधित क्वेरी क्यों नहीं चला सके। वे दो कॉलम डेटा प्रकार में मेल खाते हैं और इसे अच्छी तरह से देखें! उनका एक समान मूल्य भी है! बदले में पाने के लिए यह शायद एक अजीब डेटा सेट होगा। मेरा कहना है कि यह किया जा सकता है और आप कभी नहीं जानते कि आपके डेटा में दिलचस्प कनेक्शन के लिए भविष्य में आपको क्या चाहिए। डेटाबेस के डिज़ाइन को समझें लेकिन "रिश्ते" को ऐसे नियम न समझें जिन्हें नज़रअंदाज़ नहीं किया जा सकता है।

इस बीच... स्वयं शामिल हों!

निम्न तालिका पर विचार करें...

PERSON

| PERSONID | FAMILYID |  NAME  |
--------------------------------
      1    |     1    |  John
      2    |     1    | Brynn
      3    |     2    | Arpan
      4    |     2    | Steve
      5    |     2    |  Tim
      6    |     3    | Becca

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

उदाहरण के लिए, यदि आप एक व्यक्ति, PERSONID 4 को वापस करना चाहते हैं, तो आप लिखेंगे...

SELECT * FROM PERSON WHERE PERSONID = 4;

आप सीखेंगे कि वह FAMILYID 2 वाले परिवार में है। फिर सभी को खोजने के लिए आप उनके परिवार के लोगों के बारे में लिखेंगे...

SELECT * FROM PERSON WHERE FAMILYID = 2;

किया और किया! एसक्यूएल, निश्चित रूप से, इसे एक क्वेरी में पूरा कर सकता है, आपने अनुमान लगाया है, एक सेल्फ जॉइन।

क्या वास्तव में स्वयं शामिल होने . की आवश्यकता को ट्रिगर करता है यहाँ यह है कि तालिका में एक अद्वितीय कॉलम (PERSONID) और एक कॉलम है जो "श्रेणी" (FAMILYID) के रूप में कार्य करता है। इस अवधारणा को कार्डिनैलिटी . कहा जाता है और इस मामले में एक से अनेक या 1:M . का प्रतिनिधित्व करता है रिश्ता। केवल एक . है प्रत्येक व्यक्ति . का लेकिन कई . हैं व्यक्ति एक परिवार . में ।

तो, हम जो वापस करना चाहते हैं वह है सब परिवार के सदस्यों में से यदि एक परिवार के PERSONID का सदस्य ज्ञात है...

SELECT fam.*
FROM PERSON per
JOIN PERSON fam
    ON per.FamilyID = fam.FamilyID
WHERE per.PERSONID = 4;

यहां आपको क्या मिलेगा...

| PERSONID | FAMILYID |  NAME  |
--------------------------------
      3    |     2    | Arpan
      4    |     2    | Steve
      5    |     2    |  Tim

आइए कुछ बातों पर ध्यान दें। शब्द स्वयं शामिल हों कहीं नहीं होता है। ऐसा इसलिए है क्योंकि एक स्वयं शामिल हों सिर्फ एक अवधारणा है। शब्द शामिल हों उपरोक्त क्वेरी में बाएं जॉइन हो सकता था इसके बजाय और अलग चीजें होतीं। स्वयं शामिल होने . का बिंदु यह है कि आप एक ही तालिका का दो बार उपयोग कर रहे हैं।

डेटा सेट पर पहले से मेरे सोपबॉक्स पर विचार करें। यहां हमने दो बार PERSON तालिका से डेटा सेट के साथ शुरुआत की है। न तो उदाहरण जब तक हम यह नहीं कहते कि डेटा सेट दूसरे को प्रभावित करता है।

आइए क्वेरी के निचले भाग से शुरू करें। प्रति डेटा सेट केवल उन पंक्तियों तक सीमित किया जा रहा है जहां PERSONID =4 है। तालिका को जानने के बाद हम जानते हैं कि ठीक एक पंक्ति वापस आ जाएगी। उस पंक्ति में FAMILYID कॉलम का मान 2 है।

ON क्लॉज में हम fam . को सीमित कर रहे हैं डेटा सेट (जो इस बिंदु पर अभी भी संपूर्ण PERSON तालिका है) केवल उन पंक्तियों के लिए जहां FAMILYID का मान एक या अधिक से मेल खाता है प्रति . के FAMILYIDs में से डेटा सेट। जैसा कि हमने चर्चा की हम जानते हैं प्रति डेटा सेट में केवल एक पंक्ति होती है, इसलिए एक FAMILYID मान होता है। इसलिए परिवार डेटा सेट में अब केवल पंक्तियाँ हैं जहाँ FAMILYID =2.

अंत में, क्वेरी के शीर्ष पर हम fam . में सभी पंक्तियों का चयन कर रहे हैं डेटा सेट।

वोइला! एक में दो प्रश्न।

अंत में, एक INNER JOIN कई प्रकार के जॉइन ऑपरेशनों में से एक है। मैं दृढ़ता से बाएँ, दाएँ और पूर्ण OUTER JOINs में आगे पढ़ने का सुझाव दें (जिन्हें सामूहिक रूप से OUTER JOINs कहा जाता है) ) मैंने व्यक्तिगत रूप से एक बार OUTER JOINs के बारे में कमजोर ज्ञान होने के कारण नौकरी का अवसर गंवा दिया और इसे दोबारा नहीं होने दूंगा!

एक स्वयं शामिल हों बस कोई भी जॉइन ऑपरेशन है जहां आप खुद को एक टेबल से संबंधित कर रहे हैं। जिस तरह से आप उस तालिका में शामिल होने के लिए चुनते हैं, वह INNER JOIN . का उपयोग कर सकता है या एक बाहरी शामिल हों। ध्यान दें कि स्वयं शामिल हों . के साथ , ताकि आपके SQL इंजन को भ्रमित न करने के लिए आपको जरूरी तालिका उपनामों का उपयोग करें (ऊपर से परिवार और प्रति। अपनी क्वेरी के लिए जो कुछ भी समझ में आता है) या विभिन्न संस्करणों में अंतर करने का कोई तरीका नहीं है एक ही टेबल के।

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

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

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

मुझे उम्मीद है यह मदद करेगा। यदि आप जॉइन को अपनी पिछली जेब में रख सकते हैं तो आप SQL के साथ जादू कर सकते हैं!

हैप्पी पूछताछ!