एसक्यूएल ट्यूटोरियल में शामिल होता है

SQL जॉइन वह जगह है जहाँ आप एक क्वेरी चलाते हैं जो कई तालिकाओं को जोड़ती है।

यह एसक्यूएल जॉइन ट्यूटोरियल एसक्यूएल जॉइन के मूल उदाहरण प्रस्तुत करता है, साथ ही विभिन्न जॉइन प्रकारों के लिए एक परिचय भी प्रस्तुत करता है।

एसक्यूएल जॉइन टाइप्स

एएनएसआई एसक्यूएल मानक पांच प्रकार के जॉइन को निर्दिष्ट करता है, जैसा कि निम्न तालिका में सूचीबद्ध है।

जॉइन टाइप
INNER JOIN	पंक्तियों को लौटाता है जब दोनों तालिकाओं में कम से कम एक पंक्ति होती है जो शामिल होने की स्थिति से मेल खाती है।
LEFT OUTER JOIN या LEFT JOIN	उन पंक्तियों को लौटाता है जिनमें बाईं तालिका में डेटा होता है (JOIN के बाईं ओर) कीवर्ड), भले ही सही तालिका में कोई मेल खाने वाली पंक्तियाँ न हों।
RIGHT OUTER JOIN या RIGHT JOIN	उन पंक्तियों को लौटाता है जिनमें डेटा सही तालिका में होता है (JOIN . के दाईं ओर) कीवर्ड), भले ही बाईं तालिका में कोई मेल खाने वाली पंक्तियाँ न हों।
FULL OUTER JOIN या FULL JOIN	सभी पंक्तियों को लौटाता है, जब तक कि किसी एक तालिका में मिलान डेटा है।
CROSS JOIN	पहली तालिका की प्रत्येक पंक्ति को दूसरी तालिका की प्रत्येक पंक्ति के साथ संयोजित करने वाली पंक्तियाँ देता है।

विभिन्न जॉइन ऑपरेशंस के लिए अन्य शर्तें भी हैं, जैसे कि निम्नलिखित:

एसक्यूएल सिंटेक्स में शामिल हों

इनर जॉइन को FROM . में से किसी एक में निर्दिष्ट किया जा सकता है या WHERE खंड। आउटर जॉइन और क्रॉस जॉइन को FROM . में निर्दिष्ट किया जा सकता है केवल खंड।

SQL बनाने के लिए FROM . में शामिल हों खंड, कुछ इस तरह करें:

SELECT *
FROM Table1 < JoinType > Table2 [ ON ( JoinCondition ) ]

जहां JoinType निर्दिष्ट करता है कि किस प्रकार का जुड़ाव किया जाता है, और JoinCondition शामिल पंक्तियों की प्रत्येक जोड़ी के लिए मूल्यांकन किए जाने वाले विधेय को परिभाषित करता है।

WHERE . में शामिल होने को निर्दिष्ट करने के लिए खंड, कुछ इस तरह करें:

SELECT *
FROM Table1, Table2 [ WHERE ( JoinCondition ) ]

फिर से, JoinCondition शामिल पंक्तियों की प्रत्येक जोड़ी के लिए मूल्यांकन किए जाने वाले विधेय को परिभाषित करता है।

साथ ही, वर्गाकार कोष्ठकों में संलग्न सब कुछ ([] ) वैकल्पिक है।

इस ट्यूटोरियल में उदाहरणों के लिए नमूना तालिकाएं

इस ट्यूटोरियल के अधिकांश उदाहरण निम्नलिखित दो तालिकाओं के विरुद्ध जॉइन करते हैं।

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)

द इनर जॉइन

एसक्यूएल INNER JOIN पंक्तियों को लौटाता है जब दोनों तालिकाओं में कम से कम एक पंक्ति होती है जो शामिल होने की स्थिति से मेल खाती है।

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

परिणाम:

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

