MySQL
में शामिल

वाक्य - विन्यास

• INNER और OUTER को नजरअंदाज किया जाता है।

• MySQL में FULL लागू नहीं है।

• "commajoin" ( FROM a,b WHERE ax=by ) पर फेंक दिया गया है; इसके बजाय FROM a JOIN b ON ax=by उपयोग FROM a JOIN b ON ax=by ।

• कुल्हाड़ी से एक जॉय बी से = दोनों तालिकाओं में मेल खाने वाली पंक्तियों को शामिल करें।

• कुल्हाड़ी से एक बाईं तरफ से = a मिलान पंक्ति नहीं है, तो b , या NULLs से प्लस मिलान डेटा से सभी पंक्तियों को शामिल करता है।

सम्मिलित होने का उदाहरण

Db पर तालिका बनाने की क्वेरी

CREATE TABLE `user` (
`id` smallint(5) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(30) NOT NULL,
`course` smallint(5) unsigned DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;

CREATE TABLE `course` (
`id` smallint(5) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(50) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB;

चूंकि हम InnoDB तालिकाओं का उपयोग कर रहे हैं और जानते हैं कि user.course और course.id संबंधित हैं, हम एक विदेशी कुंजी संबंध निर्दिष्ट कर सकते हैं:

ALTER TABLE `user`
ADD CONSTRAINT `FK_course`
FOREIGN KEY (`course`) REFERENCES `course` (`id`)
ON UPDATE CASCADE;

सम्मिलित हों क्वेरी (इनर जॉइन)

SELECT user.name, course.name
FROM `user`
INNER JOIN `course` on user.course = course.id;

उपकुंजी के साथ शामिल हों ("व्युत्पन्न" तालिका)

SELECT x, ...
    FROM ( SELECT y, ... FROM ... ) AS a
    JOIN tbl  ON tbl.x = a.y
    WHERE ...

यह एक टेंपरेचर टेबल में सबक्वेरी का मूल्यांकन करेगा, फिर tbl JOIN लिए tbl ।

5.6 से पहले, अस्थायी तालिका पर एक सूचकांक नहीं हो सकता था। तो, यह संभावित रूप से बहुत अक्षम था:

SELECT ...
    FROM ( SELECT y, ... FROM ... ) AS a
    JOIN ( SELECT x, ... FROM ... ) AS b  ON b.x = a.y
    WHERE ...

5.6 के साथ, ऑप्टिमाइज़र सबसे अच्छे सूचकांक का पता लगाता है और इसे मक्खी पर बनाता है। (इसमें कुछ ओवरहेड हैं, इसलिए यह अभी भी 'परफेक्ट' नहीं है।)

एक और सामान्य प्रतिमान कुछ को इनिशियलाइज़ करने के लिए एक उपश्रेणी है:

SELECT 
        @n := @n + 1,
        ...
    FROM ( SELECT @n := 0 ) AS initialize
    JOIN the_real_table
    ORDER BY ...

(नोट: यह तकनीकी रूप से एक CROSS JOIN (कार्टेशियन उत्पाद) है, जैसा कि ON की कमी से संकेत मिलता है। हालाँकि यह कुशल है क्योंकि the_real_table केवल एक पंक्ति देता है जिसे the_real_table में n पंक्तियों से the_real_table ।)

आदेश के साथ ग्राहकों को पुनः प्राप्त करें - एक विषय पर विविधताएं

इससे सभी ग्राहकों को सभी ऑर्डर मिलेंगे:

SELECT c.CustomerName, o.OrderID
    FROM Customers AS c
    INNER JOIN Orders AS o
        ON c.CustomerID = o.CustomerID
    ORDER BY c.CustomerName, o.OrderID;

यह प्रत्येक ग्राहक के लिए आदेशों की संख्या की गणना करेगा:

SELECT c.CustomerName, COUNT(*) AS 'Order Count'
    FROM Customers AS c
    INNER JOIN Orders AS o
        ON c.CustomerID = o.CustomerID
    GROUP BY c.CustomerID;
    ORDER BY c.CustomerName;

इसके अलावा, मायने रखता है, लेकिन शायद तेज:

SELECT  c.CustomerName,
        ( SELECT COUNT(*) FROM Orders WHERE CustomerID = c.CustomerID ) AS 'Order Count'
    FROM Customers AS c
    ORDER BY c.CustomerName;

आदेशों के साथ केवल ग्राहक को सूचीबद्ध करें।

SELECT  c.CustomerName,
    FROM Customers AS c
    WHERE EXISTS ( SELECT * FROM Orders WHERE CustomerID = c.CustomerID )
    ORDER BY c.CustomerName;

पूर्ण बाहरी सम्मिलित हों

MySQL FULL OUTER JOIN समर्थन नहीं करता है, लेकिन एक अनुकरण करने के तरीके हैं।

डेटा सेट करना

-- ----------------------------
-- Table structure for `owners`
-- ----------------------------
DROP TABLE IF EXISTS `owners`;
CREATE TABLE `owners` (
`owner_id` int(11) NOT NULL AUTO_INCREMENT,
`owner` varchar(30) DEFAULT NULL,
PRIMARY KEY (`owner_id`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=latin1;

-- ----------------------------
-- Records of owners
-- ----------------------------
INSERT INTO `owners` VALUES ('1', 'Ben');
INSERT INTO `owners` VALUES ('2', 'Jim');
INSERT INTO `owners` VALUES ('3', 'Harry');
INSERT INTO `owners` VALUES ('6', 'John');
INSERT INTO `owners` VALUES ('9', 'Ellie');
-- ----------------------------
-- Table structure for `tools`
-- ----------------------------
DROP TABLE IF EXISTS `tools`;
CREATE TABLE `tools` (
`tool_id` int(11) NOT NULL AUTO_INCREMENT,
`tool` varchar(30) DEFAULT NULL,
`owner_id` int(11) DEFAULT NULL,
PRIMARY KEY (`tool_id`)
) ENGINE=InnoDB AUTO_INCREMENT=11 DEFAULT CHARSET=latin1;
-- ----------------------------
-- Records of tools
-- ----------------------------
INSERT INTO `tools` VALUES ('1', 'Hammer', '9');
INSERT INTO `tools` VALUES ('2', 'Pliers', '1');
INSERT INTO `tools` VALUES ('3', 'Knife', '1');
INSERT INTO `tools` VALUES ('4', 'Chisel', '2');
INSERT INTO `tools` VALUES ('5', 'Hacksaw', '1');
INSERT INTO `tools` VALUES ('6', 'Level', null);
INSERT INTO `tools` VALUES ('7', 'Wrench', null);
INSERT INTO `tools` VALUES ('8', 'Tape Measure', '9');
INSERT INTO `tools` VALUES ('9', 'Screwdriver', null);
INSERT INTO `tools` VALUES ('10', 'Clamp', null);

हम क्या देखना चाहते हैं?

हम एक सूची प्राप्त करना चाहते हैं, जिसमें हम देखते हैं कि कौन कौन से उपकरण का मालिक है, और कौन से उपकरण का मालिक नहीं हो सकता है।

प्रश्न

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

दूसरी क्वेरी में हम मालिकों के टूल में शामिल होने के लिए RIGHT JOIN का उपयोग कर रहे हैं। इस तरह हम अपने परिणाम में सभी उपकरण प्राप्त करने का प्रबंधन करते हैं, यदि वे किसी के स्वामित्व में हैं तो उनके मालिक कॉलम में केवल NULL । WHERE -clause जोड़कर, जो मालिकों द्वारा फ़िल्टर किया owners.owner_id IS NULL हम उन डेटासेट के रूप में परिणाम को परिभाषित कर रहे हैं, जो पहले से ही पहले क्वेरी द्वारा वापस नहीं आए हैं, क्योंकि हम केवल दाईं ओर तालिका में डेटा की तलाश कर रहे हैं।

चूँकि हम UNION ALL का उपयोग कर रहे हैं, दूसरी क्वेरी के सभी परिणाम पहले प्रश्नों के परिणाम से जुड़े होंगे।

SELECT `owners`.`owner`, tools.tool
FROM `owners`
LEFT JOIN `tools` ON `owners`.`owner_id` = `tools`.`owner_id`
UNION ALL
SELECT `owners`.`owner`, tools.tool
FROM `owners`
RIGHT JOIN `tools` ON `owners`.`owner_id` = `tools`.`owner_id`
WHERE `owners`.`owner_id` IS NULL;

+-------+--------------+
| owner | tool         |
+-------+--------------+
| Ben   | Pliers       |
| Ben   | Knife        |
| Ben   | Hacksaw      |
| Jim   | Chisel       |
| Harry | NULL         |
| John  | NULL         |
| Ellie | Hammer       |
| Ellie | Tape Measure |
| NULL  | Level        |
| NULL  | Wrench       |
| NULL  | Screwdriver  |
| NULL  | Clamp        |
+-------+--------------+
12 rows in set (0.00 sec)

3 तालिकाओं के लिए इनर-जॉइन करें

चलिए मान लेते हैं कि हमारे पास तीन टेबल हैं जिनका उपयोग टैग के साथ सरल वेबसाइट के लिए किया जा सकता है।

• मुट्ठी टेबल पोस्ट के लिए है।
• टैग के लिए दूसरा
• टैग और पोस्ट संबंध के लिए तीसरा

मुट्ठी टेबल "वीडियोगेम"

"टैग" तालिका

"tags_meta" तालिका

SELECT videogame.id,
    videogame.title,
    videogame.reg_date,
    tags.name,
    tags_meta.post_id
FROM tags_meta
INNER JOIN videogame ON videogame.id = tags_meta.post_id
INNER JOIN tags ON tags.id = tags_meta.tag_id
WHERE tags.name = "elizabeth"
ORDER BY videogame.reg_date

यह कोड उन सभी पोस्टों को वापस कर सकता है जो उस टैग से संबंधित हैं "#elizabeth"

कल्पना से जुड़ जाता है

यदि आप एक नेत्रहीन व्यक्ति हैं, तो यह Venn आरेख आपको MySQL के भीतर मौजूद JOIN s के विभिन्न प्रकारों को समझने में मदद कर सकता है।