इसके अलावा आप विभिन्न प्रकार के प्रकारों के लिए निम्न स्कीमा पर विचार कर सकते हैं;

स्रोत: सीएल मोफैट द्वारा विस्तार से समझाए गए Visual-Representation-of-SQL-Joins विज़ुअलाइजेशन

"इनर जॉइन" और "बाहरी जॉइन" के बीच क्या अंतर है?

वे एसक्यूएल में सबसे अधिक इस्तेमाल किए जाने वाले अस्तित्व वाले ऑपरेटरों हैं, जहां INNER JOIN'अस्तित्व' के LEFT OUTER JOINलिए उपयोग किया जाता है और 'अस्तित्व में नहीं है' के लिए प्रयोग किया जाता है।

इन प्रश्नों पर विचार करें:

users who have posted and have votes
users who have posted but have no badges

जो लोग सेट-आधारित समाधान (एक उद्योग शब्द) की तलाश करते हैं, वे संबंधित प्रश्नों को इस प्रकार पहचानेंगे:

users who have posted INTERSECT users who have votes
users who have posted MINUS users who have badges

इन्हें मानक एसक्यूएल में अनुवाद करना:

SELECT UserId FROM Posts
INTERSECT 
SELECT UserId FROM Votes;

SELECT UserId FROM Posts
EXCEPT 
SELECT UserId FROM Badges;

अन्य सेट समावेशन के समान लाइनों के साथ सोचेंगे:

users who have posted and IN the set of users who have votes
users who have posted and NOT IN the set of users who have badges

इन्हें मानक एसक्यूएल में अनुवाद करना:

SELECT UserId 
  FROM Posts
 WHERE UserId IN ( SELECT UserId FROM Votes );

SELECT UserId 
  FROM Posts
 WHERE UserId NOT IN ( SELECT UserId FROM Badges );

कुछ सेटों के भीतर 'अस्तित्व' के संदर्भ में सोचेंगे

users who have posted and EXIST in the set of users who have votes
users who have posted and do NOT EXIST in the set of users who have badges

मानक SQL (ध्यान दें कि हम अब यानी सीमा चर का उपयोग करने की आवश्यकता है में इन का अनुवाद p, v, b):

SELECT p.UserId 
  FROM Posts p
 WHERE EXISTS ( SELECT *
                  FROM Votes v
                 WHERE v.UserId = p.UserId );

SELECT p.UserId 
  FROM Posts p
 WHERE NOT EXISTS ( SELECT *
                      FROM Badges b
                     WHERE b.UserId = p.UserId );

हालांकि, मैंने पाया है कि "उद्योग मानक" दृष्टिकोण विशेष रूप से जुड़ने का उपयोग करना है। मुझे नहीं पता कि सोच क्या है ( उपकरण का कानून ? समयपूर्व अनुकूलन ?), तो मैं सीधे वाक्यविन्यास पर जाऊंगा:

SELECT p.UserId 
  FROM Posts p
       INNER JOIN Votes v ON v.UserId = p.UserId;

SELECT p.UserId 
  FROM Posts p
       LEFT JOIN Badges b ON b.UserId = p.UserId
 WHERE b.UserId IS NULL;

ध्यान देने योग्य बातें:

• केवल प्रक्षेपण से है Usersलेकिन हम अभी भी उन सभी रेंज चर (की जरूरत है p, v, b) खोज स्थितियों के लिए।
• UserId IS NULLखोज हालत के लिए 'अंतर्गत आता है' OUTER JOINलेकिन क्वेरी में काट दिया गया है।
• LEFTउद्योग मानक है: पेशेवरों का उपयोग करने से बचने के लिए एक प्रश्न फिर से लिखना होगा RIGHT!
• OUTERतैयार किए गए कीवर्ड LEFT OUTER JOINछोड़ा गया है।

अंतिम शब्द:

कभी-कभी प्रश्नों का उपयोग केवल यह निर्धारित करने के लिए किया जाता है कि मूल्य मौजूद हैं या किसी अन्य सेट में मौजूद नहीं हैं। प्रक्षेपित किए गए विशेषताओं ( SELECTखंड में कॉलम ) पर ध्यान से देखना सीखें : यदि शामिल तालिका से कोई भी नहीं है तो उन्हें केवल अस्तित्व वाले ऑपरेटरों के रूप में उपयोग किया जा रहा है। इसके अतिरिक्त बाहरी शामिल होने के लिए, खंड <key_column> IS NULLमें उदाहरणों की तलाश करें WHERE।

के लिए सटीक एल्गोरिथ्म INNER JOIN, LEFT/RIGHT OUTER JOINनिम्न प्रकार हैं:

