Di SQL Server, Anda dapat membuat pemicu DML yang mengeksekusi kode hanya ketika kolom tertentu diperbarui.
Pemicu masih aktif, tetapi Anda dapat menguji apakah kolom tertentu telah diperbarui atau tidak, lalu menjalankan kode hanya jika kolom tersebut telah diperbarui.
Anda dapat melakukannya dengan menggunakan UPDATE() berfungsi di dalam pemicu Anda. Fungsi ini menerima nama kolom sebagai argumennya. Ini mengembalikan boolean.
Contoh
Berikut tabelnya:
CREATE TABLE t1 (
id int IDENTITY(1,1) NOT NULL,
c1 int DEFAULT 0,
c2 int DEFAULT 0,
c3 int DEFAULT 0
);Dan inilah pemicunya:
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;
Dalam contoh ini, saya membuat tabel bernama t1 dan pemicu yang disebut trg_t1 .
Saya menggunakan IF pernyataan bersama dengan UPDATE() berfungsi untuk menguji apakah c1 kolom telah diperbarui.
Saat pemicu berjalan, pemicu hanya akan mengeksekusi kode berikutnya jika kondisi tersebut benar.
Nyalakan Pemicunya
Mari kita menyisipkan baris, tetapi kita hanya akan memasukkan nilai ke dalam c1 kolom.
INSERT INTO t1 (c1)
VALUES (1);
SELECT * FROM t1;Hasil:
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 1 | 0 | 1 | +------+------+------+------+
Seperti yang diharapkan, pemicu diaktifkan, dan kolom c3 juga diperbarui.
Ini terjadi karena saya menyertakan INSERT argumen dalam definisi pemicu saya (yaitu saya menetapkan AFTER INSERT, UPDATE yang berarti bahwa pemicu diaktifkan setiap kali data dimasukkan atau diperbarui). Jika saya hanya menentukan AFTER UPDATE , itu tidak akan menyala ketika saya memasukkan data – itu hanya akan menyala setiap kali saya memperbarui data yang ada.
Ingat bahwa tabel didefinisikan dengan DEFAULT 0 , jadi kolom c2 default ke nol.
Sekarang mari kita perbarui c1 kolom.
UPDATE t1
SET c1 = c1 + 1
WHERE id = 1;
SELECT * FROM t1;Hasil:
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 0 | 2 | +------+------+------+------+
Sekali lagi, c3 kolom telah diperbarui bersama dengan c1 .
Sekarang mari kita lakukan pembaruan pada c2 kolom (kolom ini tidak termasuk dalam pemicu).
UPDATE t1
SET c2 = c2 + 1
WHERE id = 1;
SELECT * FROM t1;Hasil:
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 2 | +------+------+------+------+
Jadi kali ini, c2 telah diperbarui tetapi c3 tidak. Itu karena c1 kolom tidak diperbarui, dan pemicu kami hanya memperbarui c3 ketika c1 diperbarui.
Hal yang sama akan terjadi jika kita menyisipkan baris tanpa menentukan c1 di INSERT pernyataan.
Bagaimana jika Saya Memperbarui Kolom dengan Nilai yang Sama?
Jika Anda memperbarui kolom dengan nilai yang sama, UPDATE() fungsi akan kembali benar.
Ini contohnya.
Kita tahu dari contoh sebelumnya bahwa kolom c1 berisi nilai 2 .
Mari kita perbarui kolom itu secara eksplisit dengan nilai yang sama:1
UPDATE t1
SET c1 = 2
WHERE id = 1;
SELECT * FROM t1;Hasil:
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 3 | +------+------+------+------+
Jadi sekarang c3 telah bertambah, meskipun nilai untuk c1 masih sama.
Mari kita lakukan lagi, tapi kali ini atur ke dirinya sendiri (yaitu ubah c1 = 1 ke c1 = c1 ).
UPDATE t1
SET c1 = c1
WHERE id = 1;
SELECT * FROM t1;Hasil:
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 4 | +------+------+------+------+
Sekali lagi, c3 telah bertambah.
Upaya Pembaruan Gagal
Penting untuk dicatat bahwa UPDATE() fungsi hanya menunjukkan apakah INSERT atau UPDATE berusaha dibuat pada kolom tertentu dari tabel atau tampilan. Itu akan tetap mengembalikan true jika upaya tidak berhasil.
