एक MySQL डेटाबेस में ट्रिगर के साथ कार्य करना - एक ट्यूटोरियल

एक ट्रिगर एक पूर्व-निर्धारित SQL कमांड है जो डेटाबेस में विशिष्ट क्रियाओं के होने पर स्वचालित रूप से निष्पादित होती है। इसे INSERT . से पहले या बाद में सक्रिय किया जा सकता है , UPDATE , या DELETE घटना।

ट्रिगर मुख्य रूप से MySQL सर्वर में सॉफ़्टवेयर लॉजिक को बनाए रखने के लिए उपयोग किए जाते हैं, और उनके कई लाभ हैं:

• ट्रिगर वैश्विक संचालन को एक स्थान पर केंद्रीकृत रखने में मदद करते हैं।

• वे क्लाइंट-साइड कोड को कम करते हैं और डेटाबेस सर्वर पर किए गए राउंड-ट्रिप को कम करने में मदद करते हैं।

• वे विभिन्न प्लेटफॉर्म पर एप्लिकेशन को अधिक स्केलेबल बनाने में मदद करते हैं।

ट्रिगर के कुछ सामान्य उपयोग के मामलों में ऑडिट लॉगिंग, प्री-कंप्यूटिंग डेटाबेस मान (जैसे संचयी रकम), और जटिल डेटा अखंडता और सत्यापन नियमों को लागू करना शामिल है।

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

• ट्रिगर के लिए सिंटैक्स कैसे संरचित किया जाता है।

• अन्य डेटाबेस ईवेंट होने से पहले निष्पादित होने वाले ट्रिगर कैसे बनाएं।

• अन्य डेटाबेस ईवेंट होने के बाद निष्पादित होने वाले ट्रिगर कैसे बनाएं।

• ट्रिगर कैसे हटाएं।

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

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

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

3. लाइनोड सर्वर पर स्थापित एक MySQL सर्वर और क्लाइंट। MySQL के लिए इंस्टॉलेशन गाइड हमारे MySQL सेक्शन में विभिन्न वितरणों के लिए उपलब्ध हैं।

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

यह समझने के लिए कि ट्रिगर कैसे काम करते हैं, हम एक नमूना डेटाबेस बनाएंगे और उसमें नमूना डेटा जोड़ेंगे। बाद में, हम अवधारणा अभ्यास के प्रमाण के रूप में डेटाबेस पर अलग-अलग ट्रिगर बनाएंगे।

1. सबसे पहले, अपने MySQL सर्वर में लॉग इन करें:

   mysql -u root -p
   

   फिर, अपने MySQL सर्वर का रूट पासवर्ड दर्ज करें और Enter hit दबाएं आगे बढ़ने के लिए।

2. इसके बाद, आपको नीचे दिखाए गए के समान एक MySQL प्रॉम्प्ट दिखाई देगा:

   mysql >

3. एक test_database बनाएं नीचे कमांड चलाकर:

   CREATE DATABASE test_database;
   

   आउटपुट:

   Query OK, 1 row affected (0.02 sec)

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

   USE test_database;
   

   आउटपुट:

   Database changed

5. एक बार डेटाबेस का चयन करने के बाद, हम कुछ टेबल बनाएंगे जिनका उपयोग हम ट्रिगर्स को प्रदर्शित करने के लिए करेंगे। हम stores . बनाकर शुरुआत करेंगे टेबल। इस तालिका में दो नमूना स्टोर/कार्यालयों के बारे में जानकारी होगी जहां से हमारा काल्पनिक व्यवसाय संचालित होता है:

   CREATE TABLE stores
   (
   store_id BIGINT PRIMARY KEY AUTO_INCREMENT,
   store_name VARCHAR(50)
   ) ENGINE=InnoDB;
   

   आउटपुट:

   Query OK, 0 rows affected (0.07 sec)

