Dans SQL Server, vous pouvez créer des déclencheurs DML qui exécutent du code uniquement lorsqu'une colonne spécifique est mise à jour.
Le déclencheur se déclenche toujours, mais vous pouvez tester si une colonne spécifique a été mise à jour ou non, puis exécuter le code uniquement si cette colonne a été mise à jour.
Vous pouvez le faire en utilisant le UPDATE() fonction à l'intérieur de votre déclencheur. Cette fonction accepte le nom de la colonne comme argument. Il renvoie un booléen.
Exemple
Voici le tableau :
CREATE TABLE t1 (
id int IDENTITY(1,1) NOT NULL,
c1 int DEFAULT 0,
c2 int DEFAULT 0,
c3 int DEFAULT 0
);Et voici le déclencheur :
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;
Dans cet exemple, je crée une table appelée t1 et un déclencheur appelé trg_t1 .
J'utilise un IF déclaration avec le UPDATE() fonction pour tester si oui ou non le c1 colonne a été mise à jour.
Lorsque le déclencheur s'exécute, il n'exécute le code suivant que si cette condition est vraie.
Appuyez sur la gâchette
Insérons une ligne, mais nous n'insérerons qu'une valeur dans le c1 colonne.
INSERT INTO t1 (c1)
VALUES (1);
SELECT * FROM t1;Résultat :
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 1 | 0 | 1 | +------+------+------+------+
Comme prévu, le déclencheur s'est déclenché et la colonne c3 a également été mis à jour.
Cela s'est produit parce que j'ai inclus le INSERT argument dans la définition de mon déclencheur (c'est-à-dire que j'ai spécifié AFTER INSERT, UPDATE ce qui signifie que le déclencheur est déclenché chaque fois que des données sont insérées ou mises à jour). Si j'avais seulement spécifié AFTER UPDATE , il ne se serait pas déclenché lorsque j'aurais inséré des données - il ne se déclencherait que lorsque je mettrais à jour des données existantes.
Rappelez-vous que la table a été définie avec DEFAULT 0 , donc la colonne c2 est par défaut à zéro.
Maintenant, mettons à jour le c1 colonne.
UPDATE t1
SET c1 = c1 + 1
WHERE id = 1;
SELECT * FROM t1;Résultat :
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 0 | 2 | +------+------+------+------+
Encore une fois, le c3 la colonne a été mise à jour avec c1 .
Faisons maintenant une mise à jour du c2 colonne (cette colonne n'est pas incluse dans le déclencheur).
UPDATE t1
SET c2 = c2 + 1
WHERE id = 1;
SELECT * FROM t1;Résultat :
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 2 | +------+------+------+------+
Alors cette fois, c2 a été mis à jour mais c3 n'était pas. C'est parce que le c1 la colonne n'a pas été mise à jour et notre déclencheur ne met à jour que c3 quand c1 est mis à jour.
La même chose se serait produite si nous avions inséré une ligne sans spécifier c1 dans le INSERT déclaration.
Et si je mets à jour la colonne avec la même valeur ?
Si vous mettez à jour une colonne avec la même valeur, le UPDATE() fonction renverra vrai.
Voici un exemple.
Nous savons de nos exemples précédents que la colonne c1 contient une valeur de 2 .
Mettons explicitement à jour cette colonne avec la même valeur :1
UPDATE t1
SET c1 = 2
WHERE id = 1;
SELECT * FROM t1;Résultat :
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 3 | +------+------+------+------+
Alors maintenant c3 a augmenté, même si la valeur de c1 est toujours le même.
Recommençons, mais cette fois, réglez-le sur lui-même (c'est-à-dire changez c1 = 1 à c1 = c1 ).
UPDATE t1
SET c1 = c1
WHERE id = 1;
SELECT * FROM t1;Résultat :
+------+------+------+------+ | id | c1 | c2 | c3 | |------+------+------+------| | 1 | 2 | 1 | 4 | +------+------+------+------+
Encore une fois, c3 a augmenté.
Tentatives de mise à jour infructueuses
Il est important de noter que le UPDATE() fonction indique simplement si un INSERT ou UPDATE tentative a été effectuée sur une colonne spécifiée d'une table ou d'une vue. Il renverra toujours vrai si la tentative a échoué.
