Lycée Hassan II Pr.

Mme Andaloussi
2ème année DSI

Transact SQL

Année Universitaire:
2020-2021
 Introduction
• SQL est un langage non procédural
• Les traitements complexes sont parfois difficiles à écrire si on ne peut utiliser des
variables et les structures de programmation comme les boucles et les alternatives
• On ressent vite le besoin d’un langage procédural pour lier plusieurs requêtes SQL
avec des variables et dans les structures de programmation habituelles

Principales caractéristiques de Transact/SQL

• Extension de SQL : des requêtes SQL cohabitent avec les structures de contrôle
habituelles de la programmation structurée (blocs, alternatives, boucles)
• Un programme est constitué d’un ensemble de blocs.
• Des variables permettent l’échange d’information entre les requêtes SQL et le
reste du programme

Mme Andaloussi/DSI2 2
 Les variables
Déclarer des variables:
Declare @Nom_Variable Type_Donnée

Exemples: DECLARE @IdClient int

Declare @b varchar(10)

Assigner une valeur à une variable

Select @Nom_Variable = valeur

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

SELECT @IdClient = (SELECT Id_Client FROM Client WHERE …

Exemples:
Select @a=(Select count(NumArt) from Article)
Set @b=‘Mon Nom’

Mme Andaloussi/DSI2 3
 Affichage de variable et message
Print message
Print @nom_variable
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ée avec la valeur
de @b
puisque @c est de type numérique, il faut passer par une fonction de conversion
comme:
Convert (Type de conversion, Valeur à convertir) Ou CAST (exp1 AS types_données)

Mme Andaloussi/DSI2 4
 Les structures de contrôles
1. La structure IF
IF condition
Syntaxe: begin
instructions
end
[ELSE
begin
instructions
End]

Exemple: SELECT * FROM Client

DECLARE @id int = 1
IF EXISTS (SELECT * FROM Client WHERE Id_Client = @id)
BEGIN
DELETE FROM Client WHERE Id_Client = @id
PRINT 'Le Client’+convert(varchar, @id)+' a bien été supprimé !'
END
ELSE
PRINT 'Pas de Client pour ce Id !'
SELECT * FROM Client
Mme Andaloussi/DSI2 5
 Exemple
On souhaite vérifier si le stock de l'article portant le numéro 10 a atteint
son seuil minimum. Si c'est le cas, on affiche le message 'Rupture de
stock' :

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'

Mme Andaloussi/DSI2 6
 2. La structure case
Syntaxe: Case
When Condition1 Then Résultat 1
When Condition2 Then Résultat 2
...
Else Résultat N
Exemple: End

Select NumArt, DesArt, PUArt,'Observation' = Case

When QteEnStock=0 then
'Non Disponible'
When QteEnStock>SeuilMinimum then
'Disponible'
Else
'à Commander'
End
From Article

Mme Andaloussi/DSI2 7
 3. La boucle while
Syntaxe: Remarques:

While Condition • Le mot clé Break est utilisé dans une boucle While pour

Begin forcer l'arrêt de la boucle

instructions • Le mot clé Continue est utilisé dans une boucle While pour

End annuler l'itération en cours et passer aux itérations

suivantes (renvoyer le programme à la ligne du while)

While ((Select avg(puart) from article)<20) )

Begin
Exemple:
Update article Set puart=puart+puart*0.1

Select * from article

End

Select avg(puart) as moyenne from article

Mme Andaloussi/DSI2 8
 4. Branchement inconditionnel
Syntaxe:
GOTO label

Exemple: Declare @a decimal

Etiquette_1:
Set @a= (Select avg(puart) from article)
If @a<20
Begin
Update article Set puart=puart+puart*0.2
Select * from article
Goto Etiquette_1
End
Select avg(puart) as moyenne from article

Mme Andaloussi/DSI2 9
 Les Transactions
Une transaction est un ensemble d’instructions de manipulations de données s’exécutant
dans une même unité de travail. La validation d’une transaction(commit) assure que
toutes les instructions en faisant partie se sont correctement terminées. L’annulation de la
transaction(rollback) assurera l’annulation de l’ensemble de ses instructions.