6. इसके बाद, stores . में दो रिकॉर्ड जोड़ें नीचे दिए गए आदेशों को चलाकर तालिका:

   INSERT INTO stores (store_name) VALUES ('Philadelphia');
   INSERT INTO stores (store_name) VALUES ('Galloway');
   

   प्रत्येक कमांड के बाद, आपको निम्न आउटपुट मिलेगा:

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

7. नीचे दिए गए आदेश को चलाकर रिकॉर्ड की पुष्टि करें:

   SELECT * FROM stores;
   

   आउटपुट:

   +----------+--------------+
   | store_id | store_name   |
   +----------+--------------+
   |        1 | Philadelphia |
   |        2 | Galloway     |
   +----------+--------------+
   2 rows in set (0.01 sec)

8. इसके बाद, products बनाएं टेबल। टेबल स्टोर में पेश किए जा रहे विभिन्न उत्पादों को रखेगी:

   CREATE TABLE products
   (
   product_id BIGINT PRIMARY KEY AUTO_INCREMENT,
   product_name VARCHAR(40),
   cost_price DOUBLE,
   retail_price DOUBLE,
   availability VARCHAR(5)
   ) ENGINE=InnoDB;
   

   आउटपुट:

   Query OK, 0 rows affected (0.13 sec)

   • प्रत्येक उत्पाद की विशिष्ट रूप से एक product_id . द्वारा पहचान की जाएगी ।

   • एक product_name फ़ील्ड आइटम के नाम निर्दिष्ट करेगा।

   • cost_price और retail_price फ़ील्ड क्रमशः खरीद और बिक्री मूल्य निर्धारित करेंगे।

   • एक availability कॉलम विभिन्न दुकानों में उत्पाद की उपलब्धता को परिभाषित करेगा। यदि उत्पाद केवल हमारे स्थानीय स्टोर (फिलाडेल्फ़िया) में उपलब्ध है, तो हम इसे LOCAL से प्रदर्शित करेंगे। मूल्य। अन्यथा, हम ALL . के मान का उपयोग करेंगे एक ऐसे उत्पाद को दर्शाने के लिए जो दोनों दुकानों (फिलाडेल्फिया और गैलोवे) में उपलब्ध है।

9. products में नमूना डेटा जोड़ें तालिका:

   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('WIRELESS MOUSE', '18.23', '30.25','ALL');
   
   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('8 MP CAMERA', '60.40', '85.40','ALL');
   
   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('SMART WATCH', '189.60', '225.30','LOCAL');
   

   प्रत्येक इंसर्ट कमांड के बाद आपको नीचे दिखाया गया आउटपुट मिलेगा:

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

10. पुष्टि करें कि क्या उत्पाद नीचे दिए गए आदेश को चलाकर सम्मिलित किए गए थे:

    SELECT * FROM products;
    

    आउटपुट:

    +------------+----------------+------------+--------------+--------------+
    | product_id | product_name   | cost_price | retail_price | availability |
    +------------+----------------+------------+--------------+--------------+
    |          1 | WIRELESS MOUSE |      18.23 |        30.25 | ALL          |
    |          2 | 8 MP CAMERA    |       60.4 |         85.4 | ALL          |
    |          3 | SMART WATCH    |      189.6 |        225.3 | LOCAL        |
    +------------+----------------+------------+--------------+--------------+
    3 rows in set (0.00 sec)

11. इसके बाद, उत्पादों की उपलब्धता को products_to_stores . नाम की एक अन्य तालिका में मैप किया जाएगा . यह तालिका केवल product_id . का संदर्भ देगी products . से टेबल और store_id stores . से तालिका जहां आइटम उपलब्ध है।

    products_to_stores बनाएं नीचे दिए गए कोड को चलाकर तालिका:

    CREATE TABLE products_to_stores
    (
    ref_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    product_id BIGINT,
    store_id BIGINT
    ) ENGINE=InnoDB;
    

    आउटपुट:

    Query OK, 0 rows affected (0.14 sec)

