मारियाडीबी इंटरसेक्ट ऑपरेटर ने समझाया

MariaDB में, INTERSECT ऑपरेटर दो प्रश्नों को काटता है और केवल उन पंक्तियों को लौटाता है जो दोनों प्रश्नों में वापस आती हैं।

यह बाईं ओर से सभी पंक्तियों को लौटाता है SELECT परिणाम सेट जो दाईं ओर भी मौजूद हैं SELECT परिणाम सेट।

सिंटैक्स

आधिकारिक वाक्य रचना इस प्रकार है:

SELECT ...
(INTERSECT [ALL | DISTINCT] | EXCEPT [ALL | DISTINCT] | UNION [ALL | DISTINCT]) SELECT ...
[(INTERSECT [ALL | DISTINCT] | EXCEPT [ALL | DISTINCT] | UNION [ALL | DISTINCT]) SELECT ...]
[ORDER BY [column [, column ...]]]
[LIMIT {[offset,] row_count | row_count OFFSET offset}]

उपरोक्त में EXCEPT . भी शामिल है और UNION सिंटैक्स में ऑपरेटर, जैसा कि उन ऑपरेटरों पर समान सिंटैक्स लागू होता है।

मारियाडीबी 10.4.0 से, कोष्ठकों का उपयोग पूर्वता निर्दिष्ट करने के लिए किया जा सकता है।

उदाहरण

मान लीजिए कि हमारे पास निम्नलिखित टेबल हैं:

SELECT * FROM Employees;
SELECT * FROM Customers;

परिणाम:

+------------+--------------+
| EmployeeId | EmployeeName |
+------------+--------------+
|          1 | Bart         |
|          2 | Jan          |
|          3 | Ava          |
|          4 | Rohit        |
|          5 | Monish       |
|          6 | Monish       |
|          7 | Monish       |
+------------+--------------+

+------------+--------------+
| CustomerId | CustomerName |
+------------+--------------+
|          1 | Mia          |
|          2 | Rohit        |
|          3 | Peter        |
|          4 | Ava          |
|          5 | Monish       |
|          6 | Monish       |
+------------+--------------+

हम INTERSECT . का उपयोग कर सकते हैं ऑपरेटर उन कर्मचारियों को लौटाएगा जो ग्राहक भी हैं:

SELECT EmployeeName FROM Employees
INTERSECT
SELECT CustomerName FROM Customers;

परिणाम:

+--------------+
| EmployeeName |
+--------------+
| Ava          |
| Rohit        |
| Monish       |
+--------------+

इसलिए हमें केवल वही मान मिलते हैं जो Employees . में दिखाई देते हैं तालिका जो Customers . में भी दिखाई देती है टेबल।

डिफ़ॉल्ट रूप से, यह अलग-अलग पंक्तियाँ देता है, इसलिए मोनिश के लिए केवल एक पंक्ति लौटाई जाती है, भले ही उस नाम के कई कर्मचारी और कई ग्राहक हों। हालांकि हम इसे बदल सकते हैं।

डुप्लिकेट शामिल करें

डिफ़ॉल्ट रूप से, INTERSECT ऑपरेटर परोक्ष रूप से एक DISTINCT लागू करता है कार्यवाही। दूसरे शब्दों में, यह डिफ़ॉल्ट रूप से केवल विशिष्ट मान देता है।

MariaDB 10.5.0 से पहले, निहित DISTINCT हमारा एकमात्र विकल्प था - हम ALL निर्दिष्ट करने में असमर्थ थे . हालाँकि, MariaDB 10.5.0 ने INTERSECT ALL . की शुरुआत की और INTERSECT DISTINCT वाक्य - विन्यास।

इसका मतलब है कि अब हम इस तरह की क्वेरी कर सकते हैं:

SELECT EmployeeName FROM Employees
INTERSECT ALL
SELECT CustomerName FROM Customers;

परिणाम:

+--------------+
| EmployeeName |
+--------------+
| Monish       |
| Ava          |
| Rohit        |
| Monish       |
+--------------+

इस बार हमें अपने पहले उदाहरण में तीन के बजाय चार पंक्तियाँ मिलीं।

हम देख सकते हैं कि मोनिश नाम वाली दो पंक्तियाँ हमारे पहले उदाहरण की तरह एक के बजाय वापस कर दी गईं। वास्तव में मोनिश नाम के तीन ग्राहक हैं, लेकिन उस नाम के केवल दो कर्मचारी हैं। इसलिए, ऑपरेशन केवल उनमें से दो को काटता है।

और पूर्णता के लिए, यहां एक उदाहरण दिया गया है जो स्पष्ट रूप से DISTINCT . का उपयोग करता है ऑपरेटर:

SELECT EmployeeName FROM Employees
INTERSECT DISTINCT
SELECT CustomerName FROM Customers;

परिणाम:

+--------------+
| EmployeeName |
+--------------+
| Ava          |
| Rohit        |
| Monish       |
+--------------+

यह वही परिणाम है जो हमें मिलेगा यदि हम DISTINCT . को हटा दें ऑपरेटर।

एक वैकल्पिक क्वेरी

INTERSECT . का उपयोग किए बिना समान परिणाम प्राप्त करना संभव है ऑपरेटर। उदाहरण के लिए, हम इसके लिए अपना पहला उदाहरण फिर से लिख सकते हैं:

SELECT 
    DISTINCT EmployeeName
FROM Employees e 
WHERE EXISTS (SELECT CustomerName FROM Customers c
WHERE e.EmployeeName = c.CustomerName);

परिणाम:

+--------------+
| EmployeeName |
+--------------+
| Ava          |
| Rohit        |
| Monish       |
+--------------+

ध्यान रहे, INTERSECT ऑपरेटर कोड को सरल बनाने में मदद करता है।