FROM . में एक आंतरिक जुड़ाव निर्दिष्ट करने के लिए खंड, हम उपयोग करते हैं INNER JOIN . हम ON . का भी उपयोग करते हैं शामिल पंक्तियों की प्रत्येक जोड़ी के लिए मूल्यांकन किए जाने वाले विधेय को परिभाषित करने के लिए कीवर्ड।

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

इस उदाहरण में, दोनों तालिकाओं में एक PetTypeId है कॉलम। Pets.PetTypeId कॉलम PetTypes.PetTypeId . के लिए एक विदेशी कुंजी है कॉलम, जो उस तालिका की प्राथमिक कुंजी है।

इस उदाहरण में, हम देख सकते हैं कि सभी पालतू जानवर वापस कर दिए गए हैं, लेकिन सभी प्रकार के पालतू जानवर वापस नहीं किए गए हैं। Pets . में कोई खरगोश नहीं है तालिका, और इसलिए Rabbits पालतू जानवर का प्रकार वापस नहीं किया जाता है।

कारण Rabbits प्रकार वापस नहीं किया गया है क्योंकि INNER JOIN केवल पंक्तियों को लौटाता है जब दोनों तालिकाओं में कम से कम एक पंक्ति होती है जो शामिल होने की स्थिति से मेल खाती है। इस मामले में, Rabbits केवल एक टेबल में है (PetTypes टेबल)।

ध्यान दें कि शामिल होने का प्रकार वैकल्पिक है। इसलिए, अधिकांश (यदि सभी नहीं) DBMS आपको INNER . को छोड़ने की अनुमति देते हैं खोजशब्द। जब आप इसे छोड़ देते हैं (अर्थात केवल JOIN . निर्दिष्ट करें ), इसे आंतरिक जुड़ाव माना जाता है।

इसलिए, हम उपरोक्त उदाहरण को फिर से लिख सकते हैं:

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

साथ ही, किसी भी SQL कथन की तरह, FROM यदि आप चाहें तो क्लॉज एक पूरी लाइन पर हो सकता है:

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

उपनाम

SQL जॉइन करते समय टेबल एलियासेस का उपयोग करना आम बात है। उपनाम कोड को अधिक संक्षिप्त और पढ़ने में आसान बनाने में मदद करते हैं।

इसलिए, हम पिछले उदाहरण को इसमें बदल सकते हैं:

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p INNER 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)

द इक्वि-जॉइन

उपरोक्त जॉइन को इक्वि-जॉइन . के रूप में भी संदर्भित किया जा सकता है . एक इक्वि-जॉइन एक जॉइन है जिसमें जॉइन विधेय में केवल समानता की तुलना होती है।

उपरोक्त जॉइन लिखने का दूसरा तरीका इस प्रकार है:

SELECT
    p.PetName,
    pt.PetType
FROM 
    Pets p, 
    PetTypes pt
WHERE p.PetTypeId = pt.PetTypeId;

परिणाम:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

यह WHERE . में इनर जॉइन को निर्दिष्ट करने का एक उदाहरण है खंड। हमने केवल तालिकाओं की अल्पविराम से अलग की गई सूची प्रदान की, और फिर एक WHERE . प्रदान किया स्थिति। अगर हम WHERE . को छोड़ देते शर्त, हम एक CROSS JOIN के साथ समाप्त हो गए होंगे ।

कई शुरुआती लोगों को INNER JOIN . की तुलना में उपरोक्त सिंटैक्स को समझना बहुत आसान लगता है वाक्य - विन्यास। यदि आप चाहें तो इस सिंटैक्स का उपयोग करने के लिए स्वतंत्र महसूस करें, हालांकि, इस बात से अवगत रहें कि अधिकांश SQL पेशेवर INNER JOIN का उपयोग करना पसंद करते हैं। पिछले उदाहरण से वाक्य रचना।

अधिक उदाहरणों के लिए SQL इनर जॉइन देखें, जिसमें 3 टेबल को जोड़ने वाला इनर जॉइन भी शामिल है।

