Principes de base de données

420-2DB-HY

Notes de cours
La vue
Le langage SQL procédural
Les transactions
La procédure stockée

Enseignant
Giovana Velarde

Hiver 2023
CÉGEP DE SAINT-HYACINTHE

Table des matières

LA VUE ...........................................................................................................................................................3
CRÉER UNE VUE............................................................................................................................................3
MODIFIER UNE VUE .......................................................................................................................................4
SUPPRIMER UNE VUE.....................................................................................................................................5
UTILISATION D’UNE VUE .................................................................................................................................5
MODIFIER LES DONNÉES PAR L'INTERMÉDIAIRE D'UNE VUE ...............................................................................5
Option WITH CHECK OPTION ..............................................................................................................6
LE LANGAGE SQL PROCÉDURAL : TRANSACT-SQL .............................................................................8
LES VARIABLES .............................................................................................................................................8
Les variables utilisateur ou variables locales .........................................................................................8
Les variables système ou variables globales .........................................................................................9
LES INSTRUCTIONS..................................................................................................................................... 10
USE...................................................................................................................................................... 10
PRINT .................................................................................................................................................. 10
La structure de condition IF…ELSE .................................................................................................... 11
BEGIN … END .................................................................................................................................... 11
La boucle WHILE ................................................................................................................................. 12
EXECUTE ou EXEC ............................................................................................................................ 12
GO ....................................................................................................................................................... 12
RETURN .............................................................................................................................................. 13
LOT (BATCH) .............................................................................................................................................. 13
Script .................................................................................................................................................... 13
TABLE TEMPORAIRE ................................................................................................................................... 14
LES TRANSACTIONS ................................................................................................................................ 15
LA PROCÉDURE STOCKÉE ..................................................................................................................... 18
CRÉER OU MODIFIER UNE PROCÉDURE STOCKÉE ......................................................................................... 18
SUPPRIMER UNE PROCÉDURE STOCKÉE ...................................................................................................... 21

420-2DB-HY Principes de base de données Page 2 sur 22

CÉGEP DE SAINT-HYACINTHE La vue

La vue
Une vue est une table virtuelle dont le contenu est défini par une requête. Les lignes et les
colonnes de données proviennent de tables référencées dans la requête qui définit la vue et
sont produites dynamiquement lorsque la vue est référencée1.
Une vue apparaît à l'utilisateur comme une table réelle, cependant les lignes d'une vue ne sont
pas stockées dans la BD2. Les tables référencées par une vue sont appelées « tables de
base », « tables sous-jacentes » ou « tables référencées ». La requête qui définit la vue peut
faire aussi référence à d'autres vues.

Créer une vue

Utilisez l’instruction CREATE VIEW pour créer une vue.
Syntaxe :

CREATE VIEW nom_vue [ ( nom_colonne [ ,...n ] ) ]

AS <instruction_select>
[ WITH CHECK OPTION ]

Paramètres :
nom_vue Nom de la vue.
nom_colonne Nom à utiliser pour une colonne dans une vue. (Facultatif)
instruction_select Instruction SELECT qui définit la vue. Elle peut utiliser plusieurs
tables et d'autres vues.
WITH CHECK OPTION Cette option permet d’implanter une contrainte d'intégrité lors des
mises à jour au travers de la vue. Oblige toutes les instructions de
modification de données exécutées sur la vue à respecter les
conditions exprimées dans instruction_select.
Notes :
• Les noms de colonnes doivent être uniques.
• Si vous ne spécifiez pas le paramètre nom_colonne, les colonnes de la vue prennent les
mêmes noms que les colonnes de l’instruction SELECT.
• Une colonne qui est dérivée d'une expression arithmétique, d'une fonction ou d'une
constante doit avoir soit un alias assigné dans la clause SELECT, soit un nom de colonne
dans la déclaration de la vue.
• L’instruction SELECT ne peut pas inclure les clauses suivantes :
o Une clause ORDER BY, sauf si une clause TOP figure également dans la liste de sélection
de l'instruction SELECT.
o Le mot clé INTO.

1
https://docs.microsoft.com/fr-fr/sql/relational-databases/views/views?view=sql-server-ver15
2
Sauf pour une vue indexée.

420-2DB-HY Principes de base de données Page 3 sur 22

CÉGEP DE SAINT-HYACINTHE La vue

Exemple :

CREATE VIEW vue_employés_anniversaires

AS
SELECT prénom, nom, DAY(date_naissance) AS jour_naissances,
MONTH(date_naissance) AS mois_naissance
FROM employé;

