M13 Preparation PDF

ROYAUME DU MAROC
OFPPT Office de la Formation Professionnelle et de la Promotion du

Travail
DIRECTION RECHERCHE ET INGENIERIE DE FORMATION
RESUME THEORIQUE
&
GUIDE DES TRAVAUX PRATIQUES
TITRE DU MODULE : Programmation des procédures

stockées et des triggers
SECTEUR : NTIC
SPECIALITE : TSDI
Niveau : TECHNICIEN SPECIALISE
Version 1.0
Résumé de Théorie et guide de
M 12 : Programmation des procédures stockées et des triggers
travaux pratiques
Document élaboré par :
Nom et prénom EFP DR

HALA Nourreddine CFMOTI GC
Révision linguistique
Validation
OFPPT / DRIF / Page : 2 juillet 2007

travaux pratiques
Sommaire
I. INTODUCTION............................................................................................................................................7
II. TYPES DE DONNÉES.................................................................................................................................8
II.1.VALEURS NUMÉRIQUES EXACTES...................................................................................................................8
II.2.DECIMAL ET NUMERIC....................................................................................................................................9
II.3.TYPES DE DONNÉES MONÉTAIRES REPRÉSENTANT DES VALEURS MONÉTAIRES OU DES DEVISES.................9
II.4.DONNÉES NUMÉRIQUES APPROCHÉES............................................................................................................9
II.6.CHAÎNES DE CARACTÈRES............................................................................................................................11
II.7.CHAÎNES DE CARACTÈRES UNICODE............................................................................................................12
II.8.CHAÎNES BINAIRES.......................................................................................................................................13
II.9.AUTRES TYPES DE DONNÉES........................................................................................................................13
III. DÉCLARATION DES VARIABLES LOCALES....................................................................................18
IV. AFFICHAGE DES VALEURS..................................................................................................................18
V. BLOC D’INSTRUCTIONS........................................................................................................................19
VI. STRUCTURE ALTERNATIVE................................................................................................................20
VII. STRUCTURE ITÉRATIVE.......................................................................................................................21
VIII. STRUCTURE DE CHOIX (CASE)...........................................................................................................22
IX. LOTS D'INSTRUCTIONS.........................................................................................................................23
X. TRAITEMENT DES TRANSACTIONS..................................................................................................24
XI. GESTION DES VERROUS........................................................................................................................26
XII. MESSAGES D'ERREUR...........................................................................................................................27
XIII. PROCÉDURES STOCKÉES.....................................................................................................................31
SYNTAXE.............................................................................................................................................................31
ARGUMENTS.......................................................................................................................................................31
AUTORISATIONS..................................................................................................................................................38
EXEMPLE.............................................................................................................................................................38
EXERCICES..........................................................................................................................................................46
XIV. DÉCLENCHEURS (TRIGGERS)............................................................................................................47
EXERCICES..........................................................................................................................................................54
XV. CURSEURS(CURSOR)..............................................................................................................................55
SYNTAXE.............................................................................................................................................................55
AUTORISATIONS..................................................................................................................................................55
EXEMPLE.............................................................................................................................................................55
AUTORISATIONS..................................................................................................................................................57
I. TP1................................................................................................................................................................60
II. TP2................................................................................................................................................................61
III. TP 3...............................................................................................................................................................62
IV. TP 4...............................................................................................................................................................64

travaux pratiques
MODULE 12 : Programmation des procédures stockées et des

triggers
Code : Théorie :40h

Durée : 65 Heures Travaux pratiques :20 h
Évaluation :5h
OBJECTIFS OPERATIONNELS DE PREMIER NIVEAU

DE SITUATION
COMPORTEMENT ATTENDU
Pour démontrer sa compétence, le stagiaire doit Programmer des procédures

stockées et des triggers selon les conditions, les critères et les précisions qui
suivent :
CONDITIONS D’EVALUATION
 Epreuve écrite de programmation
 Travail individuel effectué sur PC sous Windows avec SQL Server
CRITERES GENERAUX DE PERFORMANCE

 Utilisation des commandes appropriées.
 Respect du temps alloué. Respect des règles d’utilisation du matériel et logiciel
Informatique.

travaux pratiques
OBJECTIF OPERATIONNEL DE PREMIER NIVEAU

DE COMPORTEMENT
PRECISIONS SUR LE COMPORTEMENT CRITERES PARTICULIERS DE
ATTENDU PERFORMANCE
A. Programmer des procédures stockées sur  Identification judicieuse des
le SGBD traitements des données à
automatiser
 Programmation correcte des

procédures stockées avec le langage
de programmation du SGBD
B. Programmer des déclencheurs (Triggers)  Identification judicieuse des

événements qui vont déclencher les
triggers
 Programmation correcte des Triggers
C. Tester la procédure ou le trigger  Justesse d’élaboration d’un jeu

d’essai pour tester le bon
fonctionnement du programme

travaux pratiques
OBJECTIFS OPERATIONNELS DE SECOND NIVEAU
LE STAGIARE DOIT MAITRISER LES SAVOIR, SAVOIR-FAIRE, SAVOIR-PERCEVOIR OU

SAVOIR-ETRE JUGES PREALABLES AUX APPRENTISSAGES DIRECTEMENT REQUIS POUR
L’ATTEINTE DE L’OBJECTIF DE PREMIER NIVEAU, TELS QUE :
Avant d’apprendre à Programmer des procédures stockées sur le SGBD (A) et

Programmer des déclencheurs (Triggers) (B) :
1. Sensibiliser le stagiaire à l’utilité de programmer des procédures stockés et des

déclencheurs
2. Analyser les données et les traitements de l’application
3. Maîtriser le langage de requête SQL
4. Savoir coder et programmer avec un outil de développement
5. préparer la connexion au serveur de base des données

travaux pratiques
RESUME THEORIQUE

travaux pratiques
I. Intoduction
SQL Server 2000 répond aux besoins émanant des grandes entreprises mondiales. Grâce aux
fonctionnalités de partitionnement et d'indexation de Transact-SQL, les développeurs créent de
véritables applications de bases de données distribuées et évolutives.
Ce cours apporte une expérience approfondie de la création de procédures stockées et de triggers, il

concerne tous ceux qui travaillent avec SQL Server 2000. Des connaissances de base de SQL sont
nécessaires.
Transact-SQL est une extension de SQL vers un langage de promgrammation, il est aussi le point
central de l'utilisation de Microsoft SQL Server. Toutes les applications qui communiquent avec SQL
Server le font en envoyant des instructions Transact-SQL au serveur, quelle que soit l'interface
utilisateur de l'application.
Transact-SQL est généré à partir de différents types d'applications :
 les applications de productivité bureautique générales
 les applications qui utilisent une interface utilisateur graphique (GUI)

 les applications professionnelles qui stockent leurs données dans les bases de données SQL
Server. Elles peuvent inclure à la fois les applications des autres fournisseurs et les
applications maison ;
 les scripts Transact-SQL exécutés à l'aide d'utilitaires tels que osql ;
 les applications créées avec des systèmes de développement tels que Microsoft Visual C++,
Microsoft Visual Basic ou Microsoft Visual J++ qui utilisent les interfaces de programmation
d'application (API) telles que ADO, OLE DB et ODBC ;
 les pages Web qui extraient les données des bases de données SQL Server ;
Historique
Le langage SQL est né à la suite des travaux du mathématicien CODD.Historiquement, les années
suivantes sont importantes :
-1970 : IBM développe SQL
-1986 :Normalisation de SQL-86
-1989 :Normalisation de SQL-89
-1992 : Normalisation de ANSI SQL-92
-1996 :Microsoft adopte Transact-SQL
II. Déclaration des variables locales

Synataxe génarale :

travaux pratiques
Declare @nom_variable type
Le caractère @ est obligatoire
Exemple : Declare @maVariable int
Déclaration multiple
Declare @var1 type1, @var2 type2
Exemple :Declare @x int, @y int, @z char
NB : Declare @x ,@y int est incorrecte
Affectation
Syntaxe générale :
Select @variable=Valeur où set @variable=valeur
Exemple
select @i=3
set @j=4
select @str='TSDI'
affectation multiple
select @i=3,@j=4,@str='TSDI' est correcte, mais par contre set @i=3,@j=4,@str='TSDI' est une
affectation incorrecte.
III. Affichage des valeurs

Pour afficher le contenu d’une variable on utilise la même instruction select.
Select @i
Affichage multiple
Select @i,@j,@str
NB:On peut utiliser select pour affecter une valeur ou bien pour afficher une autre, mais pas pour
faire les deux, donc l’instruction select @i=20, @str est incorrecte.

travaux pratiques
Exemple de variable de type table :
Declare @stg table(numInsc int primary key, nom varchar(20), prenom varchar(20),moyenne numeric(4,2))
/*la particularité des variables de type table, est qu’on peut utiliser des commandes insert,
select,update, delete */
insert into @stg values(103,'LAAROUSSI','SALAH',14)
insert into @stg values(107,'AADISSA','Youness',14.5)
insert into @stg values(200,'SOQRAT','Sanaa',12.5)
select * from @stg
NB : les variables de type table sont différentes des tables temporairement qui sont créer
physiquement dans la base de données tempDB comme des objetspar contre les premeires sont
stockées dans la RAM (mémoire volatile).
Ainsi, si vous créez une table nommée employees, elle est accessible à toute personne possédant les
autorisations de sécurité sur la base de données pour l'utiliser, et ce jusqu'à sa suppression. Si vous
créez une table temporaire locale nommée #employees, vous êtes le seul à pouvoir y travailler, et elle
est supprimée dès que vous vous déconnectez. En revanche, une table temporaire globale du nom de
##employees peut être manipulée par tout utilisateur de la base de données. Si aucun autre utilisateur
ne se sert de la table après que vous l'avez créée, elle est supprimée au moment où vous vous
déconnectez. Si un autre utilisateur l'utilise, SQL Server la supprime dès que celui-ci et vous-même
vous déconnectez.
Les variables globales
Les variables globales sont affectées directement par le serveur, elle retournent une seul valeur,elle
sont utilisées pour communiquer une information au client, elle sont notées @@nom_variable
Exemple :
@@error :indique le type d’erreur survenu lors de la derniere instruction.
@@rowcount : indique le nombre de lignes affectées par la derniere instruction.

