SQL
शामिल हों

परिचय

वाक्य - विन्यास

• [ { INNER | { { LEFT | RIGHT | FULL } [ OUTER ] } } ] JOIN

टिप्पणियों

बुनियादी स्पष्ट आंतरिक सम्मिलित हों

एक बुनियादी (भी "आंतरिक में शामिल होने के" कहा जाता है) में शामिल होने के लिए दो तालिकाओं के डेटा से क्वेरी करता, उनके रिश्ते के साथ एक में परिभाषित join खंड।

निम्नलिखित उदाहरण कर्मचारियों की तालिका से कर्मचारियों के पहले नाम (FName) और विभाग तालिका से (नाम) के लिए काम करने वाले विभाग का नाम चुनेंगे:

SELECT Employees.FName, Departments.Name
FROM   Employees
JOIN   Departments
ON Employees.DepartmentId = Departments.Id

यह उदाहरण डेटाबेस से निम्नलिखित लौटाएगा:

सम्मिलित हों

जॉइंट्स को क्लॉज from कई टेबल में रखकर भी प्रदर्शन किया जा सकता है, कॉमा के साथ अलग किया जा सकता है , और where क्लॉज में उन दोनों के बीच संबंध को परिभाषित किया जा सकता है। इस तकनीक को इंप्लांट जॉइन कहा जाता है (क्योंकि इसमें वास्तव में join क्लॉज नहीं होता है)।

सभी RDBMS इसका समर्थन करते हैं, लेकिन आमतौर पर वाक्य रचना के खिलाफ सलाह दी जाती है। इस सिंटैक्स का उपयोग करने के लिए यह एक बुरा विचार है कारण:

• आकस्मिक क्रॉस जॉइन प्राप्त करना संभव है जो फिर गलत परिणाम लौटाता है, खासकर यदि आपके पास क्वेरी में बहुत सारे जोड़ हैं।
• यदि आपने एक क्रॉस जॉइन का इरादा किया है, तो यह सिंटैक्स से स्पष्ट नहीं है (इसके बजाय CROSS JOIN लिखें), और किसी को रखरखाव के दौरान इसे बदलने की संभावना है।

निम्नलिखित उदाहरण कर्मचारी के पहले नामों और उन विभागों के नाम का चयन करेंगे जिनके लिए वे काम करते हैं:

SELECT e.FName, d.Name
FROM   Employee e, Departments d
WHERE  e.DeptartmentId = d.Id

यह उदाहरण डेटाबेस से निम्नलिखित लौटाएगा:

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

एक लेफ्ट आउटर जॉइन (जिसे लेफ्ट जॉइन या आउटर जॉइन के नाम से भी जाना जाता है) एक जॉइन है जो यह सुनिश्चित करता है कि लेफ्ट टेबल से सभी पंक्तियों का प्रतिनिधित्व किया जाता है; यदि सही तालिका से कोई मिलान पंक्ति मौजूद नहीं है, तो इसके संबंधित क्षेत्र NULL ।

निम्नलिखित उदाहरण सभी विभागों और उस विभाग में काम करने वाले कर्मचारियों के पहले नाम का चयन करेंगे। परिणाम में कोई कर्मचारी नहीं है, लेकिन अभी भी कर्मचारी के नाम के लिए NULL नहीं है:

SELECT          Departments.Name, Employees.FName
FROM            Departments 
LEFT OUTER JOIN Employees 
ON              Departments.Id = Employees.DepartmentId

यह उदाहरण डेटाबेस से निम्नलिखित लौटाएगा:

यह कैसे काम करता है?

FROM क्लॉज में दो टेबल हैं:

तथा

पहले एक कार्टेशियन उत्पाद को दो टेबल से बनाया जाता है जो एक मध्यवर्ती तालिका देता है।
ज्वाइन मानदंड ( विभागों ) ।d = Employees.DepboxId ) को पूरा करने वाले रिकॉर्ड बोल्ड में हाइलाइट किए गए हैं; इन्हें क्वेरी के अगले चरण में पास किया जाता है।

जैसा कि यह एक LEFT OUTER JOIN है, सभी रिकॉर्ड ज्वाइन (विभागों) के LEFT साइड से दिए जाते हैं, जबकि RIGHT साइड के किसी भी रिकॉर्ड को NULL मार्कर दिया जाता है यदि वे जॉइन मापदंड से मेल नहीं खाते हैं। नीचे दी गई तालिका में NULL साथ Tech वापस आ जाएगी

