एसक्यूएल पूर्ण शामिल हों

यह लेख FULL JOIN . का एक सिंहावलोकन प्रदान करता है SQL में, साथ ही साथ कुछ बुनियादी उदाहरण।

एसक्यूएल FULL JOIN (या FULL OUTER JOIN ) सभी पंक्तियों को लौटाता है, जब तक कि किसी एक तालिका में मिलान डेटा है।

यह ऐसा है जैसे बाएँ दाएँ दोनों को एक जॉइन में शामिल करना।

सिंटैक्स

आप FROM . में पूर्ण जुड़ाव निर्दिष्ट करते हैं खंड। आप या तो FULL JOIN का उपयोग कर सकते हैं या FULL OUTER JOIN वाक्य रचना।

FULL JOIN का उपयोग करना वाक्य रचना:

SELECT *
FROM Table1 FULL JOIN Table2 
ON Table1.Column = Table2.Column;

FULL OUTER JOIN का उपयोग करना वाक्य रचना:

SELECT *
FROM Table1 FULL OUTER JOIN Table2 
ON Table1.Column = Table2.Column;

ये दोनों बिल्कुल एक ही काम करते हैं। यह बस इतना ही है कि OUTER कीवर्ड वैकल्पिक है।

उदाहरण

प्रदर्शित करने के लिए यहां कुछ उदाहरण दिए गए हैं।

नमूना डेटा

सबसे पहले, यहां वे टेबल हैं जिनका हम उदाहरणों के लिए उपयोग करेंगे।

PetTypes तालिका:

+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)

Pets तालिका:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)

Owners तालिका:

+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
| 5         | Woody       | Eastwood   | (308) 555-0112 | [email protected] |
+-----------+-------------+------------+----------------+-------------------+

ध्यान दें कि:

• द PetTypeId Pets . का कॉलम तालिका PetTypeId . की एक विदेशी कुंजी है PetTypes का तालिका (जो उस तालिका की प्राथमिक कुंजी है)।
• द OwnerId Pets . का कॉलम तालिका OwnerId . की एक विदेशी कुंजी है Owners . का कॉलम टेबल.

पूरी तरह से शामिल होने की क्वेरी

यहां उन दो तालिकाओं के विरुद्ध पूर्ण जुड़ाव करने का एक उदाहरण दिया गया है।

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
FULL JOIN PetTypes pt
ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

इस उदाहरण में, हमें एक PetType मिलता है मान जो PetName . से मेल नहीं खाता है . ऐसा इसलिए है क्योंकि पालतू जानवर के रूप में कोई खरगोश नहीं हैं। लेकिन पूर्ण जुड़ाव Rabbit causes का कारण बनता है लौटाया जाना है, भले ही Pets . में कोई पालतू जानवर न हो उस प्रकार की तालिका। इसका परिणाम NULL होता है PetName में मान Rabbit . के सामने स्तंभ ।

यह वही परिणाम है जो हमें मिला होता अगर हम सही जॉइन का उपयोग करते, क्योंकि PetTypes तालिका JOIN के दाईं ओर है खोजशब्द। लेफ्ट जॉइन के साथ ऐसा नहीं होता, क्योंकि PetTypes तालिका JOIN के बाईं ओर नहीं है खोजशब्द। अगर हम इसे लेफ्ट जॉइन के साथ फिर से बनाना चाहते हैं, तो हमें टेबल्स के क्रम को बदलना होगा, ताकि PetTypes तालिका JOIN के बाईं ओर थी खोजशब्द।

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

SELECT 
    p.PetName,
    pt.PetType
FROM PetTypes pt
FULL JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Tweet     | Bird      |
| Fluffy    | Cat       |
| Scratch   | Cat       |
| Meow      | Cat       |
| Fetch     | Dog       |
| Wag       | Dog       |
| Fluffy    | Dog       |
| Bark      | Dog       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

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

3 टेबल पर पूर्ण रूप से शामिल हों

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

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o FULL JOIN Pets p
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Tweet     | Bird      | Homer Connery  |
| Scratch   | Cat       | Bart Pitt      |
| Bark      | Dog       | Bart Pitt      |
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
| NULL      | Rabbit    |                |
+-----------+-----------+----------------+
(10 rows affected)

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

यदि हम चारों ओर की तालिकाओं के क्रम में फेरबदल करते हैं, तो हमें एक ही परिणाम मिलता है, हालांकि पंक्तियों को एक अलग क्रम में सूचीबद्ध किया जाता है।

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt FULL JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
FULL JOIN Owners o 
    ON p.OwnerId = o.OwnerId;

परिणाम:

-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Tweet     | Bird      | Homer Connery  |
| Fluffy    | Cat       | Nancy Simpson  |
| Scratch   | Cat       | Bart Pitt      |
| Meow      | Cat       | Boris Trump    |
| Fetch     | Dog       | Nancy Simpson  |
| Wag       | Dog       | Nancy Simpson  |
| Fluffy    | Dog       | Boris Trump    |
| Bark      | Dog       | Bart Pitt      |
| NULL      | Rabbit    |                |
| NULL      | NULL      | Woody Eastwood |
+-----------+-----------+----------------+
(10 rows affected)

और अगर हम उन्हें एक बार फिर से फेरबदल करते हैं, तो भी हमें वही परिणाम मिलता है।

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Pets p FULL JOIN Owners o
    ON p.OwnerId = o.OwnerId
FULL JOIN PetTypes pt
    ON p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+----------------+
| PetName   | PetType   | PetOwner       |
|-----------+-----------+----------------|
| Fluffy    | Cat       | Nancy Simpson  |
| Fetch     | Dog       | Nancy Simpson  |
| Scratch   | Cat       | Bart Pitt      |
| Wag       | Dog       | Nancy Simpson  |
| Tweet     | Bird      | Homer Connery  |
| Fluffy    | Dog       | Boris Trump    |
| Bark      | Dog       | Bart Pitt      |
| Meow      | Cat       | Boris Trump    |
| NULL      | NULL      | Woody Eastwood |
| NULL      | Rabbit    |                |
+-----------+-----------+----------------+
(10 rows affected)

अगर आप सोच रहे हैं कि आखिरी PetOwner . क्यों NULL नहीं है (पिछले की तरह PetName है), ऐसा इसलिए है क्योंकि यह एक स्ट्रिंग संयोजन का परिणाम है। मैंने टी-एसक्यूएल का इस्तेमाल किया CONCAT() स्वामी के प्रथम और अंतिम नामों को जोड़ने का कार्य करता है।