MySQL डेटाबेस में दृश्यों का उपयोग कैसे करें

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

• डेटाबेस सुरक्षा बढ़ाएँ। यदि आपके डेटाबेस में संवेदनशील जानकारी है जिसे सुरक्षित करने की आवश्यकता है, तो दृश्य का उपयोग करने से आपको डेटा को अलग करने में मदद मिलती है। एक पूर्वनिर्धारित परिणाम सेट के साथ एक दृश्य बनाया जा सकता है, और आप संवेदनशील जानकारी वाली तालिका के बजाय उपयोगकर्ताओं को केवल उस दृश्य तक पहुंच प्रदान कर सकते हैं।
• जटिल व्यावसायिक तर्क को डेटाबेस सर्वर पर ले जाएं। विभिन्न क्लाइंट में अक्सर उपयोग किए जाने वाले सॉफ़्टवेयर तर्क को कोड करने के बजाय, एक डेवलपर एक दृश्य का उपयोग करके तर्क को डेटाबेस स्तर में स्थानांतरित कर सकता है। उदाहरण के लिए, ग्राहक वर्गीकरण को उनकी कुल बिक्री के आधार पर प्रदर्शित करने के लिए एक दृश्य बनाया जा सकता है।
• डेटा का ध्यान भटकाना कम करें. एक दृश्य विभिन्न तालिकाओं के परिणामों को जोड़ सकता है और केवल तभी प्रासंगिक कॉलम प्रदर्शित कर सकता है जब इसे लागू किया जाए।

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

• MySQL दृश्य का सिंटैक्स कैसे संरचित किया जाता है।
• MySQL व्यू कैसे बनाएं।
• MySQL व्यू को कैसे इनवाइट करें।
• MySQL में किसी दृश्य को कैसे छोड़ें।

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

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

1. एक लाइनोड, जिस पर आप MySQL सॉफ़्टवेयर चलाते हैं। आप लाइनोड के प्रावधान के लिए लिनोड के साथ आरंभ करना मार्गदर्शिका का अनुसरण कर सकते हैं।

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

डेटाबेस तैयार करना

अपने MySQL दृश्य बनाने से पहले, एक नमूना डेटाबेस बनाएं, कुछ तालिकाओं को परिभाषित करें, और उन्हें पहले कुछ डेटा के साथ पॉप्युलेट करें:

1. आपके लिनोड के लिए एसएसएच। फिर, रूट उपयोगकर्ता के रूप में MySQL में लॉग इन करने के लिए यह कमांड दर्ज करें:

   mysql -u root -p
   

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

   नोट

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

   sudo mysql -u root -p
   

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

   
   mysql >
   

   नोट

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

   
   MariaDB [(none)]>
   

3. इसके बाद, एक नमूना डेटाबेस बनाने के लिए इस SQL ​​​​कमांड को चलाएं जिसका नाम sample_database . है :

   CREATE DATABASE sample_database;
   

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

   
   Query OK, 1 row affected (0.02 sec)
   

4. sample_database का चयन करें डेटाबेस:

   USE sample_database;
   

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

   
   Database changed
   

5. customers create बनाने के लिए इस आदेश को चलाएँ तालिका:

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

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

   
   Query OK, 0 rows affected (0.07 sec)
   

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

   INSERT INTO customers (customer_name) VALUES ('Leslie');
   INSERT INTO customers (customer_name) VALUES ('Andy');
   INSERT INTO customers (customer_name) VALUES ('Ben');
   

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

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

7. सुनिश्चित करें कि नमूना रिकॉर्ड इस SELECT . को चलाकर डेटाबेस में डाला गया था आदेश:

   SELECT * FROM customers;
   

   यह आउटपुट प्रकट होता है, जो पुष्टि करता है कि डेटा पिछले चरण में सफलतापूर्वक डाला गया था:

   
   +-------------+---------------+
   | customer_id | customer_name |
   +-------------+---------------+
   |           1 | Leslie        |
   |           2 | Andy          |
   |           3 | Ben           |
   +-------------+---------------+
   3 rows in set (0.01 sec)
   

8. इसके बाद, एक sales बनाएं टेबल। यह आदेश चलाएँ:

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

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

   
   Query OK, 0 rows affected (0.07 sec)
   

