SYSTÈME DE GESTION DE BASES

DE DONNÉES II
 SOMMAIRE
1. NOTIONS EN TRANSACT SQL.

2. PROGRAMMATION DES PROCEDURES

STOCKEES

3. PROGRAMMATION DES FONCTIONS

4. PROGRAMMATION DES CURSEURS

5. PROGRAMMATION DES DECLENCHEURS

(TRIGGERS )

2
 1. Notions de Transact Sql
En plus des instructions SQL classiques, Transact-SQL met à la disposition des
programmeurs un grand nombre d'instructions complémentaires pour :
 Les variables
 Structures alternatives
 Structures répétitives
 Affichage de messages d’erreurs
Base de données exemple :

3
 Les variables
 Déclaration
syntaxe : Declare @Nom_Variable Type_Donnée
 Exemples :
 Declare @a int
 Declare @b nvarchar(10)

 Affectation d’une valeur à une variable

 Syntaxe :
 Select @Nom_Variable = valeur
 Select @Nom_Variable = (Select ...from...Where)
ou
 Set @Nom_Variable =valeur
 Set @Nom_Variable = (Select ...from...Where)

4
 Les variables suite
Exemples :
Select @a=1
-- Affecte la valeur 1 à la variable @a
Select @a=(Select count(NumArt) from Article)
-- Affecte le nombre d'articles enregistrés dans la table
article à la variable @a
Select @b='Table pour ordinateur'
-- Affecte la valeur 'Table pour ordinateur' à la variable
@b

5
Les variables : L’affichage d’information
 Syntaxe :
 Print Elément_A_Afficher
 Exemples :

Soient @a et @b des variables de type Chaîne de caractères, @c et @d des

variables de type entier
Print 'Bonjour' -- Affiche le texte Bonjour
Print @a -- Affiche la valeur de @a
Print @c -- Affiche la valeur de @c
Print @c + @d -- Affiche la somme des variables @c et @d
Print convert(varchar, @c) + @b -- Affiche la valeur de @c concaténé
avec la valeur de @b mais puisque @c est de type numérique et qu'on
ne peut jamais concaténer une valeur numérique avec une valeur chaîne
de caractères, il faut passer par une fonction de conversion dont la
syntaxe est la suivante :
 Convert (Type de conversion, Valeur à convertir)
 Rque : L'instruction return arrête l'exécution d'un programme sans condition
 Structure Alternative
If...Else : Remarques :
Syntaxe :  Si une instruction Select apparaît dans la
If Condition condition, il faut la mettre entre
Begin
parenthèses
Instructions  Si dans la clause If ou Else il existe une
End seule instruction, on peut omettre le
Begin et le End
Else
Exemple :
Begin  On souhaite vérifier si le stock de l'article
Instructions portant le numéro 10 a atteint son seuil
minimum. Si c'est le cas afficher le
End message 'Rupture de stock' sinon 'stock
disponible'

7
 Declare @QS int
Declare @SM int
Select @QS = (Select QteEnStock from article Where
NumArt =10)
Select @SM = (Select SeuilMinimum from article Where
NumArt =10)
If @QS<=@SM
Print 'Rupture de stock'
Else
Print 'Stock disponible'

8
Structure Alternative
Case : Permet d'affecter, selon une Exemple :
condition, une valeur à un champ dans
une requête Select  Afficher la liste des articles
Syntaxe : (Numéro, Désignation et
Case prix) avec en plus une
When Condition1 Then Résultat 1 colonne Observation qui
When Condition2 Then Résultat 2 affiche 'Non Disponible' si
... la quantité en stock est
Else Résultat N égale à 0, 'Disponible' si la
End quantité en stock est
supérieure au stock
Minimum et 'à commander'
sinon :
 Select NumArt, DesArt, PUArt, 'Observation' =
Case
When QteEnStock=0 then 'Non Disponible'
When QteEnStock>SeuilMinimum then 'Disponible'
Else 'à Commander'
End
From Article

10
 TP 01
