एसक्यूएल लेफ्ट जॉइन

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

LEFT JOIN , या LEFT OUTER JOIN , उन पंक्तियों को लौटाता है जिनमें बाईं तालिका में डेटा होता है (JOIN . के बाईं ओर कीवर्ड), भले ही सही तालिका में कोई मेल खाने वाली पंक्तियाँ न हों।

सिंटैक्स

आप FROM . में लेफ्ट जॉइन निर्दिष्ट करते हैं खंड। आप या तो LEFT JOIN का उपयोग कर सकते हैं या LEFT OUTER JOIN वाक्य रचना।

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

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

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

SELECT *
FROM Table1 LEFT 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 PetTypes pt
LEFT 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)

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

ऐसा सिर्फ इसलिए हुआ क्योंकि Rabbit लेफ्ट टेबल में था (यानी LEFT JOIN . के बाईं ओर) कीवर्ड)। ठीक है, मेरा स्वरूपण इसे "बाएं" से अधिक "ऊपर" बनाता है, लेकिन आपको चित्र मिलता है।

यदि हम अपनी क्वेरी में तालिका क्रम को बदलते हैं तो यहां क्या होता है।

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

परिणाम:

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

इस बार Rabbit वापस नहीं किया गया था। ऐसा इसलिए है क्योंकि इसकी तालिका (PetTypes ) शामिल होने के दाईं ओर था।

अगर हमें Rabbit . चाहिए तो हमें इसे राइट जॉइन या फुल जॉइन में बदलना होगा इस तालिका क्रम का उपयोग करके लौटाया जाना है।

3 टेबल पर लेफ्ट जॉइन करें

यहां तीनों टेबल पर लेफ्ट जॉइन करने का एक उदाहरण दिया गया है।

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM Owners o LEFT JOIN Pets p
    ON p.OwnerId = o.OwnerId
LEFT 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 |
+-----------+-----------+----------------+
(9 rows affected)

इस बार हमारे पास एक पालतू जानवर का मालिक है जिसके पास कोई पालतू जानवर नहीं है।

हम फिर से तालिकाओं के क्रम में फेरबदल कर सकते हैं, और हमें एक अलग परिणाम मिलेगा।

SELECT 
    p.PetName,
    pt.PetType,
    CONCAT(o.FirstName, ' ', o.LastName) AS PetOwner
FROM PetTypes pt LEFT JOIN Pets p
    ON p.PetTypeId = pt.PetTypeId
LEFT 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    |               |
+-----------+-----------+---------------+
(9 rows affected)

इस बार हमें अतिरिक्त पालतू प्रकार मिला (Rabbit ), लेकिन अतिरिक्त स्वामी नहीं।

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