Une transaction est caractérisée par le mot l’acronyme ACID (Atomic Consistency Isolation
Durability) :
• Atomique: Les commandes SQL faisant partie de la transaction sont exécutées
complètement ou pas du tout
• Consistance : à la fin d’une transaction, les données montrées sont soit celles d’avant
la transaction (dans le cas d’une annulation de la transaction) soit celles d’après la
transaction (dans le cas d’une validation).
• Isolation : il est possible de verrouiller (isoler) les données pendant l’exécution de la
transaction (verrouillage en lecture, en écriture, …).

• Durée : les changements effectués au terme de la transaction sont permanents

Mme Andaloussi/DSI2 10
 Les Transactions
Exemple:
Syntaxe:

BEGIN TRAN nom_transaction BEGIN TRAN Transaction1

--Démarrage de la transaction UPDATE dbo.Client
COMMIT TRAN nom_transaction SET Nom_Client = 'ANDREO'
--Validation de la transaction WHERE Nom_Client = 'CASANOVA'
SAVE TRAN nom_point_de_retour BEGIN TRAN Transaction2
--Déclaration d'un point de contrôle UPDATE dbo.Client
--de la transaction SET Nom_Client = 'VASSELON'
ROLLBACK TRAN nom_transaction WHERE Nom_Client = 'HOLLEBECQ'
OR nom_point_de_controle COMMIT TRAN Transaction2
--Annulation de la transaction ROLLBACK TRAN Transaction1

Mme Andaloussi/DSI2 11
 Les curseurs
• En programmation SQL, lorsqu’une requête retourne plusieurs lignes, il est possible de
traiter chaque ligne au moyen d’un curseur.

• Il s’agit donc d’un mécanisme qui va permettre de parcourir chaque enregistrement du

résultat pour effectuer une opération précise.

• Un curseur est une variable dynamique qui prend pour valeur le résultat d’une requête.

• A l'ouverture du curseur, la base de données est interrogée et la requête associée au

curseur est traitée. Une copie des enregistrements répondant aux critères demandés est
créée. De ce fait toutes les modifications effectuées sur les enregistrements du curseur
ne seront pas visibles sur la base de données source tant que le curseur n'a pas été
fermé. De même si d'autres utilisateurs ont opéré des modifications sur la base de
données source, celles ci ne seront visibles que si le curseur a été fermé et ré ouvert.

Mme Andaloussi/DSI2 12
 Types des curseurs
• Curseurs à défilement en avant (Forward Only) : Ce type de curseur ne met, à la
disposition de l'utilisateur, qu'une seule ligne à la fois. Cette ligne peut être lue et mise à
jour. L'utilisateur ne peut se déplacer que vers la ligne suivante (accès séquentiel)

• Curseurs statiques (Static) : L'avantage de ce type de curseur par rapport au précédent est
que l'accès peut se faire à partir d'une ligne dans différents sens (MoveFirst, MoveNext,
MovePrior, MoveLast)

• Curseurs d'ensemble de valeurs clés (Keyset) :Une clé (un signet) faisant référence à la
ligne d'origine de la base de données source est créée et enregistrée pour chaque ligne du
curseur cela permet d'accéder aux données en temps réel à la lecture ou à la manipulation
d'une ligne du curseur. Le déplacement entre les lignes est sans restriction (MoveFirst,
MoveNext, MovePrior, MoveLast) et la mise à jour des données est possible

• Curseurs dynamiques (Dynamic) : Avec ce type de curseurs, le système vérifie en

permanence si toutes les lignes vérifiant la requête du curseur sont incluses. Ce curseur ne
crée pas de clé sur les lignes ce qui le rend plus rapide que le curseur Keyset mais il
consomme plus de ressources système.
Mme Andaloussi/DSI2 13
 Les curseurs
Déclaration: Declare nom_curseur Cursor [Static| Keyset |Dynamic] For Requête

ouverture: Open nom_curseur

•Atteindre le premier enregistrement du curseur