अंत में सेलेक्ट क्लॉज के भीतर इस्तेमाल होने वाले प्रत्येक एक्सप्रेशन का मूल्यांकन हमारी अंतिम तालिका को लौटाने के लिए किया जाता है:

स्वयं सम्मिलित हों

एक तालिका खुद से जुड़ सकती है, जिसमें अलग-अलग पंक्तियाँ एक-दूसरे से किसी न किसी स्थिति से मेल खाती हैं। इस उपयोग के मामले में, टेबल की दो घटनाओं को अलग करने के लिए उपनाम का उपयोग किया जाना चाहिए।

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

SELECT 
    e.FName AS "Employee", 
    m.FName AS "Manager"
FROM   
    Employees e
JOIN   
    Employees m 
    ON e.ManagerId = m.Id

यह क्वेरी निम्नलिखित डेटा लौटाएगी:

यह कैसे काम करता है?

मूल तालिका में ये रिकॉर्ड हैं:

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

अगली कार्रवाई को ही रिकार्ड को पूरा मापदंड शामिल हों रखने के लिए, किसी भी रिकॉर्ड जहां aliased इतना है e तालिका ManagerId aliased के बराबर होती है m तालिका Id :

फिर, SELECT क्लॉज़ के भीतर उपयोग की जाने वाली प्रत्येक अभिव्यक्ति का मूल्यांकन इस तालिका को लौटाने के लिए किया जाता है:

अंत में, स्तंभ के नाम e.FName और m.FName को उनके उपनाम स्तंभ नामों से बदल दिया जाता है, जिन्हें AS ऑपरेटर द्वारा सौंपा गया है:

क्रोस जॉइन

क्रॉस ज्वाइन दो सदस्यों के कार्टेशियन उत्पाद करता है, ए कार्टेशियन उत्पाद का मतलब है कि एक तालिका की प्रत्येक पंक्ति में दूसरी तालिका की प्रत्येक पंक्ति के साथ संयुक्त है। उदाहरण के लिए, यदि TABLEA में 20 पंक्तियाँ हैं और TABLEB में 20 पंक्तियाँ हैं, तो परिणाम 20*20 = 400 आउटपुट पंक्तियाँ होंगी।

उदाहरण डेटाबेस का उपयोग करना

SELECT d.Name, e.FName
FROM   Departments d
CROSS JOIN Employees e;

कौन सा रिटर्न:

यदि आप एक कार्टेसियन जॉइन करना चाहते हैं, तो यह स्पष्ट करने के लिए कि आप क्या चाहते हैं, एक स्पष्ट क्रॉस लिखने की सिफारिश की जाती है।

एक उपकेंद्र पर शामिल हो रहे हैं

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

SELECT po.Id, po.PODate, po.VendorName, po.Status, item.ItemNo, 
  item.Description, item.Cost, item.Price
FROM PurchaseOrders po
LEFT JOIN 
     (
       SELECT l.PurchaseOrderId, l.ItemNo, l.Description, l.Cost, l.Price, Min(l.id) as Id 
       FROM PurchaseOrderLineItems l
       GROUP BY l.PurchaseOrderId, l.ItemNo, l.Description, l.Cost, l.Price
     ) AS item ON item.PurchaseOrderId = po.Id

पार का आवेदन और स्थानीय जॉय

JOIN का एक बहुत ही रोचक प्रकार है LATERAL JOIN (PostgreSQL 9.3+ में नया)
जिसे SQL-Server और Oracle में CROSS APPLY / OUTER APPLY के रूप में भी जाना जाता है।

मूल विचार यह है कि आपके द्वारा जुड़ने वाली प्रत्येक पंक्ति के लिए एक टेबल-वैल्यू फ़ंक्शन (या इनलाइन सबक्वेरी) लागू किया जाता है।

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

वाक्य - विन्यास:

PostgreSQL 9.3+

छोड़ दिया | सही | आंतरिक जॉय लोकल

एस क्यू एल सर्वर:

CROSS | OUTER APPLY

INNER JOIN LATERAL , CROSS APPLY के समान है
और LEFT JOIN LATERAL , OUTER APPLY के समान है

उदाहरण का उपयोग (PostgreSQL 9.3+):

SELECT * FROM T_Contacts 