12. इसके बाद, हम एक archived_products तैयार करेंगे टेबल। तालिका भविष्य में संदर्भ के लिए हटाए गए उत्पादों के बारे में जानकारी रखेगी:

    CREATE TABLE archived_products
    (
    product_id BIGINT PRIMARY KEY ,
    product_name VARCHAR(40),
    cost_price DOUBLE,
    retail_price DOUBLE,
    availability VARCHAR(5)
    ) ENGINE=InnoDB;
    

    आउटपुट:

    Query OK, 0 rows affected (0.14 sec)

13. अंत में, हम एक products_price_history बनाएंगे समय के साथ प्रत्येक उत्पाद की विभिन्न कीमतों पर नज़र रखने के लिए तालिका:

    CREATE TABLE products_price_history
    (
    product_id BIGINT PRIMARY KEY AUTO_INCREMENT,
    price_date DATETIME,
    retail_price DOUBLE
    ) ENGINE=InnoDB;
    

    आउटपुट:

    Query OK, 0 rows affected (0.14 sec)

एक बार हमारी डेटाबेस संरचना तैयार हो जाने के बाद, हम अब आगे बढ़ सकते हैं और अपना पहला नमूना बनाने के लिए MySQL डेटाबेस ट्रिगर के मूल सिंटैक्स को सीख सकते हैं।

ट्रिगर सिंटैक्स

जैसा कि पहले बताया गया है, डेटाबेस में SQL कमांड चलाने से पहले या बाद में ट्रिगर स्वचालित रूप से सक्रिय हो जाते हैं। ट्रिगर बनाने का मूल सिंटैक्स इस प्रकार है:

CREATE TRIGGER TRIGGER_NAME

TRIGGER_TIME TRIGGER_EVENT

ON TABLE_NAME FOR EACH ROW

[TRIGGER BODY];

• TRIGGER_NAME :प्रत्येक ट्रिगर का एक विशिष्ट नाम होना चाहिए और आपको इसे यहां परिभाषित करना चाहिए।

• TRIGGER_TIME :या तो BEFORE या AFTER ।

• TRIGGER_EVENT :आपको डेटाबेस ईवेंट निर्दिष्ट करना होगा जो ट्रिगर को लागू करेगा:INSERT , UPDATE , या DELETE ।

• TRIGGER BODY :यह वास्तविक SQL कमांड (या कमांड) को निर्दिष्ट करता है जिसे आप अपने ट्रिगर द्वारा चलाना चाहते हैं।

यदि किसी ट्रिगर बॉडी में एक से अधिक SQL कथन हैं, तो आपको उसे एक BEGIN...END में संलग्न करना होगा खंड मैथा। साथ ही, आपको DELIMITER . को अस्थायी रूप से बदलना होगा जो ट्रिगर बॉडी के अंत को एक नए मान के लिए संकेत देता है। यह सुनिश्चित करता है कि आपके MySQL क्लाइंट द्वारा शरीर के भीतर के बयानों की समय से पहले व्याख्या नहीं की जाती है। इसका एक उदाहरण निम्न जैसा दिखता है:

DELIMITER &&

CREATE TRIGGER TRIGGER_NAME

TRIGGER_TIME TRIGGER_EVENT

ON TABLE_NAME FOR EACH ROW

BEGIN

[TRIGGER BODY]

END &&

DELIMITER ;

नोट इस उदाहरण की अंतिम पंक्ति DELIMITER . को बदल देती है डिफ़ॉल्ट पर वापस ; मान।

ईवेंट ट्रिगर से पहले बनाना

इस खंड में, हम विभिन्न प्रकार के ट्रिगर्स पर गौर करेंगे जो एक डेटाबेस ऑपरेशन से पहले निकाल दिए जाते हैं। इनमें BEFORE INSERT . शामिल हैं , BEFORE UPDATE , और BEFORE DELETE ट्रिगर।

एक बिफोर इंसर्ट ट्रिगर बनाना

हम अपना पहला BEFORE INSERT . बनाएंगे चालू कर देना। ट्रिगर यह सुनिश्चित करेगा कि जब भी आइटम products में डाले जाते हैं, तो उत्पाद का खुदरा मूल्य लागत मूल्य से अधिक होता है टेबल। अन्यथा, डेटाबेस उपयोगकर्ता को एक त्रुटि मिलेगी।