9. फिर, sales . में कुछ डेटा जोड़ें टेबल। इन आदेशों को एक-एक करके चलाएँ:

   INSERT INTO sales (customer_id, monthly_sales) VALUES ('1','500.27');
   INSERT INTO sales (customer_id, monthly_sales) VALUES ('2','7600.32');
   INSERT INTO sales (customer_id, monthly_sales) VALUES ('3', '25879.63');
   

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

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

10. इसके बाद, एक SELECT चलाएं यह सत्यापित करने के लिए क्वेरी कि बिक्री डेटा तालिका में डाला गया था:

    SELECT * FROM sales;
    

    यह आउटपुट प्रकट होता है, जो पुष्टि करता है कि बिक्री डेटा पिछले चरण में सफलतापूर्वक डाला गया था:

    
    
    
    +-------------+---------------+
    | customer_id | monthly_sales |
    +-------------+---------------+
    |           1 |        500.27 |
    |           2 |       7600.32 |
    |           3 |      25879.63 |
    +-------------+---------------+
    3 rows in set (0.00 sec)
      

आपने काम करने के लिए डेटाबेस और तालिकाओं को परिभाषित किया है। अगला भाग MySQL व्यू के सिंटैक्स का वर्णन करता है।

MySQL व्यू सिंटैक्स

यह MySQL व्यू सिंटैक्स का सरलीकृत संस्करण है:

    CREATE
    VIEW view_name
    AS select_statement

• view_name :MySQL व्यू का नाम यहां परिभाषित किया जाना चाहिए। वर्णनात्मक नाम का उपयोग करने की सलाह दी जाती है ताकि आप बाद में दृश्य के कार्य को याद रख सकें।

• select_statement :यह SQL क्वेरी है जो परिभाषित दृश्य के साथ युग्मित है। जब दृश्य का आह्वान किया जाता है, तो MySQL इस क्वेरी को एक रिकॉर्डसेट वापस करने के लिए चलाता है।

MySQL व्यू बनाना

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

सुनिश्चित करें कि आप अपने MySQL सर्वर में लॉग इन हैं। फिर, customers_membership बनाने के लिए नीचे दी गई कमांड चलाएँ देखें:

CREATE
VIEW customers_membership
AS SELECT sales.customer_id,
customer_name,
(IF(sales.monthly_sales >= 5000, 'PREMIUM', 'BASIC')) as membership
FROM sales
LEFT JOIN customers
ON sales.customer_id = customers.customer_id;

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

Query OK, 0 rows affected (0.01 sec)

उपरोक्त MySQL कमांड customers_membership . नाम से एक व्यू बनाता है जो customers . से जुड़ता है और sales PRIMARY KEY के साथ तालिका customer_id . तार्किक IF(expression, value_if_true, value_if_false) स्टेटमेंट लॉजिक का उपयोग ग्राहक की मासिक बिक्री से उसकी सदस्यता निर्धारित करने के लिए किया जाता है:

• यदि किसी ग्राहक की बिक्री 5,000 के बराबर या उससे अधिक है, तो दृश्य ग्राहक को PREMIUM के रूप में वर्गीकृत करता है सदस्य।

• अन्यथा (यदि बिक्री 5,000 . से कम है ), ग्राहक को BASIC . के रूप में वर्गीकृत किया गया है सदस्य।

customers_membership दृश्य अब डेटाबेस में सहेजा गया है। अगला खंड दिखाता है कि कैसे एक MySQL व्यू को कॉल करें और सीधे बेस टेबल को क्वेरी किए बिना एक रिकॉर्डसेट प्रदर्शित करें।

MySQL व्यू को इनवाइट करना

यह खंड दिखाता है कि आपके द्वारा ऊपर बनाए गए MySQL दृश्य को कैसे लागू किया जाए और पुष्टि की जाए कि यह अपेक्षा के अनुरूप काम करता है। एक बार एक दृश्य बन जाने के बाद, यह डेटाबेस ऑब्जेक्ट के रूप में दिखाई देता है और इसे SELECT . का उपयोग करके कॉल किया जा सकता है बयान।