1. प्रत्येक पंक्ति को पहली तालिका से लें: a
2. इसके बगल में दूसरी टेबल से सभी पंक्तियों पर विचार करें: (a, b[i])
3. ON ...प्रत्येक जोड़ी के खिलाफ खंड का मूल्यांकन करें :ON( a, b[i] ) = true/false?
   • जब स्थिति का मूल्यांकन होता है true, तो उस संयुक्त पंक्ति को वापस कर दें (a, b[i])।
   • किसी भी मैच के बिना दूसरी तालिका के अंत तक पहुंचने पर, और Outer Joinफिर यह एक तालिका (वर्चुअल) जोड़ी Nullको अन्य तालिका के सभी कॉलम के लिए उपयोग कर देता है: (a, Null)बाएं बाहरी जुड़ने के लिए या (Null, b)दाएं बाहरी जुड़ने के लिए। यह सुनिश्चित करना है कि अंतिम तालिका की सभी पंक्तियां अंतिम परिणामों में मौजूद हैं।

नोट:ON खंड में निर्दिष्ट शर्त कुछ भी हो सकती है, प्राथमिक कुंजी का उपयोग करने की आवश्यकता नहीं है (और आपको हमेशा दोनों तालिकाओं के कॉलम को संदर्भित करने की आवश्यकता नहीं है)! उदाहरण के लिए:

• ... ON T1.title = T2.title AND T1.version < T2.version(=> इस पोस्ट को नमूना उपयोग के रूप में देखें: कॉलम पर अधिकतम मान वाले पंक्तियों का चयन करें )
• ... ON T1.y IS NULL
• ... ON 1 = 0 (बस नमूना के रूप में)

नोट: बाएं जुड़ें = बाएं बाहरी शामिल हों, दाएं जुड़ें = दाएं बाहरी शामिल हों।

आंतरिक जुड़ने की आवश्यकता होती है कि एक संबंधित आईडी के साथ एक रिकॉर्ड शामिल तालिका में मौजूद है।

बाहरी जुड़ाव बाईं तरफ के रिकॉर्ड वापस कर देगा, भले ही सही पक्ष के लिए कुछ भी मौजूद न हो।

उदाहरण के लिए, आपके पास ऑर्डर और ऑर्डर डिस्प्ले टेबल है। वे "ऑर्डर आईडी" से संबंधित हैं।

आदेश

• आदेश कामतत्व
• ग्राहक का नाम

ऑर्डर का विवरण

• OrderDetailID
• आदेश कामतत्व
• उत्पाद का नाम
• मात्रा
• मूल्य

अनुरोध

SELECT Orders.OrderID, Orders.CustomerName
  FROM Orders 
 INNER JOIN OrderDetails
    ON Orders.OrderID = OrderDetails.OrderID

केवल ऑर्डर लौटाएगा जिसमें ऑर्डर डिस्प्ले टेबल में कुछ भी है।

यदि आप इसे बाहरी बाएं जॉइन में बदल देते हैं

SELECT Orders.OrderID, Orders.CustomerName
  FROM Orders 
  LEFT JOIN OrderDetails
    ON Orders.OrderID = OrderDetails.OrderID

तो यह ऑर्डर तालिका से रिकॉर्ड्स वापस कर देगा, भले ही उनके पास कोई ऑर्डर डिस्काउंट रिकॉर्ड न हो।

आप ऑर्डर खोजने के लिए इसका उपयोग कर सकते हैं जिनके पास कोई ऑर्डर डिस्प्ले नहीं है, जहां कोई ऑर्डर WHERE OrderDetails.OrderID IS NULL , WHERE OrderDetails.OrderID IS NULL ।

समान्य शब्दों में,

1. अंदरूनी जॉइन या इक्की जॉइन: परिणामसेट देता है जो दोनों टेबलों में केवल स्थिति से मेल खाता है।

2. बाहरी जॉइन: स्थिति होने पर या नहीं, भले ही दोनों टेबलों से सभी मानों के परिणामसेट को वापस कर देता है।

3. बाएं जॉइन: बाएं टेबल से सभी मानों के परिणामसेट को लौटाता है और केवल पंक्तियां जो सही तालिका में स्थिति से मेल खाते हैं।

4. सही जॉइन: दाएं टेबल से सभी मानों के परिणामसेट को लौटाता है और केवल पंक्तियां जो बाएं तालिका में स्थिति से मेल खाते हैं।

5. पूर्ण जॉइन: पूर्ण जुड़ें और पूर्ण बाहरी शामिल हों।

आंतरिक शामिल होने और बाहरी जुड़ने के बीच का अंतर निम्नानुसार है:

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

आंतरिक रूप से जुड़ा

मिलान की गई पंक्तियों को केवल पुनर्प्राप्त करें, यानी, A intersect B ।

SELECT *
FROM dbo.Students S
INNER JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

बाईं ओर का बाहरी जोड़

पहली तालिका से सभी रिकॉर्ड्स का चयन करें, और दूसरी तालिका में किसी भी रिकॉर्ड जो कि जुड़ी कुंजी से मेल खाता है।

SELECT *
FROM dbo.Students S
LEFT JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

पूर्ण बाहरी शामिल हों

दूसरी तालिका से सभी रिकॉर्ड्स का चयन करें, और शामिल की गई कुंजी से मेल खाने वाली पहली तालिका में कोई भी रिकॉर्ड चुनें।