1. जबकि अभी भी mysql > . पर है प्रॉम्प्ट, नीचे कमांड दर्ज करें:

   DELIMITER $$
   
   CREATE TRIGGER price_validator
   
   BEFORE INSERT
   
   ON products FOR EACH ROW
   
   IF NEW.cost_price>=NEW.retail_price
   
   THEN
   
   SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Retail price must be greater than cost price.';
   
   END IF $$
   
   DELIMITER ;
   

   • उपरोक्त कोड ट्रिगर नाम को परिभाषित करता है (price_validator ), समय (BEFORE ), घटना (INSERT ), और तालिका (products ) प्रभावित होना।

   • हमारा ट्रिगर NEW . का उपयोग करता है cost_price की जांच करने के लिए कीवर्ड और retail_price products में रिकॉर्ड डालने से पहले तालिका, IF...THEN...END IF . का उपयोग करके बयान।

   • अगर cost_price retail price . से अधिक या बराबर है , हमारे ट्रिगर्स MySQL को एक कस्टम अपवाद फेंकने के लिए कहते हैं जो उपयोगकर्ता को त्रुटि को सुधारने का निर्देश देता है।

2. उपरोक्त ट्रिगर का परीक्षण करने के लिए, सत्यापन नियम का उल्लंघन करने वाले उत्पाद को सम्मिलित करने का प्रयास करें:

   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('GAMING MOUSE PAD', '145.00', '144.00','LOCAL');
   

   आउटपुट:

   ERROR 1644 (45000): Retail price must be greater than cost price.

   उपरोक्त सम्मिलित आदेश विफल होना चाहिए क्योंकि retail_price (144.00) cost_price . से अधिक नहीं है (145.00)।

अद्यतन से पहले ट्रिगर बनाना

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

1. एक नया product_name_validator बनाएं नीचे दिए गए आदेश के साथ ट्रिगर करें:

   DELIMITER $$
   
   CREATE TRIGGER product_name_validator
   
   BEFORE UPDATE
   
   ON products FOR EACH ROW
   
   IF NEW.product_name<>OLD.product_name
   
   THEN
   
   SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'Product name is read-only and it can not be changed.';
   
   END IF $$
   
   DELIMITER ;
   

   यह ट्रिगर नए product_name . के मानों की तुलना करता है (NEW.product_name ) और पुराना नाम पहले से ही डेटाबेस में है (OLD.product_name ) यदि कोई बेमेल है, तो एक अपवाद फेंका जाता है।

2. product_name_validator का आह्वान करने के लिए ट्रिगर, हम आईडी 1 . के साथ उत्पाद का नाम अपडेट करने का प्रयास कर सकते हैं :

   UPDATE products SET product_name='WIRELESS BLUETOOTH MOUSE' WHERE product_id='1';
   

   आउटपुट:

   ERROR 1644 (45000): Product name is read-only and it can not be changed.

बिफोर डिलीट ट्रिगर को परिभाषित करना

इस खंड में, आप देखेंगे कि आप BEFORE DELETE . को कैसे परिभाषित कर सकते हैं? उपयोगकर्ताओं को किसी तालिका से विशिष्ट रिकॉर्ड हटाने से रोकने के लिए ट्रिगर करें।

1. prevent_delete बनाने के लिए ट्रिगर, नीचे कमांड चलाएँ:

   DELIMITER $$
   
   CREATE TRIGGER prevent_delete
   
   BEFORE DELETE
   
   ON products FOR EACH ROW
   
   IF OLD.availability='ALL'
   
   THEN
   
   SIGNAL SQLSTATE '45000' SET MESSAGE_TEXT = 'The product can not be deleted because it is available in ALL stores.';
   
   END IF $$
   
   DELIMITER ;
   

   यह ट्रिगर ALL . के मान से चिह्नित उत्पादों को रोक देगा उपलब्धता कॉलम में हटाए जाने से।