1. Ecrire un programme qui calcule le montant de la commande numéro 10 et affiche un
message 'Commande Normale' ou 'Commande Spéciale' selon que le montant est
inférieur ou supérieur à 100000 DH
2. Ecrire un programme qui supprime l'article numéro 8 de la commande numéro 5 et met à
jour le stock. Si après la suppression de cet article, la commande numéro 5 n'a plus
d'articles associés, la supprimer.
3. Ecrire un programme qui affiche la liste des commandes et indique pour chaque
commande dans une colonne Type s'il s'agit d'une commande normale (montant
<=100000 DH) ou d'une commande spéciale (montant > 100000 DH)
4. A supposer que toutes les commandes ont des montants différents, écrire un programme
qui stocke dans une nouvelle table temporaire les 5 meilleures commandes (ayant le
montant le plus élevé) classées par montant décroissant (la table à créer aura la structure
suivante : NumCom, DatCom, MontantCom)
5. Ecrire un programme qui :
 Recherche le numéro de commande le plus élevé dans la table commande et l'incrémente de 1
 Enregistre une commande avec ce numéro
 Pour chaque article dont la quantité en stock est inférieure ou égale au seuil
 minimum enregistre une ligne de commande avec le numéro calculé et une quantité commandée
11
égale au triple du seuil minimum
 Structure répétitive
Syntaxe : Remarques :
While Condition • Le mot clé Break est utilisé
Begin dans une boucle While pour
instructions forcer l'arrêt de la Boucle
End • Le mot clé Continue est
utilisé dans une boucle While
pour annuler l'itération en
cours et passer aux
itérations suivantes
(renvoyer le programme à la
ligne du while)

12
 Structure répétitive
Exemple :
 Tant que la moyenne des prix des articles n'a pas encore
atteint 20 DH et le prix le plus élevé pour un article n'a pas
encore atteint 30 DH, augmenter les prix de 10% et afficher
après chaque modification effectuée la liste des articles.
Une fois toutes les modifications effectuées, afficher la
moyenne des prix et le prix le plus élevé :

13
 While ((Select avg(puart) from article)<20) and (select max(puart)
from article) <30)
Begin
Update article Set puart=puart+(puart*10)/100
Select * from article
End
Select avg(puart) as moyenne , max(puart) as [Prix élevé] from article

14
 2. Programmation Des Procédures
Stockées
 Une procédure stockée (Stored Procedure pour SQL Server)
est une suite d’instructions SQL stockées dans la base de
données et pouvant être exécutée par appel de son nom
avec ou sans paramètre.

 Les procédures stockées sont des programmes créés et exécutés du côté

serveur. Elles sont destinées à être appelées par un ou plusieurs clients
de la base de données et sont très importantes pour plusieurs raisons :
• Elles sont pré-compilées à la création et donc l'utilisation d'une
procédure stockée garantit un temps de réponse plus rapide et une
meilleure performance système ;
• Elles évitent de réécrire plusieurs fois les mêmes instructions ;

15
 • Elles soulagent les applications client en répartissant des
traitements entre le client et le serveur ;
• Elles soulagent le réseau puisque seule l'instruction
d'exécution de la procédure stockée sera envoyée à travers
le réseau ;
• Il est possible de donner aux utilisateurs le droit d'exécuter
une procédure stockée sans qu'ils aient le droit sur les
objets qu'elle manipule

16
 REMARQUES

 Une procédure stockée est également appelée procédure cataloguée ou

procédure mémorisée ;
 Une fois validée le nom de la procédure stockée apparaît dans la liste
des objets procédures stockée de la base de données ;

17
 Programmation Des Procédures
Stockées Sans paramètres
 La programmation d'une procédure stockée diffère selon que cette procédure ne
reçoit aucun paramètre, reçoit des paramètres en entrée, renvoie des paramètres
de sortie ou retourne une valeur.
1. Sans paramètres : Laprocédure stockée exécute un traitement
donné mais ce traitement ne dépend d'aucune valeur
Syntaxe :
 Create Procedure [proc ]Nom_Procédure as
Instructions

 Exécution :
Exec Nom_Procedure