--LEFT JOIN T_MAP_Contacts_Ref_OrganisationalUnit ON MAP_CTCOU_CT_UID = T_Contacts.CT_UID AND MAP_CTCOU_SoftDeleteStatus = 1 
--WHERE T_MAP_Contacts_Ref_OrganisationalUnit.MAP_CTCOU_UID IS NULL -- 989


LEFT JOIN LATERAL 
(
    SELECT 
         --MAP_CTCOU_UID    
         MAP_CTCOU_CT_UID   
        ,MAP_CTCOU_COU_UID  
        ,MAP_CTCOU_DateFrom 
        ,MAP_CTCOU_DateTo   
   FROM T_MAP_Contacts_Ref_OrganisationalUnit 
   WHERE MAP_CTCOU_SoftDeleteStatus = 1 
   AND MAP_CTCOU_CT_UID = T_Contacts.CT_UID 

    /*  
    AND 
    ( 
        (__in_DateFrom <= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateTo) 
        AND 
        (__in_DateTo >= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateFrom) 
    ) 
    */
   ORDER BY MAP_CTCOU_DateFrom 
   LIMIT 1 
) AS FirstOE 

और SQL- सर्वर के लिए

SELECT * FROM T_Contacts 

--LEFT JOIN T_MAP_Contacts_Ref_OrganisationalUnit ON MAP_CTCOU_CT_UID = T_Contacts.CT_UID AND MAP_CTCOU_SoftDeleteStatus = 1 
--WHERE T_MAP_Contacts_Ref_OrganisationalUnit.MAP_CTCOU_UID IS NULL -- 989

-- CROSS APPLY -- = INNER JOIN 
OUTER APPLY    -- = LEFT JOIN 
(
    SELECT TOP 1 
         --MAP_CTCOU_UID    
         MAP_CTCOU_CT_UID   
        ,MAP_CTCOU_COU_UID  
        ,MAP_CTCOU_DateFrom 
        ,MAP_CTCOU_DateTo   
   FROM T_MAP_Contacts_Ref_OrganisationalUnit 
   WHERE MAP_CTCOU_SoftDeleteStatus = 1 
   AND MAP_CTCOU_CT_UID = T_Contacts.CT_UID 

    /*  
    AND 
    ( 
        (@in_DateFrom <= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateTo) 
        AND 
        (@in_DateTo >= T_MAP_Contacts_Ref_OrganisationalUnit.MAP_KTKOE_DateFrom) 
    ) 
    */
   ORDER BY MAP_CTCOU_DateFrom 
) AS FirstOE 

पूरा जोइन

JOIN का एक प्रकार जिसे कम जाना जाता है, वह पूर्ण JOIN है।
(नोट: फुल जॉइन 2016 के अनुसार MySQL द्वारा समर्थित नहीं है)

एक पूर्ण OUT JOIN, बाईं तालिका से सभी पंक्तियों को और दाएं तालिका से सभी पंक्तियों को वापस करता है।

यदि बाईं तालिका में ऐसी पंक्तियाँ हैं, जिनमें दाईं तालिका में मिलान नहीं हैं, या यदि दाईं तालिका में ऐसी पंक्तियाँ हैं, जिनकी बाईं तालिका में मिलान नहीं हैं, तो उन पंक्तियों को भी सूचीबद्ध किया जाएगा।

उदाहरण 1 :

SELECT * FROM Table1

FULL JOIN Table2 
     ON 1 = 2 

उदाहरण 2:

SELECT 
     COALESCE(T_Budget.Year, tYear.Year) AS RPT_BudgetInYear 
    ,COALESCE(T_Budget.Value, 0.0) AS RPT_Value 
FROM T_Budget 

FULL JOIN tfu_RPT_All_CreateYearInterval(@budget_year_from, @budget_year_to) AS tYear 
      ON tYear.Year = T_Budget.Year 

ध्यान दें कि यदि आप सॉफ्ट-डिलीट का उपयोग कर रहे हैं, तो आपको WHERE- क्लॉज में सॉफ्ट-डिलीट स्टेटस को फिर से जांचना होगा (क्योंकि फुल जॉइन एक यूनिअन की तरह ही व्यवहार करता है);
इस छोटे से तथ्य को अनदेखा करना आसान है, क्योंकि आप AP_SoftDeleteStatus = 1 को क्लॉज में शामिल करते हैं।

इसके अलावा, अगर आप फुल जॉइन कर रहे हैं, तो आपको आमतौर पर NULL को WHERE-क्लॉज में अनुमति देनी होगी; एक मूल्य पर NULL की अनुमति देना भूल जाने से INNER जॉइन के समान ही प्रभाव पड़ेगा, जो कि आप चाहते हैं कि अगर आप FULL JOIN कर रहे हैं तो कुछ ऐसा न हो।

