MySQL सबक्वेरी के साथ कैसे काम करें

एक सबक्वायरी एक SQL (संरचित क्वेरी भाषा) क्वेरी है जो किसी अन्य SQL क्वेरी में नेस्टेड है। जिस कमांड में सबक्वेरी नेस्टेड है उसे पैरेंट क्वेरी कहा जाता है। उपश्रेणियों का उपयोग डेटा को पूर्व-संसाधित करने के लिए किया जाता है जिसका उपयोग मूल क्वेरी में किया जाता है। उपश्रेणियों को SELECT in में लागू किया जा सकता है , INSERT , UPDATE , और DELETE संचालन।

जब सबक्वेरी निष्पादित की जाती हैं, तो सबक्वेरी को पहले पैरेंट क्वेरी से पहले प्रोसेस किया जाता है। MySQL अनुप्रयोगों का निर्माण करते समय, उपश्रेणियों का उपयोग करने से कई लाभ मिलते हैं:

• वे SQL कथनों को सरल तार्किक इकाइयों में तोड़ते हैं, जिससे उन्हें समझने और बनाए रखने में आसानी हो सकती है। दूसरे शब्दों में, उपश्रेणियाँ प्रश्नों के जटिल भागों को अलग करने में मदद करती हैं।
• वे जटिल का उपयोग करने की आवश्यकता को समाप्त करते हैंUNION बयान औरJOIN बयान।
• उनका उपयोग ऐसे परिदृश्य में संदर्भित अखंडता को लागू करने के लिए किया जाता है जहां विदेशी कुंजी लागू नहीं की जाती हैं।
• वे डेवलपर्स को MySQL क्वेरी में व्यावसायिक तर्क को कोड करने में मदद करते हैं।

इस गाइड में आप सीखेंगे:

• सहसंबद्ध सबक्वेरी का उपयोग कैसे करें
• तुलना ऑपरेटर में सहसंबद्ध सबक्वेरी का उपयोग कैसे करें
• एक उपश्रेणी को एक व्युत्पन्न तालिका के रूप में कैसे उपयोग करें

शुरू करने से पहले

इस गाइड का पालन करने के लिए, सुनिश्चित करें कि आपके पास निम्नलिखित हैं:

1. यदि आपने पहले से ऐसा नहीं किया है, तो एक लिनोड खाता बनाएं और उदाहरण की गणना करें। लिनोड के साथ शुरुआत करना और कंप्यूट इंस्टेंस गाइड बनाना देखें।

2. अपने सिस्टम को अपडेट करने के लिए कंप्यूट इंस्टेंस गाइड की स्थापना और सुरक्षा का पालन करें। आप समय क्षेत्र सेट करना, अपना होस्टनाम कॉन्फ़िगर करना, एक सीमित उपयोगकर्ता खाता बनाना और SSH पहुंच को सख्त करना भी चाह सकते हैं।

3. MySQL सर्वर सॉफ़्टवेयर (या MariaDB) आपके लिनोड पर स्थापित है। कृपया MySQL अनुभाग देखें, जिसमें गाइड शामिल हैं जो कई लिनक्स वितरणों पर MySQL को स्थापित करने का वर्णन करते हैं।

डेटाबेस सेट करना

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

1. SSH अपने सर्वर पर और रूट के रूप में MySQL में लॉग इन करें:

    mysql -u root -p
   

   संकेत मिलने पर, अपने MySQL सर्वर का रूट पासवर्ड दर्ज करें और Enter hit दबाएं जारी रखने के लिए। ध्यान दें कि आपके MySQL सर्वर का रूट पासवर्ड आपके लाइनोड के रूट पासवर्ड के समान नहीं है।

   नोट

   यदि आपका पासवर्ड स्वीकार नहीं किया जाता है, तो आपको पिछली कमांड को sudo . के साथ चलाने की आवश्यकता हो सकती है :

   sudo mysql -u root -p
   