IV. Bloc d’instructions

travaux pratiques
Un bloc d’instruction est une ensemble d’instruction T-SQL qui sont considéré comme un tout ( une
seule).
Un bloc d’instruction peut contenir d’autres sous blocs.
Pour declarer un bloc d’instructions en t-SQL en utilise :
Begin
--instruction(1)
--instruction(2)
--instruction(N)
end
example:
declare @i int,@j int
begin
set @i=2
set @j=3
select @i=@i+1
set @j=@j-1
select @i as 'i', @j as 'j'
end
V. Structure alternative
La structure alternative est une structure de contrôle qui permet d’exécuter un de deux actions
suivant une condition.
Syntaxe
If(condition)
-instruction ou bloc d’instruction
else
-instruction ou bloc d’instruction

travaux pratiques
NB :
la partie « else » est optionnelle.
Il est possible d’imbriquer des if.
Exemple :
Declare @stg table(numInsc int primary key, nom varchar(20), prenom varchar(20),moyenne numeric(4,2))
insert into @stg values(103,'LAAROUSSI','SALAH',14)
If not exits(select * from @stg )
Print 'la table est vide'
Else
Print 'la table n''est pas vide'

VI. structure itérative
La structure itérative est une structure qui permet d’executer un même traitement plusieurs fois.
Syntaxe générale :
While(condition)
-instruction ou bloc d’instructions
où
etiquette
goto etiquette
exmple : calcule de la factorielle d’un nombre
declare @i int, @f int,@n int
set @n=6
set @f=1
set @i=1
while (@i<=@n)
begin
set @f=@f*@i
set @i=@i+1

travaux pratiques
end
select @f as 'la factorielle'
deuxieme solution :
declare @i int, @f int,@n int
set @n=6
set @f=1
set @i=1
label:
set @f=@f*@i
set @i=@i+1
if(@i<=@n) goto label
select @f as 'la factorielle'

VII. structure de choix (CASE)
La fonction CASE est une expression Transact-SQL spéciale qui permet l'affichage d'une valeur de
remplacement en fonction de la valeur d'une colonne. Ce changement est temporaire. Par conséquent,
aucune modification permanente n'est apportée aux données. La fonction CASE peut afficher par
exemple Casablanca dans le jeu de résultats d'une requête pour les lignes qui ont la valeur CA dans la
colonne ville.
La fonction CASE est composée des éléments suivants :
le mot clé CASE,
le nom de colonne à transformer,
les clauses WHEN spécifiant les expressions à rechercher et les clauses THEN spécifiant les
expressions par lesquelles les remplacer,
le mot clé END,
une clause AS facultative définissant un alias pour la fonction CASE.
Cet exemple affiche dans le jeu de résultats d'une requête, le nom complet de la ville dans laquelle vit
chaque Fomateur :
SELECT nomFormateur, ville,
CASE state
WHEN 'CA' THEN 'Casblanca'
WHEN 'Kn' THEN 'Kenitra'
WHEN 'RB' THEN 'Rabat'
END AS 'ville d''affectation’

travaux pratiques
FROM Formateur
ORDER BY nomFormateur
VIII. Lots d'instructions

Un lot est un groupe d'instructions Transact-SQL envoyées simultanément par une application à
Microsoft® SQL Server™, en vue de leur exécution. SQL Server compile ensemble les instructions
d'un même lot au sein d'une seule unité exécutable, appelée plan d'exécution. Les instructions
appartenant à un plan d'exécution sont ensuite exécutées simultanément.
Une erreur de compilation, comme une erreur de syntaxe, empêche la compilation du plan d'exécution,
si bien qu'aucune instruction du lot n'est exécutée.
Une erreur au moment de l'exécution, tel qu'un débordement arithmétique ou une violation de
contrainte, a l'un des deux effets suivants :
La plupart des erreurs d'exécution interrompent l'instruction en cours ainsi que celles qui la suivent
dans le lot.
Quelques erreurs d'exécution, telles que les violations de contraintes, n'interrompent que l'instruction
en cours. Toutes les instructions restantes dans le lot sont exécutées.
Les instructions exécutées avant celle qui a subit l'erreur d'exécution ne sont pas affectées. La seule
exception s'applique lorsque le lot est dans une transaction et que l'erreur provoque son annulation
(rollback). Dans ce cas, toutes les modifications de données non validées avant la condition d'erreur
sont annulées.
Supposons qu'un lot comporte 10 instructions. Si la cinquième instruction comporte une erreur de
syntaxe, aucune instruction ne sera exécutée. Si le lot est compilé et que la seconde instruction échoue
pendant son exécution, les résultats de la première instruction ne sont pas affectés car elle a déjà été
exécutée.
Les règles suivantes s'appliquent aux lots d'instructions :
Les instructions CREATE PROCEDURE, CREATE RULE, et CREATE VIEW ne peuvent pas être
combinées à d'autres instructions du lot. L'instruction CREATE doit démarrer le lot. Tous les autres
instructions qui suivent dans ce lot seront interprétées comme une partie de la définition de la première
instruction CREATE.
Dans le même lot, vous ne pouvez pas modifier une table puis faire référence aux nouvelles colonnes.
 Si une instruction EXECUTE(voir plus loin) est la première instruction d'un lot, le mot clé
EXECUTE n'est pas nécessaire. Le mot clé EXECUTE n'est nécessaire que si l'instruction
EXECUTE n'est pas la première instruction du lot.

travaux pratiques
IX. Traitement des transactions

Qu'est-ce qu'une transaction et pourquoi en ai-je besoin ?
 C'est une unité de travail logique

 Modification de la base de données en groupe
 Assure la cohérence de la base de données
Ce sont les propriétés ACID
 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
C'est une tâche du programmeur de l'application ou de la base de données de définir une

transaction avec SQLServer
Les transactions peuvent être utilisées dans le langage graphique ainsi que dans Transac-SQL
(Procédure stockée) :
Dans TSQL, il n'y aura pas d'aller-retour vers le client, la transaction sera donc
terminée plus rapidement.
Dans le langage graphique l'utilisation des transactions dépend du developpement,

écriture du code nécessaire aux transactions.
Instructions Transact SQL de gestion d'une transaction
Syntaxes
Début de transaction
BEGIN TRAN[SACTION] [nomtransaction]
Validation de transaction
COMMIT TRAN[SACTION] [nomtransaction]
Déclaration d'un point de contrôle
SAVE TRAN[SACTION] [nom du point de contrôle]
Annulation de transaction
ROLLBACK TRAN[SACTION] [nomtransaction/nom de point de contrôle]
Exemple de transaction Serveur
Libération des personnes affectées à un projet à la fin de celui-ci .

travaux pratiques
CREATE PROC ProjectCompleted (@pid NUMERIC (10))

as
BEGIN TRANSACTION Augmente
UPDATE Project
SET CompletionDate = getdate()
WHERE ProjectID = @pid
If @@rowcount = 0
BEGIN
ROLLBACK TRANSACTION
RAISERROR ('Id Project incorrect ', 16, 1)
RETURN
END
UPDATE Assignment
SET ReleaseDate = getdate()
WHERE ProjectID = @pid
AND ReleaseDate is NULL
COMMIT TRANSACTION

travaux pratiques
Transactions imbriquées
… … …
Begin Tran Begin Tran
Begin Tran … …
… CALL C If not ok
CALL B If not ok Rollback
If not ok Rollback Tran Tran
Else Else
Rollback
Commit Tran Commit Tran
Tran
Else
Tran
Le Rollback des transactions imbriquées renvoie toujours au début de la première procédure

qui démarre la première transaction.
X. Gestion des verrous

Lors de transactions concurrentes, SQLServer gère automatiquement des verrous
afin de garantir la cohérence des données de chaque transaction.
Une transaction ne pourra pas modifier des pages accessibles par une autre
transaction, et ne pourra lire des pages en cours de modifications (lecture cohérente).
On peut agir sur les verrous de plusieurs façon, au niveau de la configuration et

au niveau des transactions.
 Les opérations Select ont besoin d'un verrou partagé (share lock)
 Insert, update et delete nécessitent des verrous exclusifs
Choix du niveau
 Niveau de la page (Page level)

 Des pages de 2K (2,048 octets), c'est beaucoup pour des tables étroites
 Le niveau de la page a moins de surcoût (temps machine) que le niveau
ligne.
 Niveau de la table (Table level)

 Après le dépassement d'un seuil, le verrouillage passe au niveau de table
 Ceci réduit le surcoût dû à la gestion du verrouillage de pages
individuelles
 Niveau de l'insertion des lignes (Insert Row level)
 Réduit la contention quand les insertions ajoutent des lignes à la table
C'est choix sont fait au niveau général est appartiennent au responsable de la base de
données, le développeur indique ce qu'il fait dans ses applications.

travaux pratiques
XI. Messages d'erreur

Avec la précédente version de SQL Server (2000), on ne pouvait tester la présence d'une erreur que
par la
variable système @@ERROR. Ainsi une requête provoquant une erreur charge la variable
@@ERROR avec le
code erreur correspondant.
On peut donc voir que la requête :
SELECT * FROM TABLEINEXISTANTE;
Provoque une erreur :
Msg 208, Niveau 16, État 1, Ligne 1 Nom d'objet 'TABLEINEXISTANTE' non valide.
Et charge la variable @@ERROR avec la valeur 208 :
SELECT @@ERROR
De ce fait, dans les scripts TSQL ou dans les procédures stockées, nous devions faire un test de
validation avec
cette variable système pour valider une transaction par un COMMIT ou l'annuler avec un
ROLLBACK.
------------ DEBUT DE TRANSACTION -----------
BEGIN TRAN
SELECT * FROM pubs.dbo.authors
IF (@@ERROR = 0)
BEGIN
COMMIT
PRINT 'EXECUTION OK : '+ CAST(@@ERROR AS VARCHAR(10))
END
ELSE
BEGIN
ROLLBACK
PRINT 'ERREUR : '+ CAST(@@ERROR AS VARCHAR(10))
END

