INSERT UPDATE trigger comment déterminer si insert ou update

CREATE TRIGGER dbo.TableName_IUD
ON dbo.TableName
AFTER INSERT, UPDATE, DELETE
AS 
BEGIN
    SET NOCOUNT ON;

    --
    -- Check if this is an INSERT, UPDATE or DELETE Action.
    -- 
    DECLARE @action as char(1);

    SET @action = 'I'; -- Set Action to Insert by default.
    IF EXISTS(SELECT * FROM DELETED)
    BEGIN
        SET @action = 
            CASE
                WHEN EXISTS(SELECT * FROM INSERTED) THEN 'U' -- Set Action to Updated.
                ELSE 'D' -- Set Action to Deleted.       
            END
    END
    ELSE 
        IF NOT EXISTS(SELECT * FROM INSERTED) RETURN; -- Nothing updated or inserted.

    ...

    END

Beaucoup de ces propositions ne prennent pas en compte si vous exécutez une instruction delete supprime rien.
disons que vous essayez de supprimer où un ID est égal à une valeur qui n'existe pas dans la table.
votre déclencheur est toujours appelé mais il n'y a rien dans les tables supprimées ou insérées.

Utilisez ceci pour être sûr:

--Determine if this is an INSERT,UPDATE, or DELETE Action or a "failed delete".
DECLARE @Action as char(1);
    SET @Action = (CASE WHEN EXISTS(SELECT * FROM INSERTED)
                         AND EXISTS(SELECT * FROM DELETED)
                        THEN 'U'  -- Set Action to Updated.
                        WHEN EXISTS(SELECT * FROM INSERTED)
                        THEN 'I'  -- Set Action to Insert.
                        WHEN EXISTS(SELECT * FROM DELETED)
                        THEN 'D'  -- Set Action to Deleted.
                        ELSE NULL -- Skip. It may have been a "failed delete".   
                    END)

Un merci spécial à @ Kendog et @Net_Prog pour leurs réponses.
Je l'ai construit à partir de leurs scripts.

J'utilise ce qui suit, il détecte également correctement les instructions delete qui ne suppriment rien:

CREATE TRIGGER dbo.TR_TableName_TriggerName
    ON dbo.TableName
    AFTER INSERT, UPDATE, DELETE
AS
BEGIN
    SET NOCOUNT ON;

    IF NOT EXISTS(SELECT * FROM INSERTED)
        -- DELETE
        PRINT 'DELETE';
    ELSE
    BEGIN
        IF NOT EXISTS(SELECT * FROM DELETED)
            -- INSERT
            PRINT 'INSERT';
        ELSE
            -- UPDATE
            PRINT 'UPDATE';
    END
END;

Après beaucoup de recherches, je n'ai pas pu trouver un exemple exact d'un seul déclencheur SQL Server qui gère toutes les (3) trois conditions des actions de déclenchement INSERT, UPDATE et DELETE. J'ai finalement trouvé une ligne de texte qui parlait du fait que lorsqu'une suppression ou une mise à jour se produit, la table commune supprimée contiendra un enregistrement pour ces deux actions. Sur la base de ces informations, j'ai ensuite créé une petite routine D'Action qui détermine pourquoi le déclencheur a été activé. Ce type de l'interface est parfois nécessaire lorsqu'il y a à la fois une configuration commune et une action spécifique sur un déclencheur INSERT vs UPDATE. Dans ces cas, créer un déclencheur séparé pour la mise à jour et L'insertion deviendrait un problème de maintenance. (c'est-à-dire les deux déclencheurs ont-ils été mis à jour correctement pour le correctif d'algorithme de données commun nécessaire?)

À cette fin, je voudrais donner l'extrait de code d'événement multi-trigger suivant pour gérer INSERT, UPDATE, DELETE dans un déclencheur pour un Microsoft SQL Serveur.

CREATE TRIGGER [dbo].[INSUPDDEL_MyDataTable]
ON [dbo].[MyDataTable] FOR INSERT, UPDATE, DELETE
AS 

-- SET NOCOUNT ON added to prevent extra result sets from
-- interfering with caller queries SELECT statements.
-- If an update/insert/delete occurs on the main table, the number of records affected
-- should only be based on that table and not what records the triggers may/may not
-- select.
SET NOCOUNT ON;