राइट जॉइन

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

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
RIGHT 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 मिला है मूल्य - Rabbits - भले ही Pets में कोई पालतू जानवर न हो उस प्रकार की तालिका। इसका परिणाम NULL होता है PetName में मान Rabbits . के सामने स्तंभ ।

अधिक उदाहरणों के लिए SQL राइट जॉइन देखें, जिसमें राइट जॉइन भी शामिल है जो 3 टेबल को जोड़ता है।

बाएं शामिल हों

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

यह RIGHT 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)

इस विशेष मामले में, हमारे परिणाम आंतरिक जुड़ाव के समान ही हैं।

हालांकि, अगर हम अपने FROM . में टेबल ऑर्डर को इधर-उधर कर देते हैं क्लॉज, हम पिछले उदाहरण में राइट जॉइन के समान परिणाम प्राप्त करेंगे।

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)

तो आप देख सकते हैं कि बाएँ और दाएँ जोड़ के बीच कोई भी परिणामी अंतर पूरी तरह से इस बात पर निर्भर करता है कि आप FROM में स्तंभों को कैसे क्रमित करते हैं खंड।

अधिक उदाहरणों के लिए SQL लेफ्ट जॉइन देखें, जिसमें लेफ्ट जॉइन भी शामिल है जो 3 टेबल को जोड़ता है।

पूर्ण जुड़ाव

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

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

यहां एक पूर्ण जुड़ाव का उदाहरण दिया गया है।

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
FULL 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       |
| NULL      | Rabbit    |
+-----------+-----------+
(9 rows affected)

यह वही परिणाम देता है जो हमें राइट जॉइन के साथ मिला था, लेकिन यह एक अलग परिणाम देता अगर बाईं तालिका में एक पंक्ति होती जिसका दाएँ तालिका में संबंधित मान नहीं होता।

आइए तालिका के नामों की अदला-बदली करें और इसे फिर से चलाएं।

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)

वही परिणाम।

अधिक उदाहरणों के लिए SQL फुल जॉइन देखें, जिसमें 3 टेबल्स को जोड़ने वाला फुल जॉइन भी शामिल है।

द क्रॉस जॉइन

एसक्यूएल CROSS JOIN उन पंक्तियों को लौटाता है जो पहली तालिका से प्रत्येक पंक्ति को दूसरी तालिका से प्रत्येक पंक्ति के साथ जोड़ती हैं।

दूसरे शब्दों में, यह जॉइन में टेबल से पंक्तियों का कार्टेशियन उत्पाद लौटाता है।

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt;

परिणाम:

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

जैसा कि आप शायद कल्पना कर सकते हैं, यदि आप इसे गलत तालिकाओं के विरुद्ध चलाते हैं तो यह बहुत खतरनाक हो सकता है।

यह ऐसा करने जैसा ही है:

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p, PetTypes pt;

आप एक WHERE जोड़ सकते हैं क्रॉस जॉइन के लिए क्लॉज, जो इसे इनर जॉइन में बदल देगा।

इस तरह:

SELECT 
    p.PetName,
    pt.PetType
FROM Pets p
CROSS JOIN PetTypes pt
WHERE 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)

अधिक उदाहरणों के लिए SQL क्रॉस जॉइन देखें।

द नेचुरल जॉइन

एसक्यूएल NATURAL JOIN इक्वि-जॉइन का एक प्रकार है, जहां जॉइन विधेय दोनों टेबलों में सभी कॉलमों की तुलना करके निहित रूप से उत्पन्न होता है, जिसमें शामिल टेबल में समान कॉलम नाम होते हैं।

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

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

परिणाम:

petname | pettype 
---------+---------
 Fluffy  | Cat
 Fetch   | Dog
 Scratch | Cat
 Wag     | Dog
 Tweet   | Bird
 Fluffy  | Dog
 Bark    | Dog
 Meow    | Cat