travaux pratiques
--------------- FIN DE TRANSACTION -----------
Cette gestion pouvait être très lourde, car la variable @@ERROR ne conserve qu'un code d'erreur, et
dans
certains scripts ceci est trop limité.
Dans ces situations, la commande GOTO pouvait nous aider en demandant au moteur d'aller à un
point donné
du script TSQL, cela permet de faire une gestion globale de ces erreurs.
------------ DEBUT DE TRANSACTION -----------
BEGIN TRAN
SELECT * FROM pubs.dbo.authors
IF (@@ERROR = 0)
BEGIN
COMMIT
GOTO AFFICHAGEOK
END
ELSE
BEGIN
ROLLBACK
GOTO AFFICHAGEERREUR
END
AFFICHAGEERREUR:
PRINT 'ERREUR : '+ CAST(@@ERROR AS VARCHAR(10))
SELECT @@ERROR
AFFICHAGEOK:
PRINT 'EXECUTION OK : '+ CAST(@@ERROR AS VARCHAR(10))
--------------- FIN DE TRANSACTION -----------
Malgré tout, on sent bien que cette gestion devient vite complexe à gérer et à suivre. De plus,
certaines erreurs

travaux pratiques
ne sont pas captées par la variable, comme le cas des objets inexistants qui bloque directement le
script.
Sous le langage TSQL de SQL Server 2005, ceci a été revu et une nouvelle gestion est apparue qui
rapproche le
TSQL d'un réel langage de développement.
Il existe de nombreux messages d'erreurs prédéfinis, qu'il est possible de lever avec l'instruction
RAISERROR. Il est toutefois possible de définir ses propres messages d'erreur par l'intermédiaire de
sp_addmessage.
Chaque message est caractérisé par les éléments suivants:
numéro: numéro qui permet d'identifier l'erreur
gravité: niveau compris entre 1 et 25 afin de mesurer l'importance de l'erreur
message: message explicatif de l'erreur
langue: permet de connaitre la langue relative au message. L'adaptation est faite de façon automatique
en fonction des paramètres de langues de la connexion.
1. Exemple d'ajout de messages

Les messages personnalisé portent un numéro supérieur strictement à 50000. Les messages
personnalisés doivent tout d'abord être défini dans la langue anglaise avant de pouvoir être définis
pour une version localisé de SQL Server. Il est en plus possible de forcer l'inscription du message dans
l'observateur des évènements de Widows (with_log). Enfin la procédure sp_addmessage permet de
remplacer un message existant avec l'option with replace.
Syntaxe: sp_addmessage @msgnum = numéro, @severity =gravité, @msgtext

=message
[ , @lang = 'langue' ][ , @with_log =] 'with_log' ]
[ , @replace = 'replace']

travaux pratiques
2. Exemple d'utilisation de RAISERROR

L'instruction RAISERROR permet de lever une erreur prédéfinie, ou bien de définir de façon
dynamique son propre message d'erreur. Dans ce dernier cas, l'erreur ne porte pas de numéro mais il
est nécessaire de définir le message. Pour chaque erreur levée avec RAISERROR il est possible de
fixer un niveau de gravité. Chaque message possède également un état qui est représentée par un entier
compris entre 1 et 127.
Syntaxe: RAISERROR ( { numéro | message } { ,gravité ,état }

[ ,paramètre...] )
[ WITH option ... ]

travaux pratiques
XII. 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.
Autres termes utilisés : procédure cataloguée / procédure mémorisée, Remote procedure en anglais.
Particularités :
Les procédures stockées diffèrent des instructions SQL :
 Leur syntaxe est vérifiée et elles sont compilées. C’est le code compilé qui est utilisé
lors des appels
 Ne sont pas appelées automatiquement, mais doivent faire l’objet d’un appel explicite
de la part de l’utilisateur.
 Peuvent être appelées par plusieurs applications frontales
 Avantages :
Améliorent les performances par utilisation du code compilé
Renforcent l’intégrité de la base :
 en centralisant les traitements en un endroit unique  unicité du code
Syntaxe
CREATE PROC [ EDURE ] procedure_name [ ; number ]

