एसक्यूएल इनर जॉइन

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

एसक्यूएल INNER JOIN पंक्तियों को लौटाता है जब दोनों तालिकाओं में कम से कम एक पंक्ति होती है जो शामिल होने की स्थिति से मेल खाती है। यह दोनों तालिकाओं से बेजोड़ पंक्तियों को त्याग देता है। यह डिफ़ॉल्ट जुड़ाव प्रकार है।

सिंटैक्स

इनर जॉइन को निर्दिष्ट करने के दो तरीके हैं:FROM . में खंड (INNER JOIN का उपयोग करके) सिंटैक्स), या WHERE . का उपयोग करके खंड।

FROM . में एक आंतरिक जुड़ाव निर्दिष्ट करने के लिए खंड:

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

WHERE . में एक आंतरिक जुड़ाव निर्दिष्ट करने के लिए खंड:

SELECT *
FROM Table1, Table2 
WHERE Table1.Column = Table2.Column;

नीचे प्रत्येक के उदाहरण दिए गए हैं।

उदाहरण

यहां, हमारे पास एक आंतरिक जुड़ाव निर्दिष्ट करने की प्रत्येक विधि के लिए उदाहरण हैं।

नमूना डेटा

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

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              |
+-----------+-------------+------------+----------------+-------------------+

ध्यान दें कि:

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

इनर जॉइन सिंटैक्स का उपयोग करने का उदाहरण

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

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)

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;

जब आप बड़ी तालिकाएँ लिखते हैं जो कई तालिकाओं को जोड़ती हैं, तो इंडेंटिंग से बहुत मदद मिल सकती है।

WHERE क्लॉज का उपयोग करने का उदाहरण

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

यहां WHERE . का उपयोग करके एक आंतरिक जुड़ाव निर्दिष्ट करने का एक उदाहरण दिया गया है खंड:

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       |
+-----------+-----------+
(8 rows affected)

यह पिछले उदाहरण के समान परिणाम लौटाता है।

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

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

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

यहां 3 टेबल पर इनर जॉइन करने का एक उदाहरण दिया गया है।

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

परिणाम:

+-----------+-----------+---------------+
| 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   |
+-----------+-----------+---------------+
(8 rows affected)

इस उदाहरण में, हम Owners . लाए हैं मिश्रण में तालिका क्योंकि हमें मालिक के बारे में जानकारी वापस करने के लिए इस क्वेरी की आवश्यकता थी।

तीसरी तालिका का उपयोग करने के लिए, हमने केवल एक और INNER JOIN... ON add जोड़ा था प्रासंगिक तालिका/स्तंभ विवरण के साथ तर्क।

इस मामले में, मैंने टी-एसक्यूएल के CONCAT() . का इस्तेमाल किया दो स्तंभों को जोड़ने के लिए कार्य करता है, लेकिन यह शामिल होने के लिए अप्रासंगिक है।