2. इसके बाद, उत्पाद तालिका से पहले उत्पाद को हटाने का प्रयास करें और देखें कि क्या ट्रिगर लागू किया जाएगा:

   DELETE FROM products WHERE product_id='1';
   

   आउटपुट:

   ERROR 1644 (45000): The product can not be deleted because it is available in ALL stores.

हमने विभिन्न ट्रिगर्स को देखा है जो एक डेटाबेस ऑपरेशन से पहले लागू होते हैं। इसके बाद, हम अन्य प्रकार के ट्रिगर्स पर गौर करेंगे जो डेटाबेस ईवेंट के बाद सक्रिय होते हैं।

इवेंट ट्रिगर के बाद बनाना

उत्पादन परिवेश में, आप चाहते हैं कि डेटाबेस ईवेंट होने के बाद कुछ ट्रिगर स्वचालित रूप से निष्पादित हों (उदाहरण के लिए, विभिन्न तालिकाओं में रिकॉर्ड सम्मिलित करना)। नीचे दिए गए उदाहरण प्रदर्शित करते हैं कि हमारे नमूना डेटाबेस में इस प्रकार के ट्रिगर का उपयोग कैसे किया जा सकता है।

आफ्टर इंसर्ट ट्रिगर बनाना

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

1. product_availability बनाने के लिए नीचे दिए गए कोड को चलाएँ चालू कर देना। चूंकि हमारे पास ट्रिगर बॉडी में कोड की कई लाइनें हैं, इसलिए हम एक BEGIN...END . का उपयोग करेंगे ब्लॉक करें:

   DELIMITER $$
   
   CREATE TRIGGER product_availability
   
   AFTER INSERT
   
   ON products FOR EACH ROW
   
   BEGIN
   
   IF NEW.availability='LOCAL' then
   
   INSERT INTO products_to_stores (product_id, store_id) VALUES (NEW.product_id, '1');
   
   ELSE
   
   INSERT INTO products_to_stores (product_id, store_id) VALUES (NEW.product_id, '1');
   
   INSERT INTO products_to_stores (product_id, store_id) VALUES (NEW.product_id, '2');
   
   END IF;
   
   END $$
   
   DELIMITER ;
   

   • जब कोई आइटम products में डाला जा रहा हो तालिका में, ट्रिगर availability की जांच करेगा फ़ील्ड.

   • अगर इसे LOCAL . से चिह्नित किया गया है मूल्य, उत्पाद केवल एक स्टोर में उपलब्ध कराया जाएगा।

   • कोई अन्य मान ट्रिगर को हमारे द्वारा पहले बनाए गए दो स्टोर पर उत्पाद उपलब्ध कराने का निर्देश देगा।

2. product_availability देखने के लिए कार्रवाई में ट्रिगर, उत्पाद तालिका में दो रिकॉर्ड डालें:

   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('BLUETOOTH KEYBOARD', '17.60', '23.30','LOCAL');
   INSERT INTO products (product_name, cost_price, retail_price, availability) VALUES ('DVB-T2 RECEIVE', '49.80', '53.40','ALL');
   

3. फिर, products_to_stores से पूछताछ करें तालिका:

   SELECT * FROM products_to_stores;
   

   आपको नीचे दिखाए गए आउटपुट जैसा दिखना चाहिए:

   +--------+------------+----------+
   | ref_id | product_id | store_id |
   +--------+------------+----------+
   |      1 |          4 |        1 |
   |      2 |          5 |        1 |
   |      3 |          5 |        2 |
   +--------+------------+----------+
   3 rows in set (0.00 sec)

आफ्टर अपडेट ट्रिगर को परिभाषित करना

UPDATE . के बाद भी एक ट्रिगर सक्रिय किया जा सकता है प्रतिस्पर्धा। हम देखेंगे कि समय के साथ हमारे स्टोर में कीमतों में बदलाव का ट्रैक रखने के लिए हम इस प्रकार के ट्रिगर का लाभ कैसे उठा सकते हैं।