18
 1. Créer une procédure stockée nommée PS_Articles qui affiche
la liste des articles avec pour chaque article le numéro et la
désignation :
Create Procedure PS_Articles as
Select NumArt, DesArt from Article
 Exécuter cette procédure :
Exec PS_Articles
2. Créer une procédure stockée qui calcule le nombre d'articles
par commande
Create Procedure SP_NbrArticlesParCommande as
Select [Link], DatCom, Count(NumArt)
From Commande, LigneCommande
Where [Link]=[Link]
Group by [Link], DatCom

19
 Programmation Des Procédures Stockées avec
paramètres en entrée
 Avec des paramètres en entrée : La procédure stockée
en fonction de valeurs provenant de l'extérieur va
effectuer certains traitements
 Syntaxe :
Create Procedure Nom_Procedure
@Nom_Param1_Entrée Type_Donnée = Valeur_Par_Defaut,
@Nom_Param2_Entrée Type_Donnée = Valeur_Par_Defaut…
As Instructions
 Exécution :
Exec Nom_Procedure Valeur_Param1, Valeur_Param2...
ou
Exec Nom_Procedure @Nom_Param1 = Valeur_Param1,
@Nom_Param2 = Valeur_Param2...

20
  Exemples :
Create Proc Factoriel @n int
as
begin
declare @f int, @i int
select @f=1, @i=1
while (@i<=@n)
begin
set @f=@f*@i
set @i=@i+1
end
select @n as "N", @f as "Factoriel de N"
End
21
Go
 Appel d’une Procédure
Stockée
Exec Factoriel 4
Go
ou
Exec Factoriel @n=4
Go

22
  Exemples :
1. Créer une procédure stockée nommée PS_ListeArticles qui
affiche la liste des articles d'une commande dont le numéro est
donné en paramètre :
 Create Procedure PS_ListeArticles @NumCom int as
Select [Link], NomArt, PUArt, QteCommandee
From Article A, LigneCommande LC
Where [Link]=[Link] and [Link]=@NumCom

23
  Exécuter cette procédure pour afficher la liste des articles de la commande
numéro 1 :
 Exec PS_ListeArticles 1
Ou
Declare @nc int
Set @nc=1
Exec PS_ListeArticles @nc
2. Créer une procédure stockée nommée PS_ComPeriode qui affiche
la liste des commandes effectuées entre deux dates données en
paramètres :
 Create Procedure PS_ComPeriode
 @DateD DateTime, @DateF DateTime as
Select * from Commande Where datcom between @dateD and @DateF

24
 Exécuter cette procédure pour afficher la liste des commandes
effectuées entre le 10/10/2006 et le 14/12/2006 :
 Exec SP_ComPeriode '10/10/2006', '14/12/2006‘
Ou
 Declare @dd DateTime, @df DateTime
Set @dd='10/10/2006'
Set @df='14/12/2006'
Exec SP_ComPeriode @dd, @df

25
 3. Créer une procédure stockée nommée PS_TypeComPeriode qui
affiche la liste des commandes effectuées entre deux dates passées
en paramètres. En plus si le nombre de ces commandes est
supérieur à 100, afficher 'Période rouge'. Si le nombre de ces
commandes est entre 50 et 100 afficher 'Période jaune' sinon
afficher 'Période blanche' (exploiter la procédure précédente) :

26
Create Procedure SP_TypeComPeriode @DateD DateTime,
@DateF DateTime as
Exec SP_ComPeriode @DateD, @DateF
Declare @nbr int
Set @nbr=(Select count(NumCom) from Commande Where
datcom between @dateD and @DateF)
If @nbr >100
Print 'Période Rouge'
Else
Begin
If @nbr<50
Print 'Période blanche'
Else
Print 'Période Jaune'
27
End
 Programmation Des Procédures Stockées avec
paramètres en sortie

 Avec des paramètres en sortie : La procédure stockée suite à un traitement

réalisé va attribuer des valeurs à des paramètres en sortie. Les valeurs de
ces paramètres peuvent être récupérées par des applications clientes.
 Remarque : Les procédures utilisant des paramètres de sortie peuvent
