SQL में Joins ट्यूटोरियल

SQL Server एक relational database management system है। relational database का एक प्रमुख सिद्धांत यह है कि डेटा कई तालिकाओं में संग्रहीत होता है।

हमें अपनी आवश्यकता का डेटा निकालने के लिए तालिकाओं को आपस में जोड़ने (join) में सक्षम होना चाहिए। हम तालिकाओं को जोड़ने के लिए primary और foreign keys का उपयोग करते हैं।

Primary Key

Primary key वह कॉलम है जिसका उपयोग किसी तालिका की प्रत्येक पंक्ति की विशिष्ट पहचान के लिए किया जाता है। यह विशिष्टता एक identity कॉलम के रूप में क्रमानुगत पूर्णांक का उपयोग करके प्राप्त की जा सकती है। या कभी-कभी, मौजूदा कॉलम स्वाभाविक रूप से अद्वितीय मान रखते हैं, और उनका उपयोग किया जा सकता है।

नीचे दिए गए उदाहरण में, हम artist तालिका की शुरुआती कुछ पंक्तियाँ देख सकते हैं। इसमें दो कॉलम हैं, artist_id और name। artist_id कॉलम इस तालिका के लिए primary key का काम करता है; यह एक integer कॉलम है और प्रत्येक मान अलग है।

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
संचालित द्वारा

अब album तालिका पर नज़र डालते हैं। क्या आप primary key ढूँढ सकते हैं? हाँ, यह album_id कॉलम है। प्रायः primary key का नाम "table-name underscore id" होता है। लेकिन आपने देखा होगा कि यहाँ एक artist_id कॉलम भी है। यह भी पूर्णांकों से बना है और इसका नाम artist तालिका के artist_id कॉलम जैसा ही है। इसका क्या अर्थ है?

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
संचालित द्वारा

Foreign Keys

पिछले आउटपुट से स्पष्ट है कि album तालिका में जो artist_id है, वह artist तालिका के लिए एक Foreign_key की तरह कार्य करता है। FOREIGN KEY प्रतिबंध (constraint) का उपयोग उन कार्रवाइयों को रोकने के लिए किया जाता है जो तालिकाओं के बीच कड़ियाँ (links) नष्ट कर दें।

• artist तालिका

+-----------+-------------------+
| artist_id | name              |
|-----------+-------------------|
| 1         | AC/DC             |
| 2         | Accept            |
| 3         | Aerosmith         |
| 4         | Alanis Morissette |
| 5         | Alice In Chains   |
+-----------+-------------------+
संचालित द्वारा

• album तालिका

+----------+-------------------------+-----------+
| album_id | title                   | artist_id |  
|----------+-------------------------+-----------|
| 1        | For Those About To Rock | 1         |
| 2        | Balls to the Wall       | 2         |
| 3        | Restless and Wild       | 2         |
| 4        | Let There Be Rock       | 1         |
| 5        | Big Ones                | 3         |
+----------+-------------------------+-----------+
संचालित द्वारा

इसका अर्थ है कि जब album तालिका का artist_id, artist तालिका के artist_id से मेल खाता है, तो वे पंक्तियाँ एक JOIN के रूप में जोड़ी जा सकती हैं।

Album और Artist को जोड़ना

artist तालिका की पंक्ति 1 और 4 में artist_id 1 है। artist तालिका में artist_id 1, AC/DC है। तो, जब हम दोनों तालिकाओं को जोड़ते हैं, हम album तालिका से album का विवरण और artist तालिका से संबद्ध artist का विवरण लौटाते हैं—इन दोनों को जोड़ने के लिए artist_id फ़ील्ड का उपयोग करते हुए, जो दोनों तालिकाओं में सामान्य है।

इसे inner join कहा जाता है।

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist ON artist.artist_id = album.artist_id
WHERE album.artist_id = 1;
संचालित द्वारा

+----------+-------------------------+-----------+-------------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
+----------+-------------------------+-----------+-------------|
संचालित द्वारा

हमने artist तालिका के artist_id को album तालिका के artist_id से मिलाकर album और artist तालिकाओं को जोड़ा।

अलग-अलग तालिकाओं से एक ही नाम वाले कॉलम का चयन करते समय, आपको कॉलम नाम को पूर्ण रूप से योग्य (fully qualify) करना होगा। अन्यथा, SQL Server को यह नहीं पता होगा कि कॉलम किस तालिका से SELECT करना है।

किसी कॉलम को पूर्ण रूप से योग्य बनाने के लिए, आपको उसके आगे संबंधित तालिका का नाम लगाना होता है, और उसके बाद एक बिंदु (period) लगाना होता है।

Inner Join का वाक्यविन्यास (Syntax)

यहाँ वाक्यविन्यास याद दिलाने के लिए एक सामान्य उदाहरण दिया गया है। जब हम मुख्य तालिका, यानी इस मामले में table_A, से संबंधित कॉलम चुनते हैं, तब कोई भी अतिरिक्त कॉलम जिसे हम जोड़ना चाहते हैं—इस मामले में table_B—का चयन करते हैं। फिर हम INNER JOIN और ON कीवर्ड का उपयोग करके, दोनों तालिकाओं के आवश्यक key कॉलम प्रदान करते हुए join निर्दिष्ट करते हैं।

SELECT
    table_A.columnX,
    table_A.columnY,
    table_B.columnZ,
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key;
संचालित द्वारा

WHERE क्लॉज़ का उपयोग न करना

इस उदाहरण में, हम WHERE क्लॉज़ निर्दिष्ट नहीं करते, इसलिए हम artist और album तालिकाओं के बीच सभी मेलों के सभी संयोजन लौटाते हैं—फिर से, artist_id कॉलम के आधार पर, जो दोनों में सामान्य है।

SELECT
  album_id,
  title,
  album.artist_id,
  name AS artist_name
FROM album
INNER JOIN artist on artist.artist_id = album.artist_id;
संचालित द्वारा

+----------+---------------------------------------+-----------+
| album_id | title                   | artist_id | artist_name |
|----------+---------------------------------------+-----------|
| 1        | For Those About To Rock | 1         | AC/DC       |
| 4        | Let There Be Rock       | 1         | AC/DC       |
| 2        | Balls To The Wall       | 2         | Accept      |
| 3        | Restless and Wild       | 2         | Accept      |
+----------+---------------------------------------+-----------+
संचालित द्वारा

एकाधिक Inner Join

आप INNER JOINS का उपयोग करके दो से अधिक तालिकाओं को भी जोड़ सकते हैं। आप प्रत्येक तालिका संयोजन के लिए एक अतिरिक्त INNER JOIN प्रदान करते हैं। नीचे दिए गए कोड में, हम तालिकाएँ A और B, तथा B और C को जोड़ते हैं।

SELECT
  table_A.columnX,
  table_A.columnY,
  table_B.columnZ table_C columnW
FROM table_A
INNER JOIN table_B ON table_B.foreign_key = table_A.primary_key
INNER JOIN table_C ON table_C.foreign_key = table_B.primary_key;
संचालित द्वारा

तालिकाओं को जोड़ने के बारे में और जानने के लिए, कृपया हमारे पाठ्यक्रम Introduction to SQL Server का यह वीडियो देखें।

यह सामग्री DataCamp के John MacKintosh द्वारा बनाए गए Introduction to SQL Server पाठ्यक्रम से ली गई है।