SELECT *
FROM dbo.Students S
FULL JOIN dbo.Advisors A
    ON S.Advisor_ID = A.Advisor_ID

संदर्भ

• आंतरिक और बाहरी एसक्यूएल उदाहरण और जुड़ें ब्लॉक में शामिल हो जाता है

• एसक्यूएल: जॉइन

आंतरिक रूप से जुड़ा।

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

बाहरी शामिल हों।

एक बाएं दूसरी तालिका में पंक्तियों को पहली तालिका से पंक्तियों से मिलान करने का प्रयास करने में प्रयास करती है। यदि यह कोई मिलान नहीं मिल रहा है, तो यह कॉलम को पहली तालिका से वापस कर देगा और कॉलम को दूसरी तालिका रिक्त (शून्य) से छोड़ देगा।

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

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

select  * from employee inner join location on employee.empID = location.empID
OR
select  * from employee, location where employee.empID = location.empID

अब, एसक्यूएल चलाने का नतीजा यह है कि ऐसा दिखाई देगा:

बाहरी शामिल हों: - एक बाहरी जुड़ने के लिए मिलान करने वाले रिकॉर्ड के लिए दो शामिल तालिकाओं में प्रत्येक रिकॉर्ड की आवश्यकता नहीं होती है। शामिल तालिका प्रत्येक रिकॉर्ड को बरकरार रखती है-भले ही कोई अन्य मिलान रिकॉर्ड मौजूद न हो। कौन सा टेबल की पंक्तियों को बनाए रखा जाता है (बाएं या दाएं) के आधार पर बाहरी बाएं बाहरी जोड़ों और दाएं बाहरी जुड़ने में आगे बढ़ता है।

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

select  * from employee left outer join location on employee.empID = location.empID;
//Use of outer keyword is optional

अब, यह एसक्यूएल चलाने का नतीजा यहां दिखेगा:

दायां बाहरी शामिल हों: - तालिकाओं के उपचार को छोड़कर, एक बाहरी बाहरी जुड़ाव (या दाएं शामिल) निकट बाएं बाहरी जुड़ने जैसा दिखता है। "दाएं" तालिका ( स्थान ) से प्रत्येक पंक्ति कम से कम एक बार शामिल तालिका में दिखाई देगी। यदि "बाएं" तालिका ( कर्मचारी ) से कोई मिलान पंक्ति मौजूद नहीं है, तो उन रिकॉर्ड्स के लिए कर्मचारी से कॉलम में NULL दिखाई देगा जिनके पास स्थान में कोई मिलान नहीं है। एसक्यूएल इस तरह दिखता है:

select * from employee right outer join location  on employee.empID = location.empID;
//Use of outer keyword is optional

उपर्युक्त सारणी का उपयोग करके, हम दिखा सकते हैं कि सही बाहरी जुड़ने का परिणाम सेट कैसा दिखता है:

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

छवि स्रोत

MySQL 8.0 संदर्भ मैनुअल - सिंटेक्स में शामिल हों

ओरेकल संचालन में शामिल हों

जवाब प्रत्येक के अर्थ में है, इसलिए परिणामों में।

नोट:
इसमें SQLiteकोई नहीं है RIGHT OUTER JOINया नहीं FULL OUTER JOIN।
और इसमें भी MySQLनहीं है FULL OUTER JOIN।

मेरा जवाब उपरोक्त नोट पर आधारित है ।

जब आपके पास दो टेबल हैं:

--[table1]               --[table2]
id | name                id | name
---+-------              ---+-------
1  | a1                  1  | a2
2  | b1                  3  | b2

क्रॉस जॉइन / बाहरी जॉइन:
आप उन सभी टेबल डेटा के साथ CROSS JOINया बस ,इस तरह के साथ हो सकते हैं:

SELECT * FROM table1, table2
--[OR]
SELECT * FROM table1 CROSS JOIN table2

--[Results:]
id | name | id | name 
---+------+----+------
1  | a1   | 1  | a2
1  | a1   | 3  | b2
2  | b1   | 1  | a2
2  | b1   | 3  | b2

इनर जॉइन:
जब आप एक रिलेशनशिप के आधार पर उपरोक्त परिणामों में एक फ़िल्टर जोड़ना चाहते हैं जैसे table1.id = table2.idआप इसका उपयोग कर सकते हैं INNER JOIN:

SELECT * FROM table1, table2 WHERE table1.id = table2.id
--[OR]
SELECT * FROM table1 INNER JOIN table2 ON table1.id = table2.id

--[Results:]
id | name | id | name 
---+------+----+------
1  | a1   | 1  | a2

बाएं [बाहरी] जॉइन:
जब आप उपर्युक्त परिणाम में तालिकाओं में से एक की सभी पंक्तियां रखना चाहते हैं- उसी संबंध के साथ- आप इसका उपयोग कर सकते हैं LEFT JOIN:
( दाएं जॉइन के लिए बस टेबल की जगह बदलें)