[ { @parameter data_type }
[ VARYING ] [ = default ] [ OUTPUT ]
] [ ,...n ]
[ WITH
{ RECOMPILE | ENCRYPTION | RECOMPILE , ENCRYPTION } ]
[ FOR REPLICATION ]
AS sql_statement [ ...n ]
Arguments
procedure_name
Nom de la nouvelle procédure stockée. Les noms des procédures doivent respecter les règles
applicables aux identificateurs et doivent être uniques dans la base de données et pour son
propriétaire.
Les procédures temporaires locales ou globales peuvent être créées en faisant précéder le
procedure_name, par un signe dièse unique (#procedure_name) pour les procédures temporaires
locales, et par deux signes dièse (##procedure_name) pour les procédures temporaires globales. Le

travaux pratiques
nom complet, y compris les signes # ou ##, ne peut dépasser 128 caractères. Facultativement, vous
pouvez spécifier le nom du propriétaire de la procédure.
;number
Nombre entier facultatif utilisé pour regrouper les procédures de même nom afin qu'elles puissent
être supprimées ensemble à l'aide d'une seule instruction DROP PROCEDURE. Par exemple, les
procédures utilisées avec une application appelée order peuvent être nommées orderproc;1,
orderproc;2, etc. L'instruction DROP PROCEDURE orderproc abandonne le groupe tout entier. Si le
nom contient des identificateurs délimités, le numéro ne doit pas être compris dans l'identificateur,
utilisez le délimiteur adéquat autour de procedure_name uniquement.
@parameter
Un paramètre de la procédure. Vous pouvez déclarer un ou plusieurs paramètres dans une

instruction CREATE PROCEDURE. La valeur de chaque paramètre déclaré doit être fournie par
l'utilisateur lors de l'exécution de la procédure (sauf si vous définissez une valeur par défaut pour le
paramètre). Une procédure stockée peut comprendre au maximum 2100 paramètres.
Spécifiez un nom de paramètre en plaçant le signe @ comme premier caractère. Ce nom doit
respecter les règles gouvernant les identificateurs. Un paramètre est local à une procédure, vous
pouvez donc utiliser le même nom dans d'autres procédures. Par défaut, les paramètres ne peuvent
que prendre la place de constantes ; ils ne peuvent pas être utilisés à la place de noms de tables, de
colonnes ou d'autres objets base de données. data_type
Type de données du paramètre. Tous les types de données y compris les types text, ntext et image,
peuvent être utilisés comme paramètre dans une procédure stockée. Toutefois, le type de données
cursor ne peut être utilisé que dans des paramètres OUTPUT. Lorsque vous spécifiez un type de
données cursor, vous devez également spécifier les mots clés VARYING et OUTPUT.
Remarque Le nombre maximal de paramètres de sortie de type de données cursor n'est pas limité.
VARYING
Spécifie le jeu de résultats pris en charge comme paramètre de sortie (construit dynamiquement par
la procédure stockée et dont le contenu peut varier). S'applique uniquement aux paramètres de type
cursor.
default
Valeur par défaut pour le paramètre. Si vous avez défini une valeur par défaut, la procédure peut être
exécutée sans spécifier de valeur pour ce paramètre. La valeur par défaut doit être une constante ou
elle peut avoir la valeur NULL. La valeur par défaut peut contenir des caractères génériques (%, _,
[ ] et [^]) si la procédure utilise le nom du paramètre avec le mot clé LIKE.
OUTPUT

travaux pratiques
Indique que le paramètre est un paramètre de retour renvoyé par la procédure. La valeur de cette
option peut être renvoyée à EXEC[UTE]. Utilisez les paramètres OUTPUT pour renvoyer
l'information à la procédure appelante. Les paramètres de type Text, ntext et image peuvent être
utilisés comme paramètres OUTPUT. Un paramètre de sortie qui utilise le mot clé OUTPUT peut
être un espace réservé de curseur.
Emplacement réservé signalant qu'un nombre maximal de 2100 paramètres peut être spécifié.
{RECOMPILE | ENCRYPTION | RECOMPILE, ENCRYPTION}
RECOMPILE indique que SQL Server n'utilise pas le cache pour le plan de cette procédure et que la
procédure est recompilée à l'exécution. Utilisez l'option RECOMPILE lorsque vous utilisez des
valeurs temporaires ou atypiques sans remplacer le plan d'exécution placé en mémoire cache.
ENCRYPTION indique que SQL Server crypte l'entrée de la table syscomments contenant le texte
de l'instruction CREATE PROCEDURE. L'utilisation de l'argument ENCRYPTION évite la
publication de la procédure dans le cadre de la réplication SQL Server.
Remarque Pendant une mise à niveau, SQL Server utilise les commentaires cryptés qui sont
stockés dans syscomments pour recréer les procédures cryptées.
FOR REPLICATION
Indique que les procédures stockées créées pour la réplication ne peuvent pas être exécutées sur
l'abonné. Une procédure stockée créée avec l'option FOR REPLICATION est utilisée comme filtre
de procédure stockée et n'est exécutée que pendant la réplication. Cette option ne peut pas être
utilisée avec l'option WITH RECOMPILE.
AS
Spécifie les actions que peut entreprendre la procédure.
sql_statement
Tout numéro et type d'instructions Transact-SQL à inclure dans la procédure. Certaines limitations
s'appliquent.
Espace réservé qui indique que plusieurs instructions Transact-SQL peuvent être incluses dans cette
procédure.
NB :
La taille maximale d'une procédure stockée est limitée à 128 Mo.

travaux pratiques
Vous ne pouvez créer une procédure stockée définie par l'utilisateur que dans la base de données
courante (excepté pour les procédures temporaires qui sont toujours créées dans tempdb).
L'instruction CREATE PROCEDURE ne peut pas s'utiliser conjointement avec d'autres instructions
Transact-SQL dans un même lot d'instructions.
Par défaut, les paramètres peuvent accepter les valeurs NULL. Dans le cas où une valeur de
paramètre NULL est passée, et que ce paramètre est utilisé dans une instruction CREATE ou
ALTER TABLE dans laquelle la colonne référencée n'accepte pas les valeurs NULL, SQL Server
génère une erreur. Pour éviter de passer une valeur de paramètre NULL à une colonne qui n'accepte
pas les valeurs NULL, ajoutez une logique programmée à la procédure ou utilisez une valeur par
défaut pour la colonne (en utilisant le mot clé DEFAULT avec CREATE ou ALTER TABLE).
Il est recommandé de spécifier explicitement NULL ou NOT NULL pour chaque colonne dans toute
instruction CREATE TABLE ou ALTER TABLE d'une procédure stockée, comme par exemple lors
de la création d'une table temporaire. Les options ANSI_DFLT_ON et ANSI_DFLT_OFF
définissent la manière dont SQL Server assigne les attributs NULL ou NOT NULL aux colonnes,
s'ils ne sont pas spécifiés dans une instruction CREATE TABLE ou ALTER TABLE. Si une
connexion exécute une procédure stockée avec des valeurs différentes pour ces options que pour la
connexion qui a créé la procédure, les colonnes de la table créée par la seconde connexion peuvent
avoir des possibilités différentes de valeurs Null et présenter des comportements différents. Si
NULL ou NOT NULL est explicitement établi pour chaque colonne, les tables temporaires sont
créées avec la même possibilité de valeurs Null pour toutes les connexions qui exécutent la
procédure stockée.
SQL Server enregistre les paramètres de SET QUOTED_IDENTIFIER et de SET ANSI_NULLS

lors de la création ou de la modification d'une procédure stockée. Ces paramètres d'origine sont
utilisés lors de l'exécution de la procédure stockée. Par conséquent, tous les paramètres de session
client pour SET QUOTED_IDENTIFIER et SET ANSI_NULLS sont ignorés lors de l'exécution de
la procédure stockée. Les instructions SET QUOTED_IDENTIFIER et SET ANSI_NULLS qui sont
exécutées dans une procédure stockée n'affectent pas la fonctionnalité de cette procédure stockée.
D'autres options SET, telles que SET ARITHABORT, SET ANSI_WARNINGS ou SET
ANSI_PADDINGS ne sont pas sauvegardées lorsqu'une procédure stockée est créée ou modifiée. Si
la logique de la procédure stockée dépend d'un paramétrage particulier, incluez une instruction SET
au lancement de la procédure pour être certain de la bonne configuration. Lorsqu'une instruction
SET est exécutée à partir d'une procédure stockée, les paramètres ne restent effectifs que jusqu'à la
fin de l'exécution de la procédure stockée. Les paramètres reprennent ensuite la valeur qu'ils avaient
avant l'appel de la procédure stockée. Ceci permet aux clients individuels de définir les options
souhaitées sans affecter la logique de la procédure stockée.

travaux pratiques
La façon dont SQL Server interprète une chaîne vide, comme un espace unique ou comme une vraie
chaîne vide, dépend de la valeur du niveau de compatibilité. Si le niveau de compatibilité est
inférieur ou égal à 65, SQL Server interprète les chaînes vides comme des espaces simples. Si le
niveau de compatibilité est égal à 70, SQL Server interprète les chaînes vides comme telles.
Informations sur les procédures stockées
Pour afficher le texte utilisé pour créer la procédure, exécutez sp_helptext dans la base de données
dans laquelle la procédure se trouve en passant le nom de la procédure en paramètre.
Remarque : Les procédures stockées créées avec l'option ENCRYPTION ne peuvent être affichées
à l'aide de sp_helptext.
Pour obtenir une liste des objets référencés par une procédure, utilisez sp_depends.
Pour renommer une procédure, utilisez sp_rename.

Exécution des procédures stockées
Lorsque l'exécution d'une instruction CREATE PROCEDURE réussit, le nom de la procédure est
stocké dans la table système sysobjects et le texte de l'instruction CREATE PROCEDURE est
enregistré dans syscomments. Lorsque vous exécutez une procédure pour la première fois, elle est
compilée afin d'optimiser le plan d'accès pour la récupération des données.
Paramètres utilisant le type de données cursor
Les procédures stockées ne peuvent utiliser le type de données cursor que pour les paramètres
OUTPUT. Si le type de données cursor est spécifié pour un paramètre, les paramètres VARYING et
OUTPUT sont alors obligatoires. Si le mot clé VARYING est spécifié pour un paramètre, le type de
données doit obligatoirement être cursor et il faut spécifier le mot clé OUTPUT.
Remarque : Le type de données cursor ne peut pas être lié à des variables d'application par
l'intermédiaire des API de base de données, telles que OLE DB, ODBC, ADO et DB-Library. Les
paramètres OUTPUT devant être liés avant qu'une application puisse exécuter une procédure
stockée, les procédures stockées qui contiennent des paramètres OUTPUT de type cursor ne
peuvent pas être appelées à partir des API de bases de données. Ces procédures ne peuvent être
appelées à partir des procédures stockées, des déclencheurs ou des lots d'instructions Transact-
SQL que lorsque la variable OUTPUT de type cursor est affectée à une variable Transact-SQL
locale de type cursor.
Paramètres de sortie de type cursor
Les règles suivantes régissent les paramètres de sortie de type cursor lors de l'exécution de la
procédure :
Dans le cas d'un curseur en avant uniquement, les lignes renvoyées dans le jeu de résultats du curseur
sont seulement celles situées à la position du curseur ou au-delà de celui-ci, à la fin de l'exécution de la
procédure stockée, par exemple :

travaux pratiques
Un curseur ne permettant pas le défilement est ouvert dans une procédure, dans un jeu de résultats de
100 lignes, appelé RS.
La procédure extrait les 5 premières lignes du jeu de résultats RS.
La procédure est renvoyée vers son appelant.
Le jeu de résultats RS renvoyé à l'appelant est constitué des lignes 6 à 100 de RS et le curseur dans
l'appelant est placé avant la première ligne de RS.
Dans le cas d'un curseur en avant uniquement, si le curseur se trouve avant la première ligne après
l'achèvement de la procédure stockée, la totalité du jeu de résultats est renvoyée au lot d'instructions, à
la procédure stockée ou au déclencheur appelant. Lorsqu'elle est renvoyée, la position du curseur est
fixée au début de la première ligne.
Dans le cas d'un curseur en avant uniquement, si le curseur est placé au-delà de la fin de la dernière
ligne après l'achèvement de la procédure stockée, le système renvoie un jeu de résultats vide au lot
d'instructions, à la procédure stockée ou au déclencheur appelant.
Dans le cas d'un curseur permettant le défilement, toutes les lignes du jeu de résultats sont renvoyées
au lot d'instructions, à la procédure stockée ou au déclencheur appelant à la fin de l'exécution de la
procédure stockée. Lors du renvoi, la position du curseur est conservée à la position de la dernière
extraction exécutée dans la procédure.
Pour tous les types de curseur, si le curseur est fermé, une valeur NULL est repassée au lot
d'instructions, à la procédure stockée ou au déclencheur appelant. Cette situation se produit également
si un curseur est affecté à un paramètre mais qu'il n'a jamais été ouvert.
Remarque : L'état fermé n'a d'importance qu'au moment du retour. Par exemple, vous pouvez
fermer un curseur au cours de l'exécution de la procédure, le rouvrir plus tard dans la procédure et
renvoyer le jeu de résultats de ce curseur au lot d'instructions, à la procédure stockée ou au
déclencheur appelant.
Procédures stockées temporaires
SQL Server prend en charge deux types de procédures stockées temporaires : local et global. Seule la
connexion qui crée une procédure temporaire locale peut voir cette procédure. Une procédure
temporaire globale est accessible par toutes les connexions. Les procédures temporaires locales sont
supprimées automatiquement à la fin de la session en cours. Les procédures temporaires globales sont
supprimées à la fin de la dernière session qui utilise la procédure, généralement, quand la session qui a
créé la procédure se termine.
Les procédures temporaires nommées avec # et ## peuvent être créées par n'importe quel utilisateur.
Lorsque la procédure est créée, le propriétaire de la procédure locale est le seul à pouvoir l'utiliser.
L'autorisation d'exécuter une procédure temporaire locale ne peut pas être accordée à d'autres

travaux pratiques
utilisateurs. Si une procédure temporaire globale est créée, tous les utilisateurs peuvent y accéder ; les
permissions ne peuvent pas être révoquées de manière explicite. La création explicite d'une procédure
temporaire dans tempdb (nommée sans le signe dièse) ne peut se faire que par les personnes possédant
l'autorisation explicite CREATE PROCEDURE dans la base de données tempdb. L'autorisation peut
être accordée et révoquée pour ces procédures.
Remarque : Une utilisation importante des procédures stockées temporaires peut créer une
contention sur les tables systèmes dans tempdb et réduire les performances. Il est recommandé
d'utiliser sp_executesql à la place. sp_executesql ne stocke pas les données dans les tables systèmes et
évite ainsi le problème.
Exécution automatique des procédures stockées
Il est possible de lancer l'exécution automatique d'une ou plusieurs procédures stockées au démarrage
de SQL Server. Les procédures stockées doivent être créées par l'administrateur système et exécutée
sous le rôle de serveur fixe sysadmin en tant que processus d'arrière-plan. La ou les procédure(s) ne
peuvent pas comprendre de paramètres d'entrée.
Le nombre de procédures au démarrage est illimité mais gardez à l'esprit que chacune utilise une
connexion lors de son exécution. Si vous devez exécuter plusieurs procédures au démarrage mais que
vous ne devez pas les exécuter de manière parallèle, utilisez comme procédure de démarrage, une des
procédures qui appellera les autres. Ceci permet de n'utiliser qu'une seule connexion.
L'exécution des procédures stockées commence lorsque la dernière base de données est restaurée au
démarrage. Afin d'éviter de lancer ces procédures stockées, spécifiez l'indicateur de traces 4022
comme paramètre de démarrage. Si vous lancer SQL Server avec la configuration minimale, (à l'aide
de l'indicateur -f), les procédures stockées de démarrage ne sont pas exécutées.
Pour créer une procédure stockée de démarrage, vous devez être connecté en tant que membre du rôle
de serveur fixe sysadmin et créer la procédure stockée dans la base de données master.
Utilisez sp_procoption pour :
 désigner une procédure stockée existante comme procédure de démarrage ;
 supprimer l'exécution automatique d'une procédure au démarrage de SQL Server ;

 afficher une liste de toutes les procédures stockées qui sont exécutées au démarrage de SQL
Server.

travaux pratiques
Imbrication de procédures stockées
Les procédures stockées peuvent être imbriquées, en ce sens qu'une procédure stockée en appelle une
autre. Le niveau d'imbrication est incrémenté lorsque la procédure appelée commence à s'exécuter, et
décrémenté lorsque l'exécution est terminée. Le dépassement des niveaux d'imbrication maximum
autorisés, provoque l'échec de la totalité de la chaîne de procédures appelante. Le niveau d'imbrication
actuel est renvoyé par la fonction @@NESTLEVEL.
Autorisations
Les autorisations CREATE PROCEDURE reviennent par défaut aux membres du rôle de serveur fixe
sysadmin et des rôles de base de données fixes db_owner et db_ddladmin. Les membres du rôle de
serveur fixe sysadmin et du rôle de base de données fixe db_owner peuvent transmettre les
autorisations CREATE PROCEDURE à d'autres utilisateurs. L'autorisation d'exécution d'une
procédure stockée est accordée au propriétaire de la procédure, qui peut définir une autorisation
d'exécution pour d'autres utilisateurs de la base de données.
Exemple
A. Utiliser une procédure simple avec une instruction SELECT complexe
Cette procédure stockée renvoie tous les auteurs (nom et prénom), leurs titres et leurs éditeurs à partir
d'une jointure de quatre tables. Cette procédure stockée n'utilise aucun paramètre.
USE pubs
IF EXISTS (SELECT name FROM sysobjects
WHERE name = 'au_info_all' AND type = 'P')
DROP PROCEDURE au_info_all
GO
CREATE PROCEDURE au_info_all
AS
SELECT au_lname, au_fname, title, pub_name
FROM authors a INNER JOIN titleauthor ta
ON a.au_id = ta.au_id INNER JOIN titles t
ON t.title_id = ta.title_id INNER JOIN publishers p
ON t.pub_id = p.pub_id
GO
L'exécution de la procédure stockée au_info_all peut s'effectuer selon plusieurs combinaisons :

EXECUTE au_info_all
-- Or
EXEC au_info_all
Ou bien, si cette procédure est la première instruction du lot :

au_info_all
B. Utiliser une procédure simple avec des paramètres
Cette procédure stockée ne renvoie que les auteurs spécifiés (nom et prénom), leurs titres et leurs
éditeurs à partir d'une jointure de quatre tables. Cette procédure stockée accepte les correspondances
exactes pour les paramètres passés.

travaux pratiques
USE pubs
WHERE name = 'au_info' AND type = 'P')
DROP PROCEDURE au_info
GO
USE pubs
GO
CREATE PROCEDURE au_info
@lastname varchar(40),
@firstname varchar(20)
AS
WHERE au_fname = @firstname
AND au_lname = @lastname
GO
L'exécution de la procédure stockée au_info peut s'effectuer selon plusieurs combinaisons :

EXECUTE au_info 'Dull', 'Ann'
-- Or
EXECUTE au_info @lastname = 'Dull', @firstname = 'Ann'
-- Or
EXECUTE au_info @firstname = 'Ann', @lastname = 'Dull'
-- Or
EXEC au_info 'Dull', 'Ann'
-- Or
EXEC au_info @lastname = 'Dull', @firstname = 'Ann'
-- Or
EXEC au_info @firstname = 'Ann', @lastname = 'Dull'
Ou bien, si cette procédure est la première instruction du lot :

au_info 'Dull', 'Ann'
-- Or
au_info @lastname = 'Dull', @firstname = 'Ann'
-- Or
au_info @firstname = 'Ann', @lastname = 'Dull'
C. Utiliser une procédure simple avec des paramètres génériques
Cette procédure stockée ne renvoie que les auteurs spécifiés (nom et prénom), leurs titres et leurs
éditeurs à partir d'une jointure de quatre tables. Ce modèle de procédure stockée fait correspondre les
paramètres passés ou, s'ils ne sont pas fournis, utilise les valeurs par défaut prédéfinies.
USE pubs
WHERE name = 'au_info2' AND type = 'P')
DROP PROCEDURE au_info2
GO
USE pubs
GO
CREATE PROCEDURE au_info2
@lastname varchar(30) = 'D%',
@firstname varchar(18) = '%'
AS

travaux pratiques

WHERE au_fname LIKE @firstname
AND au_lname LIKE @lastname
GO
L'exécution de la procédure stockée au_info2 peut s'effectuer selon plusieurs combinaisons. Vous
trouverez ci-dessous certaines de ces combinaisons :
EXECUTE au_info2
-- Or
EXECUTE au_info2 'Wh%'
-- Or
EXECUTE au_info2 @firstname = 'A%'
-- Or
EXECUTE au_info2 '[CK]ars[OE]n'
-- Or
EXECUTE au_info2 'Hunter', 'Sheryl'
-- Or
EXECUTE au_info2 'H%', 'S%'
D. Utiliser les paramètres OUTPUT
Les paramètres OUTPUT permettent à une procédure externe, un lot d'instructions ou à plus d'une
instruction Transact-SQL d'accéder à un ensemble de valeurs pendant l'exécution de la procédure.
Dans cet exemple, une procédure stockée (titles_sum) est créée et accepte un paramètre d'entrée
facultatif et un paramètre de sortie.
Commencez par créer la procédure :

USE pubs
GO
IF EXISTS(SELECT name FROM sysobjects
WHERE name = 'titles_sum' AND type = 'P')
DROP PROCEDURE titles_sum
GO
USE pubs
GO
CREATE PROCEDURE titles_sum @@TITLE varchar(40) = '%', @@SUM money OUTPUT
AS
SELECT 'Title Name' = title
FROM titles
WHERE title LIKE @@TITLE
SELECT @@SUM = SUM(price)
FROM titles
WHERE title LIKE @@TITLE
GO
Ensuite, utilisez le paramètre OUTPUT avec le langage de contrôle de flux.
Remarque La variable OUTPUT doit être définie au cours de la création de la table ainsi que
pendant l'utilisation de la variable.
Le nom du paramètre et de la variable ne doivent pas nécessairement correspondre, contrairement au

type de données et à la position du paramètre (sauf si vous utilisez @@SUM = variable).

travaux pratiques
DECLARE @@TOTALCOST money

EXECUTE titles_sum 'The%', @@TOTALCOST OUTPUT
IF @@TOTALCOST < 200
BEGIN
PRINT ' '
PRINT 'All of these titles can be purchased for less than $200.'
END
ELSE
SELECT 'The total cost of these titles is $'
+ RTRIM(CAST(@@TOTALCOST AS varchar(20)))
Voici le jeu de résultats obtenu :

Title Name
------------------------------------------------------------------------
The Busy Executive's Database Guide
The Gourmet Microwave
The Psychology of Computer Cooking
(3 row(s) affected)
Warning, null value eliminated from aggregate.
All of these titles can be purchased for less than $200.
E. Utiliser un paramètre OUTPUT de type cursor
Les paramètres OUTPUT de type cursor servent à renvoyer un curseur local à une procédure, au lot
d'instructions appelant, à la procédure stockée ou au déclencheur.
Commencez par créer la procédure qui déclare puis ouvre un curseur dans la table titles :
USE pubs
WHERE name = 'titles_cursor' and type = 'P')
DROP PROCEDURE titles_cursor
GO
CREATE PROCEDURE titles_cursor @titles_cursor CURSOR VARYING OUTPUT
AS
SET @titles_cursor = CURSOR
FORWARD_ONLY STATIC FOR
SELECT *
FROM titles
OPEN @titles_cursor
GO
Ensuite, exécutez un lot d'instructions qui déclare une variable curseur locale, exécute la procédure
pour affecter le curseur à la variable locale et extrait les lignes du curseur.
USE pubs
GO
DECLARE @MyCursor CURSOR
EXEC titles_cursor @titles_cursor = @MyCursor OUTPUT
WHILE (@@FETCH_STATUS = 0)
BEGIN
FETCH NEXT FROM @MyCursor
END
CLOSE @MyCursor
DEALLOCATE @MyCursor