2. यदि आपका पासवर्ड स्वीकार किया जाता है, तो आपको MySQL प्रॉम्प्ट देखना चाहिए:

   
   mysql >
   

   नोट

   यदि आप मारियाडीबी का उपयोग कर रहे हैं, तो आपको इसके बजाय निम्न की तरह एक संकेत दिखाई दे सकता है:

   
   MariaDB [(none)]>
   

3. test_db . नामक एक नमूना डेटाबेस बनाने के लिए , भागो:

   CREATE DATABASE test_db;
   

   आपको यह आउटपुट देखना चाहिए, जो पुष्टि करता है कि डेटाबेस सफलतापूर्वक बनाया गया था:

   
   Query OK, 1 row affected (0.01 sec)
   

4. test_db पर स्विच करें डेटाबेस:

   USE test_db;
   

   आपको यह आउटपुट देखना चाहिए:

   
   Database changed
   

5. आपने test_db बनाया है और इसे चुना। इसके बाद, customers . नाम की एक टेबल बनाएं :

    CREATE TABLE customers
    (
    customer_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    customer_name VARCHAR(50)
    ) ENGINE = InnoDB;
   

   आपको यह आउटपुट देखना चाहिए:

   
   Query OK, 0 rows affected (0.03 sec)
   

6. customers . में कुछ रिकॉर्ड जोड़ें टेबल। नीचे दिए गए INSERT को चलाएँ एक-एक करके आदेश:

   INSERT INTO customers(customer_name) VALUES ('JOHN PAUL');
   INSERT INTO customers(customer_name) VALUES ('PETER DOE');
   INSERT INTO customers(customer_name) VALUES ('MARY DOE');
   INSERT INTO customers(customer_name) VALUES ('CHRISTINE JAMES');
   INSERT INTO customers(customer_name) VALUES ('MARK WELL');
   INSERT INTO customers(customer_name) VALUES ('FRANK BRIAN');
   

   प्रत्येक रिकॉर्ड डालने के बाद यह आउटपुट दिखाया जाता है:

   
   Query OK, 1 row affected (0.00 sec)
   ...
   

7. सत्यापित करें कि ग्राहकों की जानकारी डेटाबेस में डाली गई थी। इसे निष्पादित करें SELECT आदेश:

   SELECT * FROM customers;
   

   आपको ग्राहकों की यह सूची देखनी चाहिए:

   
   +-------------+-----------------+
   | customer_id | customer_name   |
   +-------------+-----------------+
   |           1 | JOHN PAUL       |
   |           2 | PETER DOE       |
   |           3 | MARY DOE        |
   |           4 | CHRISTINE JAMES |
   |           5 | MARK WELL       |
   |           6 | FRANK BRIAN     |
   +-------------+-----------------+
   6 rows in set (0.00 sec)
   

8. एक sales बनाएं टेबल। यह तालिका customer_id column कॉलम का उपयोग करती है customers . को संदर्भित करने के लिए तालिका:

   CREATE TABLE sales
   (
   order_id BIGINT PRIMARY KEY AUTO_INCREMENT,
   customer_id BIGINT,
   sales_amount DECIMAL(17,2)
   ) ENGINE = InnoDB;
   

   यह आउटपुट प्रकट होता है:

   
   Query OK, 0 rows affected (0.03 sec)
   

9. इसके बाद, sales को पॉप्युलेट करें कुछ रिकॉर्ड के साथ तालिका। नीचे दिए गए INSERT को चलाएँ एक-एक करके आदेश:

   INSERT INTO sales (customer_id, sales_amount) VALUES ('1','25.75');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('2','85.25');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('5','3.25');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('4','200.75');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('5','88.10');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('1','100.00');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('2','45.00');
   INSERT INTO sales (customer_id, sales_amount) VALUES ('4','15.80');
   

   प्रत्येक रिकॉर्ड डालने के बाद यह आउटपुट दिखाया जाता है:

   
   Query OK, 1 row affected (0.01 sec)
   ...
   