SELECT * FROM table1, table2 WHERE table1.id = table2.id 
UNION ALL
SELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)
--[OR]
SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id

--[Results:]
id | name | id   | name 
---+------+------+------
1  | a1   | 1    | a2
2  | b1   | Null | Null

पूर्ण आउटर जॉइन:
जब आप अपने परिणामों में दूसरी तालिका की सभी पंक्तियां भी लेना चाहते हैं तो आप इसका उपयोग कर सकते हैं FULL OUTER JOIN:

SELECT * FROM table1, table2 WHERE table1.id = table2.id
UNION ALL
SELECT *, Null, Null FROM table1 WHERE Not table1.id In (SELECT id FROM table2)
UNION ALL
SELECT Null, Null, * FROM table2 WHERE Not table2.id In (SELECT id FROM table1)
--[OR] (recommended for SQLite)
SELECT * FROM table1 LEFT JOIN table2 ON table1.id = table2.id
UNION ALL
SELECT * FROM table2 LEFT JOIN table1 ON table2.id = table1.id
WHERE table1.id IS NULL
--[OR]
SELECT * FROM table1 FULL OUTER JOIN table2 On table1.id = table2.id

--[Results:]
id   | name | id   | name 
-----+------+------+------
1    | a1   | 1    | a2
2    | b1   | Null | Null
Null | Null | 3    | b2

खैर, आपकी ज़रूरत के अनुसार आप अपनी जरूरत को पूरा करने वाले प्रत्येक व्यक्ति को चुनते हैं;)।

1. आंतरिक शामिल हों: इसमें शामिल होने के रूप में भी कहा जाता है। यह बाएं टेबल दोनों में मौजूद पंक्तियों को लौटाता है, और यदि कोई मिलान होता है तो दाएं टेबल पर ही लौटाता है । अन्यथा, यह शून्य रिकॉर्ड देता है।

उदाहरण:

SELECT
  e1.emp_name,
  e2.emp_salary    
FROM emp1 e1
INNER JOIN emp2 e2
  ON e1.emp_id = e2.emp_id

2. पूर्ण बाहरी शामिल हों: पूर्ण जुड़ाव भी कहा जाता है। यह बाएं टेबल, और दाएं टेबल दोनों में मौजूद सभी पंक्तियां लौटाता है ।

उदाहरण:

SELECT
  e1.emp_name,
  e2.emp_salary    
FROM emp1 e1
FULL OUTER JOIN emp2 e2
  ON e1.emp_id = e2.emp_id

3. बाएं बाहरी शामिल हों: या बस बाएं जुड़ें के रूप में बुलाया जाता है। यह बाएं टेबल में मौजूद सभी पंक्तियां और दाएं तालिका से मेल खाने वाली पंक्तियों (यदि कोई हो) देता है।

4. दाएं बाहरी शामिल हों: राइट जॉइन के रूप में भी बुलाया जाता है। यह बाएं टेबल (यदि कोई हो) से मेल खाने वाली पंक्तियां देता है, और दायां तालिका में मौजूद सभी पंक्तियां।

जुड़ने के फायदे

1. तेजी से निष्पादित करता है।

मान लें कि आप कॉलम पर शामिल नहीं हो रहे हैं जिसमें कोई डुप्लीकेट नहीं है, जो एक बहुत ही आम मामला है:

• ए और बी का एक आंतरिक जुड़ाव एक अंतरण बी का परिणाम देता है, यानी वेन आरेख चौराहे का आंतरिक हिस्सा।

• ए और बी का बाहरी हिस्सा ए यूनियन बी, यानी वेन आरेख संघ के बाहरी हिस्सों के परिणाम देता है।

उदाहरण

मान लें कि आपके पास एक ही कॉलम के साथ दो टेबल हैं, और डेटा निम्नानुसार है:

A    B
-    -
1    3
2    4
3    5
4    6

ध्यान दें कि (1,2) ए के लिए अद्वितीय हैं, (3,4) आम हैं, और (5,6) बी के लिए अद्वितीय हैं।

आंतरिक रूप से जुड़ा

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

select * from a INNER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a = b.b;

a | b
--+--
3 | 3
4 | 4

बाईं ओर का बाहरी जोड़

एक बाएं बाहरी जुड़ाव ए में सभी पंक्तियां, साथ ही बी में किसी भी आम पंक्तियां देगा।

select * from a LEFT OUTER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a = b.b(+);

a |  b
--+-----
1 | null
2 | null
3 |    3
4 |    4

सही बाहरी शामिल हों

एक सही बाहरी जुड़ाव बी में सभी पंक्तियां देगा, साथ ही ए में किसी भी आम पंक्तियां।

select * from a RIGHT OUTER JOIN b on a.a = b.b;
select a.*, b.*  from a,b where a.a(+) = b.b;

a    |  b
-----+----
3    |  3
4    |  4
null |  5
null |  6

पूर्ण बाहरी शामिल हों

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

select * from a FULL OUTER JOIN b on a.a = b.b;

 a   |  b