travaux pratiques
GO
F. Utiliser l'option WITH RECOMPILE
La clause WITH RECOMPILE est utile lorsque les paramètres fournis à la procédure ne sont pas
typiques et lorsqu'un nouveau plan d'exécution ne doit pas être mis en mémoire cache ou stocké dans
la mémoire.
USE pubs
WHERE name = 'titles_by_author' AND type = 'P')
DROP PROCEDURE titles_by_author
GO
CREATE PROCEDURE titles_by_author @@LNAME_PATTERN varchar(30) = '%'
WITH RECOMPILE
AS
SELECT RTRIM(au_fname) + ' ' + RTRIM(au_lname) AS 'Authors full name',
title AS Title
ON ta.title_id = t.title_id
WHERE au_lname LIKE @@LNAME_PATTERN
GO
G. Utiliser l'option WITH ENCRYPTION
La clause WITH ENCRYPTION cache le texte de la procédure stockée aux utilisateurs. Cet exemple
crée une procédure cryptée, utilise la procédure stockée du système sp_helptext pour obtenir des
informations sur cette procédure cryptée puis tente d'obtenir directement des informations sur cette
procédure dans la table syscomments.
WHERE name = 'encrypt_this' AND type = 'P')
DROP PROCEDURE encrypt_this
GO
USE pubs
GO
CREATE PROCEDURE encrypt_this
WITH ENCRYPTION
AS
SELECT *
FROM authors
GO
EXEC sp_helptext encrypt_this

The object's comments have been encrypted.
Ensuite, sélectionnez le numéro d'identification et le texte du contenu de la procédure stockée cryptée.

SELECT c.id, c.text
FROM syscomments c INNER JOIN sysobjects o
ON c.id = o.id
WHERE o.name = 'encrypt_this'