Atteindre
un Fetch First from nom_curseur into variable1, variable2,..
tuple: •Atteindre l'enregistrement du curseur suivant celui en cours
Fetch Next from nom_curseur into variable1, variable2,...
Ou Fetch nom_curseur into variable1, variable2…
•Atteindre l'enregistrement du curseur précédent celui en cours
Fetch Prior from nom_curseur into variable1, variable2,...
•Atteindre le dernier enregistrement du curseur
Fetch Last from nom_curseur into variable1, variable2,...
•Atteindre l'enregistrement se trouvant à la position n dans le curseur
Fetch absolute n from nom_curseur into variable1, variable2,...
•Atteindre l'enregistrement se trouvant après n positions de la ligne en cours
Fetch Relative Num_Ligne from nom_curseur into variable1, …

Mme Andaloussi/DSI2 14
 Les curseurs
Fermer un curseur: close nom_curseur
Deallocate Nom_Curseur
Libérer les ressources allouées:

Remarque: La variable système @@fetch_status est utilisée pour détecter la fin du

curseur. Tant que cette variable a la valeur 0, on a pas encore atteint la
fin du curseur.

Exemple: DECLARE @Id_Client INT

DECLARE curseur CURSOR FOR SELECT Id_Client FROM Client
OPEN curseur
FETCH curseur INTO @Id_Client
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT @Id_Client
FETCH curseur INTO @Id_Client
END
CLOSE curseur
DEALLOCATE curseur
Mme Andaloussi/DSI2 15
 Utilisation d’un curseur
La méthode pour utiliser un curseur est invariable.

1. En premier lieu, celui-ci doit être défini.

 Exemple : DECLARE CURSOR empCur for SELECT id_emp FROM emp

2. Le curseur de nom empCur est chargé dans cet exemple de récupérer le résultat de la
requête qui suit. Il peut alors être ouvert lorsqu’on souhaite l’utiliser : OPEN empCur

3. Pour récupérer les tuples(enregistrements) successifs de la requête, on utilise

l’instruction : FETCH from empCur INTO @employeVar

4. La première fois, c’est le premier tuple du résultat de la requête qui est affecté comme
valeur à la variable @employeVar (qui devra être déclarée de façon adéquate).

5. A chaque exécution de l’instruction: FETCH from empCur INTO @employeVar, un

nouveau tuple résultat est chargé dans @employeVar.

6. Enfin, lorsque le traitement sur le résultat de la requête est terminé, on ferme le

curseur : CLOSE empCur et on libère les ressources utilisées par le curseur à l’aide de
l’instruction deallocate empCur
Mme Andaloussi/DSI2 16
 Exemples:

Declare @a int, @b Varchar(10), @c real

Declare Cur_ListeArt Cursor for Select NumArt, DesArt,puart from article
Open Cur_ListeArt
Fetch Next from Cur_ListeArt into @a,@b,@c
While @@fetch_status=0
Begin
Print ‘L article numéro ' + convert(varchar,@a) + ‘ portant la désignation ‘ +
@b+ ' coûte ' + convert(varchar,@c) + ‘ dh’
Fetch Next from Cur_ListeArt into @a,@b,@c
End
Close Cur_ListeArt
Deallocate Cur_ListeArt

Mme Andaloussi/DSI2 17
 Exemples:
• L’exemple suivant sélectionne l’ensemble des employés dont le salaire ne dépasse
pas 6000.00 et les augmente de 500.00
DECLARE SalCur CURSOR for
SELECT empno FROM EMP WHERE SAL<6000.00
DECLARE @id int
OPEN SalCur
FETCH from SalCur INTO @id
While @@fetch_status=0
begin
UPDATE EMP
SET SAL=SAL+500.00 WHERE EMPNO=@id
FETCH from SalCur INTO @id
end
Close SalCur
Deallocate SalCur
Mme Andaloussi/DSI2 18
Un lot d’instructions

Mme Andaloussi/DSI2 19
 Procédures et Fonctions
• Dans TransactSQL, on peut exécuter directement un lot en tapant sa définition

• Le plus souvent, on crée plutôt une procédure ou une fonction nommée pour
réutiliser le code.

• Syntaxe :

Create FUNCTION nomF[(listeparam)]

Create PROCEDURE nomP[(listeparam)]
RETURNS type_retour AS
AS
begin
-- Déclaration des variables locales
-- déclaration des variables locales
-- code de la procédure
-- code de la fonction
end

Mme Andaloussi/DSI2 20
 Procédures et Fonctions