(8 rows)

वास्तव में, प्राकृतिक जुड़ाव वास्तव में एक जुड़ाव प्रकार नहीं है, जैसा कि एएनएसआई मानक द्वारा माना जाता है। यह एक ऐसा कीवर्ड है जिसे आप जॉइन को एक प्राकृतिक जुड़ाव बनाने के लिए वैकल्पिक रूप से सम्मिलित कर सकते हैं।

इसलिए, हम उपरोक्त उदाहरण को NATURAL INNER JOIN . में बदल सकते हैं अगर हम चाहते थे:

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

जैसा कि पहले उल्लेख किया गया है, आंतरिक जुड़ाव डिफ़ॉल्ट जुड़ाव प्रकार हैं, इसलिए यदि आप शामिल होने के प्रकार को छोड़ देते हैं (जैसे, INNER , LEFT , RIGHT , आदि), तो इसे एक आंतरिक जुड़ाव के रूप में माना जाता है।

यदि इन परिणामों का स्वरूपण पिछले परिणामों की तुलना में अलग दिखता है, तो ऐसा इसलिए है क्योंकि मुझे इस क्वेरी को चलाने के लिए PostgreSQL पर कूदना पड़ा। मैंने SQL सर्वर में पिछले उदाहरण चलाए, लेकिन SQL सर्वर प्राकृतिक जुड़ाव का समर्थन नहीं करता है।

अधिक उदाहरणों के लिए SQL नेचुरल जॉइन देखें, जिसमें 3 टेबल में शामिल होने वाले नेचुरल जॉइन भी शामिल है।

सेल्फ जॉइन

एसक्यूएल SELF JOIN अपने आप में एक तालिका में शामिल हो रहा है।

कर्मचारी तालिका में स्वयं शामिल होने का एक उत्कृष्ट उदाहरण है। ऐसी तालिका में, एक कर्मचारी दूसरे कर्मचारी को रिपोर्ट कर सकता है। इसलिए, आप अपने कर्मचारी आईडी कॉलम और प्रबंधक आईडी कॉलम पर तालिका में शामिल होने के लिए स्वयं शामिल होने का उपयोग कर सकते हैं।

मान लीजिए हमारे पास निम्न तालिका है:

+--------------+-------------+------------+-------------+
| EmployeeId   | FirstName   | LastName   | ReportsTo   |
|--------------+-------------+------------+-------------|
| 1            | Homer       | Connery    | NULL        |
| 2            | Bart        | Pitt       | 1           |
| 3            | Maggie      | Griffin    | 1           |
| 4            | Peter       | Farnsworth | 2           |
| 5            | Marge       | Morrison   | NULL        |
| 6            | Lisa        | Batch      | 5           |
| 7            | Dave        | Zuckerberg | 6           |
| 8            | Vlad        | Cook       | 7           |
+--------------+-------------+------------+-------------+

हम सभी कर्मचारियों और उनके प्रबंधकों को वापस करने के लिए इस टेबल पर सेल्फ जॉइन कर सकते हैं।

SELECT
    CONCAT(e1.FirstName, ' ', e1.LastName) AS Employee,
    CONCAT(e2.FirstName, ' ', e2.LastName) AS Manager
FROM Employees e1
LEFT JOIN Employees e2 
ON e1.ReportsTo = e2.EmployeeId;

परिणाम:

+------------------+-----------------+
| Employee         | Manager         |
|------------------+-----------------|
| Homer Connery    |                 |
| Bart Pitt        | Homer Connery   |
| Maggie Griffin   | Homer Connery   |
| Peter Farnsworth | Bart Pitt       |
| Marge Morrison   |                 |
| Lisa Batch       | Marge Morrison  |
| Dave Zuckerberg  | Lisa Batch      |
| Vlad Cook        | Dave Zuckerberg |
+------------------+-----------------+

अधिक उदाहरणों के लिए SQL Self Join देखें।