travaux pratiques
Remarque La valeur de la colonne text apparaît sur une ligne séparée. Lorsqu'elle est exécutée, cette
information apparaît sur la même ligne que l'information relative à la colonne id.
id text
---------- ------------------------------------------------------------
1413580074 ?????????????????????????????????
e??????????????????????????????????????????????????????????????????????????
(1 row(s) affected)
H. Créer une procédure stockée du système définie par l'utilisateur
Cet exemple crée une procédure qui permet d'afficher toutes les tables dont le nom commence par la
chaîne emp, ainsi que leurs index correspondants. En l'absence de cette chaîne, la procédure renvoie
toutes les tables (et les index) dont le nom commence par sys.
WHERE name = 'sp_showindexes' AND type = 'P')
DROP PROCEDURE sp_showindexes
GO
USE master
GO
CREATE PROCEDURE sp_showindexes
@@TABLE varchar(30) = 'sys%'
AS
SELECT o.name AS TABLE_NAME,
i.name AS INDEX_NAME,
indid AS INDEX_ID
FROM sysindexes i INNER JOIN sysobjects o
ON o.id = i.id
WHERE o.name LIKE @@TABLE
GO
USE pubs
EXEC sp_showindexes 'emp%'
GO

TABLE_NAME INDEX_NAME INDEX_ID
---------------- ---------------- ----------------
employee employee_ind 1
employee PK_emp_id 2
(2 row(s) affected)
I. Utiliser la résolution différée des noms
Cet exemple montre quatre procédures et les différentes manières d'utiliser la résolution de nom
différée. Chaque procédure stockée est créée, même si la table ou la colonne référencée n'existe pas au
moment de la compilation.
WHERE name = 'proc1' AND type = 'P')
DROP PROCEDURE proc1
GO
-- Creating a procedure on a nonexistent table.
USE pubs
GO
CREATE PROCEDURE proc1

travaux pratiques
AS
SELECT *
FROM does_not_exist
GO
-- Here is the statement to actually see the text of the procedure.
SELECT o.id, c.text
FROM sysobjects o INNER JOIN syscomments c
ON o.id = c.id
WHERE o.type = 'P' AND o.name = 'proc1'
GO
USE master
GO
WHERE name = 'proc2' AND type = 'P')
DROP PROCEDURE proc2
GO
-- Creating a procedure that attempts to retrieve information from a
-- nonexistent column in an existing table.
USE pubs
GO
CREATE PROCEDURE proc2
AS
DECLARE @middle_init char(1)
SET @middle_init = NULL
SELECT au_id, middle_initial = @middle_init
FROM authors
GO
-- Here is the statement to actually see the text of the procedure.
SELECT o.id, c.text
FROM sysobjects o INNER JOIN syscomments c
ON o.id = c.id
WHERE o.type = 'P' and o.name = 'proc2'
La suppression d’une procédure mémorisée se fait par :

DROP PROCedure nom_de_procédure

travaux pratiques
On exécute cette procédure, en utilisant la commande exec

travaux pratiques
Exercices
Reprendre le cahier des charges GOELAND et traiter les demandes suivantes en procédures stockées :
Procédure 1 :
On souhaite obtenir par modèle la moyenne des heures de vol des avions.
Procédure 2 :
On souhaite obtenir pour une date donnée la liste des réservations par ligne, vol et étape, passer la date
en paramètre.
Distinguer la classe touriste de la 1ere classe ; préciser le nombre de personnes .
Procédure 3 :
On veut créer une qualification pour un pilote sur un modèle d'avion.

- Vérifier que l'employé est un pilote (Type personnel = "P")
- Vérifier qu'il a le diplôme requis pour ce modèle
- Vérifier la date de validité du diplôme
- Positionner la date de qualification à la date du jour
Entrer le numéro d'employé et le numéro de modèle.
Procédure 4 :
On veut affecter un type de personnel à un vol
- Vérifier que cette personne est bien active (code activité = 'A')
- Vérifier que cette personne n'est pas affectée à un autre vol sur les mêmes dates
- Vérifier que la date du vol pour cette affectation est égale à date de dernière affectation plus
2 jours.
- Vérifier qu'il n'y a pas pour :
- Les pilotes : plus de deux déjà affectés
- Les hotesses : plus de trois déjà affectées
- Les stewards : plus de 1 déjà affecté
- Renvoyer la liste des personnels affecté à ce vol après cette affectation
Entrer le numéro d'employé et le numéro de vol.

travaux pratiques
XIII. Déclencheurs (triggers)
Définition des déclencheurs
Forme évoluée de règles utilisées pour renforcer l’intégrité de la base de données, particulièrement
l’intégrité référentielle.
Le plus souvent on parle de TRIGGERS.
Les triggers sont stockées avec les données dans la base.
 Principes:
Les triggers sont un type particulier de procédure mémorisée.
- sont attachés à des tables

- réagissent aux fonctions de création (create), modification (update) et suppression (delete)
- ne peuvent pas être appelés explicitement dans les applications
Les triggers sont déclenchés automatiquement par le noyau SQL à chaque intervention sur la table qui les
supportent.
Pas de possibilités de passer outre quelque soit l’utilisateur.
Mise en place d’un trigger.
Précautions à prendre.
Un trigger est toujours associé à une table, il est impossible de l’associer à une vue ou a une table
temporaire.
Une table peut avoir au maximum trois triggers, chacun étant déclenché en fonction de l’événement
détecté sur la table
 Insertion de ligne
 modification de ligne
 suppression de ligne
Chaque trigger est facultatif et une table peut n’avoir aucun trigger
D’autre part, un trigger ne s’applique qu’à une seule table, plusieurs tables ne pouvant pas utiliser le
même trigger.
La suppression d’une table entraîne la destruction de ses triggers
Principe de fonctionnement.
Deux tables virtuelles sont créées au moment de la MAJ sur la table:

INSERTED
DELETED.
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.

travaux pratiques
Ce traitement est à écrire par le développeur .
Les mécanismes d’utilisation par SQL Server de ces deux tables diffèrent en fonction de
l’opération effectuée sur la table contenant le ou les triggers.
Cas de suppression d’une ligne de table (delete)

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.
Cas de création d’une ligne de table (insert)

La/les lignes nouvelles sont placées dans la table temporaire INSERTED et dans la table
réelle; toutes les lignes de la table INSERTED apparaissent dans la table de la base.
Cas de modification d’une ligne de table (update)

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.
Création d’un trigger.
Un trigger est un objet SQL Server, en conséquence de quoi:

- les triggers seront gérés de manière autonome
- chaque trigger porte un nom
- chaque trigger possède un certain nombre de propriétés.
Les triggers doivent être créés juste après la création de la table de sorte que l’intégrité
référentielle des données soit assurée.
La création d’un trigger peut se faire

- de manière interactive grâce à l’interface graphique
- en utilisant les procédures de SQL Server.
Utiliser la procédure create trigger
Syntaxe : CREATE TRIGGER nom de trigger

ON nom de table
FOR INSERT
AS
séquence1 d’ordres SQL
FOR UPDATE
AS
FOR DELETE
AS
ou CREATE TRIGGER nom de trigger

ON nom de table
FOR INSERT, UPDATE
AS
séquence d’ordres SQL
Attention à la gestion des déclencheurs dans la fenêtre SQL Server.

travaux pratiques
Exemples de mise en place de triggers.
Les triggers définis sur la base de données ont deux rôles principaux:
- contrôler que les données manipulées vérifient l’intégrité référentielle, c’est à dire que
les tables restent synchronisées.
Exemple: créer un nouveau salarié nécessite de l’affecter à un service existant.
- mettre en oeuvre des traitements correspondant à une règle de gestion de l’entreprise
Exemple: lorsqu’un produit est passé en commande, on mettra à jour la quantité

disponible en stock dans la table Produits.
Triggers d’intégrité référentielle.
Exemple 1 : « Un avion ne peut être créé que si le modèle qui lui correspond existe
déjà dans la base »
CREATE TRIGGER TI_Avion ON AVION FOR INSERT AS
BEGIN
IF (SELECT count(*) FROM MODELE, inserted

WHERE MODELE.NUMMOD = inserted.NUMMOD) = 0
BEGIN
PRINT 'Déclencheur Insert sur AVION. Modèle inexistant. Création impossible'
RETURN
END
END
Exemple 2 : « Un modèle ne peut être supprimé que si aucun avion ne correspond
à ce modèle dans la base de données »
CREATE TRIGGER TD_Modele ON MODELE FOR DELETE AS
BEGIN
IF (SELECT count(*) FROM AVION, deleted

WHERE AVION.NUMMOD = deleted. NUMMOD) > 0
BEGIN
PRINT 'Déclencheur Delete sur modèle. Il existe des avions
correspondant au modèle'
RETURN
END
end

travaux pratiques
Exemple 3 .
« En cas de modification des données concernant un avion, il est nécessaire de

contrôler si le modèle qui lui correspond existe effectivement dans la base; mais
cette vérification n’est à faire que si la clé étrangère dans la table avion a été
modifiée. »
CREATE TRIGGER TU_Avion ON AVION FOR UPDATE AS
BEGIN
 IF UPDATE (CODEMODELE_MODELE)
BEGIN
IF (SELECT count(*) FROM MODELE, inserted
WHERE MODELE.NUMMOD = inserted. NUMMOD) = 0
BEGIN
PRINT 'Déclencheur Update sur Avion. Modèle inexistant,
vous ne pouvez pas le modifier.'
RETURN
END
END
END
Triggers traduisant des règles de gestion.
Certaines règles de gestion concernant les données de la base peuvent être prises en
compte dans le base de données elle-même, de telle manière que la synchronisation
des données soit indépendante des traitements effectués.
Exemple 4.
« Un vol effectué à une certaine date ne doit embarquer que deux pilotes »
/*----------------------------------------------------------------------------*/
/* Règle de gestion: un vol embarque deux pilotes */
/* Mise en place sur TRIGGER INSERT */
/*----------------------------------------------------------------------------*/
IF(select count(*) from AFFECTE, PERSNAV, inserted

where AFFECTE.CODVOL = inserted.CODVOL
and PERSNAV.NUMEMPL = AFFECTE.NUMEMPL
and PERSNAV.TYPERSO = 'P'
)>2
BEGIN
PRINT 'Il y a déjà deux pilotes sur ce vol'

travaux pratiques
END
Dans l’exemple ci-dessus, une partie seulement du trigger a été listé, elle concerne
exclusivement l’application de la règle sur le pilote.
Exemple 5.
« Un modèle d’appareil n’existant plus dans la compagnie, on souhaite ne pas

conserver aux pilotes la qualification correspondante»
BEGIN