• Syntaxe des Paramètres:

nom_param [OUTPUT] type_de_données,..

 Dans la définition d’une procédure ou d’une fonction, on indique le type de

paramètre que l’on veut
Absence de output: paramètre d’entrée
OUTPUT: paramètre de sortie
 Particularité : il est possible de mentionner une valeur par défaut pour un
paramètre en mentionnant, à la suite de la définition de son type, le
symbole ‘=’ et la valeur par défaut.

Mme Andaloussi/DSI2 21

Create Procedure SP_Articles
as
Select NumArt, DesArt
from Article
Create Procedure SP_NbrArtCom
@NumCom int, @Nbr int output
as
Set@Nbr = (Select count(NumArt)
from LigneCommande where
NumCom=@NumCom)
Exemples:
Create Procedure SP_ListeArticles @NumCom int as
Select A.NumArt, NomArt, PUArt, QteCommandee
From Article A, LigneCommande LC
Where LC.NumArt=A.NumArt and LC.NumCom=@NumCom
Create Procedure SP_TypePeriode as
Declare @NbrCom int
Set @NbrCom = (Select count(NumCom) from Commande)
If @NbrCom >=100
Return 1
If @NbrCom >50
Return 2
If @NbrCom <=50
Return 3
If @@ERROR <>0
Return 4
Mme Andaloussi/DSI2 22
Les Fonctions

Mme Andaloussi/DSI2 23
Fonctions Scalaire

Mme Andaloussi/DSI2 24
 Exemples:
create function euro_to_fr(@somme real)
RETURNS real AS Définition de
begin la fonction
Utilisation de la euro_to_fr
Declare @taux real = 6.55957;
fonction
return @somme * @taux;
euro_to_fr
end;

Declare cur cursor for