उदाहरण:

SELECT 
     T_AccountPlan.AP_UID
    ,T_AccountPlan.AP_Code
    ,T_AccountPlan.AP_Lang_EN
    ,T_BudgetPositions.BUP_Budget
    ,T_BudgetPositions.BUP_UID 
    ,T_BudgetPositions.BUP_Jahr
FROM T_BudgetPositions    

FULL JOIN T_AccountPlan
    ON T_AccountPlan.AP_UID = T_BudgetPositions.BUP_AP_UID 
    AND T_AccountPlan.AP_SoftDeleteStatus = 1 

WHERE (1=1) 
AND (T_BudgetPositions.BUP_SoftDeleteStatus = 1 OR T_BudgetPositions.BUP_SoftDeleteStatus IS NULL) 
AND (T_AccountPlan.AP_SoftDeleteStatus = 1 OR T_AccountPlan.AP_SoftDeleteStatus IS NULL) 

रिकर्सिव जॉयस

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

WITH RECURSIVE MyDescendants AS (
    SELECT Name
    FROM People
    WHERE Name = 'John Doe'

    UNION ALL

    SELECT People.Name
    FROM People
    JOIN MyDescendants ON People.Name = MyDescendants.Parent
)
SELECT * FROM MyDescendants;

आंतरिक / बाहरी जुड़नों के बीच अंतर

SQL में विभिन्न जुड़ने के प्रकार होते हैं, जो यह बताते हैं कि (गैर-) मिलान पंक्तियों को परिणाम में शामिल किया गया है: INNER JOIN , LEFT OUTER JOIN , RIGHT OUTER JOIN और FULL OUTER JOIN ( INNER और OUTER कीवर्ड वैकल्पिक हैं)। नीचे दिया गया आंकड़ा इन प्रकारों के बीच के अंतर को रेखांकित करता है: नीला क्षेत्र जुड़ने से वापस आए परिणामों का प्रतिनिधित्व करता है, और सफेद क्षेत्र उन परिणामों का प्रतिनिधित्व करता है जो जुड़ने पर वापस नहीं आएंगे।

क्रॉस SQL चित्र प्रस्तुति ( संदर्भ ) में शामिल हों:

नीचे इस उत्तर से उदाहरण दिए गए हैं।

उदाहरण के लिए नीचे दो तालिकाएँ हैं:

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

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

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

दोनों में से किसी एक समतुल्य प्रश्नों का उपयोग करके एक आंतरिक जुड़ाव दो तालिकाओं के प्रतिच्छेदन को देता है, अर्थात दो पंक्तियाँ जो उनके पास हैं:

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

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

एक बाईं बाहरी जुड़ाव A में सभी पंक्तियाँ देगा, साथ ही B में कोई भी सामान्य पंक्तियाँ:

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

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

सही बाहरी जुड़ना

इसी तरह, एक सही बाहरी जुड़ाव B में सभी पंक्तियों को जोड़ देगा, साथ ही A में कोई भी सामान्य पंक्तियाँ:

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

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

पूर्ण बाहरी जुड़ना

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

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

जोइन शब्दावली: इनर, आउटर, सेमी, एंटी ...

मान लें कि हमारे पास दो टेबल (A और B) हैं और उनकी कुछ पंक्तियाँ मेल खाती हैं (दिए गए JOIN स्थिति के सापेक्ष, जो कुछ विशेष स्थिति में हो सकती है):

हम दोनों में से मेल खाते हुए या गैर-मेलिंग पंक्तियों को शामिल करने या बाहर करने के लिए विभिन्न सम्मिलित प्रकारों का उपयोग कर सकते हैं, और ऊपर दिए गए आरेख से संबंधित शब्दों को उठाकर सही ढंग से जुड़ने का नाम दे सकते हैं।

नीचे दिए गए उदाहरण निम्नलिखित परीक्षण डेटा का उपयोग करते हैं:

CREATE TABLE A (
    X varchar(255) PRIMARY KEY
);

CREATE TABLE B (
    Y varchar(255) PRIMARY KEY
);

INSERT INTO A VALUES
    ('Amy'),
    ('John'),
    ('Lisa'),
    ('Marco'),
    ('Phil');