avoir ou ne pas avoir (selon le besoin) des paramètres en entrée
 Syntaxe :
Create Procedure Nom_Procedure
@Nom_Param1_Entrée Type_Donnée = Valeur_Par_Defaut,
@Nom_Param2_Entrée Type_Donnée = ValeurParDefaut,…
@Nom_Param1_Sortie Type_Donnée Output,
@Nom_Param2_Sortie Type_Donnée Output...
as
Instructions
28
  Exécution :
Declare @Var_Param1_Sortie Type_Param1_Sortie
Declare @Var_Param2_Sortie Type_Param2_Sortie
...
Exec Nom_Procedure Val_Param1_Entrée, Val_Param2_Entrée...,
@Var_Param1_Sortie Output, @Var_Param2_Sortie Output...
OU
Exec Nom_Procedure @Nom_Param1_Entrée
=Val_Param1_Entrée, @Nom_Param2_Entrée
=Val_Param2_Entrée...,
@Nom_Param1_Sortie =@Var_Param1_Sortie Output,
@Nom_Param2_Sortie =@Var_Param2_Sortie Output...

29
  Exemples :
1. Créer une procédure stockée nommée
PS_NbrCommandes qui retourne le nombre de
commandes :
 Create Procedure PS_NbrCommandes @Nbr int output as
Set @Nbr = (Select count(NumCom) from Commande)
 Exécuter cette procédure pour afficher le nombre de
commandes :
Declare @n int
Exec PS_NbrCommandes @n Output
Print 'Le nombre de commandes : ' + convert(varchar,@n)

30
 2. Créer une procédure stockée nommée PS_NbrArtCom qui retourne
le nombre d'articles d'une commande dont le numéro est donné en
paramètre :
 Exécuter cette procédure pour afficher le nombre d'articles de la
commande numéro 1
 Create Procedure SP_NbrArtCom @NumCom int, @Nbr

int output as
Set@Nbr = (Select count(NumArt) from LigneCommande
where NumCom=@NumCom)
 Declare @n int
Exec SP_NbrArtCom 1, @n Output
Print 'Le nombre d'articles de la commande numéro 1 est : ' +
convert(varchar,@n)

31
 3. Créer une procédure stockée nommée
PS_TypePeriode qui retourne le type de la
période en fonction du nombre de commande.
Si le nombre de commandes est supérieur à
100, le type sera 'Période rouge'. Si le nombre
de commandes est entre 50 et 100 le type sera
'Période jaune' sinon le type sera 'Période
blanche' (exploiter la procédure
PS_NbrCommandes) :
 Exécuter cette procédure pour afficher le type
de la période .

32
 Create Procedure SP_TypePeriode @TypePer varchar(50)
output as
Declare @NbrCom int
Exec SP_NbrCommandes @NbrCom output
If @NbrCom >100
Set @ TypePer ='Période Rouge'
Else
Begin
If @NbrCom <50
Set @ TypePer = 'Période blanche'
Else
Set @ TypePer = 'Période Jaune'
End

33
 Declare @ TypeP varchar(50)
Exec SP_NbrArtCom @ TypeP Output
Print ' le type de la période est : ' + @ TypeP

34
 Programmation Des Fonctions
 Types de fonctions

Il existe deux types de fonction :

 
Le premier type permet de renvoyer une valeur
scalaire
Le deuxième type permet de renvoyer une table.

35
 Programmation Des Fonctions
Scalaires
 Création de la fonction scalaire

 Syntaxe de la création d’une fonction

CREATE FUNCTION NomDeLaFonction
( paramètres )
RETURNS définition du type de la valeur retournée
AS 
BEGIN
Code de la fonction
…
RETURN valeur de retour
36 END
 Programmation Des Fonctions
Scalaires – Exemples
Ecrire une fonction qui retourne la quantité en stock
pour un Article dont Numéro donnée en paramètre
create function QTstock(@num int) returns int
as
begin
declare @qt int;
set @qt=(select QTenStock from Article where
NumArtic=@num)
return @qt
end
37
 Appel des fonctions scalaires