1. एक product_history_updater बनाएं नीचे दिए गए आदेश को चलाकर ट्रिगर करें:

   CREATE TRIGGER product_history_updater
   
   AFTER UPDATE
   
   ON products FOR EACH ROW
   
   INSERT INTO products_price_history (product_id, price_date, retail_price) VALUES (OLD.product_id, NOW(), NEW.retail_price);
   

   यह ट्रिगर उत्पाद के retail_price . में परिवर्तनों को रिकॉर्ड करता है products_price_history . में टेबल।

   नोट पिछले उदाहरणों के विपरीत, इस ट्रिगर का ट्रिगर के मुख्य भाग में केवल एक कथन होता है, इसलिए हमें DELIMITER को बदलने की आवश्यकता नहीं है .

2. फिर, नीचे दिए गए आदेश को चलाकर पहले उत्पाद की कीमत को अपडेट करने का प्रयास करें:

   UPDATE products SET retail_price='36.75' WHERE product_id='1';
   

3. इसके बाद, products_price_history के बारे में पूछें तालिका यह देखने के लिए कि क्या मूल्य परिवर्तन लॉग किया गया था:

   SELECT * FROM products_price_history;
   

   यदि ट्रिगर अपेक्षित रूप से काम करता है, तो आपको निम्न आउटपुट मिलना चाहिए:

   +------------+---------------------+--------------+
   | product_id | price_date          | retail_price |
   +------------+---------------------+--------------+
   |          1 | 2020-01-28 11:46:21 |        36.75 |
   +------------+---------------------+--------------+
   1 row in set (0.00 sec)

आफ्टर डिलीट ट्रिगर बनाना

कुछ मामलों में, आप डेटाबेस में एक विशिष्ट क्रिया होने के बाद डिलीट ऑपरेशन को लॉग करना चाह सकते हैं। आप इसे AFTER DELETE . का उपयोग करके प्राप्त कर सकते हैं ट्रिगर।

1. एक नया product_archiver बनाएं नीचे दिए गए आदेश के साथ ट्रिगर करें:

   CREATE TRIGGER product_archiver
   
   AFTER DELETE
   
   ON products FOR EACH ROW
   
   INSERT INTO archived_products (product_id, product_name, cost_price, retail_price, availability) VALUES (OLD.product_id, OLD.product_name, OLD.cost_price, OLD.retail_price, OLD.availability);
   

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

2. इसके बाद, products . से किसी उत्पाद को हटा दें तालिका और देखें कि क्या ट्रिगर लागू किया जाएगा:

   DELETE FROM products WHERE product_id='3';
   

3. अब, यदि आप archived_products . की जांच करते हैं तालिका, आपको एक रिकॉर्ड देखना चाहिए:

   SELECT * FROM archived_products;
   

   आउटपुट:

   +------------+--------------+------------+--------------+--------------+
   | product_id | product_name | cost_price | retail_price | availability |
   +------------+--------------+------------+--------------+--------------+
   |          3 | SMART WATCH  |      189.6 |        225.3 | LOCAL        |
   +------------+--------------+------------+--------------+--------------+
   1 row in set (0.00 sec)

एक ट्रिगर हटाना

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

यदि आप नीचे दिए गए सिंटैक्स का उपयोग करके किसी ट्रिगर का अब और उपयोग नहीं करना चाहते हैं, तो आप उसे हटा सकते हैं:

DROP TRIGGER IF EXISTS TRIGGER_NAME;

नोट IF EXISTS कीवर्ड एक वैकल्पिक पैरामीटर है जो ट्रिगर के मौजूद होने पर ही उसे हटाता है।

उदाहरण के लिए, product_archiving . को मिटाने के लिए ट्रिगर जिसे हमने ऊपर परिभाषित किया है, नीचे दिए गए कमांड का उपयोग करें:

DROP TRIGGER IF EXISTS product_archiver;

आउटपुट:

Query OK, 0 rows affected (0.00 sec)

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

अधिक जानकारी

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

• MySQL ट्रिगर सिंटैक्स और उदाहरण