Cet exemple montre une vue se reportant à trois tables.

CREATE VIEW vue_employés_boucherville

AS
SELECT E.nom, E.prénom, E.emploi,
A.ville, Prov.code
FROM employé AS E
INNER JOIN adresse AS A
ON A.no_adresse = E.no_adresse
INNER JOIN province AS Prov
ON Prov.no_province = A.no_province
WHERE A.ville = 'Boucherville';

Exemple : la définition de la vue suivante inclut la fonction d’agrégation COUNT. Si vous utilisez
des fonctions, vous devez attribuer un nom à la colonne dérivée.

CREATE VIEW vue_ventes_par_vendeur2020

AS
SELECT no_vendeur, COUNT(*) AS nb_factures
FROM facture
WHERE date > CONVERT(DATETIME,'20191231',101)
GROUP BY no_vendeur;

Modifier une vue

Pour modifier une vue utilisez l’instruction ALTER VIEW. (La syntaxe est similaire que celle de la
création d’une vue).

Syntaxe :

ALTER VIEW nom_vue [ ( colonne [ ,...n ] ) ]

AS <instruction_select>

Exemple :

ALTER VIEW vue_employé_date_embauche

AS
SELECT prénom, nom, no_employé, date_embauche
FROM employé
WHERE date_embauche < CONVERT(DATETIME,'20150101',101);

420-2DB-HY Principes de base de données Page 4 sur 22

CÉGEP DE SAINT-HYACINTHE La vue

Supprimer une vue

Pour supprimer une vue utilisez l’instruction DROP VIEW

Syntaxe :

DROP VIEW [ IF EXISTS ] { nom_vue }

Exemple :

DROP VIEW vue_employé_date_embauche;

Utilisation d’une vue

Une vue peut être référencée dans une instruction SELECT simple de la même façon que pour
une seule table. Ainsi, elle permet de simplifier la consultation de la base en enregistrant des
SELECT complexes.

Exemple : Il est possible de consulter la vue Employe10 avec une instruction SELECT comme
s'il existait une table Employe10 des employés du département 10.

CREATE VIEW vue_employés_département10

AS
SELECT * FROM employé
WHERE no_départementId = 10

SELECT *
FROM vue_employés_département10

Modifier les données par l'intermédiaire d'une vue

Les données des tables sous-jacentes peuvent être modifiées au travers d’une vue, mais cela
n’est pas toujours possible. Les conditions suivantes sont à respecter :
• Toute modification, y compris celles via les instructions UPDATE, INSERT et DELETE, doivent
faire référence aux colonnes d'une seule et même table sous-jacente.
• Les colonnes à modifier doivent être de colonnes réelles de la table sous-jacente. C’est-à-
dire que les colonnes ne peuvent être dérivées de :
o Une fonction d’agrégation : AVG, COUNT, SUM, MIN, MAX.
o Un calcul ou une expression.
o Les colonnes formées par le biais des opérateurs ensemblistes UNION, EXCEPT et
INTERSECT.
• Les colonnes à modifier ne doivent pas être affectées par l'utilisation des clauses GROUP BY,
HAVING ou DISTINCT.
Il est possible de modifier les salaires des employés du département 10 à travers la vue
Employe10 (de l’exemple précédent) Toutes les lignes de la table Employe avec code 10
(departementId = 10) seront modifiées :

UPDATE vue_employés_département10
SET salaire = salaire * 1.1;

420-2DB-HY Principes de base de données Page 5 sur 22

CÉGEP DE SAINT-HYACINTHE La vue

La vue suivante retourne des valeurs de deux tables (catégorie et produit)

CREATE VIEW vue_catégories_produits(NomCatégorie, ProdID, ProdNom)

AS
SELECT catégorie.nom_catégorie,
produit.no_produit, produit.nom_produit
FROM produit INNER JOIN catégorie
ON produit.no_catégorie = catégorie.no_catégorie

La modification suivante réussit car les colonnes qui sont modifiées proviennent uniquement
d'une des tables de base (produit)

UPDATE vue_catégories_produits
SET nom_produit = 'Chai'
WHERE no_produit = 1;

La modification suivante réussit aussi car les colonnes qui sont modifiées proviennent
uniquement d'une des tables de base (catégorie)

UPDATE vue_catégories_produits
SET nom_catégorie = 'Jus'
WHERE no_produit = 1;

Cependant, la modification suivante ne réussit pas car les colonnes qui sont modifiées
proviennent de deux tables de base (catégorie et produit)

