Discussion :

[lamiae.ch]

Bonjour à Tous

Je cherche à developper un trigger de suppresssion pour supprimer un enregistrement d'une vue qui porte sur plusieurs tables .

est ce que vous pouvez m'aider !!!
j'ai cherché le format de trigger , et j'ai un petit code , mais ne je sais pas comment je peux executer le trigger , comment je peut passer l identifiant de la ligne à supprimer ?

Merci pour votre aide
et Bonne journée

[StringBuilder]

Déjà, avec SQL Server 2005 et ultérieurs (il me semble pas que ça marchait avec 2000), tu n'as pas forcément besoin de trigger sur une vue pour faire un DELETE.

Ensuite, si nécessité de trigger il y a, alors c'est simple :

Tu crées ton trigger "intead of delete" sur ta vue.
Et dans le trigger, tu vas supprimer dans les tables sur lesquelles pointe ta vue en fonction des données que tu trouveras dans la table virtuelle "deleted" à l'intérieur du trigger.

Ensuite, pour lancer le trigger, il faut faire "delete from tavue where ..."

Ensuite, dans le trigger, la table virtuelle "deleted" contiendra l'ensemble des lignes de la vue qui correspondent à la command DELETE que tu as tapé.

Tu peux boucler dessus (avec un curseur) ou t'en servir dans des sous-requête pour faire le delete dans les tables physiques.

C'est tout ce qu'on peut de dire avec si peu d'informations...

Modèle de donnée ? Code de la vue ? Traitement attendu de la part du trigger ?

[lamiae.ch]

En faite j'utilise SSMS 2008 R2 , le code de ma vue est le suivant :

SELECT p.codeProject, p.projectName, p.PlanID, f.FileID, f.version, e.controlType, e.label, e.typeValue, fev.value, p.ProjectID, fe.FileElementID, fe.ElementID,
fev.FileElementValueID, i.codeFiness, i.name AS InstitutionName, a.codeRegion, a.name AS ARSName, pl.name AS PlanNAme
FROM dbo.DRPI_Project AS p INNER JOIN
dbo.DRPI_Institution AS i ON p.InstitutionID = i.InstitutionID INNER JOIN
dbo.DRPI_Ars AS a ON i.ArsID = a.ArsID INNER JOIN
dbo.DRPI_Plan AS pl ON p.PlanID = pl.PlanID INNER JOIN
dbo.DRPI_File AS f ON p.ProjectID = f.ProjectID LEFT OUTER JOIN
dbo.DRPI_FileElement AS fe ON fe.FileID = f.FileID LEFT OUTER JOIN
dbo.DRPI_Element AS e ON fe.ElementID = e.ElementID LEFT OUTER JOIN
dbo.DRPI_FileElementValue AS fev ON fe.FileElementID = fev.fileElementID


et j'ai comme trigger de suppression de la vue , j 'ai utilisé ce code

ALTER TRIGGER [dbo].[declencheur_suppression]
ON [dbo].[DRPI_ProjectData]
INSTEAD OF DELETE
AS

Declare @codeprojet varchar(20),@nomprojet nvarchar(255), @PlanID int, @FileID int , @version int , @controlType varchar(20), @label varchar(255), @typeValue varchar(20), @value nvarchar(MAX), @ProjectID int,
@FileElementID int, @FileElementValueID int , @nameinstitution varchar (255), @codeRegion varchar(255), @nameARS varchar(255) , @Planname varchar (50)

BEGIN
SELECT @codeprojet = codeProject , @version = version , @label = label FROM deleted
Delete from DRPI_ProjectData where @codeprojet=codeProject


END


mais comme je ne suis pas professionnelle en T-SQL , j ai douté , pouviez vous me verifier le trigger !!

[StringBuilder]

Voici une illustration simpliste de mes dires.

Je me suis amusé ici à utiliser un trigger non pas pour supprimer des lignes dans les tables physiques, mais pour alimenter une table d'exclusion.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
drop view v_test1;
drop view v_test2;
drop table exclude;
drop table test1;
 
create table test1
(
	id int not null identity primary key,
	filtre bit not null,
	val int not null
);
 
create table exclude (id int not null primary key references test1(id));
 
insert into test1 (filtre, val) values (0, 1);
insert into test1 (filtre, val) values (1, 2);
insert into test1 (filtre, val) values (1, 3);
insert into test1 (filtre, val) values (0, 4);
insert into test1 (filtre, val) values (1, 5);
insert into test1 (filtre, val) values (0, 6);
go
 
create view v_test1 as select id, val from test1 where filtre = 0;
go
 
create view v_test2 as select id, val from test1 where id not in (select id from exclude);
go
 
select * from v_test1;
 
delete v_test1 where val > 5;
 
select * from v_test1;
go
 
create trigger trg_test1 on v_test2
instead of delete
as
begin
	insert into exclude (id) select id from deleted;
end;
go
 
select * from v_test2;
 
delete v_test2 where val > 3;
 
select * from v_test2;
select * from test1;
select * from exclude;

[StringBuilder]

Votre trigger est presque bon, au détail près que si vous supprimez plusieurs lignes à la fois, ça va planter, vu que votre SELECT qui alimente vos variables va retourner plusieurs lignes.

Soit vous faites un "delete matbale where id in (select id from deleted)" (en ajoutant les jointures nécessaires) soit vous devez passer par un curseur.

[elsuket]

Bonjour,

Quand un trigger n'est pas ensembliste, il est tout simplement faux.
Utiliser un curseur est une erreur, et un curseur dans un trigger une stupidité.

@++

[StringBuilder]

J'aime bien ces affirmations qui sortent d'on ne sait où...

Que d'un point de vue performances, simplicité de relecture, etc. qu'on préconise fortement certaines méthodologies est une chose.

Mais de là à dire que les autres solutions sont fausses, il y a une certaine marge.

Déjà, si c'était clairement interdit de faire des curseur dans un trigger, pourquoi SQL Server le permettrait ?
=> Il est interdit dans SQL Server de modifier l'état de la base dans une fonction, et SQL Server refuse de compiler une fonction qui tente de modifier des données, ce qui est spécifique à SQL Server. Pourquoi ne pas interdire aux trigger de faire des curseurs alors ?

Ensuite, il n'est pas rare que les traitements nécessaires à la validation d'un enregistrement ne se limitent pas à une vérification ensembliste. A ce moment, cela voudrait dire qu'il ne faut pas le faire par trigger mais par procédure stockée, et ainsi prendre le risque de ne pas utiliser la PS et retrouver ses données dans un état foireux ?