1. customers_membership का आह्वान करने के लिए देखें, दौड़ें:

   SELECT * FROM customers_membership;
   

   यदि दृश्य अपेक्षित रूप से काम कर रहा है, तो अब आपको ग्राहकों की उनकी जेनरेट की गई membership . के साथ एक सूची देखनी चाहिए उनकी बिक्री के आधार पर मूल्य। चूंकि Leslie की बिक्री 5000 (500.27) से कम थी, यह दृश्य ग्राहक की सदस्यता को BASIC के रूप में प्रदर्शित करता है . Andy और Ben की बिक्री क्रमशः 7600.32 और 25879.63 थी और यह उन्हें PREMIUM बनाता है सदस्य:

   
   +-------------+---------------+------------+
   | customer_id | customer_name | membership |
   +-------------+---------------+------------+
   |           1 | Leslie        | BASIC      |
   |           2 | Andy          | PREMIUM    |
   |           3 | Ben           | PREMIUM    |
   +-------------+---------------+------------+
   3 rows in set (0.00 sec)
   

2. एक बार बेस टेबल डेटा अपडेट हो जाने के बाद और आप फिर से एक MySQL व्यू को इनवाइट करते हैं, तो आपको नवीनतम जानकारी देखनी चाहिए। दृश्य उनके आधार तालिकाओं से जानकारी खींचते हैं, और वे डेटा संग्रहीत नहीं करते हैं। यह प्रदर्शित करने के लिए कि कैसे एक दृश्य आधार तालिकाओं से अद्यतन जानकारी को खींचता है, Rajie . नामक एक अन्य ग्राहक को जोड़ें customers . के लिए तालिका:

   INSERT INTO customers (customer_name) VALUES ('Rajie');
   

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

   
   Query OK, 1 row affected (0.01 sec)
   

3. फिर, ग्राहक की मासिक बिक्री जानकारी को बिक्री तालिका में जोड़ें:

   INSERT INTO sales (customer_id, monthly_sales) VALUES ('4', '147.41');
   

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

   
   Query OK, 1 row affected (0.01 sec)
   

4. इसके बाद, customers_membership का आह्वान करें फिर से देखें:

   SELECT * FROM customers_membership;
   

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

   
   +-------------+---------------+------------+
   | customer_id | customer_name | membership |
   +-------------+---------------+------------+
   |           1 | Leslie        | BASIC      |
   |           2 | Andy          | PREMIUM    |
   |           3 | Ben           | PREMIUM    |
   |           4 | Rajie         | BASIC      |
   +-------------+---------------+------------+
   4 rows in set (0.00 sec)
   

   जैसा कि आप ऊपर व्यू रिकॉर्डसेट में देख सकते हैं, अब आपके पास Rajie . नाम का एक नया ग्राहक है एक BASIC . के साथ सदस्यता।

एक MySQL दृश्य को छोड़ना

अन्य डेटाबेस ऑब्जेक्ट्स की तरह, यदि आपको अब दृश्यों की आवश्यकता नहीं है, तो आप उन्हें हटा सकते हैं। MySQL व्यू को छोड़ने के लिए यह मूल सिंटैक्स है:

    DROP VIEW IF EXISTS view_name;

1. MySQL व्यू को छोड़ने से पहले, पहले नीचे दिए गए कमांड को चलाकर उसके नाम की पहचान करें:

   SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';
   

   वर्तमान में चयनित डेटाबेस में सभी दृश्यों की एक सूची दिखाई देती है:

   
   +---------------------------+------------+
   | Tables_in_sample_database | Table_type |
   +---------------------------+------------+
   | customers_membership      | VIEW       |
   +---------------------------+------------+
   1 row in set (0.01 sec)
   

2. इस मामले में, उस दृश्य का नाम जिसे आप छोड़ना चाहते हैं customers_membership . है . तो, इसे हटाने के लिए, दौड़ें:

   DROP VIEW IF EXISTS customers_membership;
   

   सुनिश्चित करें कि डेटाबेस से दृश्य हटाए जाने के बाद नीचे दिया गया आउटपुट प्रदर्शित होता है:

   
   Query OK, 0 rows affected (0.01 sec)
   

   नोट कृपया ध्यान दें, यदि आप किसी ऐसे MySQL दृश्य को हटाने का प्रयास करते हैं जो IF EXISTS का उपयोग किए बिना मौजूद नहीं है। कीवर्ड, MySQL एक त्रुटि देता है।

3. जब चरण 1 से आदेश फिर से चलाया जाता है, तो अब कोई परिणाम नहीं होना चाहिए:

   SHOW FULL TABLES WHERE TABLE_TYPE LIKE 'VIEW';
   

   
   Empty set (0.000 sec)
   

अधिक जानकारी

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

• MySQL - दृश्यों का उपयोग करना