UPDATE vue_catégories_produits
SET nom_produit = 'Chai', nom_catégorie = 'Jus'
WHERE no_produit = 1; -- erreur

Option WITH CHECK OPTION

Avec l’option WITH CHECK OPTION, il n’est pas possible d’ajouter ou modifier, par l'intermédiaire
de la vue, des lignes de la table sous-jacente que la vue ne pourrait relire. C’est-à-dire que la
vue vérifie que les données resteront visibles après la saisie.

Par exemple : L’option WITH CHECK OPTION est ajoutée à la vue

vue_employé_département10.

ALTER VIEW vue_employé_département10

AS
SELECT *
FROM employé
WHERE no_département = 10
WITH CHECK OPTION

Le code suivant remplace la valeur de la colonne téléphone dans la table employé d’une
employée spécifique (Marie Leblanc) par l'intermédiaire de la vue
vue_employé_département10.

420-2DB-HY Principes de base de données Page 6 sur 22

CÉGEP DE SAINT-HYACINTHE La vue

UPDATE vue_employé_département10
SET téléphone = '4387752356'
WHERE nom_employé = 'Leblanc' AND prénom_employé = 'Marie';

Le code suivant donne erreur car la vue affiche seulement les employés du département 20.

UPDATE vue_employé_département10
SET no_département = 20
WHERE nom_employé = 'Leblanc' AND prénom_employé = 'Marie'; -- erreur

INSERT INTO vue_employé_département10

(nom_employé, prénom_employé, téléphone, no_département)
VALUES('Leblanc','Marie','4387432890',20); -- erreur

420-2DB-HY Principes de base de données Page 7 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

Le langage SQL procédural : Transact-SQL

Transact-SQL (T-SQL) est un langage procédural offert par SQL Server comme une extension
au langage déclaratif SQL. Il a été créé par Sybase inc. à la fin des années 80 pour répondre
aux besoins d'extension de la programmation des bases de données.
T-SQL permet de programmer des algorithmes de traitement des données en utilisant des
déclarations de variables, des structures de contrôle (alternatives et répétitives) pour permettre
d’implémenter des fonctionnalités que SQL seul ne peut implémenter.
Par rapport au SQL, le T-SQL ajoute les fonctionnalités suivantes :
• La possibilité de créer et d'utiliser des variables locales
• Éléments de programmation procédurale (boucle, conditions...)
• Des fonctions de manipulations de chaîne de caractères, de dates et de calculs
mathématiques

Les variables
Une variable est une zone mémoire caractérisée par un type et un nom, et permettant de
stocker une valeur respectant le type.

Les variables utilisateur ou variables locales

Syntaxe :

DECLARE { @nom_variable[AS] type_donnee [ = valeur ] }

Paramètres :
nom_variable Nom de la variable.
Type donnée Valeur assignée à la variable.
valeur Instruction SELECT qui définit la vue. Elle peut utiliser plusieurs
tables et d'autres vues.
Notes :
• Le nom d’une variable locale est précédé du symbole @.
• Une variable utilisateur doit être obligatoirement déclarée avant d’être utilisée.
• Après la déclaration, toutes les variables sont initialisées avec la valeur nulle à moins qu'une
valeur ne soit fournie dans le cadre de la déclaration.
• La notion de constante n'existe pas dans Transact-SQL
Exemples :

DECLARE @IdClient INT;

DECLARE @NomClient VARCHAR(50);

DECLARE @Prix DECIMAL;

420-2DB-HY Principes de base de données Page 8 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

Une variable peut être affectée avec une valeur au moment de sa déclaration ou en utilisant
l’instruction SET ou SELECT. Une sous-requête assignant une valeur à une variable locale ne
doit retourner qu'une seule valeur.

Exemples :

DECLARE @Id INT = 0

SET @Id = 0

DECLARE @CoursID AS INT,

@NomCours AS VARCHAR(5)
SET @CoursID = 5
SET @NomCours = 'python'

DECLARE @CoursID INT

SELECT @CoursID = 5

L’instruction SELECT permet d’assigner une valeur à plusieurs variables séparées par comma.

DECLARE @CoursID AS INT,

@NomCours AS VARCHAR(5)

SELECT @CoursID = 5, @NomCours = 'python'

L’instruction suivante permet de valoriser une variable via l’exécution d’une requête SELECT
scalaire. Si la requête ne renvoie aucune ligne, la valeur assignée à la variable est NULL

SELECT @Id = no_client

FROM client
WHERE no_Client = 'CL00005';