--
-- Variables Needed for this Trigger
-- 
DECLARE @PACKLIST_ID varchar(15)
DECLARE @LINE_NO smallint
DECLARE @SHIPPED_QTY decimal(14,4)
DECLARE @CUST_ORDER_ID varchar(15)
--
-- Determine if this is an INSERT,UPDATE, or DELETE Action
-- 
DECLARE @Action as char(1)
DECLARE @Count as int
SET @Action = 'I' -- Set Action to 'I'nsert by default.
SELECT @Count = COUNT(*) FROM DELETED
if @Count > 0
    BEGIN
        SET @Action = 'D' -- Set Action to 'D'eleted.
        SELECT @Count = COUNT(*) FROM INSERTED
        IF @Count > 0
            SET @Action = 'U' -- Set Action to 'U'pdated.
    END

if @Action = 'D'
    -- This is a DELETE Record Action
    --
    BEGIN
        SELECT @PACKLIST_ID =[PACKLIST_ID]
                    ,@LINE_NO = [LINE_NO]
        FROM DELETED

        DELETE [dbo].[MyDataTable]
        WHERE [PACKLIST_ID]=@PACKLIST_ID AND [LINE_NO]=@LINE_NO
    END
 Else
    BEGIN
            --
            -- Table INSERTED is common to both the INSERT, UPDATE trigger
            --
            SELECT @PACKLIST_ID =[PACKLIST_ID]
                ,@LINE_NO = [LINE_NO]
                ,@SHIPPED_QTY =[SHIPPED_QTY]
                ,@CUST_ORDER_ID = [CUST_ORDER_ID]
            FROM INSERTED 

         if @Action = 'I'
            -- This is an Insert Record Action
            --
            BEGIN
                INSERT INTO [MyChildTable]
                    (([PACKLIST_ID]
                    ,[LINE_NO]
                    ,[STATUS]
                VALUES
                    (@PACKLIST_ID
                    ,@LINE_NO
                    ,'New Record'
                    )
            END
        else
            -- This is an Update Record Action
            --
            BEGIN
                UPDATE [MyChildTable]
                    SET [PACKLIST_ID] = @PACKLIST_ID
                          ,[LINE_NO] = @LINE_NO
                          ,[STATUS]='Update Record'
                WHERE [PACKLIST_ID]=@PACKLIST_ID AND [LINE_NO]=@LINE_NO
            END
    END   

Je crois que les ifs imbriqués sont un peu confus et:

Plat est meilleur que imbriqué [le Zen de Python]

;)

DROP TRIGGER IF EXISTS AFTER_MYTABLE

GO

CREATE TRIGGER dbo.AFTER_MYTABLE ON dbo.MYTABLE AFTER INSERT, UPDATE, DELETE 

AS BEGIN 

    --- FILL THE BEGIN/END SECTION FOR YOUR NEEDS.

    SET NOCOUNT ON;

    IF EXISTS(SELECT * FROM INSERTED)  AND EXISTS(SELECT * FROM DELETED) 
        BEGIN PRINT 'UPDATE' END 
    ELSE IF EXISTS(SELECT * FROM INSERTED)  AND NOT EXISTS(SELECT * FROM DELETED) 
        BEGIN PRINT 'INSERT' END 
    ELSE IF    EXISTS(SELECT * FROM DELETED) AND NOT EXISTS(SELECT * FROM INSERTED)
        BEGIN PRINT 'DELETED' END
    ELSE BEGIN PRINT 'NOTHING CHANGED'; RETURN; END  -- NOTHING

END

Essayez ceci..

ALTER TRIGGER ImportacionesGS ON dbo.Compra 
    AFTER INSERT, UPDATE, DELETE
AS
BEGIN
  -- idCompra is PK
  DECLARE @vIdCompra_Ins INT,@vIdCompra_Del INT
  SELECT @vIdCompra_Ins=Inserted.idCompra FROM Inserted
  SELECT @vIdCompra_Del=Deleted.idCompra FROM Deleted
  IF (@vIdCompra_Ins IS NOT NULL AND @vIdCompra_Del IS NULL)  
  Begin
     -- Todo Insert
  End
  IF (@vIdCompra_Ins IS NOT NULL AND @vIdCompra_Del IS NOT NULL)
  Begin
     -- Todo Update
  End
  IF (@vIdCompra_Ins IS NULL AND @vIdCompra_Del IS NOT NULL)
  Begin
     -- Todo Delete
  End
END

Declare @Type varchar(50)='';
IF EXISTS (SELECT * FROM inserted) and  EXISTS (SELECT * FROM deleted)
BEGIN
    SELECT @Type = 'UPDATE'
END
ELSE IF EXISTS(SELECT * FROM inserted)
BEGIN
    SELECT @Type = 'INSERT'
END
ElSE IF EXISTS(SELECT * FROM deleted)
BEGIN
    SELECT @Type = 'DELETE'
END

Un problème potentiel avec les deux solutions proposées est que, selon la façon dont elles sont écrites, une requête update peut mettre à jour zéro enregistrements et une requête insert peut insérer zéro enregistrements. Dans ces cas, les jeux D'enregistrements insérés et supprimés seront vides. Dans de nombreux cas, si les jeux D'enregistrements insérés et supprimés sont vides, vous pouvez simplement quitter le déclencheur sans rien faire.

Cela pourrait être un moyen plus rapide:

DECLARE @action char(1)

IF COLUMNS_UPDATED() > 0 -- insert or update
BEGIN
    IF EXISTS (SELECT * FROM DELETED) -- update
        SET @action = 'U'
    ELSE
        SET @action = 'I'
    END
ELSE -- delete
    SET @action = 'D'

J'ai trouvé une petite erreur dans Grahams sinon cool solution:

Il devrait être Si COLUMNS_UPDATED() > 0 -- insérer ou mettre à jour
au lieu de > 0 probablement parce que le bit supérieur est interprété comme un bit de signe entier signé...(?). Donc au total:

DECLARE @action CHAR(8)  
IF COLUMNS_UPDATED() <> 0 -- delete or update?
BEGIN     
  IF EXISTS (SELECT * FROM deleted) -- updated cols + old rows means action=update       
    SET @action = 'UPDATE'     
  ELSE
    SET @action = 'INSERT' -- updated columns and nothing deleted means action=insert
END 
ELSE -- delete     
BEGIN
  SET @action = 'DELETE'
END

Cela fait l'affaire pour moi:

declare @action_type int;
select @action_type = case
                       when i.id is not null and d.id is     null then 1 -- insert
                       when i.id is not null and d.id is not null then 2 -- update
                       when i.id is     null and d.id is not null then 3 -- delete
                     end
  from      inserted i
  full join deleted  d on d.id = i.id

Comme toutes les colonnes ne peuvent pas être mises à jour à la fois, vous pouvez vérifier si une colonne particulière est mise à jour par quelque chose comme ceci:

IF UPDATE([column_name])

declare @insCount int
declare @delCount int
declare @action char(1)

select @insCount = count(*) from INSERTED
select @delCount = count(*) from DELETED

    if(@insCount > 0 or @delCount > 0)--if something was actually affected, otherwise do nothing
    Begin
        if(@insCount = @delCount)
            set @action = 'U'--is update
        else if(@insCount > 0)
            set @action = 'I' --is insert
        else
            set @action = 'D' --is delete

        --do stuff here
    End

J'aime les solutions qui sont "l'informatique élégante."Ma solution frappe ici les pseudotables [insérés] et [supprimés] une fois chacun pour obtenir leurs statuts et met le résultat dans une variable mappée. Ensuite, chaque combinaison possible D'insertion, de mise à jour et de suppression peut facilement être testée tout au long du déclencheur avec des évaluations binaires efficaces (sauf pour la combinaison improbable D'insertion ou de suppression).

Il fait l'hypothèse que peu importe ce que l'instruction DML était si non les lignes ont été modifiées (ce qui devrait satisfaire la grande majorité des cas). Ainsi, bien qu'il ne soit pas aussi complet que la solution de Roman Pekar, il est plus efficace.

Avec cette approche, nous avons la possibilité d'un déclencheur" for INSERT, UPDATE, DELETE " par table, nous donnant A) un contrôle complet sur l'ordre d'action et b)une implémentation de code par action multi-action applicable. (Évidemment, chaque modèle d'implémentation a ses avantages et ses inconvénients; vous devrez évaluer vos systèmes individuellement pour ce qui fonctionne le mieux.)