10. sales . में डेटा सत्यापित करें टेबल। इसे निष्पादित करें SELECT आदेश:

    SELECT * FROM sales;
    

    बिक्री डेटा की यह सूची अब दिखाई जानी चाहिए:

    
    +----------+-------------+--------------+
    | order_id | customer_id | sales_amount |
    +----------+-------------+--------------+
    |        1 |           1 |        25.75 |
    |        2 |           2 |        85.25 |
    |        3 |           5 |         3.25 |
    |        4 |           4 |       200.75 |
    |        5 |           5 |        88.10 |
    |        6 |           1 |       100.00 |
    |        7 |           2 |        45.00 |
    |        8 |           4 |        15.80 |
    +----------+-------------+--------------+
    8 rows in set (0.00 sec)
    

डेटाबेस और संबंधित तालिकाओं को स्थापित करने के बाद, अब आप MySQL में विभिन्न उपश्रेणियों को लागू कर सकते हैं।

सहसंबद्ध सबक्वेरी का उपयोग कैसे करें

एक सहसंबद्ध उपश्रेणी एक प्रकार की नेस्टेड क्वेरी है जो मूल क्वेरी के मानों का उपयोग करती है। इस प्रकार की क्वेरीज़ मूल क्वेरी को कॉलम के साथ संदर्भित करती हैं। नेस्टेड क्वेरी को पैरेंट क्वेरी में प्रत्येक पंक्ति के लिए एक बार निष्पादित किया जाता है।

नीचे दिया गया उदाहरण एक क्वेरी प्रस्तुत करता है जो सभी ग्राहकों को चुनती है। क्वेरी के अंदर, एक सहसंबद्ध सबक्वेरी है जो sales से प्रत्येक ग्राहक के लिए कुल बिक्री राशि प्राप्त करती है टेबल।

1. उदाहरण क्वेरी चलाएँ:

   SELECT
   customer_id,
   customer_name,
   (SELECT SUM(sales_amount)
   FROM sales WHERE customer_id = customers.customer_id) as total_sales_amount
   FROM
   customers;
   

   इस उदाहरण में, सबक्वेरी है SELECT SUM(sales_amount) FROM sales WHERE customer_id = customers.customer_id , जो कोष्ठकों में दिखाई देता है।

   ग्राहकों द्वारा की गई कुल बिक्री की एक सूची दिखाई देती है:

   
   +-------------+-----------------+--------------------+
   | customer_id | customer_name   | total_sales_amount |
   +-------------+-----------------+--------------------+
   |           1 | JOHN PAUL       |             125.75 |
   |           2 | PETER DOE       |             130.25 |
   |           3 | MARY DOE        |               NULL |
   |           4 | CHRISTINE JAMES |             216.55 |
   |           5 | MARK WELL       |              91.35 |
   |           6 | FRANK BRIAN     |               NULL |
   +-------------+-----------------+--------------------+
   6 rows in set (0.00 sec)
   

   सहसंबद्ध सबक्वेरी से ऊपर का आउटपुट आपको ग्राहकों के आदेशों की एक संक्षिप्त सूची देने में सक्षम है। कृपया ध्यान दें, चूंकि customer_id एस 3 और 6 बिक्री तालिका में कोई संबद्ध रिकॉर्ड नहीं है, उनका total_sales_amount है NULL ।