SELECT @NombreClients = COUNT(*)

FROM client;

SET @Id = (SELECT no_client FROM client WHERE no_client = 'CL00005');

SELECT @Id =(SELECT no_client FROM client WHERE no_client='CL00005');

Il est possible d’utiliser une variable dans un requête

DECLARE @CoursID INT = 1

SELECT * from cours WHERE no_cours = @CoursID;

Les variables système ou variables globales

• Les noms de variables globales sont précédés de deux symboles @@.
• Elles sont définies par le système.
• Elles ne sont disponibles qu’en lecture.

420-2DB-HY Principes de base de données Page 9 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

L’exemples le plus courants sont 3:

• La variable @@ERROR, qui est à zéro en temps normal, et à 1 lorsqu’une erreur est levée.
• La variable @@ROWCOUNT : numéro de lignes affectées par la dernière requête.
• La variable @@LANGUAGE : Langue de la base de données.

Exemples :

SELECT @@LANGUAGE AS nom_langue;

IF @@ERROR <> 0
PRINT 'Erreur';

IF @@ROWCOUNT = 0
PRINT 'Aucune ligne a été modifiée';

Les instructions
Le langage de contrôle de flux T-SQL utilise des instructions qui permettent de rendre les
données plus présentables ou de les manipuler avec plus de facilité. Par exemple, pour des
actions répétitives ou des actions nécessitant une condition.

USE
L’instruction USE permet de préciser le nom de la base de données cible.
Exemple :

USE AdventureWorks2017;

PRINT
L’instruction PRINT permet l’affichage des messages.
L’exemple suivant personnalise la sortie d’une requête.

3
https://www.codeproject.com/Articles/39131/Global-Variables-in-SQL-Server

420-2DB-HY Principes de base de données Page 10 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

DECLARE @Variable INT;

SELECT @Variable = COUNT(*)

FROM client;

PRINT 'La quantité de clients est : ';

PRINT @Variable;

La structure de condition IF…ELSE

La structure de condition IF permet des exécutions conditionnelles. Si la condition est vraie,
l’instruction sera exécutée. Dans le cas contraire, l’instruction correspondante à la section ELSE
sera exécutée.

Exemple :

DECLARE @Variable INT = 1

IF EXISTS (SELECT * FROM client WHERE no_client = @Variable)

DELETE FROM client
WHERE no_client = @Variable
ELSE
PRINT 'Pas de Client pour cet Id !'

IF DATEPART(DW, GETDATE()) = 6 OR DATEPART(DW, GETDATE()) = 7

PRINT 'Nous sommes en week-end.'
ELSE
PRINT 'Nous sommes en semaine.'

BEGIN … END
Délimite une série ou bloc d’instructions pour permettre l'exécution groupée. Si plus d'une
instruction est nécessaire dans un bloc conditionnel, il faut utiliser BEGIN et END.

Exemple :

IF DATEPART(WEEKDAY,GETDATE()) = 6
OR DATEPART(WEEKDAY,GETDATE()) = 7
BEGIN
PRINT 'Nous sommes en week-end.'
PRINT 'Faites une pause !'
END
ELSE
BEGIN
PRINT 'Nous sommes en semaine.'
PRINT 'Vite, au boulot !'
END

420-2DB-HY Principes de base de données Page 11 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

La boucle WHILE
L’instruction WHILE permet d’exécuter un bloc d’instructions de manière répétitive, en fonction
d’une condition. Tant que la condition est vraie, ce bloc d’instructions sera exécuté.
À l’intérieur du bloc d’instructions d’une boucle WHILE il est possible d’utiliser l’instruction BREAK
qui permet de sortir de la boucle en interrompant son exécution, et l’instruction CONTINUE qui
permet de relancer immédiatement l’exécution du bloc d’instruction.

Dans l’exemple suivant la colonne ContactID est utilisée dans la boucle pour afficher la liste
de contacts enregistrés dans la table Fournisseurs.

DECLARE @iMax INT

DECLARE @i INT
DECLARE @Contact VARCHAR(100)
DECLARE @Cie VARCHAR(50)

SELECT @iMax = COUNT(*)

FROM fournisseur

SET @i = 1

WHILE (@i <= @iMax)

BEGIN
SELECT @Contact = nom_contact, @Cie = nom_companie
FROM fournisseur
WHERE no_contact = @i

PRINT CONVERT(VARCHAR,@i)+'Contact:' + @Contact + ' à ' + @Cie

SET @i = @i + 1
END

