एक विशिष्ट कॉलम अपडेट होने पर केवल ट्रिगर कैसे निष्पादित करें (एसक्यूएल सर्वर)

SQL सर्वर में, आप DML ट्रिगर बना सकते हैं जो केवल एक विशिष्ट कॉलम के अपडेट होने पर कोड निष्पादित करते हैं।

ट्रिगर अभी भी सक्रिय होता है, लेकिन आप परीक्षण कर सकते हैं कि कोई विशिष्ट कॉलम अपडेट किया गया था या नहीं, और फिर कोड तभी चलाएँ जब वह कॉलम अपडेट किया गया हो।

आप UPDATE() . का उपयोग करके ऐसा कर सकते हैं अपने ट्रिगर के अंदर कार्य करें। यह फ़ंक्शन कॉलम नाम को इसके तर्क के रूप में स्वीकार करता है। यह एक बूलियन लौटाता है।

उदाहरण

ये रही तालिका:

CREATE TABLE t1 (
    id int IDENTITY(1,1) NOT NULL,
    c1 int DEFAULT 0,
    c2 int DEFAULT 0,
    c3 int DEFAULT 0
);

और ये रहा ट्रिगर:

CREATE TRIGGER trg_t1
ON t1
AFTER INSERT, UPDATE
AS
IF ( UPDATE (c1) )
BEGIN
UPDATE t1
SET c3 = c3 + 1
WHERE id IN (SELECT DISTINCT id FROM inserted)
END;

इस उदाहरण में, मैं t1 . नामक एक तालिका बनाता हूं और एक ट्रिगर जिसे trg_t1 . कहा जाता है .

मैं एक IF . का उपयोग करता हूं UPDATE() . के साथ स्टेटमेंट यह जांचने के लिए कार्य करता है कि c1 . है या नहीं कॉलम अपडेट किया गया।

जब ट्रिगर चलता है, तो यह केवल बाद के कोड को निष्पादित करेगा यदि वह शर्त सही है।

ट्रिगर फायर करें

आइए एक पंक्ति डालें, लेकिन हम केवल c1 . में एक मान डालेंगे कॉलम।

INSERT INTO t1 (c1) 
VALUES (1);

SELECT * FROM t1;

परिणाम:

+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 1    | 0    | 1    |
+------+------+------+------+

जैसी अपेक्षित थी, ट्रिगर सक्रिय हो गया, और कॉलम c3 भी अद्यतन किया गया था।

ऐसा इसलिए हुआ क्योंकि मैंने INSERT . शामिल किया था मेरे ट्रिगर की परिभाषा में तर्क (यानी मैंने AFTER INSERT, UPDATE निर्दिष्ट किया है जिसका अर्थ है कि जब भी डेटा डाला या अपडेट किया जाता है तो ट्रिगर सक्रिय हो जाता है)। अगर मैंने केवल AFTER UPDATE निर्दिष्ट किया होता , जब मैं डेटा सम्मिलित करता हूं तो यह सक्रिय नहीं होता - जब भी मैं मौजूदा डेटा अपडेट करता हूं तो यह केवल सक्रिय होता है।

याद रखें कि तालिका को DEFAULT 0 . के साथ परिभाषित किया गया था , इसलिए c2 कॉलम डिफ़ॉल्ट रूप से शून्य हो गया।

चलिए अब c1 को अपडेट करते हैं कॉलम।

UPDATE t1 
SET c1 = c1 + 1
WHERE id = 1;

SELECT * FROM t1;

परिणाम:

+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 0    | 2    |
+------+------+------+------+

फिर से, c3 कॉलम को c1 . के साथ अपडेट किया गया था ।

चलिए अब c2 . में एक अपडेट करते हैं कॉलम (यह कॉलम ट्रिगर में शामिल नहीं है)।

UPDATE t1 
SET c2 = c2 + 1
WHERE id = 1;

SELECT * FROM t1;

परिणाम:

+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 1    | 2    |
+------+------+------+------+

तो इस बार, c2 अपडेट किया गया था लेकिन c3 नहीं था। ऐसा इसलिए है क्योंकि c1 कॉलम अपडेट नहीं किया गया था, और हमारा ट्रिगर केवल c3 अपडेट करता है जब c1 अपडेट किया गया है।

यदि हम INSERT में c1 निर्दिष्ट किए बिना एक पंक्ति सम्मिलित करते तो वही होता बयान।

यदि मैं समान मान वाले कॉलम को अपडेट करूं तो क्या होगा?

यदि आप समान मान वाले कॉलम को अपडेट करते हैं, तो UPDATE() समारोह सच हो जाएगा।

यहाँ एक उदाहरण है।

हम अपने पिछले उदाहरणों से जानते हैं कि c1 कॉलम में 2 . का मान होता है .

आइए उस कॉलम को समान मान के साथ स्पष्ट रूप से अपडेट करें:1

UPDATE t1 
SET c1 = 2
WHERE id = 1;

SELECT * FROM t1;

परिणाम:

+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 1    | 3    |
+------+------+------+------+

तो अब c3 वृद्धि हुई है, भले ही c1 . के लिए मान अब भी वही है।

चलिए इसे फिर से करते हैं, लेकिन इस बार इसे अपने आप पर सेट करें (यानी c1 = 1 बदलें) करने के लिए c1 = c1 )।

UPDATE t1 
SET c1 = c1
WHERE id = 1;

SELECT * FROM t1;

परिणाम:

+------+------+------+------+
| id   | c1   | c2   | c3   |
|------+------+------+------|
| 1    | 2    | 1    | 4    |
+------+------+------+------+

फिर से, c3 बढ़ गया है।

अपडेट के असफल प्रयास

यह नोट करना महत्वपूर्ण है कि UPDATE() फ़ंक्शन केवल यह इंगित करता है कि क्या कोई INSERT . है या UPDATE प्रयास किसी तालिका या दृश्य के निर्दिष्ट स्तंभ पर बनाया गया था। यदि प्रयास असफल रहा तो भी यह सच हो जाएगा।