2. इस सूची को प्रस्तुत करने का एक और शानदार तरीका है 0 . लौटाना NULL . के बजाय शून्य बिक्री वाले ग्राहकों के लिए। ऐसा करने के लिए, सबक्वेरी द्वारा उत्पन्न आउटपुट को IFNULL(expression, 0) के साथ संलग्न करें बयान। इस अद्यतन आदेश को चलाएँ:

    SELECT
    customer_id,
    customer_name,
    IFNULL((SELECT SUM(sales_amount)
    FROM sales WHERE customer_id = customers.customer_id), 0) as total_sales_amount
    FROM
    customers;
   

   निम्न आउटपुट प्रकट होता है। MySQL उन सभी पंक्तियों के लिए 0.00 लौटाता है जो अन्यथा NULL लौटाती हैं मान।

   
   +-------------+-----------------+--------------------+
   | customer_id | customer_name   | total_sales_amount |
   +-------------+-----------------+--------------------+
   |           1 | JOHN PAUL       |             125.75 |
   |           2 | PETER DOE       |             130.25 |
   |           3 | MARY DOE        |               0.00 |
   |           4 | CHRISTINE JAMES |             216.55 |
   |           5 | MARK WELL       |              91.35 |
   |           6 | FRANK BRIAN     |               0.00 |
   +-------------+-----------------+--------------------+
   6 rows in set (0.00 sec)
   

   यह दृष्टिकोण यह सुनिश्चित करने में मदद करता है कि आउटपुट रिकॉर्ड पर किसी भी आगे की गणना को नुकसान नहीं पहुंचाता है।

एक तुलना ऑपरेटर में एक सहसंबद्ध सबक्वेरी का उपयोग कैसे करें

डेटाबेस क्वेरी स्तर में व्यावसायिक तर्क को स्थानांतरित करने के लिए उपश्रेणियाँ उपयोगी हैं। निम्नलिखित व्यावसायिक उपयोग-मामलों में मूल क्वेरी के WHERE क्लॉज़ के अंदर सहसंबद्ध उपश्रेणियाँ होती हैं:

• एक ऐसे परिदृश्य पर विचार करें जहां आप डेटाबेस में पंजीकृत उन सभी ग्राहकों की सूची प्राप्त करना चाहते हैं जिनकी बिक्री संबद्ध नहीं है। आप MySQL तुलना ऑपरेटर के साथ एक सबक्वेरी का उपयोग कर सकते हैं NOT IN और इन ग्राहकों को पुनः प्राप्त करें:

    SELECT
    customer_id,
    customer_name
    FROM
    customers
    WHERE customer_id NOT IN (SELECT customer_id FROM sales);
  

  इस उदाहरण में, सबक्वेरी SELECT customer_id FROM sales . है , जो कोष्ठकों में दिखाई देता है। ऊपर दिया गया SQL कमांड उन दो ग्राहकों की सूची को आउटपुट करता है जो बिक्री तालिका में नहीं पाए जाते हैं:

  
  +-------------+---------------+
  | customer_id | customer_name |
  +-------------+---------------+
  |           3 | MARY DOE      |
  |           6 | FRANK BRIAN   |
  +-------------+---------------+
  2 rows in set (0.00 sec)
  

  उत्पादन के माहौल में, आप बेहतर व्यावसायिक निर्णय लेने के लिए इस तरह के रिकॉर्डसेट का उपयोग कर सकते हैं। उदाहरण के लिए, आप इन ग्राहकों को ईमेल करने के लिए PHP या पायथन जैसी किसी अन्य भाषा का उपयोग करके एक स्क्रिप्ट बना सकते हैं और पूछताछ कर सकते हैं कि क्या उन्हें ऑर्डर देने में कोई समस्या है।