Lors de l’appel d’une fonction, il est nécessaire de
préciser la base et le propriétaire de cette dernière, ici:
select [Gestion stock].[Link](11)

38
  L'exemple suivant crée une fonction scalaire qui calcul le montant
d’une commande donnée.
 CREATE FUNCTION total_commande(@numcom int) RETURNS
real
AS
BEGIN
DECLARE @ret REAL
SET @ret = SELECT SUM(PU * QTE)
FROM ligne_commande c join article a on [Link] = [Link]
WHERE numcom= @numcom
RETURN @ret
END

39
 Appel des fonctions scalaires
 Exemple :

 Select numcom, datecom, [Link](numcom) as

total from commande

40
 Programmation Des Fonctions
table
 Création de la fonction table

 L'instruction RETURNS spécifie table comme type de

données retourné.
 La clause RETURN contient une seule instruction
SELECT entre parenthèses.
 Le corps de la fonction ne doit pas se trouver dans un
bloc BEGIN...END.

41
  Exemple :
 Les détails d’une commande donnée.
USE stock_articles
GO
CREATE FUNCTION articles_commandes
(@numcom int)
RETURNS TABLE
AS
RETURN (SELECT [Link],desart, PU, qtecom, (PU *
qtecom) montant FROM ligne_commande lc join article a
on [Link] = [Link]
WHERE numcom = @numcom )
 Appel des fonctions tables
 Select numart, PU, qtecom,montant from dbo.aricles_commandes

42
 LES CURSEURS
 Les curseurs sont des mécanismes de mémoire tampons permettant
d’accéder aux données renvoyées par une requête et donc de parcourir
les lignes de résultat.
 Les curseurs permettent de réaliser des traitements itératifs sur des jeux
de
résultats, comme le balayage d’une table, enregistrement par
enregistrement, en lecture seul.
 Syntaxe transact sql de déclaration des curseurs
DECLARE nom_curseur CURSOR

FOR instruction select

43
 LES CURSEURS
 Ouverture du curseur : OPEN nomc
 Récupérer les valeurs actuelles contenues dans le curseur :
 FETCH nomc into @var1,@var2, ……..

Ou FETCH next FROM nomc into @var1,@var2, ……..

 Aller à la première ligne :
 FETCH first FROM nomc into @var1,@var2, ……..
 Aller à la dernière ligne :
 FETCH last FROM nomc into @var1,@var2, ……..
 Aller à la ligne précedente:
 FETCH prior FROM nomc into @var1,@var2, ……..
 Aller à la ligne n:
 FETCH absolute n FROM nomc into @var1,@var2, ……..
 Aller à n ligne plus loin que l’actuelle :
44  FETCH next FROM nomc into @var1,@var2, ……..
 LES CURSEURS
 @@fetch_status

 Renvoie l'état de la dernière instruction FETCH effectuée sur un curseur

actuellement ouvert par la connexion.
 Valeurs renvoyées par l’instruction FETCH
 0 : L'instruction FETCH a réussi.
 -1 : L'instruction FETCH a échoué ou la ligne se situait au-
delà du jeu de résultats.
 -2 : La ligne recherchée est manquante.

 Pour parcourir un curseur, on peut employer une boucle WHILE qui teste la valeur
de la fonction @@FETCH_STATUS qui renvoie 0 tant que l'on n'est pas à la fin.
 Fermeture et libération mémoire :
 CLOSE nomc
45  DEALLOCATE nomc
 LES CURSEURS
 Exemple :
 Afficher par l’instruction print tous les noms des clients.
DECLARE @nom VARCHAR(50)
DECLARE curseur_clients CURSOR FOR
SELECT nom FROM client
OPEN curseur_clients
FETCH curseur_clients INTO @nom
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT @nom
FETCH curseur_clients INTO @nom
END
CLOSE curseur_clients
DEALLOCATE curseur_clients

46
 Les Exceptions

TRY...CATCH :Implémente la gestion des erreurs