EXECUTE ou EXEC
Cette instruction permet de lancer une requête, une procédure stockée ou un déclencheur.

L’exemple suivant lance l’exécution de la requête SELECT assemblée dans la variable @SQL.

DECLARE @Mot VARCHAR(20), -- mot recherché

DECLARE @SQL VARCHAR(1000) -- requête de recherche

SET @Mot = 'jouet'

SET @SQL = 'SELECT * FROM produit WHERE LOWER(nom_produit) LIKE ''%'
+ @Mot +'%'''

EXEC (@SQL)

GO
Le mot clé GO permet de forcer l'exécution d’un ordre ou une suite d'ordres SQL ou T-SQL. Il
demande au serveur l'exécution immédiate de cet ordre ou de l'ensemble d'ordres.

420-2DB-HY Principes de base de données Page 12 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

Exemple :

USE MaBaseDeDonnees
GO

CREATE TABLE client

(no_client INTEGER IDENTITY NOT NULL PRIMARY KEY,
nom_client VARCHAR(250));
GO

RETURN
Cette instruction vous permet de sortir d’un bloc d’instructions (transaction, procédure stockée,
déclencheur) en retournant une valeur.

L'exemple suivant renvoie la valeur 1 lorsqu'un ouvrage dispose d'un contrat correct et la valeur
2 dans tous les autres cas.

DECLARE @titreId VARCHAR(6) = '000120'

IF (SELECT COUNT(*)
FROM titre
WHERE no_titre = @titreId ) > 1
RETURN 1
ELSE
RETURN 2

Lot (batch)
Un lot est une suite d'ordres SQL ou T-SQL qui seront exécutées en un seul et unique bloc. Un
lot se termine par l’instruction GO4. Un lot est exécuté en tout ou rien. Ainsi, une simple erreur de
syntaxe, même sur le dernier ordre du lot, fera que tout le lot ne s’exécutera pas.

Script
Un script est un ensemble de lots, qui peut être enregistré dans un fichier dont l’extension est
« .sql ». Par exemple, un fichier « script.sql » qui contient la définition physique de la base de
données : des tables, certaines entrées de données et certains objets de la base tels que les
contraintes, les vues, les procédures stockées ou les déclencheurs.
Note : Certains ordres ne peuvent pas être passés simultanément dans le même lot. Par
exemple la suppression d'un objet (DROP) et sa recréation immédiatement après, (CREATE) est
source de conflits.

4
GO n’est pas une instruction T-SQL, mais une commande reconnue par les utilitaires sqlcmd et osql, ainsi que l’éditeur de code
SQL Server Management Studio. https://docs.microsoft.com/fr-fr/sql/t-sql/language-elements/sql-server-utilities-statements-
go?view=sql-server-ver15

420-2DB-HY Principes de base de données Page 13 sur 22

CÉGEP DE SAINT-HYACINTHE Le langage procédural T-SQL

Table temporaire
La table temporaire est une table ayant une durée de vie très limitée. Elle est destinée à fournir
un espace de travail pour les résultats intermédiaires lors du traitement de données. Cette table
est visible uniquement à la connexion courante de l'utilisateur et est supprimée dès que
l'utilisateur se déconnecte de l'instance de SQL Server. Pour créer, modifier et supprimer une
table temporaire, on utilise les mêmes commandes que pour les tables normales. Le premier
caractère du nom des tables temporaires locales est un signe dièse « # ».

Exemple :

SELECT GETDATE() AS date_saisie INTO #tempTable;

SELECT * FROM #tempTable;

420-2DB-HY Principes de base de données Page 14 sur 22

CÉGEP DE SAINT-HYACINTHE Les transactions

Les transactions
Une transaction est une unité logique et atomique de traitement qui contienne un ensemble de
modifications de la base de données permettant de faire passer la BD d'un état cohérent à un
autre état cohérent. Cette unité est indivisible car elle est soit complètement exécutée, ou soit
complètement abandonnée. En effet, si une transaction ne va pas à son terme pour une raison
ou pour une autre, la base de données est restaurée dans l'état où elle se trouvait avant que la
transaction ne démarre.
Par exemple, une transaction peut transférer une somme d'argent entre deux comptes d'un
client d'une banque. Elle comporte deux ordres : d’abord un débit sur un compte et puis un
crédit sur un autre compte. Si un problème empêche le crédit, le débit doit être annulé. Le
pseudocode suivant process le transfert bancaire d’une somme d’argent S d’un compte C1 vers
un compte C2.

