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

यह आलेख SQL में स्वाभाविक जुड़ाव के साथ-साथ कुछ बुनियादी उदाहरणों का एक सिंहावलोकन प्रदान करता है।

प्राकृतिक जुड़ाव क्या है?

SQL नेचुरल जॉइन एक प्रकार का इक्वि-जॉइन है जो समान नाम और प्रकार के कॉलम के आधार पर तालिकाओं को जोड़ता है। सम्मिलित तालिकाओं में समान स्तंभ नाम वाले दोनों तालिकाओं के सभी स्तंभों की तुलना करके जॉइन विधेय निहित रूप से उत्पन्न होता है।

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

सिंटैक्स

प्राकृतिक जुड़ाव किसी भी INNER . पर लागू किया जा सकता है , LEFT , RIGHT , या FULL जोड़ना। आप बस जुड़ने के प्रकार को NATURAL . के साथ उपसर्ग करें कीवर्ड।

आंतरिक जुड़ाव पर प्रयुक्त वाक्य रचना का उदाहरण:

SELECT *
FROM Table1 NATURAL INNER JOIN Table2 
ON Table1.Column = Table2.Column;

INNER as के रूप में देखा जा रहा है डिफ़ॉल्ट मान है, आप इसे इस तरह भी कर सकते हैं:

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

NATURAL कीवर्ड एक निहित USING रखता है शामिल होने की बाधाओं के लिए खंड। यह एक USING बनाता है सूची में सभी कॉलम नाम शामिल हैं जो दोनों इनपुट टेबल में दिखाई देते हैं। यह स्पष्ट रूप से केवल उन DBMS पर लागू होता है जो USING . का समर्थन करते हैं खंड।

सभी DBMS नेचुरल जॉइन का समर्थन नहीं करते हैं, इसलिए अपने DBMS के दस्तावेज़ देखें।

जैसा कि मैंने इसे लिखा है, PostgreSQL, MySQL, MariaDB, SQLite और Oracle में प्राकृतिक जुड़ाव समर्थित हैं। हालाँकि, SQL सर्वर (2019) में प्राकृतिक जुड़ाव समर्थित नहीं हैं।

उदाहरण

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

नमूना डेटा

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

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 . का कॉलम टेबल.

उदाहरण 1 - प्राकृतिक आंतरिक जुड़ाव

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

SELECT 
    PetName,
    PetType
FROM Pets
NATURAL JOIN PetTypes;

परिणाम:

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

इस उदाहरण में, नेचुरल जॉइन परोक्ष रूप से दो PetTypeId . पर टेबल में शामिल हो गए हैं कॉलम (यानी Pets.PetTypeId कॉलम, और PetTypes.PetTypeId कॉलम)।

यह निम्नलिखित करने का एक अंतर्निहित तरीका है:

SELECT 
    PetName,
    PetType
FROM Pets
INNER JOIN PetTypes USING (PetTypeId);

जो वास्तव में निम्नलिखित करता है।

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

उदाहरण 2 - प्राकृतिक अधिकार शामिल हों

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

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

परिणाम:

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

इस मामले में, यह निम्न कार्य करने जैसा ही है:

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

उदाहरण 3 - 3 टेबल पर प्राकृतिक पूर्ण जुड़ाव

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

SELECT 
    PetName,
    PetType,
    CONCAT(FirstName, ' ', LastName) AS PetOwner
FROM Owners NATURAL FULL JOIN Pets
NATURAL FULL JOIN PetTypes;

परिणाम:

 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
         |         | Woody Eastwood
         | Rabbit  |  
(10 rows)

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

उदाहरण 4 - तारांकन चिह्न का उपयोग करना (* ) वाइल्डकार्ड कैरेक्टर

यहां एक उदाहरण दिया गया है जो सभी स्तंभों को चुनने के लिए तारक (*) वाइल्डकार्ड वर्ण का उपयोग करता है।

SELECT *
FROM Pets
NATURAL JOIN PetTypes;

परिणाम:

 pettypeid | petid | ownerid | petname |    dob     | pettype 
-----------+-------+---------+---------+------------+---------
         2 |     1 |       3 | Fluffy  | 2020-11-20 | Cat
         3 |     2 |       3 | Fetch   | 2019-08-16 | Dog
         2 |     3 |       2 | Scratch | 2018-10-01 | Cat
         3 |     4 |       3 | Wag     | 2020-03-15 | Dog
         1 |     5 |       1 | Tweet   | 2020-11-28 | Bird
         3 |     6 |       4 | Fluffy  | 2020-09-17 | Dog
         3 |     7 |       2 | Bark    |            | Dog
         2 |     8 |       4 | Meow    |            | Cat
(8 rows)

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