-----+-----
   1 | null
   2 | null
   3 |    3
   4 |    4
null |    6
null |    5

बहुत प्यार वाले लाल रंग के वेन आरेख की आलोचना करते हुए, मैंने सोचा कि यह केवल अपने प्रयास को पोस्ट करने के लिए उचित है।

यद्यपि @ मार्टिन स्मिथ का जवाब लंबे समय से इस गुच्छा का सबसे अच्छा है, लेकिन वह केवल प्रत्येक तालिका से महत्वपूर्ण कॉलम दिखाता है, जबकि मुझे लगता है कि आदर्श गैर-कुंजी कॉलम भी दिखाना चाहिए।

सबसे अच्छा मैं आधे घंटे में कर सकता था, मुझे अभी भी नहीं लगता कि यह पर्याप्त रूप से दिखाता है कि मूल मूल्यों की अनुपस्थिति के कारण नलियां हैं TableBया OUTER JOINवास्तव में शामिल होने के बजाय संघ है:

सरल परिभाषाएं

आंतरिक शामिल हों: दोनों तालिकाओं से मिलान किए गए रिकॉर्ड लौटाता है ।

पूर्ण बाहरी शामिल हों: दोनों टेबल्स से बेजोड़ रिकॉर्ड के लिए शून्य के साथ दोनों तालिकाओं से मिलान किए गए और बेजोड़ रिकॉर्ड लौटाता है ।

बाएं बाहरी शामिल हों: केवल बाएं किनारे पर तालिका से मिलान और बेजोड़ रिकॉर्ड लौटाता है ।

दायां बाहरी शामिल हों: दाएं किनारे पर केवल तालिका से मिलान और बेजोड़ रिकॉर्ड लौटाता है ।

संक्षेप में

मिलान + बाएं बेजोड़ + दाएं बेजोड़ = पूर्ण बाहरी शामिल हों

मिलान + बाएं बेजोड़ = बाएं बाहरी शामिल हों

मिलान + दाएं बेजोड़ = दाएं बाहरी शामिल हों

मिलान = आंतरिक शामिल हों

INNER JOINदो टेबल की तुलना में कम से कम एक मैच की आवश्यकता है। उदाहरण के लिए, तालिका ए और तालिका बी जो ए 8 बी (एक चौराहे बी) का तात्पर्य है।

LEFT OUTER JOINऔर LEFT JOINवही हैं। यह दोनों टेबलों और बाएं टेबल की सभी संभावनाओं से मेल खाने वाले सभी रिकॉर्ड देता है।

इसी प्रकार, RIGHT OUTER JOINऔर RIGHT JOINवही हैं। यह दोनों टेबलों और सही तालिका की सभी संभावनाओं से मेल खाने वाले सभी रिकॉर्ड देता है।

FULL JOINनकल के बिना LEFT OUTER JOINऔर RIGHT OUTER JOINबिना संयोजन है ।

• INNER JOINदो या दो से अधिक टेबल के लिए सबसे आम शामिल हों। यह प्राथमिक तालिका और फोर्निकी संबंध दोनों तालिकाओं पर डेटा मिलान देता है।
• OUTER JOINजैसा ही है INNER JOIN, लेकिन इसमें NULLपरिणामसेट पर डेटा भी शामिल है ।
  • LEFT JOIN= INNER JOIN+ दाएं टेबल पर नल मैच के साथ बाएं टेबल का बेजोड़ डेटा।
  • RIGHT JOIN= INNER JOIN+ बाएं टेबल पर नल मैच के साथ दाएं टेबल का बेजोड़ डेटा।
  • FULL JOIN= INNER JOIN+ शून्य मिलान के साथ दाएं और बाएं टेबल दोनों पर बेजोड़ डेटा।
• स्वयं में शामिल होने वाला एसक्यूएल में कोई कीवर्ड नहीं है, जब एक तालिका संदर्भ डेटा स्वयं को स्वयं में शामिल होने के रूप में जानता है। उपयोग करना INNER JOINऔर OUTER JOINहम स्वयं से जुड़े प्रश्न लिख सकते हैं।

उदाहरण के लिए:

SELECT * 
FROM   tablea a 
       INNER JOIN tableb b 
               ON a.primary_key = b.foreign_key 
       INNER JOIN tablec c 
               ON b.primary_key = c.foreign_key 

आंतरिक रूप से जुड़ा

एक आंतरिक शामिल परिणाम परिणाम उत्पन्न करता है जो पंक्तियों तक ही सीमित है जहां हम जो खोज रहे हैं उसके लिए दोनों टेबलों में एक मैच है। यदि आपको नहीं पता कि आपको किस प्रकार की आवश्यकता है, तो यह आमतौर पर आपकी सबसे अच्छी शर्त होगी।

बाईं ओर का बाहरी जोड़

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

सही बाहरी जॉइन

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

पूर्ण आउटर जॉइन

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

अधिक Reference

वेन आरेख वास्तव में मेरे लिए यह नहीं करते हैं।

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