(1) début-transaction
(2) lire C1
(3) C1 := C1 - S
(4) écrire C1
(5) lire C2
(6) C2 := C2 + S
(7) écrire C2
(8) fin-transaction

Cette transaction est constituée d’un ensemble d’actions élémentaires, mais elle doit être traitée
comme une seule opération. Autrement dit, le gestionnaire des transactions doit assurer que
toutes les actions de la transaction sont exécutées, ou bien que aucune ne l’est.

La syntaxe générique d’une transaction est la suivante :

BEGIN TRANSACTION nom_transaction -- Démarrage de la transaction

COMMIT TRANSACTION nom_transaction -- Validation de la transaction

ROLLBACK TRANSACTION nom_transaction -- Annulation de la transaction

Paramètres :
nom_transaction Nom de la variable.

Notes :
• Une transaction débute par les mots clés BEGIN TRANSACTION et termine par les mots clés
COMMIT TRANSACTION ou un ROLLBACK TRANSACTION.
• L’instruction COMMIT termine une transaction avec succès. Toutes les mises à jour de la
transaction sont validées et on dit que la transaction est validée. Tous ses effets sont alors
connus des autres transactions s'exécutant concurremment. En bref, l’opération COMMIT
détermine le point ou la base de données est de nouveau cohérente.

420-2DB-HY Principes de base de données Page 15 sur 22

CÉGEP DE SAINT-HYACINTHE Les transactions

• L’instruction ROLLBACK termine une transaction avec échec. Toutes les opérations sont
annulées et la base de données retourne dans l’état où elle était au moment de l’appel à
l’instruction BEGIN TRAN. On dit que la transaction est annulée. Aucune des opérations
effectuées par cette transaction n'est connue des autres transactions.

Dans l’exemple suivant, le nom du client avec code ‘CL00013’ sera changé par ‘Michel‘ du fait
du COMMIT TRANSACTION qui valide la transaction.

BEGIN TRANSACTION TransactionClient1

UPDATE client
SET nom_client = 'Michel'
WHERE no_client = 'CL00013'

COMMIT TRANSACTION TransactionClient1

Dans l’exemple suivant, le nom du client avec code ‘CL00012’ ne sera pas changé par ‘André’
car la transaction se termine par un ROLLBACK TRANSACTION.

BEGIN TRANSACTION TransactionClient2

UPDATE client
SET nom_client = 'André'
WHERE no_client = 'CL00012'

ROLLBACK TRANSACTION TransactionClient2

Dans la transaction suivante, il y a un problème avec la deuxième instruction INSERT, la clé

primaire est dupliquée. Alors, les trois premières instructions du bloc sont annulées. La
validation de la transaction n’a pas lieu.

BEGIN TRANSACTION trans1;

INSERT INTO départements

VALUES('D005', 'Resources humaines');

UPDATE employé
SET no_département ='D005'
WHERE no_employé = 10;

UPDATE employé
SET salaire = 45000
WHERE no_employé = 10;

INSERT INTO départements

VALUES('D005', 'Resources humaines');

COMMIT TRANSACTION trans1;

420-2DB-HY Principes de base de données Page 16 sur 22

CÉGEP DE SAINT-HYACINTHE Les transactions

Dans l’exemple suivant, la transaction permet de réserver trois places dans le vol AF714 pour le
client C00123, s'il y a bien de la place pour ce vol.

BEGIN TRANSACTION

-- Reste-t-il de la place pour ce vol ?

IF NOT EXISTS(
SELECT * FROM vol
WHERE no_vol = 'AF714'
AND places_livres > 3)
BEGIN
ROLLBACK TRANSACTION
RETURN
END

-- Décompte des places vendues

UPDATE vol
SET places_livres = places_livres - 3
WHERE no_vol = 'AF714'

IF (@@ERROR <> 0) OR (@@ROWCOUNT = 0)

ROLLBACK TRANSACTION

-- Génération d'une réservation

INSERT INTO réservation (no_vol, no_client, places)
VALUES ('AF714', 'C00123', 3)

IF (@@ERROR <> 0) OR (@@ROWCOUNT = 0)

ROLLBACK TRANSACTION

-- Validation de l'ensemble
COMMIT TRANSACTION

420-2DB-HY Principes de base de données Page 17 sur 22

CÉGEP DE SAINT-HYACINTHE La procédure stockée