select ename, sal from emp
Declare @n,@c real
Declare @b varchar(25)
Open cur select ename, sal, euro_to_fr(sal)
Fetch from cur into @b,@c from emp;
While @@fetch_status=0
begin
@n= euro_to_fr(@c)
Print(@b+ ‘ gagne ‘+convert(varchar,@n)+ ' francs’) Utilisation de la
Fetch from cur into @b,@c fonction
end euro_to_fr dans
Close cur une requête SQL
Deallocate cur
Mme Andaloussi/DSI2 25
Création d’une fonction retournant une table
Create FUNCTION nomF[(listeparam)]
RETURNS TAble
[WITH ENCRYPTION|WITH SHEMABINDING]

AS
return requête_de_sélection

Create FUNCTION nomF[(listeparam)]

RETURNS @nom_Table TABLE(champ1 type,..)
[WITH ENCRYPTION|WITH SHEMABINDING]
AS
begin
-- déclaration des variables locales
-- code de la fonction
--return @nom_Table
end

Mme Andaloussi/DSI2 26
 Exemples
Create Function F_ListeArticles (@NumCom int )
Returns Table
as
Select A.NumArt, DesArt From Article A, LigneCommande LC
Where LC.NumArt=A.NumArt and LC.NumCom=@NumCom

Create FUNCTION infoCommande(@num int)

RETURNS @infoC TABLE(nom varchar(25), valeur int)
AS
Begin
Declare @nbr int
Declare @total real
Select @nbr=count(numArt), @total=sum(pu*qtecde)
From Article A, LigneCommande L
Where A.numArt=L.numArt
And numCom=@num
insert into @info values(‘nombre d’article’, @nbr)
insert into @info values(‘Total commande’, @total)
Return @infoC
end
Mme Andaloussi/DSI2 27
 Exercices

1. Définir une fonction qui retourne le nombre de commande passées

par un client

2. Définir une fonction table inline qui permet l’affichage des articles

possédant un inférieur à celui passé en paramètre

3. Définir une fonction retournant une table et qui permet de connaitre

pour le client passé en paramètre, le nombre de commandes

passées et le montant moyen de ses commandes

Mme Andaloussi/DSI2 28
 L’option with schemabinding

Exemple :

Mme Andaloussi/DSI2 29
Mme Andaloussi/DSI2 30
Mme Andaloussi/DSI2 31
Mme Andaloussi/DSI2 32
 L’affichage des messages d’erreur
Il est parfois intéressant de signaler une erreur. En effet, en levant une erreur, on
peut mentionner, par un message, le type de l’erreur rencontré. Pour ce faire, il faut
utiliser l’instruction Transact-SQL RAISERROR dont le format est le suivant :

RAISERROR ( { identifiant | message }

{ ,gravité ,état }
[ ,argument [ ,...n ] ] )
[WITH option, ...]

• Identifiant : Numéro d’identification du message tel qu’il est enregistré dans la

table sysmessages.

• Le message est une chaîne de caractères libre mentionnant le type de l’erreur qui
est survenu.

Mme Andaloussi/DSI2 33
 L’affichage des messages d’erreur
• La gravité(ou sévérité) est un entier compris entre 0 et 18 qui représente la gravité
de l’erreur. Seul l'administrateur système peut ajouter des messages avec un niveau
de gravité compris entre 19 et 25
• L’état est un entier, compris entre 1 et 127, qui peut être utilisé pour repérer l’endroit
où l’erreur s’est produite. Par exemple, si la même erreur peut survenir à plusieurs
endroits du déclencheur, l’état permettra de désigner l’instruction RAISERROR qui a
été exécutée.
• Argument : Dans le cas où le message d’erreur prédéfini ou non possède des
paramètres, il faut les valoriser à partir de constantes ou bien de variables(voir
deuxième exemple de la diapositive qui suit).

Mme Andaloussi/DSI2 34
 Exemples
If (@s<0)
RAISERROR (‘!!Le stock est négatif !!', 12, 1)

Lorsqu’on veut lever une erreur, on peut soit donner l’identifiant de l’erreur en question, soit
lui donner un message particulier. Si on lui donne un message particulier comme nous l’avons
fait dans l’exemple ci-dessus, il faut automatiquement lui préciser une gravité et un état.

Declare @n int =1
Raiserror(‘erreur sur le client : %d ’, 18,1,@n)

Mme Andaloussi/DSI2 35
 Les messages d’erreur
On peut aussi ajouter un nouveau message d’erreur en faisant appel à la
procédure stockée sp_addmessage et le supprimer par la procédure stockée
sp_dropmessage.

exec sp_addmessage @msgnum, @severity,

@msgtext, @lang, @with_log, @replace

Dans l’ordre, les paramètres correspondent aux données suivantes :

identifiant(>50000), sévérité, message, langue, log et replace. Les paramètres Log et
Replace ne sont pas obligatoires. Replace sert à remplacer le message d’une erreur
existante.

Mme Andaloussi/DSI2 36
 Les messages d’erreur

exec sp_addmessage @msgnum=500001, @severity =12,

Exemple :
@msgtext = 'le stock maximal doit être supérieur au stock
minimal',@lang = 'us_english'
go
raiserror(500001,12,1)

Mme Andaloussi/DSI2 37
 Gestion des erreurs dans le code
Il existe deux manières de gérer les erreur : La première consiste à tester la valeur de la variable
système @@ERROR, la seconde consiste à positionner dans un gestionnaire d’exception TRY le
bloc d’instructions à tester, et dans le CATCH, l’erreur à lever. Voyons la syntaxe :

BEGIN TRY
-- ...
END TRY
BEGIN CATCH
-- ...
END CATCH

Le bloc TRY permet de regrouper ensemble toutes les instructions susceptibles de

lever une erreur. SI le cas se présente où une instruction lève une erreur dans le bloc
TRY, le contrôle est directement donné à la première instruction du bloc CATCH.

Le bloc CATCH suit toujours le bloc TRY. Celui-ci est exécuté si et seulement si,
l’exécution d’une instruction du bloc TRY lève une erreur. Dans le bloc CATCH, le code
permet de gérer l’erreur levée. Pour obtenir des informations sur cette dernière, il est
Mme Andaloussi/DSI2 38
 Gestion des erreurs dans le code
possible d’utiliser les fonctions SQL suivantes :
- ERROR_MESSAGE() : Retourne le texte du message à communiquer à l’application. Ce
texte comprend tous les paramètres mis en argument à l’erreur en question.
- ERROR_NUMBER() : Retourne le numéro de l’erreur.
- ERROR_SEVERITY() : Retourne le niveau de gravité.
- ERROR_STATE() : Retourne l’état.

Exemple :
begin try
insert into commande values(1,’10/10/2018’)
insert into commande values (1,getDate())
end try
begin catch
print ‘erreur lors de l’insertion dans la table Commande’ + ERROR_MESSAGE()
end catch

Mme Andaloussi/DSI2 39
Gestion des erreurs dans le code

Mme Andaloussi/DSI2 40
Exemple :

Mme Andaloussi/DSI2 41
 Les déclencheurs(Triggers)
• Les déclencheurs ou ”triggers” sont des séquences d’actions définis par le programmeur
qui se déclenchent, non pas suite à un appel, mais directement quand un événement
particulier (spécifié lors de la définition du trigger) sur une ou plusieurs tables se produit.

• Les triggers complètent les contraintes d’intégrité en permettant des contrôles et des
traitements plus complexes.

• Un trigger est un objet stocké (comme une table, une vue, un index, une séquence ou
une procédure)

• Syntaxe :

CREATE TRIGGER nom_trigger ON { table | vue }

[ WITH ENCRYPTION ]
{FOR | AFTER | INSTEAD OF } { INSERT , UPDATE ,DELETE }
AS
Instructions SQL

Mme Andaloussi/DSI2 42
 Les déclencheurs(Triggers)
• Un trigger se déclenche après (FOR|AFTER) une insertion, destruction ou mise à
jour (INSERT|DELETE|UPDATE ) sur une table (à noter que l’on peut exprimer des
conditions plus complexes avec la virgule: INSERT , DELETE, ...).

• FOR ou AFTER : Ces déclencheurs s’exécutent après que l’instruction SQL ait été
complètement exécutée. Le déclencheur ne sera exécuté que si l’instruction SQL
s’est passée correctement. En particulier, si toutes les contraintes programmées
(contraintes d’intégrité, contrainte référentielle, clause CHECK) ont été vérifiées.
FOR et AFTER sont des synonymes.

• INSTEAD OF: Il s’agit d’un type particulier de déclencheur. Ainsi au lieu d’exécuter
la requête SQL qui a déclenché le trigger, seul le code du trigger est exécuté.
• WITH ENCRYPTION: La définition du déclencheur est enregistrée de façon cryptée.

Mme Andaloussi/DSI2 43
 Les anciennes et les nouvelles valeurs
• Un déclencheur n’est exécuté qu’une seule fois même si la requête SQL
qui a provoqué son exécution porte sur plusieurs lignes.

• Pour travailler sur chaque ligne pointée par la requête SQL, il est
nécessaire de définir un curseur sur les pseudo-tables inserted ou deleted.

• SQL Server permet d’avoir accès, lors de l’exécution du déclencheur, aux

anciennes et nouvelles valeurs de la table.

• A cette fin, et suivant l’événement déclencheur, le programmeur peut faire

appel aux pseudo-tables inserted et deleted.

Mme Andaloussi/DSI2 44
 Exemples:
Create Trigger Empêcher_Modif
Create Trigger Tr_Empêcher_Modif
On Commande
On Commande
For Update As
For Update
if update(NumCom)
As
Begin
rollback
Raiserror('le numéro de commande ne peut
être modifié',15,120)
Rollback
CREATE TABLE T1 (num1 int, num2 int);
CREATE TABLE T2 (num3 int, num4 int); End
CREATE TRIGGER inverse if update(DatCom)
AFTER INSERT ON T1
Declare @n1,@n2 int
Begin
Select @n1= num1,@n2=num2 from inserted if ((select count (DatCom) from inserted
INSERT INTO T2 VALUES(@n2, @n1) Where datediff(day,datcom,getdate() )>0)<> 0)
Begin
Raiserror('La date de commande ne peut pas
être inférieure à la date en cours',15,120)
Rollback
End End
Mme Andaloussi/DSI2 45
 Gestion des Triggers
• Suppression d’un trigger:

DROP TRIGGER NomDéclencheur

• Modification d’un trigger:

ALTER TRIGGER NomDéclencheur On Nom_Table

For Opération1, Opération2...
as
Nouvelles Instructions

Mme Andaloussi/DSI2 46