WHERE AVION.NUMMOD = deleted. NUMMOD) > 0
BEGIN
RETURN
END
ELSE
BEGIN
DELETE QUALIFICATION FROM QUALIFICATION, DELETED
WHERE NUMMOD = DELETED. NUMMOD
PRINT 'Qualifications correspondant au modèle. Suppression
effectuée.'
END
END
Les triggers en cascade.
Une opération sur une table déclenche automatiquement, s’il existe, le trigger correspondant à
l’opération.
Si le trigger déclenché effectue une opération sur une autre table, les triggers associés à cette
table sont alors déclenchés.
C’est ce que l’on qualifie de cascade.
Le nombre de niveaux cascadés est fonction du SGBD (16 en SQL Server).
Exemple.
« Dans la base de données Avions; on décide qu’à la suppression d’un avion, on vérifiera s’il
existe d’autres avions du même modèle. S’il s’agit du dernier avion de ce modèle dans la base,
on détruira le modèle en question de la table des modèle.
Hors le fait de détruire un modèle entraîne la destruction par trigger des lignes
de qualification des pilotes pour ce modèle. (cf exemple 5) ».

travaux pratiques
On est en pleine cascade!!
Mise en oeuvre.
CREATE TRIGGER TD_AVION ON AVION FOR DELETE AS
BEGIN
declare @mod char(3)
IF(SELECT COUNT(*) FROM AVION, deleted

WHERE AVION.NUMMOD = DELETED.NUMMOD) = 0
BEGIN
SELECT @mod = (SELECT NUMMOD from deleted)
PRINT 'Déclencheur DELETE sur Avion. Plus aucun avion pour le
modèle'
PRINT @mod
DELETE MODELE WHERE NUMMOD = @mod
END
END

BEGIN

WHERE AVION.NUMMOD = deleted.NUMMOD) > 0
BEGIN
RETURN
END
ELSE
BEGIN
DELETE QUALIFICATION FROM QUALIFICATION,
DELETED
WHERE NUMMOD = DELETED.NUMMOD
PRINT 'Qualifications correspondant au modèle. Suppression
demandée.'
END
END
CREATE TRIGGER TD_QUALIFICATION ON QUALIFICATION FOR

DELETE AS
BEGIN

travaux pratiques
PRINT 'Déclencheur DELETE sur Qualif. Suppression effectuée.'

END
Suppression d’un trigger.

Utiliser la procédure SQL Server DROP TRIGGER
Syntaxe : DROP TRIGGER nom de trigger
Ou
Au travers l’interface graphique de SQL Server
Dans la fenêtre Objets,

Marquer le trigger à supprimer
Dans le menu Objets
Prendre l’option Supprimer un Objet...
Procédure de création d’un trigger grâce à l’interface graphique de SQL

Server.
Accès à la fenêtre de gestion des triggers.
Se fait à partir de la fenêtre Objets d’une base de données.

Prendre dans le menu Gestion l’option Déclencheurs....
Ou menu contextuel sur la table (bouton droit de la souris sur la table)
SQL Server affiche la fenêtre de gestion de triggers

Présentation de la fenêtre de gestion de triggers

travaux pratiques
Choisir le trigger à coder sur la table concernée
Coder le traitement du trigger à partir de la fenêtre de saisie que vous propose SQL
Server. Utilisation de l’éditeur.
Le fait de demander la création d’un déclencheur, SQL Server propose une trame de séquence
SQL pouvant être modifiée.
Exercices
sur la base de données GOELAND (voir dossier gestion d'une compagnie aérienne, étude de cas)
Triggers de création
Table vol
Vérifier que date de vol inférieure ou égale date d'arrivée et heure de départ
inférieur heure d'arrivée.
Table modèle
Vérifier poids à vide inférieur à poids maxi
Table Personnel
Vérifier la cohérence des dates
Date naissance inférieure date embauche inférieure ou égale date fin de contrat et date
décès non renseignée.
Triggers de mise à jour
Table personnel
- Interdire modification sur le sexe et date de naissance

travaux pratiques
- Vérifier la cohérence du code activité,

passages possibles de :
A à R et R à D, A à C et C à A, A à D, A à X.
Triggers de suppression
Table Réservation
- Ne pas supprimer une "résa" si le vol n'est pas effectué

travaux pratiques
XIV. Curseurs(CURSOR)
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 par exemple.
Syntaxe
DECLARE cursor_name CURSOR FOR select_statement
Arguments :
cursor_name
Nom du curseur de serveur Transact-SQL défini. L'argument cursor_name doit respecter les
conventions se rapportant aux identificateurs.
select_statement
Instruction SELECT standard qui définit le jeu de résultats du curseur. Les mots-clés
COMPUTE,COMPUTE BY, FOR BROWSE et INTO ne sont pas autorisés dans l'instruction SELECT
d'une déclaration de curseur.
Microsoft SQL Server convertit implicitement le curseur en un autre type si les clauses de l'instruction
SELECT sont incompatibles avec la fonctionnalité du type de curseur requis.
L'instruction DECLARE CURSOR définit les attributs d'un curseur de serveur Transact-SQL,
notamment s'il permet ou non le défilement, et la requête utilisée pour créer le jeu de résultats sur lequel
le curseur opère. L'instruction OPEN remplit le jeu de résultats tandis que l'instruction FETCH renvoie
une ligne à partir de ce jeu de résultats. L'instruction CLOSE libère le jeu de résultats actuel associé au
curseur. L'instruction DEALLOCATE libère les ressources utilisées par le curseur.
Les variables peuvent être utilisées dans l'argument select_statement qui déclare un curseur. Toutefois,
les modifications apportées à ces variables après la déclaration du curseur sont sans effet sur le
fonctionnement de celui-ci.
Autorisations
Les autorisations DECLARE CURSOR sont octroyées par défaut à tout utilisateur qui a des
autorisations SELECT sur les vues, les tables et les colonnes utilisées par le curseur.
Exemple
A. Utilisation d'un curseur et d'une syntaxe simples
Le jeu de résultats généré à l'ouverture du curseur ci-après contient toutes les lignes et toutes les
colonnes de la table authors de la base de données pubs. Ce curseur peut être mis à jour et toutes les
mises à jour et suppressions sont représentées par des extractions à partir de ce curseur. L'option
SCROLL n'ayant pas été spécifiée, seule l'extraction FETCH NEXT est disponible.
DECLARE authors_cursor CURSOR
FOR SELECT * FROM authors
OPEN authors_cursor
FETCH NEXT FROM authors_cursor

travaux pratiques
B. Utilisation de curseurs imbriqués pour la production d'un rapport
L'exemple suivant montre comment les curseurs peuvent être imbriqués pour produire des rapports
complexes. Le curseur interne est déclaré pour chaque auteur.
SET NOCOUNT ON
DECLARE @au_id varchar(11), @au_fname varchar(20), @au_lname varchar(40),

@message varchar(80), @title varchar(80)
PRINT "-------- Utah Authors report --------"
DECLARE authors_cursor CURSOR FOR

SELECT au_id, au_fname, au_lname
FROM authors
WHERE state = "UT"
ORDER BY au_id
OPEN authors_cursor

INTO @au_id, @au_fname, @au_lname
WHILE @@FETCH_STATUS = 0
BEGIN
PRINT " "
SELECT @message = "----- Books by Author: " +
@au_fname + " " + @au_lname
PRINT @message
-- Declare an inner cursor based

-- on au_id from the outer cursor.
DECLARE titles_cursor CURSOR FOR

SELECT t.title
FROM titleauthor ta, titles t
WHERE ta.title_id = t.title_id AND
ta.au_id = @au_id -- Variable value from the outer cursor
OPEN titles_cursor
FETCH NEXT FROM titles_cursor INTO @title
IF @@FETCH_STATUS <> 0
PRINT " <<No Books>>"
BEGIN
SELECT @message = " " + @title

PRINT @message
FETCH NEXT FROM titles_cursor INTO @title
END
CLOSE titles_cursor
DEALLOCATE titles_cursor
-- Get the next author.


travaux pratiques
INTO @au_id, @au_fname, @au_lname

END
CLOSE authors_cursor
DEALLOCATE authors_cursor
GO
-------- Utah Authors report --------
----- Books by Author: Anne Ringer

The Gourmet Microwave
Is Anger the Enemy?
----- Books by Author: Albert Ringer

Is Anger the Enemy?
Life Without Fear
La fonction @@FETCH_STATUS établit un rapport d'état de la dernière instruction FETCH. Les

mêmes informations sont enregistrées dans la colonne fetch_status du curseur renvoyé par
sp_describe_cursor. Ces informations d'état doivent être utilisées pour déterminer la validité des
données renvoyées par une instruction FETCH avant de tenter toute opération sur ces données .
Autorisations
Les autorisations FETCH reviennent par défaut à tous les utilisateurs valides.
exemple
A. Utilisation de FETCH dans un curseur simple
Cet exemple déclare un simple curseur pour les lignes de la table authors dont le nom commence par
B, et il utilise FETCH NEXT pour parcourir les lignes. L'instruction FETCH renvoie la valeur de la
colonne spécifiée dans DECLARE CURSOR comme un jeu de résultats sur une seule ligne.
USE pubs
GO
SELECT au_lname FROM authors
WHERE au_lname LIKE "B%"
ORDER BY au_lname
OPEN authors_cursor
-- Perform the first fetch.

-- Check @@FETCH_STATUS to see if there are any more rows to fetch.

BEGIN
-- This is executed as long as the previous fetch succeeds.
END
GO
au_lname

travaux pratiques
----------------------------------------
Bennet
au_lname
----------------------------------------
Blotchet-Halls
au_lname
----------------------------------------
B. Utilisation de FETCH pour stocker des valeurs dans des variables
Cet exemple ressemble au précédent, excepté que le résultat des instructions FETCH est stocké dans
des variables locales plutôt que d'être directement renvoyé au client. L'instruction PRINT combine les
variables dans une chaîne unique et les renvoie au client.
USE pubs
GO
-- Declare the variables to store the values returned by FETCH.

DECLARE @au_lname varchar(40), @au_fname varchar(20)

SELECT au_lname, au_fname FROM authors
WHERE au_lname LIKE "B%"
ORDER BY au_lname, au_fname
OPEN authors_cursor
-- Perform the first fetch and store the values in variables.

-- Note: The variables are in the same order as the columns
-- in the SELECT statement.

INTO @au_lname, @au_fname
-- Check @@FETCH_STATUS to see if there are any more rows to fetch.

BEGIN
-- Concatenate and display the current values in the variables.

PRINT "Author: " + @au_fname + " " + @au_lname
-- This is executed as long as the previous fetch succeeds.

INTO @au_lname, @au_fname
END
GO
Author: Abraham Bennet

Author: Reginald Blotchet-Halls

travaux pratiques
Guide de travaux pratique

travaux pratiques
I. TP1
Ce présent TP est composé de plusieurs exercices à réaliser sur machine. l’objectif de ce TP
vise à ce que le stagiaire soit capable à la fois d’écrire et d’analyser un code T-
SQL. Les exercices doivent être réaliser avec l’outil « analyseur de requêtes ».
Exercice 1
Écrire un programme T-SQL qui permet de résoudre l’équation de deuxième degré.

ax2bxc0
Éléments de réponse :
Pour résoudre cette équation, il est clair qu’on aura besoin de déclarer un ensemble de
variables, après il faut utiliser des structures alternatives imbriquées.
Declare @var type
A ne pas oublier : le caractère @ est obligatoire dans la déclaration des variables locales.
Structure alternative:
If (condition)
…
Else
If(condition)
…
Else
…
Le stagiaire est appelé à énumérer les six cas possible :

Si a=0 alors
L’équation devient de premier degré et dans ce cas il y a trois cas selon a et b.
Sinon
Il faut étudier les trois cas selon delta
NB :delta=b²-4ac
Exercice 2
Écrire un programme T-SQL qui calcule :

n
S=  i1!
i 0
n m xi
P=  j!
i  0 j 0
A ne pas oublier : Il existe que deux structure itérative en T-SQL qui sont

travaux pratiques
While (condition)
et
étiquette :
if(condition) goto étiquette
II. TP2
Ce présent TP est composé d’un exercice à réaliser sur machine. l’objectif de ce TP vise à
ce que le stagiaire soit capable à la fois d’analyser un problème et de le traduire
dans T-SQL. L’exercice doit être réaliser avec l’outil « analyseur de requêtes ».
Exercice 1
Écrire un programme qui permet d’afficher le jour qui corresponds à une date donnée.
Exemple :
30/03/1978 correspond au Jeudi
NB : cette fonction existe en T-SQL, elle a comme nom DateName
Ex : select Datename(w,'30/03/1978') --affiche Jeudi
éléments de réponse :
d’abord il faut connaître, combien de jours est composé une année? (il faut étudier le cas
d’une année bissextile?)
Après il faut ajouter le nombre de jours des mois écoulés à partir du mois 12 (par exemple)
Enfin il faut ajouter à tout cela le nombre de jours écoulé pour le mois en cours.
Calculer le modulo 7 de ce nombre, et puis selon le jour pris en référence, il faut déduire
résultat?
Exercice 2
Écrire un programme qui permet de trier une table

stagaire(num_insc,nom,prenom,age,moyenne) par moyenne, puis par age sans utiliser l’ordre
order by moyenne,age?
NB : dans cet exercice seul l’ordre select * from stagiaire est autorisé
Éléments de réponse :
dans cet exercice le stagiaire est appelé à analyser le problème puis de concrétiser ses idées
sous formes de script T-SQL.
Il y a deux solutions au moins que le stagiaire peut envisager?
PREMIERE SOLUTION : créer une table temporaire ou on va stocker à chaque fois le Max
des éléments qui restent de la table stagiaires, puis on affiche le tout à partir de cette table
temporaire.

travaux pratiques
Deuxième solution : utiliser un curseur (méthode facile et gourmande en terme d’espace

mémoire)
III. TP 3
ce que le stagiaire soit capable à la fois d’analyser un problème et de progrmmer
des procédures stockées. L’exercice doit être réaliser avec l’outil « analyseur de
requêtes ».
Soit le MCD suivant d’une gestion de coupe mondiale 1986.

travaux pratiques
Questions :
1) Ecrire des procédures stockées qui permettent de :
 Afficher les différents pays qui ont participé à la coupe mondiale ?

 Afficher la liste des arbitres ?
 Afficher les noms des stades qui ont pu accueillir plus de N spectateurs ?
 Afficher pour chaque match le nombre de places vacantes dans le stade ?
 Afficher tout les noms des joueurs marocains qui ont participé à la coupe