La procédure stockée
Une procédure stockée est un programme enregistré dans la base de données associant le
langage SQL (déclaratif) et langage de T-SQL (procédural).
Les procédures ressemblent à des constructions d'autres langages de programmation, car elles
peuvent :
• Accepter des paramètres d'entrée et retourner plusieurs valeurs sous la forme de
paramètres de sortie au programme appelant.
• Contenir des instructions de programmation qui effectuent des opérations dans la base de
données. Cela inclut l'appel d'autres procédures.
• Retourner une valeur d'état à un programme appelant pour indiquer une réussite ou un
échec.
Les procédures stockées offrent plusieurs avantages :
• Réduction du trafic sur le réseau : Les clients SQL ont seulement à envoyer l'identification de
la procédure et ses paramètres au serveur sur lequel elle est stockée.
• Optimisation de l’exécution : Les procédures sont précompilées une seule fois quand elles
sont enregistrées. Leurs exécutions ultérieures n'ont plus à passer par cette étape et sont
donc plus rapides.
• Fonctionnement en « boîte noire ». Les développeurs d’applications n'ont pas à connaître les
détails de l'exécution des procédures. L'écriture et l’entretien des applications sont donc
facilités.
• Réutilisation du code : la procédure stockée encapsule le code de toute opération répétitive.
Cela élimine les réécritures inutiles du même code et réduit les incohérences du code.

Créer ou modifier une procédure stockée

Utilisez l’instruction CREATE PROCEDURE ou ALTER PROCEDURE

Syntaxe :

CREATE [ OR ALTER ] PROCEDURE nom_procedure

