Microsoft SQL Server
शामिल हों
खोज…
परिचय
संरचित क्वेरी भाषा (SQL) में, एक JOIN एक क्वेरी में दो डेटा तालिकाओं को जोड़ने की एक विधि है, जिससे डेटाबेस को एक सेट वापस करने की अनुमति मिलती है जिसमें एक ही बार में दोनों तालिकाओं से डेटा होता है, या एक तालिका से डेटा का उपयोग करके उसे एक के रूप में उपयोग किया जाता है दूसरी टेबल पर फ़िल्टर करें। ANSI SQL मानक के भीतर कई प्रकार के JOINs परिभाषित हैं।
आंतरिक रूप से जुड़ा
Inner join रिटर्न केवल उन रिकॉर्ड / पंक्तियों को मैच / दोनों एक या कई शर्तें (का उपयोग कर निर्दिष्ट स्थान पर आधारित तालिकाओं में मौजूद है ON कीवर्ड)। यह सबसे आम प्रकार का जुड़ाव है। inner join लिए सामान्य वाक्यविन्यास है:
SELECT *
FROM table_1
INNER JOIN table_2
ON table_1.column_name = table_2.column_name
इसे केवल JOIN रूप में सरल बनाया जा सकता है:
SELECT *
FROM table_1
JOIN table_2
ON table_1.column_name = table_2.column_name
उदाहरण
/* Sample data. */
DECLARE @Animal table (
AnimalId Int IDENTITY,
Animal Varchar(20)
);
DECLARE @AnimalSound table (
AnimalSoundId Int IDENTITY,
AnimalId Int,
Sound Varchar(20)
);
INSERT INTO @Animal (Animal) VALUES ('Dog');
INSERT INTO @Animal (Animal) VALUES ('Cat');
INSERT INTO @Animal (Animal) VALUES ('Elephant');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (1, 'Barks');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (2, 'Meows');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (3, 'Trumpets');
/* Sample data prepared. */
SELECT
*
FROM
@Animal
JOIN @AnimalSound
ON @Animal.AnimalId = @AnimalSound.AnimalId;
AnimalId Animal AnimalSoundId AnimalId Sound
----------- -------------------- ------------- ----------- --------------------
1 Dog 1 1 Barks
2 Cat 2 2 Meows
3 Elephant 3 3 Trumpets
बाएं बाहरी जुड़ाव के साथ आंतरिक जुड़ाव का उपयोग करना (मौजूद नहीं है)
यह क्वेरी तालिका 1 से डेटा लौटाएगी, जहां तालिका 2 के साथ मेल खाने वाले फ़ील्ड कुंजी और डेटा के साथ तालिका 1 में नहीं हैं जब किसी शर्त और कुंजी के साथ तालिका 2 के साथ तुलना की जाती है
select *
from Table1 t1
inner join Table2 t2 on t1.ID_Column = t2.ID_Column
left join Table3 t3 on t1.ID_Column = t3.ID_Column
where t2.column_name = column_value
and t3.ID_Column is null
order by t1.column_name;
क्रॉस जॉइन करें
A cross join एक कार्टेशियन जॉइन है, जिसका अर्थ है दोनों टेबल का कार्टेशियन प्रोडक्ट। इस जॉइन को दो टेबल से जुड़ने के लिए किसी शर्त की जरूरत नहीं है। बाईं तालिका में प्रत्येक पंक्ति दाईं तालिका की प्रत्येक पंक्ति में शामिल हो जाएगी। एक क्रॉस जॉइन के लिए सिंटैक्स:
SELECT * FROM table_1
CROSS JOIN table_2
उदाहरण:
/* Sample data. */
DECLARE @Animal table (
AnimalId Int IDENTITY,
Animal Varchar(20)
);
DECLARE @AnimalSound table (
AnimalSoundId Int IDENTITY,
AnimalId Int,
Sound Varchar(20)
);
INSERT INTO @Animal (Animal) VALUES ('Dog');
INSERT INTO @Animal (Animal) VALUES ('Cat');
INSERT INTO @Animal (Animal) VALUES ('Elephant');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (1, 'Barks');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (2, 'Meows');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (3, 'Trumpet');
/* Sample data prepared. */
SELECT
*
FROM
@Animal
CROSS JOIN @AnimalSound;
परिणाम:
AnimalId Animal AnimalSoundId AnimalId Sound
----------- -------------------- ------------- ----------- --------------------
1 Dog 1 1 Barks
2 Cat 1 1 Barks
3 Elephant 1 1 Barks
1 Dog 2 2 Meows
2 Cat 2 2 Meows
3 Elephant 2 2 Meows
1 Dog 3 3 Trumpet
2 Cat 3 3 Trumpet
3 Elephant 3 3 Trumpet
ध्यान दें कि ऐसे अन्य तरीके हैं जो एक CROSS JOIN को लागू किया जा सकता है। यह एक "पुरानी शैली" जॉइन है (एएनएसआई एसक्यूएल -92 के बाद से पदावनत), जिसमें कोई शर्त नहीं है, जिसके परिणामस्वरूप क्रॉस / कार्टेशियन जॉइन होता है:
SELECT *
FROM @Animal, @AnimalSound;
यह सिंटैक्स "हमेशा सत्य" स्थिति में शामिल होने के कारण भी काम करता है, लेकिन इसकी सिफारिश नहीं की जाती है और इसे पठनीयता के लिए, स्पष्ट CROSS JOIN सिंटैक्स के पक्ष में, बचा जाना चाहिए।
SELECT *
FROM
@Animal
JOIN @AnimalSound
ON 1=1
बाहरी सम्मिलित हों
बाईं ओर का बाहरी जोड़
LEFT JOIN ओर से बाईं पंक्ति में सभी पंक्तियाँ मिलती हैं, दाएं तालिका की पंक्तियों से मेल खाती है जहाँ ON खंड की शर्तें पूरी होती हैं। जिन पंक्तियों में ON खण्ड पूरा नहीं हुआ है, उनमें दाईं ओर के सभी स्तंभों में NULL है। एक LEFT JOIN का सिंटैक्स है:
SELECT * FROM table_1 AS t1
LEFT JOIN table_2 AS t2 ON t1.ID_Column = t2.ID_Column
राइट आउटर जॉइन
RIGHT JOIN दायीं मेज से सभी पंक्तियों को लौटाता है, जहां बाईं खण्ड ON पंक्तियों से मिलान किया जाता है, जहां ON खंड की शर्तें पूरी होती हैं। जिन पंक्तियों में ON खण्ड पूरा नहीं हुआ है, उनमें बाईं तालिका के सभी स्तंभों में NULL है। RIGHT JOIN का सिंटैक्स है:
SELECT * FROM table_1 AS t1
RIGHT JOIN table_2 AS t2 ON t1.ID_Column = t2.ID_Column
पूर्ण बाहरी सम्मिलित हों
FULL JOIN LEFT JOIN और RIGHT JOIN । सभी पंक्तियों को दोनों तालिकाओं से लौटा दिया जाता है, भले ही ON क्लॉज की शर्तें पूरी हों। ऐसी पंक्तियाँ जो ON क्लॉज को संतुष्ट नहीं करती हैं, उन्हें विपरीत तालिका के सभी कॉलमों में NULL साथ वापस कर दिया जाता NULL (यानी बाईं तालिका में एक पंक्ति के लिए, दाईं तालिका के सभी कॉलमों में NULL और इसके विपरीत होंगे)। एक FULL JOIN का सिंटैक्स है:
SELECT * FROM table_1 AS t1
FULL JOIN table_2 AS t2 ON t1.ID_Column = t2.ID_Column
उदाहरण
/* Sample test data. */
DECLARE @Animal table (
AnimalId Int IDENTITY,
Animal Varchar(20)
);
DECLARE @AnimalSound table (
AnimalSoundId Int IDENTITY,
AnimalId Int,
Sound Varchar(20)
);
INSERT INTO @Animal (Animal) VALUES ('Dog');
INSERT INTO @Animal (Animal) VALUES ('Cat');
INSERT INTO @Animal (Animal) VALUES ('Elephant');
INSERT INTO @Animal (Animal) VALUES ('Frog');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (1, 'Barks');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (2, 'Meows');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (3, 'Trumpet');
INSERT INTO @AnimalSound (AnimalId, Sound) VALUES (5, 'Roars');
/* Sample data prepared. */
बाईं ओर का बाहरी जोड़
SELECT *
FROM @Animal As t1
LEFT JOIN @AnimalSound As t2 ON t1.AnimalId = t2.AnimalId;
परिणाम के लिए LEFT JOIN
AnimalId Animal AnimalSoundId AnimalId Sound
----------- -------------------- ------------- ----------- --------------------
1 Dog 1 1 Barks
2 Cat 2 2 Meows
3 Elephant 3 3 Trumpet
4 Frog NULL NULL NULL
सही जॉय शामिल हैं
SELECT *
FROM @Animal As t1
RIGHT JOIN @AnimalSound As t2 ON t1.AnimalId = t2.AnimalId;
RIGHT JOIN लिए परिणाम
AnimalId Animal AnimalSoundId AnimalId Sound
----------- -------------------- ------------- ----------- --------------------
1 Dog 1 1 Barks
2 Cat 2 2 Meows
3 Elephant 3 3 Trumpet
NULL NULL 4 5 Roars
पूरा कंप्यूटर शामिल है
SELECT *
FROM @Animal As t1
FULL JOIN @AnimalSound As t2 ON t1.AnimalId = t2.AnimalId;
FULL JOIN लिए परिणाम
AnimalId Animal AnimalSoundId AnimalId Sound
----------- -------------------- ------------- ----------- --------------------
1 Dog 1 1 Barks
2 Cat 2 2 Meows
3 Elephant 3 3 Trumpet
4 Frog NULL NULL NULL
NULL NULL 4 5 Roars
एक अद्यतन में शामिल होने का उपयोग करना
जोड़ों को एक UPDATE कथन में भी इस्तेमाल किया जा सकता है:
CREATE TABLE Users (
UserId int NOT NULL,
AccountId int NOT NULL,
RealName nvarchar(200) NOT NULL
)
CREATE TABLE Preferences (
UserId int NOT NULL,
SomeSetting bit NOT NULL
)
Users तालिका पर एक विधेय द्वारा फ़िल्टरिंग Preferences तालिका के SomeSetting कॉलम को SomeSetting अपडेट करें:
UPDATE p
SET p.SomeSetting = 1
FROM Users u
JOIN Preferences p ON u.UserId = p.UserId
WHERE u.AccountId = 1234
p कथन के FROM क्लॉज में परिभाषित Preferences लिए एक अन्य नाम है। एक मिलान के साथ केवल पंक्तियों AccountId से Users तालिका अद्यतन किया जाएगा।
लेफ्ट आउटर जॉइन स्टेटमेंट से अपडेट करें
Update t
SET t.Column1=100
FROM Table1 t LEFT JOIN Table12 t2
ON t2.ID=t.ID
भीतरी जुड़ने और कुल कार्य के साथ अद्यतन तालिकाएँ
UPDATE t1
SET t1.field1 = t2.field2Sum
FROM table1 t1
INNER JOIN (select field3, sum(field2) as field2Sum
from table2
group by field3) as t2
on t2.field3 = t1.field3
एक उपकेंद्र पर शामिल हों
जब आप एक बच्चे / विवरण तालिका से कुल डेटा (जैसे कि गणना, औसत, अधिकतम या न्यूनतम) प्राप्त करना चाहते हैं, तो एक उप-परीक्षा में शामिल होने का उपयोग किया जाता है और यह प्रदर्शित किया जाता है कि माता-पिता / हेडर टेबल से रिकॉर्ड के साथ। उदाहरण के लिए, आप दिनांक या आईडी के आधार पर शीर्ष / पहली चाइल्ड रो को पुनः प्राप्त करना चाह सकते हैं या हो सकता है कि आप सभी चाइल्ड रो या एवरेज का काउंट चाहते हैं।
यह उदाहरण उपनाम का उपयोग करता है जो कई तालिकाओं को शामिल करने पर प्रश्नों को पढ़ने में आसान बनाता है। इस मामले में हम मूल तालिका खरीद आदेशों से सभी पंक्तियों को पुनर्प्राप्त कर रहे हैं और बाल तालिका PurchaseOrderLineItems से केवल अंतिम (या सबसे हाल ही में) बाल पंक्ति को पुनः प्राप्त कर रहे हैं। यह उदाहरण मानता है कि बच्चे की तालिका वृद्धिशील संख्यात्मक आईडी का उपयोग करती है।
SELECT po.Id, po.PODate, po.VendorName, po.Status, item.ItemNo,
item.Description, item.Cost, item.Price
FROM PurchaseOrders po
LEFT JOIN
(
SELECT l.PurchaseOrderId, l.ItemNo, l.Description, l.Cost, l.Price, Max(l.id) as Id
FROM PurchaseOrderLineItems l
GROUP BY l.PurchaseOrderId, l.ItemNo, l.Description, l.Cost, l.Price
) AS item ON item.PurchaseOrderId = po.Id
स्वयं सम्मिलित हों
एक तालिका को स्वयं में शामिल किया जा सकता है जिसे एक स्वयं से जुड़ने के रूप में जाना जाता है, एक ही तालिका में अन्य रिकॉर्ड के साथ तालिका में रिकॉर्ड का संयोजन। सेल्फ जॉइन आमतौर पर उन प्रश्नों में उपयोग किया जाता है जहां तालिका के कॉलम में एक पदानुक्रम को परिभाषित किया गया है।
Employees नामक तालिका में नमूना डेटा पर विचार करें:
| आईडी | नाम | Boss_ID |
|---|---|---|
| 1 | बॉब | 3 |
| 2 | जिम | 1 |
| 3 | सैम | 2 |
प्रत्येक कर्मचारी का Boss_ID दूसरे कर्मचारी की ID पर मैप करता है। अपने संबंधित बॉस के नाम के साथ कर्मचारियों की एक सूची को पुनः प्राप्त करने के लिए, इस मानचित्रण का उपयोग करके तालिका को अपने आप से जोड़ा जा सकता है। ध्यान दें कि इस तरह से तालिका में शामिल होने के लिए मूल तालिका से खुद को अलग करने के लिए तालिका के दूसरे संदर्भ में एक उपनाम (इस मामले में Bosses ) के उपयोग की आवश्यकता होती है।
SELECT Employees.Name,
Bosses.Name AS Boss
FROM Employees
INNER JOIN Employees AS Bosses
ON Employees.Boss_ID = Bosses.ID
इस क्वेरी को निष्पादित करने से निम्नलिखित परिणाम प्राप्त होंगे:
| नाम | मालिक |
|---|---|
| बॉब | सैम |
| जिम | बॉब |
| सैम | जिम |
Join का उपयोग करके हटाएं
जॉइन का उपयोग DELETE स्टेटमेंट में भी किया जा सकता है। एक स्कीमा इस प्रकार दिया गया है:
CREATE TABLE Users (
UserId int NOT NULL,
AccountId int NOT NULL,
RealName nvarchar(200) NOT NULL
)
CREATE TABLE Preferences (
UserId int NOT NULL,
SomeSetting bit NOT NULL
)
हम Preferences तालिका से पंक्तियों को हटा सकते हैं, Users तालिका पर एक विधेय द्वारा फ़िल्टरिंग निम्नानुसार है:
DELETE p
FROM Users u
INNER JOIN Preferences p ON u.UserId = p.UserId
WHERE u.AccountId = 1234
यहाँ p के लिए एक उपनाम है Preferences में परिभाषित FROM बयान के खंड और हम केवल नष्ट पंक्तियों उससे मिलते-जुलते है AccountId से Users तालिका।
दुर्घटनावश बाहरी जुड़ाव को एक आंतरिक जोड़ में बदल देते हैं
बाहरी जोड़ सभी पंक्तियों को एक या दोनों तालिकाओं से जोड़ते हैं, साथ ही साथ मेल खाती पंक्तियाँ।
Table People
PersonID FirstName
1 Alice
2 Bob
3 Eve
Table Scores
PersonID Subject Score
1 Math 100
2 Math 54
2 Science 98
तालिकाओं में शामिल होना छोड़ दिया:
Select * from People a
left join Scores b
on a.PersonID = b.PersonID
यह दिखाता है:
PersonID FirstName PersonID Subject Score
1 Alice 1 Math 100
2 Bob 2 Math 54
2 Bob 2 Science 98
3 Eve NULL NULL NULL
यदि आप किसी भी लागू गणित स्कोर के साथ, सभी लोगों को वापस करना चाहते हैं, तो एक सामान्य गलती है:
Select * from People a
left join Scores b
on a.PersonID = b.PersonID
where Subject = 'Math'
यह आपके परिणामों से पूर्व संध्या को दूर होता है, बॉब की विज्ञान स्कोर को दूर करने के अलावा, के रूप में Subject है NULL उसके लिए।
गैर-गणित रिकॉर्ड को हटाने के लिए सही सिंटैक्स People तालिका में सभी व्यक्तियों को बनाए रखते हुए होगा:
Select * from People a
left join Scores b
on a.PersonID = b.PersonID
and b.Subject = 'Math'