questions - sql software

फुल जोइन और इनर जिन्न के बीच अंतर (6)

FULL JOIN और INNER JOIN क्या अंतर है?

जब मैं एक FULL JOIN हूं, तो मुझे 832 रिकॉर्ड मिलते हैं और एक INNER JOIN , मुझे 830 रिकॉर्ड मिलते हैं।

अंतर बेजोड़ पंक्तियों के व्यवहार में है।

उदाहरण के लिए, यदि तालिका A में एक पंक्ति है जिसमें उस क्षेत्र में तालिका B में एक पत्राचार नहीं है, जिस पर जुड़ने को परिभाषित किया गया है, तो एक आंतरिक जोड़ पंक्ति को पूरी तरह से छोड़ देगा, जबकि एक पूर्ण जोड़ में पंक्ति शामिल होगी, लेकिन NULL के साथ तालिका बी के बेजोड़ पंक्तियों के लिए तालिका बी के क्षेत्रों के लिए मूल्य।

इनर जॉइन किसी भी NULL को टार्गेट फील्ड में नहीं लाएगा। यदि कोई मिलान रिकॉर्ड नहीं है, तो मूल तालिका में नहीं होगा।

एक FULL OUTER JOIN LEFT OUTER JOIN और RIGHT OUTER JOIN का मिलन है।

(वह समझ में आया था?)

अच्छा दृश्य स्पष्टीकरण जोक्स का वर्णन करता है (नीचे बाईं ओर पूर्ण बाहरी जुड़ाव का वर्णन करता है):

क्रेडिट कोडप्रोजेक्ट पर CL Moffatt के ब्लॉगपोस्ट में जाते हैं

टेबल ए और टेबल बी पर विचार करें

तालिका A - (कुंजी, नाम)

1, डेटा 1 2, डेटा 2 4, डेटा 4 5, डेटा 5

तालिका B - (कुंजी, FKey, नाम)

1, 1, DataA 2, 2, DataB 3, NULL, DataC 4, 4, DataD

एक आंतरिक जुड़ाव लौट आएगा

1, डेटा 1, 1, 1, डेटाए
2, डेटा 2, 2, 2, डेटाबी
4, डेटा 3, 4, 4, डेटाड

एक पूर्ण बाहरी जुड़ाव लौटते समय

1, डेटा 1, 1, 1, डेटाए
2, डेटा 2, 2, 2, डेटाबी
NULL, NULL, 3, NULL, DataC
4, डेटा 4, 4, 4, डेटाड
5, Data5, NULL, NULL, NULL

बहुत सरल तरीके से, मुख्य अंतर यह है:

INNER JOIN - केवल पंक्तियों से मेल खाता है। इसलिए, बेजोड़ पंक्तियों को शामिल नहीं किया गया है।

फुल जॉइन - उन पंक्तियों को लौटाता है जो दाईं तालिका में मौजूद हैं और बाईं ओर नहीं हैं, साथ ही पंक्तियां जो बाईं तालिका में मौजूद हैं और दाईं ओर नहीं हैं, आंतरिक पंक्तियों से परे हैं।

नोट : ये सभी विकिपीडिया: जॉइन (एसक्यूएल) पर मिल सकते हैं।

तीन प्रकार के OUTER जुड़ते हैं:

बाईं ओर का बाहरी जोड़
सही जॉय शामिल हैं
पूरा कंप्यूटर शामिल है

OUTER कीवर्ड सभी कार्यान्वयनों में वैकल्पिक है जो मानक का पालन करता है, इसलिए FULL JOIN, FULL OUTER JOIN के समान है। ( मैंने इस उत्तर के शेष भाग में SQL से OUTER शब्द छोड़ा है ।)

आइए देखें कि प्रत्येक क्या करता है।

निम्नलिखित दो इनपुट डेटा सेटों पर विचार करें:

 Set "A"    Set "B"

 AA         BB
--------   --------
 Item 1     Item 3
 Item 2     Item 4
 Item 3     Item 5
 Item 4     Item 6