तार्किक प्रसंस्करण को समझने के लिए कोई विकल्प नहीं है और यह वैसे भी समझने के लिए अपेक्षाकृत सरल है।

1. एक क्रॉस में शामिल होने की कल्पना करो।
2. चरण 1 से सभी पंक्तियों के खिलाफ खंड on मूल्यांकन करें जहां अनुमानित true मूल्यांकन करते true
3. (केवल बाहरी जुड़ने के लिए) चरण 2 में खोए गए बाहरी पंक्तियों में वापस जोड़ें।

(एनबी: अभ्यास में क्वेरी ऑप्टिमाइज़र उपर्युक्त तार्किक विवरण की तुलना में क्वेरी निष्पादित करने के अधिक कुशल तरीके ढूंढ सकता है लेकिन अंतिम परिणाम समान होना चाहिए)

मैं एक पूर्ण बाहरी शामिल होने के एनिमेटेड संस्करण के साथ शुरू कर दूंगा। आगे स्पष्टीकरण निम्नानुसार है।

व्याख्या

स्रोत सारणी

पहली बार CROSS JOIN (एकेए कार्टेशियन उत्पाद) के साथ शुरू करें। इसमें कोई ON क्लॉज नहीं है और केवल दो तालिकाओं से पंक्तियों के प्रत्येक संयोजन को लौटाता है।

एक क्रॉस जॉइन बी से एक रंग, बी। रंग चुनें

आंतरिक और बाहरी जुड़ने के लिए "चालू" खंड अनुमानित होता है।

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

कुछ उदाहरण

ए। कोलोर, बी। कोलर = बी। कोलोर पर बी में शामिल हों।

उपरोक्त क्लासिक इक्की शामिल है।

एनिमेटेड संस्करण

ए। कोलोर, बी। इनरर से बी में शामिल हों ए। कॉलोर इन नहीं ('ग्रीन', 'ब्लू')

आंतरिक जुड़ने की स्थिति को समानता की स्थिति की आवश्यकता नहीं होती है और इसे तालिकाओं के दोनों (या यहां तक ​​कि) से कॉलम संदर्भित करने की आवश्यकता नहीं होती है। क्रॉस के प्रत्येक पंक्ति पर A.Colour NOT IN ('Green','Blue') मूल्यांकन रिटर्न में शामिल होता है।

ए.कॉलर, बी। 1 से 1 में एक इंटर्नर बी बी से चुनें

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

AColour = B.Colour पर एक बाएं बाहरी जॉइन बी से एक रंग, बी। रंग चुनें।

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

एकोलर, बी। कोलोर पर एक बाएं बाहरी जॉइन बी से चुनें। बी.कॉलर जहां बी.कॉलर न्यूल है

यह पिछले परिणामों को केवल उन पंक्तियों को वापस करने के लिए प्रतिबंधित करता है जहां B.Colour IS NULL । इस विशेष मामले में ये पंक्तियां होंगी जिन्हें संरक्षित किया गया था क्योंकि उनके पास दाएं हाथ की मेज में कोई मिलान नहीं था और क्वेरी तालिका B में मेल नहीं की गई एक लाल पंक्ति को लौटाती है। इसे एक विरोधी अर्द्ध शामिल के रूप में जाना जाता है।

IS NULL परीक्षण के लिए एक कॉलम चुनना महत्वपूर्ण है जो या तो IS NULL नहीं है या जिसके लिए जॉइन की स्थिति सुनिश्चित करती है कि इस पैटर्न को सही तरीके से काम करने के लिए किसी भी NULL मान को बाहर रखा जाएगा और केवल पंक्तियों को वापस लाने से बचें संयुक्त मिलान वाली पंक्तियों के अतिरिक्त उस कॉलम के लिए पूर्ण मान।

एकोलर, बी। कोलोर पर एक सही आउटर बी बी से चुनें।

दायां बाहरी जोड़ों को बाएं बाहरी जोड़ों के समान कार्य करता है सिवाय इसके कि वे सही तालिका से गैर मिलान पंक्तियों को सुरक्षित रखते हैं और नल बाएं हाथ कॉलम का विस्तार करते हैं।

एकोलर, बी। कोलोर पर एक पूर्ण बाहरी जॉइन बी से बी। सेलर, बी। रंग चुनें

पूर्ण बाहरी जुड़ने बाएं और दाएं जुड़ने के व्यवहार को जोड़ते हैं और बाएं और दाएं तालिकाओं से गैर मिलान पंक्तियों को संरक्षित करते हैं।

ए। कोलोर, बी। 1 से 0 पर एक पूर्ण बाहरी जॉइन बी से रंग चुनें

क्रॉस में कोई पंक्तियां 1=0 अनुमान से मेल नहीं खाती हैं। दोनों तरफ से सभी पंक्तियों को दूसरी तरफ टेबल से कॉलम में सामान्य के साथ सामान्य बाहरी शामिल नियमों का उपयोग करके संरक्षित किया जाता है।