[ { @parametre type_donnee } [ = defaut ] [ OUT ] [ ,...n ]
AS {
[ SET NOCOUNT ON ]
[ BEGIN ]
instructions_SQL[;] [ ...n ]
[ END ]
};

Paramètres :

nom_procedure Nom de la procédure.

@parametre Paramètre déclaré dans la procédure.

type_donnee Type de données du paramètre

420-2DB-HY Principes de base de données Page 18 sur 22

CÉGEP DE SAINT-HYACINTHE La procédure stockée

defaut Valeur par défaut pour un paramètre.

OUT ou OUTPUT Spécifie que le paramètre est en sortie

instructions_SQL Une ou plusieurs instructions Transact-SQL comprenant le corps de la

procédure.

Notes :
• Une procédure stockée peut retourner une valeur scalaire ou des lignes de table comme une
requête.
• Pour déclarer un paramètre, il faut précéder leur nom du symbole "@" et lui attribuer un type.
• L'instruction SET NOCOUNT ON placée comme première instruction dans le corps de la
procédure permet de désactiver les messages renvoyés par chaque instruction exécuté de
la procédure.
• Pour exécuter une procédure stockée utiliser l’instruction EXEC.
• Toute procédure stockée renvoie une variable de type entier pour signaler son état. Si cette
variable vaut zéro, la procédure s'est déroulée sans anomalie. Toute autre valeur indique un
problème. Les valeurs de 0 à -99 sont réservées et celles de 0 à -14 sont prédéfinies. Par
exemple la valeur -5 signifie « erreur de syntaxe ».

Exemples :

L'exemple suivant crée une procédure stockée qui retourne tous les employés (prénom et nom)
et leur nom du département à partir de la vue vue_employés.

CREATE PROCEDURE sp_employés

AS
SELECT prénom_employé, nom_employé, nom_département
FROM vue_employés
GO

L’exemple suivant cherche dans la table produit la qté des produits dont le nom contienne la
valeur du paramètre @mot.

CREATE PROCEDURE sp_recherche_produit

@mot VARCHAR(10) -- mot recherché
@qte INT = 0 OUTPUT -- qté incidences
AS
-- assemblage du texte de la requête de recherche
SET @SQL = 'SELECT COUNT(*) FROM produit WHERE nom_produit '
SET @SQL = @SQL + 'LIKE ''%' + @mot + '%'''

-- exécution de la requête de recherche

@qte = EXEC (@SQL)

Pour exécuter la procédure antérieure, le mot jouet et passé dans le paramètre @Mot et le
paramètre @qte est utilisé en sortie pour recevoir le résultat de la recherche.

DECLARE @qte INT

EXEC sp_recherche_produit, 'jouet', @qte OUTPUT;
PRINT @qte

420-2DB-HY Principes de base de données Page 19 sur 22

CÉGEP DE SAINT-HYACINTHE La procédure stockée

L’exemple suivant modifie la procédure stockée et ajoute l’instruction SET NOCOUNT ON pour
enlever les messages d’exécution dans la sortie.

ALTER PROCEDURE sp_employés

AS
SET NOCOUNT ON;
SELECT nom_employé, prénom_employé, nom_département
FROM vue_employés
GO

Si vous indiquez des paramètres sous la forme « @paramètre = valeur », vous pouvez les
placer dans n'importe quel ordre et vous devez présenter tous les autres paramètres sous la
même forme.

L'exemple suivant crée une procédure stockée qui retourne des informations pour un employé
spécifique en passant des valeurs pour le prénom et le nom de l'employé.

CREATE PROCEDURE sp_employés2

@Nom VARCHAR(50),
@Prénom VARCHAR(50)
AS
SET NOCOUNT ON;
SELECT prénom_employé, nom_employé, nom_département
FROM vue_employés
WHERE nom_employé = @Nom
AND prénom_employé = @Prénom
AND date_fin IS NULL;
GO

Pour exécuter la procédure. Notez que différentes méthodes de spécification des valeurs de
paramètre sont affichées :

EXEC sp_employés2 'Perez', 'Carmen';

GO

EXEC sp_employés2 @Nom = 'Perez', @Prénom = 'Carmen';

GO

EXEC sp_employés2 @Prénom = 'Carmen', @Nom = 'Perez';

GO

Si l’appel à la procédure est la première dans un lot, il est possible de l’exécuter sans utiliser le
mot clé EXEC.

sp_employés2 'Perez', 'Carmen';

GO

Dans l’exemple suivant, la valeur par défaut du paramètre Nom est NULL. Dans ce cas, si
l'utilisateur n'indique pas de valeur pour le paramètre @Code, SQL Server exécute la procédure
sans afficher de message d'erreur. La structure de control IF…ELSE vérifie la valeur du
paramètre @Code et déclenche une action en conséquence.

420-2DB-HY Principes de base de données Page 20 sur 22

CÉGEP DE SAINT-HYACINTHE La procédure stockée

CREATE PROCEDURE sp_employés

@Code VARCHAR(50) = NULL,
AS
SET NOCOUNT ON;
IF @Code IS NULL
PRINT 'SVP, entrez le code de l’employé';
ELSE
SELECT prénom_employé, nom_employé, emploi, no_département
FROM employé
WHERE no_employé LIKE @Code;

L'exemple ci-dessous utilise une instruction UPDATE dans une procédure stockée. La procédure
accepte le paramètre d'entrée @NouvellesHeures qui est utilisé dans l’instruction UPDATE
pour mettre à jour la colonne HeuresVacances de la table employé.

CREATE PROCEDURE sp_actualiser_HeuresVacances

@NouvellesHeures INT
AS
SET NOCOUNT ON;
UPDATE employé
SET heures_vacances = heures_vacances + @NouvellesHeures;
GO

EXEC sp_actualiser_HeuresVacances 40;

Dans l'exemple ci-dessous l'état d'exécution de la procédure est stocké dans la variable
@status. Cet exemple affiche simplement la valeur au moyen d’une instruction SELECT.

DECLARE @status INT

EXEC @status = actualiser_HeuresVacances 40

SELECT @status

Supprimer une procédure stockée

Syntaxe :

DROP PROCEDURE [ IF EXISTS ] { nom_procédure_stockée }

Note : La suppression d'une procédure stockée peut entraîner l'échec des scripts et des objets
dépendants. Avant de supprimer une procédure stockée, vérifiez les objets dépendants et
modifiez-les en conséquence.

Exemple:

DROP PROCEDURE sp_employés;

GO

Vous pouvez créer vos propres valeurs de retour dans des procédures stockées en ajoutant un
paramètre à l'instruction RETURN.

420-2DB-HY Principes de base de données Page 21 sur 22

CÉGEP DE SAINT-HYACINTHE La procédure stockée

L'exemple suivant renvoie la valeur 1 lorsqu'un ouvrage dispose d'un contrat correct et la valeur
2 dans tous les autres cas.

CREATE PROC sp_vérifier_titre

@titreId VARCHAR(6)
AS
IF (SELECT COUNT(*)
FROM titre
WHERE no_titre = @titreId ) > 1
RETURN 1
ELSE
RETURN 2

Le code suivant appelle la procédure sp_vérifier_titre et utilise des clauses

conditionnelles pour contrôler l'état de retour.

DECLARE @ValeurRetour INT

EXECUTE @ValeurRetour = sp_vérifier_titre 'MC2222';

IF (@ValeurRetour = 1)
PRINT 'Le livre existe dans notre magasin';
ELSE
PRINT 'Le livre n''existe pas dans notre magasin';

420-2DB-HY Principes de base de données Page 22 sur 22