pour Transact-SQL
Exemple:

47
 declare @a int;
set @a=1;
BEGIN TRY
print 1/@a;
END TRY
BEGIN CATCH
print 'impos! de diviser sur zero'
END CATCH;

48
 L es Transactions

49
 Traitement des transactions
Une transaction est une suite d'opérations effectuées
comme une seule unité logique de travail. Une unité
logique de travail doit posséder quatre propriétés
appelées propriétés ACID (Atomicité, Consistance,
Isolation et Durabilité).
• Atomicité : succès ou échec
• Consistance : tout est fait ou rien n'est fait
• Isolation : indépendant d'autres transactions ou événements
• Durabilité : les changements, une fois traités, ne peuvent pas être
annulés

50
 Syntaxes
 Début de transaction :
BEGIN TRAN[SACTION][nomtransaction]
 Validation de transaction :
COMMIT TRAN[SACTION] [nomtransaction]
 Annulation de transaction :
ROLLBACK TRAN[SACTION] [nomtransaction|nom
P.C.]
 un point de contrôle (P.C.) :
SAVE TRAN[SACTION] [nom P.C.]

51
 Exemple 1 :
begin TRAN Tr1
insert into Commande values(3,'21/2/2010');
save tran Tr12
insert into Commande values(4,'21/2/2010');
rollback tran Tr12
insert into Commande values(5,'21/2/2010');
Commit Tran Tr1

52
 Exemple 2 :

begin tran a
begin try
insert into Commande values(2,'21/2/2010');
commit tran a
end try
begin catch
print'impossible inserer'
rollback tran a
end catch

53
  Exemple 3 : commit tran Tr;
Begin tran Tr print 'transaction
declare @cpt real reussi';
Update Compte Set
end
solde=solde-5000 where
numclient=2; else
set @cpt=(select solde begin
from Compte where rollback tran Tr;
numclient=2);
print 'transaction
if (@cpt>=0)
annuler';
begin
end
54
select * from Compte
 LES TRIGGERS
Un triggers est une Forme de règles utilisées pour renforcer l’intégrité de la
base de données, on peut dire aussi des contraintes d’intégrité personnalisés.
 - sont attachés à des tables

 - ne peuvent pas être appelés explicitement dans les applications

55
 Les triggers sont déclenchés automatiquement par le