1/0 पर एक पूर्ण बाहरी जॉइन बी से रंग के रूप में चयन कोलेस (एकोलोर, बी। कॉलोर)

एक मामूली पूछताछ में मामूली संशोधन के साथ एक UNION ALL दो तालिकाओं का अनुकरण कर सकता है।

एकोलर, बी। कोलोर पर एक बाएं बाहरी जॉइन बी से चुनें। बी.कॉलर जहां बी.कोलर = 'ग्रीन'

ध्यान दें कि WHERE खंड (यदि मौजूद है) शामिल होने के बाद तर्कसंगत रूप से चलता है। एक सामान्य त्रुटि बाएं बाहरी जुड़ने के लिए है और फिर दाएं तालिका पर एक शर्त के साथ एक WHERE क्लॉज शामिल है जो गैर मेल खाने वाली पंक्तियों को छोड़कर समाप्त होता है। उपरोक्त समाप्त होता है बाहरी बहिष्कार प्रदर्शन ...

... और फिर "कहां" खंड चलता है। NULL= 'Green' सत्य का मूल्यांकन नहीं करता है, इसलिए बाहरी जोड़ों द्वारा संरक्षित पंक्ति को समाप्त कर दिया जाता है (नीले रंग के साथ) प्रभावशाली रूप से वापस एक आंतरिक में परिवर्तित हो जाता है।

यदि इरादा बी से केवल पंक्तियों को शामिल करना था जहां रंग ग्रीन है और सही वाक्यविन्यास के बावजूद ए से सभी पंक्तियां होंगी

एकोलर, बी। कोलोर और बी। कोलोर = 'ग्रीन' पर एक बाएं बाहरी जॉइन बी से बी। कॉलोर, बी रंग चुनें।

एसक्यूएल फिडल

इन उदाहरणों को SQLFiddle.com पर लाइव चलाएं देखें।

मैं जेफ के ब्लॉग आलेख की अनुशंसा करता हूं। सबसे अच्छा वर्णन मैंने कभी देखा है, साथ ही एक विज़ुअलाइज़ेशन भी है, उदाहरण के लिए:

आंतरिक रूप से जुड़ा:

पूर्ण बाहरी शामिल हों:

ग्रैहम एलिस द्वारा अपने ब्लॉग हॉर्स मुथ पर " माईएसक्यूएल - बाएं जॉइन एंड राइट जॉइन, इनर जॉइन एंड आउटर जॉइन " लेख से निम्नलिखित लिया गया था।

MySQL जैसे डेटाबेस में, डेटा को कई तालिकाओं में विभाजित किया जाता है जो कई तालिकाओं से रिकॉर्ड पढ़ने के लिए SELECT कमांड में JOIN द्वारा कनेक्ट ( Joined ) होते हैं। यह उदाहरण यह देखने के लिए पढ़ें कि यह कैसे काम करता है।

सबसे पहले, कुछ नमूना डेटा:

people
    mysql> select * from people;
    +------------+--------------+------+
    | name       | phone        | pid  |
    +------------+--------------+------+
    | Mr Brown   | 01225 708225 |    1 |
    | Miss Smith | 01225 899360 |    2 |
    | Mr Pullen  | 01380 724040 |    3 |
    +------------+--------------+------+
    3 rows in set (0.00 sec)

property
    mysql> select * from property;
    +------+------+----------------------+
    | pid  | spid | selling              |
    +------+------+----------------------+
    |    1 |    1 | Old House Farm       |
    |    3 |    2 | The Willows          |
    |    3 |    3 | Tall Trees           |
    |    3 |    4 | The Melksham Florist |
    |    4 |    5 | Dun Roamin           |
    +------+------+----------------------+
    5 rows in set (0.00 sec)

नियमित जॉइन

यदि हम नियमित रूप से जॉइन करते हैं (किसी भी कीवर्ड में INNER, आउटर, बाएं या दाएं) के साथ, तो हमें दो रिकॉर्डों में उचित तरीके से मेल खाने वाले सभी रिकॉर्ड मिलते हैं, और इनकमिंग टेबलों में रिकॉर्ड जो मेल नहीं खाते हैं, की रिपोर्ट नहीं की जाती है :

mysql> select name, phone, selling 
from people join property 
on people.pid = property.pid;
+-----------+--------------+----------------------+
| name      | phone        | selling              |
+-----------+--------------+----------------------+
| Mr Brown  | 01225 708225 | Old House Farm       |
| Mr Pullen | 01380 724040 | The Willows          |
| Mr Pullen | 01380 724040 | Tall Trees           |
| Mr Pullen | 01380 724040 | The Melksham Florist |
+-----------+--------------+----------------------+
4 rows in set (0.01 sec)

बाँया जोड़