INSERT INTO B VALUES
    ('Lisa'),
    ('Marco'),
    ('Phil'),
    ('Tim'),
    ('Vincent');

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

मैच से बायीं और दायीं पंक्तियों को मिलाता है।

SELECT * FROM A JOIN B ON X = Y;

X      Y
------ -----
Lisa   Lisa
Marco  Marco
Phil   Phil

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

कभी-कभी "लेफ्ट जॉइन" के लिए संक्षिप्त। उस मेल से बायीं और दायीं पंक्तियों को मिलाता है, और गैर-मिलान वाली बायीं पंक्तियों को शामिल करता है।

SELECT * FROM A LEFT JOIN B ON X = Y;

X      Y
-----  -----
Amy    NULL
John   NULL
Lisa   Lisa
Marco  Marco
Phil   Phil

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

कभी-कभी "सही जुड़ने" के लिए संक्षिप्त। उस मेल से बायीं और दायीं पंक्तियों को जोड़ती है, और गैर-मिलान वाली दाईं पंक्तियों को शामिल करती है।

SELECT * FROM A RIGHT JOIN B ON X = Y;

X      Y
-----  -------
Lisa   Lisa
Marco  Marco
Phil   Phil
NULL   Tim
NULL   Vincent

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

कभी-कभी "पूर्ण जुड़ाव" के लिए संक्षिप्त। बाएँ और दाएँ बाहरी मिलन।

SELECT * FROM A FULL JOIN B ON X = Y;

X      Y
-----  -------
Amy    NULL
John   NULL
Lisa   Lisa
Marco  Marco
Phil   Phil
NULL   Tim
NULL   Vincent

लेफ्ट सेमी जॉइन करें

दाएं पंक्तियों से मेल खाने वाली बाईं पंक्तियां शामिल हैं।

SELECT * FROM A WHERE X IN (SELECT Y FROM B);

X
-----
Lisa
Marco
Phil

राइट सेमी जॉइन

दाएं पंक्तियां शामिल हैं जो बाईं पंक्तियों से मेल खाती हैं।

SELECT * FROM B WHERE Y IN (SELECT X FROM A);

Y
-----
Lisa
Marco
Phil

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

वाम विरोधी अर्ध शामिल हों

बाईं पंक्तियाँ शामिल हैं जो सही पंक्तियों से मेल नहीं खाती हैं।

SELECT * FROM A WHERE X NOT IN (SELECT Y FROM B);

X
----
Amy
John

चेतावनी: यदि आप एक सक्षम स्तंभ पर नहीं का उपयोग कर होने के लिए सावधान रहें! अधिक जानकारी यहाँ ।

राइट एंटी सेमी जॉइन

सही पंक्तियाँ शामिल हैं जो बाईं पंक्तियों से मेल नहीं खाती हैं।

SELECT * FROM B WHERE Y NOT IN (SELECT X FROM A);

Y
-------
Tim
Vincent

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

क्रॉस जॉइन करें

सभी सही पंक्तियों के साथ सभी का एक कार्टेशियन उत्पाद।

SELECT * FROM A CROSS JOIN B;

X      Y
-----  -------
Amy    Lisa
John   Lisa
Lisa   Lisa
Marco  Lisa
Phil   Lisa
Amy    Marco
John   Marco
Lisa   Marco
Marco  Marco
Phil   Marco
Amy    Phil
John   Phil
Lisa   Phil
Marco  Phil
Phil   Phil
Amy    Tim
John   Tim
Lisa   Tim
Marco  Tim
Phil   Tim
Amy    Vincent
John   Vincent
Lisa   Vincent
Marco  Vincent
Phil   Vincent

क्रॉस ज्वाइन, ज्वाइन कंडीशन के साथ इनर जॉइन के बराबर है जो हमेशा मेल खाता है, इसलिए निम्न क्वेरी उसी परिणाम को लौटा देती है:

SELECT * FROM A JOIN B ON 1 = 1;

स्व शामिल हों

यह केवल अपने साथ शामिल होने वाली तालिका को दर्शाता है। एक स्व-जुड़ाव ऊपर चर्चा किए गए प्रकारों में से कोई भी हो सकता है। उदाहरण के लिए, यह एक आंतरिक स्व-जुड़ाव है:

SELECT * FROM A A1 JOIN A A2 ON LEN(A1.X) < LEN(A2.X);

X     X
----  -----
Amy   John
Amy   Lisa
Amy   Marco
John  Marco
Lisa  Marco
Phil  Marco
Amy   Phil