mondiale ?
 Afficher les noms ordonnés des arbitres des matchs joués par une équipe
donnée ?
 Afficher les noms des joueurs qui ont marqué au moins N buts d’un type
donné?
 afficher pour une équipe donnée le nombre de buts marqués ?
 afficher le nom du joueur marocain qui a marqué le maximum des buts ?
 Ajouter à tout joueur marocain deux buts ?
A ne pas oublier :
Syntaxe :
CREATE PROC nom_de_procédure @p type [output],@p2 type
[output ], … AS ordre_SQL

travaux pratiques
IV. TP 4
ce que le stagiaire soit capable à la fois d’analyser un problème et de programmer
des triggers. L’exercice doit être réaliser avec l’outil « analyseur de requêtes ».
Soit le MCD (vu précédemment) suivant d’une gestion de coupe mondiale 1986.

travaux pratiques
Questions :
1) écrire des triggers qui permettent de :
- Lors de l’ajour d’une personne, on met son nom en majuscule ainsi que le premier
caractère de son prénom
- Lors de l’ajout d’un match on vérifie si le nombre de spectateurs est inférieur ou
égale au nombre de places disponibles dans le stade ? si oui on l’ajoute sinon on
affiche un message d’erreur?
- Lors de l’insertion d’un but on vérifie si la minute est positive ?
- Lors de la suppression d’un joueur on supprime aussi les buts qu’il a marqué ?
- Interdire de modifier la date d’un match ?
- Lors de la suppression d’une équipe on supprime les joueurs ?
- Lors de la suppression d’une équipe on supprime les joueurs et leurs buts?
- Lors de l’ajout d’une équipe si on essaye d’insérer dans le champs nationalité
« Fr » alors on la modifie en France
« Mr » « Maroc »
« br » « Brésil»
« esp » « Espagne »
A ne pas oublier :
syntaxe
CREATE PROC [ EDURE ] procedure_name [ ; number ]

[ { @parameter data_type }
[ VARYING ] [ = default ] [ OUTPUT ]
] [ ,...n ]
[ WITH
{ RECOMPILE | ENCRYPTION | RECOMPILE , ENCRYPTION } ]
[ FOR REPLICATION ]
AS sql_statement [ ...n ]

travaux pratiques
Liste des références bibliographiques.
Ouvrage Auteur Edition

CD Livré aux formateur DRIF 2006
www.developper.com Mis à jour 2007
HELP SQLSERVER @Microsoft 2000
www.google.com

M13 Preparation PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

M13 Preparation PDF

Transféré par

Droits d'auteur :

Formats disponibles

ROYAUME DU MAROC

OFPPT Office de la Formation Professionnelle et de la Promotion du

TITRE DU MODULE : Programmation des procédures

Niveau : TECHNICIEN SPECIALISE

Document élaboré par :

Nom et prénom EFP DR

OFPPT / DRIF / Page : 2 juillet 2007

OFPPT / DRIF / Page : 3 juillet 2007

MODULE 12 : Programmation des procédures stockées et des

Code : Théorie :40h

OBJECTIFS OPERATIONNELS DE PREMIER NIVEAU

Pour démontrer sa compétence, le stagiaire doit Programmer des procédures

CRITERES GENERAUX DE PERFORMANCE

OFPPT / DRIF / Page : 4 juillet 2007

OBJECTIF OPERATIONNEL DE PREMIER NIVEAU

 Programmation correcte des

B. Programmer des déclencheurs (Triggers)  Identification judicieuse des

C. Tester la procédure ou le trigger  Justesse d’élaboration d’un jeu

OFPPT / DRIF / Page : 5 juillet 2007

OBJECTIFS OPERATIONNELS DE SECOND NIVEAU

LE STAGIARE DOIT MAITRISER LES SAVOIR, SAVOIR-FAIRE, SAVOIR-PERCEVOIR OU

Avant d’apprendre à Programmer des procédures stockées sur le SGBD (A) et

1. Sensibiliser le stagiaire à l’utilité de programmer des procédures stockés et des

OFPPT / DRIF / Page : 6 juillet 2007

OFPPT / DRIF / Page : 7 juillet 2007

Ce cours apporte une expérience approfondie de la création de procédures stockées et de triggers, il

Transact-SQL est généré à partir de différents types d'applications :

 les applications de productivité bureautique générales

 les applications qui utilisent une interface utilisateur graphique (GUI)

-1970 : IBM développe SQL

-1992 : Normalisation de ANSI SQL-92

-1996 :Microsoft adopte Transact-SQL

II. Déclaration des variables locales

OFPPT / DRIF / Page : 8 juillet 2007

Declare @nom_variable type

Le caractère @ est obligatoire

Exemple : Declare @maVariable int

Declare @var1 type1, @var2 type2

Exemple :Declare @x int, @y int, @z char

NB : Declare @x ,@y int est incorrecte

Select @variable=Valeur où set @variable=valeur

III. Affichage des valeurs

OFPPT / DRIF / Page : 9 juillet 2007

Exemple de variable de type table :

insert into @stg values(103,'LAAROUSSI','SALAH',14)

insert into @stg values(107,'AADISSA','Youness',14.5)

insert into @stg values(200,'SOQRAT','Sanaa',12.5)

select * from @stg

Les variables globales

@@error :indique le type d’erreur survenu lors de la derniere instruction.

@@rowcount : indique le nombre de lignes affectées par la derniere instruction.

OFPPT / DRIF / Page : 10 juillet 2007

Un bloc d’instruction peut contenir d’autres sous blocs.

Pour declarer un bloc d’instructions en t-SQL en utilise :

declare @i int,@j int

select @i as 'i', @j as 'j'

-instruction ou bloc d’instruction

-instruction ou bloc d’instruction

OFPPT / DRIF / Page : 11 juillet 2007

la partie « else » est optionnelle.

Il est possible d’imbriquer des if.

insert into @stg values(103,'LAAROUSSI','SALAH',14)

If not exits(select * from @stg )