noyau SQL à chaque intervention sur la table qui les
supportent.
Un trigger est toujours associé à une table, qui
peut avoir au maximum trois triggers pour
(Insertion, modification et suppression de ligne
La suppression d’une table entraîne la destruction
de ses triggers

56
 Les déclencheurs peuvent être associés à trois types
d'actions de déclenchement sur une table :
• Déclencheurs d'insertion : Se déclenchent suite à
une opération d'ajout d'enregistrements dans la table

57
 • Déclencheurs de modification : Se déclenchent
suite à une opération de modification des
enregistrements de la table ;
• Déclencheurs de suppression : Se déclenchent
suite à une opération de suppression
d'enregistrements à partir de la table

58
 Principe de fonctionnement.
Deux tables virtuelles(variable local temporaire dans le
programme) sont créées au moment de la MAJ des
données sur une table (INSERTED,DELETED) en
lecture seul, Elles sont destinées à contenir les lignes de
la table sur lesquelles ont été effectuées des opérations.
Les tables INSERTED et DELETED peuvent être
utilisées par le trigger pour déterminer comment le
traitement doit se dérouler. Ce traitement est à écrire par
le développeur.

59
 LES TRIGGERS
 Principe de fonctionnement.
 Cas de création d’une ligne de table (insert)
 Une table virtuelle temporaire est crée au moment de l’insertion sur la table:
INSERTED
 La/les lignes nouvelles sont placées dans cette table temporaire INSERTED et
dans la table réelle; toutes les lignes de la table INSERTED apparaissent dans
la table de la base.

60
 LES TRIGGERS
 Cas de suppression d’une ligne de table (delete)
 Une table virtuelle temporaire est crée au moment de la suppression sur la
table: DELETED
 La/les lignes supprimées sont placées dans la table temporaire DELETED et
supprimées de la table réelle; la table DELETED et les tables de la base ne
peuvent pas avoir de lignes en commun.

61
 LES TRIGGERS
 Cas de modification d’une ligne de table (update)

 Deux tables virtuelles sont créées au moment de la MAJ

sur la table:
 INSERTED
 DELETED.

 La/les lignes avant modification sont placées dans la table

temporaire DELETED et la/les lignes après modification
sont placées dans la table temporaire INSERTED et dans
la table réelle.

62
 LES TRIGGERS
SYNTAXE GENERALE
CREATE TRIGGER nom_trigger ON nom_table FOR
INSERT
AS
bloc d’instruction SQL
CREATE TRIGGER nom_trigger ON nom_table FOR
UPDATE
AS
bloc d’instruction SQL
CREATE TRIGGER nom_trigger ON nom_table FOR
DELETE
AS
bloc d’instruction SQL
63
 ou
CREATE TRIGGER nom_trigger ON nom_table
FOR INSERT, UPDATE
AS
bloc d’instruction SQL
 Suppression d’un triggers : DROP TRIGGER
nom_trigger
 Modifier un triggers : la même syntaxe de Create, en
remplassant Create par Alter

64
 exemple
Exemple :
Pour implémenté la contraint: de limiter l’insertion de
clients à 3, sur la table client , on doit
utilisé le trigger suivant:

65
 CREATE TRIGGER Limitclient3 ON client
FOR INSERT
AS
begin
if (select count(*) from client )>3
begin
RAISERROR('nombre limite de clients, insertion
annuler',1,15)
rollback
end
end

66
 Exemple 2:
 Le trigger suivant interdit la modification des produit

Create Trigger Tr_Empêcher_Modif1 On produit

For update
As
begin
Print 'impossible de modifier '
Rollback
end

67
 LES TRIGGERS
Déclencheurs AFTER : sont exécutés après l'action
associée à une instruction INSERT, UPDATE ou DELETE.
Le déclencheur AFTER est défini de la même manière que
le déclencheur FOR. Vous pouvez définir des déclencheurs
AFTER uniquement dans les tables.
Déclencheurs INSTEAD OF. sont exécutés à la place
de l'action de déclenchement habituelle. Ils peuvent
également être définis dans des vues avec une ou plusieurs
tables de base afin d'étendre les types de mises à jour
qu'une vue peut prendre en charge.

68
  Les déclencheurs INSTEAD OF :
Sont vérifiés avant les contraintes d'intégrité
associées à la table ce
qui permet de mettre en place des traitements qui
complètent les actions de ces contraintes ;

69
 Exemple (Instead of):
Pour la suppression d’une Matiére:
CREATE TRIGGER Supp ON Matière NSTEAD OF
DELETE
AS
begin
Delete Form Note Where IdMat in (select idmat from
deleted)
Delete From Matiere Where IdMat in (select idmat
from deleted)
end

70
 Ici la suppression des notes ce passe avant la
suppression des
matières pour évité l’erreur provoqué par la
contraint d’intégrité référentiel.

71
 Gestion Erreurs
L'instruction Raiserror affiche un message d'erreur
système. Ce message est créé par l'utilisateur ou
appelé à partir de la table SysMessages de la base de
données Master (table contenant la liste des messages
systèmes disponibles en SQL Server).

72
 Syntaxe :
Raiserror (Texte message, gravité, état)

73
 Cette fonction accepte trois arguments requis :
• Texte Message : Représente le texte du message
• un numéro qui représente le niveau de gravité de
l'erreur entre 0 et 25 Gravité : Seul l'administrateur
système peut
ajouter des messages avec un niveau de gravité
compris entre 19 et 25

74
 (consulter l'aide Transact-SQL dans l'analyseur de
requêtes SQL pour le détail des niveaux de gravité)
état de l'erreur entre 1 et 127
qui identifie la source à partir
de laquelle l'erreur a été émise (consulter l'aide
Transact-SQL pour le détail sur les différents états)

75
76
77