यदि हम एक बाएं जॉइन करते हैं, तो हमें सभी रिकॉर्ड मिलते हैं जो एक ही तरीके से मेल खाते हैं और अतिरिक्त में हमें शामिल होने की बाएं तालिका में प्रत्येक बेजोड़ रिकॉर्ड के लिए एक अतिरिक्त रिकॉर्ड मिलता है - इस प्रकार सुनिश्चित करना (इस उदाहरण में) कि प्रत्येक व्यक्ति का उल्लेख हो :

   mysql> select name, phone, selling 
    from people left join property 
    on people.pid = property.pid; 
    +------------+--------------+----------------------+
    | name       | phone        | selling              |
    +------------+--------------+----------------------+
    | Mr Brown   | 01225 708225 | Old House Farm       |
    | Miss Smith | 01225 899360 | NULL <<-- unmatch    |
    | Mr Pullen  | 01380 724040 | The Willows          |
    | Mr Pullen  | 01380 724040 | Tall Trees           |
    | Mr Pullen  | 01380 724040 | The Melksham Florist |
    +------------+--------------+----------------------+
    5 rows in set (0.00 sec)

सही जॉइन

अगर हम सही जुड़ाव करते हैं, तो हम सभी रिकॉर्ड प्राप्त करते हैं और जोड़ों में शामिल होने की सही तालिका में प्रत्येक बेजोड़ रिकॉर्ड के लिए एक अतिरिक्त रिकॉर्ड - मेरे उदाहरण में, इसका मतलब है कि प्रत्येक संपत्ति का उल्लेख होता है भले ही हम नहीं करते विक्रेता विवरण है:

mysql> select name, phone, selling 
from people right join property 
on people.pid = property.pid;
+-----------+--------------+----------------------+
| name      | phone        | selling              |
+-----------+--------------+----------------------+
| Mr Brown  | 01225 708225 | Old House Farm       |
| Mr Pullen | 01380 724040 | The Willows          |
| Mr Pullen | 01380 724040 | Tall Trees           |
| Mr Pullen | 01380 724040 | The Melksham Florist |
| NULL      | NULL         | Dun Roamin           |
+-----------+--------------+----------------------+
5 rows in set (0.00 sec)

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

यदि कोई सामान्य रिकॉर्ड नहीं है तो अंतर में शामिल होने के तरीके में अंतर है।

JOINरूप में ही है INNER JOINऔर केवल शो रिकॉर्ड दोनों तालिकाओं के लिए आम का मतलब है। चाहे रिकॉर्ड्स आम हैं, खंड में शामिल फ़ील्ड द्वारा निर्धारित किया जाता है।

उदाहरण के लिए:

SELECT * 
FROM t1
JOIN t2 on t1.ID = t2.ID

इसका मतलब है केवल रिकॉर्ड दिखाएं जहां एक ही IDमूल्य दोनों तालिकाओं में मौजूद है।

LEFT JOINLEFT OUTER JOINदाएं तालिका में मिलान रिकॉर्ड के अस्तित्व के बावजूद बाएं तालिका से सभी रिकॉर्ड (यानी SQL कथन में पहले वाला) दिखाने के लिए समान है ।

RIGHT JOINजैसा RIGHT OUTER JOINकि विपरीत है और इसका मतलब है LEFT JOIN, यानी दूसरी (दाएं) तालिका से सभी रिकॉर्ड दिखाता है और केवल पहले (बाएं) तालिका से मेल खाने वाले रिकॉर्ड दिखाता है।

सरल शब्दों में:

एक आंतरिक मिलान केवल मिलान पंक्तियों को पुनः प्राप्त करें।

जबकि एक बाहरी मिलान एक तालिका से मेल खाने वाली पंक्तियों और अन्य पंक्तियों में सभी पंक्तियों को पुनर्प्राप्त करता है .... परिणाम इस बात पर निर्भर करता है कि आप किसका उपयोग कर रहे हैं:

• बाएं : दाएं टेबल में मिलान पंक्तियां और बाएं तालिका में सभी पंक्तियां

• दाएं : बाएं टेबल में मिलान की गई पंक्तियां और दाएं तालिका में सभी पंक्तियां या

• पूर्ण : सभी तालिकाओं में सभी पंक्तियां। इससे कोई फर्क नहीं पड़ता कि कोई मैच है या नहीं

आप INNER JOINदोनों टेबलों से सभी पंक्तियों को वापस करने के लिए उपयोग करते हैं जहां एक मैच होता है। यानी परिणामी तालिका में सभी पंक्तियों और स्तंभों के मूल्य होंगे।

में OUTER JOINजिसके परिणामस्वरूप तालिका खाली कॉलम हो सकता है। बाहरी जुड़ाव LEFTया तो हो सकता है RIGHT।

LEFT OUTER JOIN पहली तालिका से सभी पंक्तियां लौटाती हैं, भले ही दूसरी तालिका में कोई मिलान न हो।

RIGHT OUTER JOIN दूसरी तालिका से सभी पंक्तियां लौटाती हैं, भले ही पहली तालिका में कोई मिलान न हो।

 DELETE a FROM WorkRecord2 a 
       INNER JOIN Employee b 
       ON a.EmployeeRun = b.EmployeeNo 
       Where a.Company = '1' 
       AND a.Date = '2013-05-06'