• एक अन्य उपयोग-मामला डेटा क्लीन-अप में है। उदाहरण के लिए, आप उन ग्राहकों को हटाने के लिए एक सबक्वेरी का उपयोग कर सकते हैं जिन्होंने कभी ऑर्डर नहीं दिया है:

    DELETE
    FROM
    customers
    WHERE customer_id NOT IN (SELECT customer_id FROM sales);
  

  ऊपर दिया गया SQL कमांड दो ग्राहकों को हटाता है और निम्नलिखित को आउटपुट करता है:

  
  Query OK, 2 rows affected (0.01 sec)
  

  यदि आप सभी ग्राहकों को फिर से सूचीबद्ध करने के लिए एक आदेश निष्पादित करते हैं, तो ये ग्राहक अब तालिका में प्रकट नहीं होने चाहिए:

    SELECT *
    FROM
    customers;
  

  नीचे दिया गया आउटपुट पुष्टि करता है कि बिना संबद्ध ऑर्डर वाले ग्राहकों को हटा दिया गया था:

  
  +-------------+-----------------+
  | customer_id | customer_name   |
  +-------------+-----------------+
  |           1 | JOHN PAUL       |
  |           2 | PETER DOE       |
  |           4 | CHRISTINE JAMES |
  |           5 | MARK WELL       |
  +-------------+-----------------+
  4 rows in set (0.00 sec)
  

उपश्रेणी को व्युत्पन्न तालिका के रूप में कैसे उपयोग करें

जब उपश्रेणियों का उपयोग FROM . में किया जाता है पैरेंट क्वेरी का क्लॉज, उन्हें व्युत्पन्न टेबल . के रूप में संदर्भित किया जाता है . जटिल प्रश्नों को लागू करते समय वे बहुत महत्वपूर्ण होते हैं जिन्हें अन्यथा एक MySQL VIEW . की आवश्यकता होती है , JOIN , या UNION खंड। उस क्वेरी में एक व्युत्पन्न तालिका मौजूद है जिसने इसे बनाया है और स्थायी रूप से डेटाबेस में सहेजा नहीं गया है।

जब उपश्रेणियों को व्युत्पन्न तालिकाओं के रूप में उपयोग किया जाता है, तो वे SQL कथन के विभिन्न भागों को अलग करते हैं। दूसरे शब्दों में, सबक्वेरी तालिका की एक सरलीकृत अभिव्यक्ति प्रदान करती है जिसका उपयोग पैरेंट क्वेरी के दायरे में किया जा सकता है।

नोट याद रखें, प्रत्येक व्युत्पन्न तालिका को अलियास किया जाना चाहिए।

order_summary के रूप में उपनामित एक व्युत्पन्न तालिका उपश्रेणी बनाने के लिए नीचे दिए गए आदेश को चलाएँ :

SELECT customer_id
FROM
    (
    SELECT
    customer_id,
    count(order_id) as total_orders
    FROM sales
    group by customer_id
    ) as order_summary
WHERE order_summary.total_orders > 1;

नोट

इस आदेश में, उपश्रेणी कोष्ठक में इस प्रकार दिखाई देती है:

SELECT
customer_id,
count(order_id) as total_orders
FROM sales
group by customer_id

उपरोक्त आदेश 1 से अधिक ऑर्डर वाले ग्राहकों को निर्धारित करने के लिए बिक्री तालिका से पूछताछ करता है। जब आप क्वेरी चलाते हैं, तो यह आउटपुट प्रकट होता है:

+-------------+
| customer_id |
+-------------+
|           1 |
|           2 |
|           5 |
|           4 |
+-------------+
4 rows in set (0.00 sec)

उपरोक्त सूची चार customer_id shows दिखाती है s जिनके एक से अधिक ऑर्डर हैं। उदाहरण के तौर पर व्यावसायिक उपयोग के मामले में, आप एक स्क्रिप्ट में ऐसी क्वेरी का उपयोग कर सकते हैं जो ग्राहकों को उनकी अगली खरीदारी पर बोनस के साथ पुरस्कृत करती है।

अधिक जानकारी

आप इस विषय पर अतिरिक्त जानकारी के लिए निम्नलिखित संसाधनों से परामर्श करना चाह सकते हैं। हालांकि ये इस उम्मीद में प्रदान किए जाते हैं कि वे उपयोगी होंगे, कृपया ध्यान दें कि हम बाहरी रूप से होस्ट की गई सामग्री की सटीकता या समयबद्धता की पुष्टि नहीं कर सकते।

• MySQL सबक्वेरी