ध्यान दें कि ए में कुछ आइटम हैं जो बी में नहीं हैं, और इसके विपरीत।

अब, यदि हम इस तरह से SQL कथन लिखते हैं, तो LEFT में शामिल हों:

SELECT * FROM A LEFT JOIN B ON AA = BB

आपको निम्नलिखित परिणाम मिलेंगे (खाली छेद वास्तव में NULL निशान हैं):

 AA         BB
--------   --------
 Item 1
 Item 2
 Item 3     Item 3
 Item 4     Item 4

ध्यान दें कि आपको AA, या यों कहें कि जॉइन क्लॉज के बाएं हिस्से से सभी पंक्तियाँ मिलेंगी।

यदि आप राइट ज्वाइन का उपयोग करने के लिए स्विच करते हैं:

SELECT * FROM A RIGHT JOIN B ON AA = BB

 AA         BB
--------   --------
 Item 3     Item 3
 Item 4     Item 4
            Item 5
            Item 6

ध्यान दें कि आपको जॉइन क्लॉज के दाहिने हिस्से से सभी पंक्तियाँ मिलती हैं।

हालाँकि, यदि आप दोनों की सभी पंक्तियाँ चाहते हैं, तो आप एक पूर्ण जोड़ का उपयोग करेंगे:

SELECT * FROM A FULL JOIN B ON AA = BB

 AA         BB
--------   --------
 Item 1            <-----+
 Item 2                  |
 Item 3     Item 3       |
 Item 4     Item 4       |
            Item 5       +--- empty holes are NULL's
            Item 6       |
   ^                     |
   |                     |
   +---------------------+

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

INNER join के साथ:

SELECT * FROM A INNER JOIN B ON AA = BB

 AA         BB
--------   --------
 Item 3     Item 3
 Item 4     Item 4

INNER join के साथ हम केवल उन पंक्तियों को प्राप्त करते हैं जो वास्तव में मेल खाती हैं, जुड़ने के कारण कोई छेद नहीं।

CROSS जॉइन एक कार्टेशियन उत्पाद का उत्पादन करता है, पहले सेट से हर पंक्ति को दूसरे सेट से हर पंक्ति के साथ मिलान करके:

SELECT * FROM A CROSS JOIN B

 AA         BB
--------   --------
 Item 1     Item 3      ^
 Item 1     Item 4      +--- first item from A, repeated for all items of B
 Item 1     Item 5      |
 Item 1     Item 6      v
 Item 2     Item 3      ^
 Item 2     Item 4      +--- second item from A, repeated for all items of B
 Item 2     Item 5      |
 Item 2     Item 6      v
 Item 3     Item 3      ... and so on
 Item 3     Item 4
 Item 3     Item 5
 Item 3     Item 6
 Item 4     Item 3
 Item 4     Item 4
 Item 4     Item 5
 Item 4     Item 6

यह भी ध्यान दें कि हम उस कॉलम से मेल नहीं खाते, जो मिलान नहीं हुआ है।

अंत में, NATURAL इस वाक्य रचना में शामिल होता है, हम यह नहीं बताते हैं कि कौन से कॉलम मेल खाते हैं, लेकिन कॉलम नामों पर मेल खाते हैं। हमारे आकस्मिक उदाहरण में, कोई स्तंभ नाम समान नहीं हैं, लेकिन इस विशिष्ट उदाहरण के लिए मान लें कि स्तंभ नाम दोनों तालिकाओं में XX था, तो हमें निम्न परिणाम मिलेगा:

SELECT * FROM A NATURAL JOIN B

 +----------+------- matches on the names, and then the data
 |          |
 v          v
 XX         XX
--------   --------
 Item 3     Item 3
 Item 4     Item 4

जैसा कि आप देख सकते हैं, आपको INNER जॉइन के समान ही मिलता है, लेकिन जॉइन क्लॉज के मैच वाले हिस्से को टाइप करने की जरूरत नहीं है।