Notez que les instructions "exists (select * from" inserted/deleted") " sont très efficaces car il n'y a pas d'accès au disque ( https://social.msdn.microsoft.com/Forums/en-US/01744422-23fe-42f6-9ab0-a255cdf2904a).

use tempdb
;
create table dbo.TrigAction (asdf int)
;
GO
create trigger dbo.TrigActionTrig
on dbo.TrigAction
for INSERT, UPDATE, DELETE
as
declare @Action tinyint
;
-- Create bit map in @Action using bitwise OR "|"
set @Action = (-- 1: INSERT, 2: DELETE, 3: UPDATE, 0: No Rows Modified 
  (select case when exists (select * from inserted) then 1 else 0 end)
| (select case when exists (select * from deleted ) then 2 else 0 end))
;
-- 21 <- Binary bit values
-- 00 -> No Rows Modified
-- 01 -> INSERT -- INSERT and UPDATE have the 1 bit set
-- 11 -> UPDATE <
-- 10 -> DELETE -- DELETE and UPDATE have the 2 bit set

raiserror(N'@Action = %d', 10, 1, @Action) with nowait
;
if (@Action = 0) raiserror(N'No Data Modified.', 10, 1) with nowait
;
-- do things for INSERT only
if (@Action = 1) raiserror(N'Only for INSERT.', 10, 1) with nowait
;
-- do things for UPDATE only
if (@Action = 3) raiserror(N'Only for UPDATE.', 10, 1) with nowait
;
-- do things for DELETE only
if (@Action = 2) raiserror(N'Only for DELETE.', 10, 1) with nowait
;
-- do things for INSERT or UPDATE
if (@Action & 1 = 1) raiserror(N'For INSERT or UPDATE.', 10, 1) with nowait
;
-- do things for UPDATE or DELETE
if (@Action & 2 = 2) raiserror(N'For UPDATE or DELETE.', 10, 1) with nowait
;
-- do things for INSERT or DELETE (unlikely)
if (@Action in (1,2)) raiserror(N'For INSERT or DELETE.', 10, 1) with nowait
-- if already "return" on @Action = 0, then use @Action < 3 for INSERT or DELETE
;
GO

set nocount on;

raiserror(N'
INSERT 0...', 10, 1) with nowait;
insert dbo.TrigAction (asdf) select top 0 object_id from sys.objects;

raiserror(N'
INSERT 3...', 10, 1) with nowait;
insert dbo.TrigAction (asdf) select top 3 object_id from sys.objects;

raiserror(N'
UPDATE 0...', 10, 1) with nowait;
update t set asdf = asdf /1 from dbo.TrigAction t where asdf <> asdf;

raiserror(N'
UPDATE 3...', 10, 1) with nowait;
update t set asdf = asdf /1 from dbo.TrigAction t;

raiserror(N'
DELETE 0...', 10, 1) with nowait;
delete t from dbo.TrigAction t where asdf < 0;

raiserror(N'
DELETE 3...', 10, 1) with nowait;
delete t from dbo.TrigAction t;
GO

drop table dbo.TrigAction
;
GO

Bien que j'aime aussi la réponse Postée par @ Alex, j'offre cette variation à la solution de @ Graham ci-dessus

Cela utilise exclusivement l'existence d'enregistrements dans les tables insérées et mises à jour, par opposition à L'utilisation de COLUMNS_UPDATED pour le premier test. Il fournit également le soulagement du programmeur paranoïaque sachant que le cas final a été considéré...

declare @action varchar(4)
    IF EXISTS (SELECT * FROM INSERTED)
    BEGIN
        IF EXISTS (SELECT * FROM DELETED) 
            SET @action = 'U'  -- update
        ELSE
            SET @action = 'I'  --insert
        END
    ELSE IF EXISTS (SELECT * FROM DELETED)
        SET @action = 'D'  -- delete
    else 
        set @action = 'noop' --no records affected
--print @action

Vous obtiendrez NOOP avec une déclaration comme la suivante:

update tbl1 set col1='cat' where 1=2

Solution Rapide MySQL

Au fait: j'utilise MySQL PDO.

(1) dans une table d'incrémentation automatique, obtenez simplement la valeur la plus élevée (mon nom de colonne = id) de la colonne incrémentée une fois que chaque script s'exécute en premier:

$select = "
    SELECT  MAX(id) AS maxid
    FROM    [tablename]
    LIMIT   1
";

(2) Exécutez la requête MySQL comme vous le feriez normalement, et convertissez le résultat en entier, par exemple:

$iMaxId = (int) $result[0]->maxid;

(3) Après le " insérer dans ... Sur la mise à jour de la clé en double" requête obtenir le dernier id inséré de votre manière préférée, par exemple:

$iLastInsertId = (int) $db->lastInsertId();

(4) Comparer et réagir: si le lastInsertId est plus élevé que le plus élevé dans la table, il est probablement un INSERT, Non? Et vice-versa.

if ($iLastInsertId > $iMaxObjektId) {
    // IT'S AN INSERT
}
else {
    // IT'S AN UPDATE
}

Je sais que c'est rapide et peut-être sale. Et c'est un vieux post. Mais, hey, je cherchais une solution depuis longtemps, et peut-être que quelqu'un trouve mon chemin quelque peu utile de toute façon. Tout le meilleur!

Juste moyen simple

CREATE TRIGGER [dbo].[WO_EXECUTION_TRIU_RECORD] ON [dbo].[WO_EXECUTION]
WITH EXECUTE AS CALLER
FOR INSERT, UPDATE
AS
BEGIN  

  select @vars = [column] from inserted 
  IF UPDATE([column]) BEGIN
    -- do update action base on @vars 
  END ELSE BEGIN
    -- do insert action base on @vars 
  END

END 

Dans le premier scénario, j'ai supposé que votre table a une colonne D'identité

CREATE TRIGGER [dbo].[insupddel_yourTable] ON [yourTable]
FOR INSERT, UPDATE, DELETE
AS
IF @@ROWCOUNT = 0 return
SET NOCOUNT ON;
DECLARE @action nvarchar(10)
SELECT @action = CASE WHEN COUNT(i.Id) > COUNT(d.Id) THEN 'inserted'
                      WHEN COUNT(i.Id) < COUNT(d.Id) THEN 'deleted' ELSE 'updated' END
FROM inserted i FULL JOIN deleted d ON i.Id = d.Id

Dans le deuxième scénario, il n'est pas nécessaire d'utiliser la colonne IDENTITTY

CREATE TRIGGER [dbo].[insupddel_yourTable] ON [yourTable]
FOR INSERT, UPDATE, DELETE
AS
IF @@ROWCOUNT = 0 return
SET NOCOUNT ON;
DECLARE @action nvarchar(10),
        @insCount int = (SELECT COUNT(*) FROM inserted),
        @delCount int = (SELECT COUNT(*) FROM deleted)
SELECT @action = CASE WHEN @insCount > @delCount THEN 'inserted'
                      WHEN @insCount < @delCount THEN 'deleted' ELSE 'updated' END

DECLARE @INSERTEDCOUNT INT,
        @DELETEDCOUNT INT

SELECT @INSERTEDCOUNT = COUNT([YourColumnName]) FROM inserted

SELECT @DELETEDCOUNT = COUNT([YourColumnName]) FROM deleted

Si sa mise à jour

 @INSERTEDCOUNT = 1
 @DELETEDCOUNT = 1

Si son insertion

 @INSERTEDCOUNT = 1
 @DELETEDCOUNT = 0

J'ai utilisé ces requêtes exists (select * from inserted/deleted) pendant longtemps, mais ce n'est toujours pas suffisant pour les opérations CRUD vides (quand il n'y a pas d'enregistrements dans les tables inserted et deleted). Donc, après avoir fait des recherches sur ce sujet un peu, j'ai trouvé une solution plus précise:

declare
    @columns_count int = ?? -- number of columns in the table,
    @columns_updated_count int = 0

-- this is kind of long way to get number of actually updated columns
-- from columns_updated() mask, it's better to create helper table
-- or at least function in the real system
with cte_columns as (
    select @columns_count as n
    union all
    select n - 1 from cte_columns where n > 1
), cte_bitmasks as (
    select
        n,
        (n - 1) / 8 + 1 as byte_number,
        power(2, (n - 1) % 8) as bit_mask
    from cte_columns
)
select
    @columns_updated_count = count(*)
from cte_bitmasks as c
where
    convert(varbinary(1), substring(@columns_updated_mask, c.byte_number, 1)) & c.bit_mask > 0

-- actual check
if exists (select * from inserted)
    if exists (select * from deleted)
        select @operation = 'U'
    else
        select @operation = 'I'
else if exists (select * from deleted)
    select @operation = 'D'
else if @columns_updated_count = @columns_count
    select @operation = 'I'
else if @columns_updated_count > 0
    select @operation = 'U'
else
    select @operation = 'D'

Il est également possible d'utiliser columns_updated() & power(2, column_id - 1) > 0 pour voir si la colonne est mise à jour, mais ce n'est pas sûr pour les tables avec un grand nombre de colonnes. J'ai utilisé une méthode de calcul un peu complexe (voir l'article utile ci-dessous).

En outre, cette approche sera toujours classifie incorrectement certaines mises à jour en tant qu'insertions (si chaque colonne de la table est affectée par la mise à jour), et classera probablement les insertions où seules les valeurs par défaut sont insérées en tant que suppressions, mais celles-ci sont Roi des opérations rares (au bail dans mon système elles sont). En outre, Je ne sais pas comment améliorer cette solution pour le moment.

• COLUMNS_UPDATED() pour les déclencheurs d'audit par Piotr Rodak
• traiter avec de très grands bitmasks par Adam Machanic