Chap II : Les fonctions, les procédures et les notions de programmation côté base de données

I- Les fonctions :
1-Définition :
Une fonction stockée est une collection d’instructions Sql stockée sous un nom au niveau de la base de
données permettant de retourner une valeur. On distingue deux types de fonctions à savoir : les fonctions
systèmes et les fonctions définies par les utilisateurs.
2- Les fonctions systèmes :
Elles sont déjà prédéfinies par le système ceci lors de l’installation du SGBD. Elles sont découpées en sous-
groupe. Nous avons examiné quelques sous-groupes dans le cadre de ce cours.
2-1 Les fonctions d’agrégation statistiques
Les fonctions d’agrégation sont des fonctions idéales pour effectuer quelques statistiques de bases sur des
tables. Les principales fonctions sont les suivantes :
 AVG() pour calculer la moyenne sur un ensemble d’enregistrement
 COUNT() pour compter le nombre d’enregistrement sur une table ou une colonne distincte
 MAX() pour récupérer la valeur maximum d’une colonne sur un ensemble de ligne. Cela s’applique à la
fois pour des données numériques ou alphanumérique
 MIN() pour récupérer la valeur minimum de la même manière que MAX()
 SUM() pour calculer la somme sur un ensemble d’enregistrement

Syntaxe : SELECT fonction(colonne) FROM table.

Exemples : On considère la table ci-après
T_Employe(Emp_Matricule, Emp_Noms, Emp_Prenoms, Emp_Salaire) ;
select AVG([Emp_Salaire]) from T_Employe Affiche le salaire moyen de tous les employés
select count(*) from T_Employe Renvoie le nombre de tous les employés
select max([Emp_Salaire]) as SalMax Renvoie la valeur du salaire maxi et mini de salaire
,min([Emp_Salaire]) as SalMin
from T_Employe
select sum([Emp_Salaire]) as MasseSalariale Renvoie la masse salariale
from T_Employe

2-2 : Fonctions de chaine de caractères :

Ces fonctions sont mono-lignes cela signifie qu’elles ne s’appliquent qu’à une seule ligne en même temps.
 CONCAT() concaténer plusieurs chaînes de caractères ;
 LEFT() retourner les n premiers caractères d’une chaîne de caractères ;
 LEN() retourner la longueur d’une chaîne ;
 LOWER() transformer la chaîne pour tout retourner en minuscule ;
 REPLACE() remplacer des caractères par d’autres ;
 REVERSE() inverser les caractères d’un chaîne ;
 RIGHT() retourner les n derniers caractères d’une chaîne de caractères ;
 RTRIM() supprimer les caractères vides en fin d’une chaîne de caractère ;
 SUBSTRING() retourne un segment de chaîne ;
 UPPER() tout retourner en majuscule ;
 FORMAT() : Retourne la valeur formatée en fonction de la langue spécifiée.

Syntaxe de chaque fonction :

Ci-dessous la syntaxe utilisée en SQL Server et MySQL.
Fonction CONCAT : CONCAT ( string_value1, string_value2 [, string_valueN ] )
Fonction Left : LEFT ( character_expression , integer_expression )
Fonction Len (utilisée uniquement en SQL Server) : LEN ( string_expression )
Fonction Length (utilisée avec MySQL) : Length ( string_expression )
Fonction LOWER : LOWER ( character_expression )
Fonction Replace : FREPLACE ( string_expression , string_pattern , string_replacement )
Fonction Reverse : REVERSE ( string_expression )
Fonction Right : RIGHT ( character_expression , integer_expression )
Fonction RTRIM : RTRIM ( character_expression )
Fonction Substring : SUBSTRING ( expression ,start , length )
Fonction Upper : UPPER ( character_expression )
1
Exemples :
select CONCAT('Bon','jour') as FConcat --- Retourne Bonjour
select Left('Bonjour',3) as FLeft ---- Retourne Bon
select Right('Bonjour',4) as FRight ---- Retourne jour
select Len('Bonjour') as FLen ---- Retourne 7
select Length('Bonjour') as FLength ---- Retourne 7
select LOWER('BONJOUR') as FlOWER ---- Retourne bonjour
select UPPER('bonjour') as FUPPER ---- Retourne BONJOUR
select SUBSTRING('Bonjour',1,3) as FSUBSTRING --- Retourne Bon
Select REPLACE('Bonjour','jour','soir') as FReplace ---- Retourne Bonsoir
Select REVERSE('NORD') as FReverse --- Retourne DRON
Select RTRIM('CIRAS ') as FRtrim --- Retourne CIRAS

2-3 Les fonctions de date avec MySQL :

Vous trouverez ci-dessous un aperçu des différentes fonctions de date MySQL
curdate() / current_date(): Retourne la date courante . Exemple: select curdate() ou Select current_date() ;

curtime() / current_time(): Retourne l'heure courante . Exemple : select curtime() ou Select current_time() ;

Now() / current_timestamp() : Retourne la date et l’heure courante

Exemple : select Now() ou Select current_timestamp() ;

DATEDIFF(date1,date2) : retourne le nombre de jours entre la date1 et la date2 . Date1 et date2 sont des
expressions de type DATE ou DATETIME . Seule la partie DATE est utilisée dans le calcul.
Exemples : select datediff(‘2023-01-10’,’2023-01-01’) ; // Renvoie 9 comme différence de jours ;
select datediff(‘2023-01-10’,’2022-01-01’) ; // Renvoie 374 comme différence de jours ;

DAY(date) : Retourne le jour ;

DAYNAME(date) : Retourne le nom du jour de la semaine de date ;
MONTH(date) : Retourne le numéro du mois de la date date , dans un intervalle de 1 à 12 ;
MONTHNAME(date) : retourne le nom du mois de la date date ;
YEAR(date) : Retourne l'année de la date date , dans un intervalle de 1000 à 9999.

DATE_ADD(date,INTERVAL expr type) et DATE_SUB(date,INTERVAL expr_type) :

effectuent des calculs arithmétiques sur les dates INTERVAL expr_type une date d'un intervalle.
Date_add fait l’ajout et date_sub la soustraction.
Exemples :
SELECT DATE_ADD('2023-01-01 23:59:59',INTERVAL 1 SECOND); // Retourne comme résultat 2023-01-02 00 :00 :00
SELECT DATE_SUB('2023-01-01 23:59:59',INTERVAL 1 SECOND); Retourne comme résultat 2023-01-01 23:59:58

SELECT DATE_ADD('2023-01-01 23:59:59',INTERVAL 1 minute); // Retourne Comme résultat 2023-01-02 00 :00 :59
SELECT DATE_SUB('2023-01-01 23:59:59',INTERVAL 1 minute); // Retourne comme résultat 2023-01-01 23:58 :59

SELECT DATE_ADD('2023-01-01 23:59:59',INTERVAL 1 day); // Retourne Comme résultat 2023-01-02 23 :59 :59
SELECT DATE_SUB('2023-01-01 23:59:59',INTERVAL 1 day); // Retourne Comme résultat 2022-12-31 23:59:59

SELECT DATE_ADD('2023-01-01 23:59:59',INTERVAL 1 week); // Retourne Comme résultat 2023-01-08 23 :59 :59
SELECT DATE_SUB('2023-01-01 23:59:59',INTERVAL 1 week); // Retourne Comme résultat 2022-12-25 23:59:59

SELECT DATE_ADD('2023-01-01 23:59:59',INTERVAL 1 month); // Retourne Comme résultat 2023-02-01 23 :59 :59
SELECT DATE_SUB('2023-01-01 23:59:59',INTERVAL 1 month); // Retourne Comme résultat 2022-12-01 23:59:59

2-4 Les fonctions de date SQL Server:

- La fonction DAY retourne un entier qui représente la partie jour de la date spécifiée. Les données retournées
par cette fonction sont de type int. La syntaxe: DAY ( date ) ;
- La fonction MONTH retourne un entier qui représente la partie mois d'une date spécifiée. Les données
retournées par cette fonction sont de type int. La syntaxe: MONTH ( date ) ;
- La fonction YEAR retourne un entier qui représente la partie année d'une date spécifiée. Les données
retournées par cette fonction sont de type int. La syntaxe est la suivante : YEAR ( date ) ;
2
- La fonction GETDATE retourne une valeur datetime qui contient la date et l'heure de l'ordinateur sur lequel
s'exécute l'instance de SQL Server.
- La fonction NOW retourne une valeur datetime qui contient la date et l'heure de l'ordinateur.
- La fonction Datediff renvoie la différente entre deux deux date, la syntaxe est la suivante :
DATEDIFF(param_interval, date_debut, date_fin);
// param_interval indique le type de période pour lequel la différence sera calculé.

- La fonction Dateadd fait l’ajout d’une date sur la base d’un intervalle, la syntaxe est :
DATEADD (param_interval, number , date_depart)

Exemples :
select Getdate() as DateDuJour; --- Renvoie la date et l'heure du jour en SQL Server;
select NOW() as DateDuJour; --- Renvoie la date et l'heure du jour avec MySQL;
Select Day(Getdate()) as Jour; --- Renvoie le jour en cours en chiffre
Select MONTH(Getdate()) as MoisEnCours;-- Renvoie le mois encours en chiffre;
Select Year(Getdate()) as MoisEnCours;-- Renvoie l'année encours en chiffre;

--- La requête ci-dessous renvoie le résultat se trouvant dans la deuxième ligne du tableau --
SELECT DATEDIFF(minute, '2023-01-03 23:59:59', '2023-01-04 00:59:59') as DifEnMinute,
DATEDIFF(second, '2023-01-03 23:59:59', '2023-01-04 00:59:59') as DifEnSeconde,
DATEDIFF(hour, '2023-01-03 23:59:59', '2023-01-04 05:59:59') as DifEnHeure,
DATEDIFF(day, '2023-01-03', '2023-01-10') as DifEnJour,
DATEDIFF(week, '2023-01-03', '2023-01-10') as DifEnSemaine,
DATEDIFF(MONTH, '2022-12-03', '2023-01-10') as DifEnMois,
DATEDIFF(year, '2022-12-03', '2023-01-10') as DifEnAnnee;

--- La requête ci-dessous renvoie le résultat se trouvant dans la deuxième ligne du tableau --
SELECT '2023-01-10' as DateDeDepart,
DATEADD(minute,1,'2023-01-10') as AjoutDuneMinute,
DATEADD(hour,1,'2023-01-10') as AjoutDuneHeure,
DATEADD(day,1,'2023-01-10') as AjoutDunJour,
DATEADD(week,1,'2023-01-10') as AjoutUneSemaine,
DATEADD(month,1,'2023-01-10') as AjoutDunMois,
DATEADD(year,1,'2023-01-10') as AjoutDuneAnnee ;

3- Les fonctions utilisateurs :

C’est une fonction dont le code est défini par l’utilisateur.
3-1 Syntaxe SQL Server :
Create FUNCTION NomFonction ( [ @Param1 as type1, @Param2 as type2,………., @Paramn typen])
RETRURNS TYPE
As
Begin
Instructions SQL
RETURN SCALAR_EXPRESSION
End
Exemples : On considère le schéma rélationnel ci-dessous
T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp) ;
T_EnfantEmploye(NumEnfant,Noms,Prenoms,Age,#MatriculeEmp) ;

3
 - la fonction ci-dessous renvoie le nbre des Employés - - la fonction ci-dessous renvoie le nbre des enfants -
Create FUNCTION F_TotalEmploye() Returns integer Create FUNCTION F_TotalEnfants() Returns integer
As As
Begin Begin
Return ( Select count(*) From T_Employe) ; Return ( Select count(*) From T_Enfant) ;
End End

//*** Cette fonction renvoie le nombre total des enfants d’un Employé ***//
Create FUNCTION F_TotalDesEnfants(@MatriculeEmp varchar(6)) Returns integer
As
Begin
Return ( Select count(*) From T_EnfantEmploye where MatriculeEmp =@MatriculeEmp ) ;
End

Utilisation d’une fonction en SQL Server :

Lorsqu’une fonction est créée elle peut être utilisée comme suit :
1- Dans une requête Select : 2- Le résultat d’une fonction peut être
Exemple : affecté dans une variable utilisateur,
Select dbo. F_TotalEmploye() as TotalDesEmployes, on y reviendra dans la suite de ce
dbo. F_TotalEnfants() as TotalDesEnfants, chapitre.
dbo. F_TotalDesEnfants(‘EMP001’) as
[NbreDesEnfantsDeL’Empoye dont le matricule est EMP001]

3-2 Syntaxe MySQL :

DELIMITER SymboleDuDelimiter
CREATE FUNCTION nom_de_la_fonction([parametres]) returns Type
Begin
Code de la fonction
Return( expression) ;
End SymboleDuDelimiter
DELIMITER ;
Exemples :
DELIMITER $$ DELIMITER |
Create FUNCTION F_TotalEmploye() Returns integer Create FUNCTION F_TotalEnfants() Returns integer
Begin Begin
Return ( Select count(*) From T_Employe) ; Return ( Select count(*) From T_Enfant ) ;
END $$ End |
DELIMITER ; DELIMITER ;

DELIMITER |
Create FUNCTION F_TotalDesEnfants(NumMatricule varchar(6)) Returns integer
Begin
Return ( Select count(*) From T_EnfantEmploye where MatriculeEmp = NumMatricule) ;
End |
DELIMITER ;

Appel ou utilisation de la fonction :

Lorsqu’une fonction est créée elle peut être utilisée comme suit :
1- Dans une requête Select : 2- Le résultat d’une fonction peut être
Exemple : affecté dans une variable utilisateur,
Select F_TotalEmploye() as TotalDesEmployes, on y reviendra dans la suite de ce
F_TotalEnfants() as TotalDesEnfants, chapitre.
F_TotalDesEnfants(‘EMP001’) as
[NbreDesEnfantsDeL’Empoye dont le matricule est EMP001]

4
II- Les procédures stockées:
1- Définition :
Une procédure stockée est une collection précompilée d'instructions SQL stockée sous un nom et traitée
comme une unité.
Une procédure est également un objet de base de données, regroupant un ensemble de commandes qui
effectuent une tâche particulière le plus souvent, récurrente.
A la différence d’une fonction, une procédure stockée ne renvoie pas de valeur.

2- Création d’une procédure stockée :

2-1 Création d’une procédure stockée en SQL Server
Syntaxe de Création :
Create Proc[edure] Nom_Proc ( [ @Param1 type1, @Param2 type2,………., @Paramn typen])
As
Begin
Instructions SQL
End
Exemples :
On considère le schéma rélationnel ci-dessous
T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp) ;
T_EnfantEmploye(NumEnfant,Noms,Prenoms,Age,#MatriculeEmp) ;

---- La procédure ci-dessous permettra l’affichage de tous les employés ----

CREATE PROCEDURE P_AfficheEmploye
AS
BEGIN
Select * from T_Employe ;
END

---- La procédure ci-dessous permettra l’insertion des données dans la table T_Employe ----
CREATE PROCEDURE P_AjoutEmploye (@MatriculeEmp varchar(6),@NomsEmp varchar(40),
@PrenomsEmp varchar(40),@DateNaissEmp date, @DateEmbaucheEmp date)
AS
BEGIN
INSERT INTO T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp)
VALUES (@MatriculeEmp,@NomsEmp,@PrenomsEmp,@DateNaissEmp, @DateEmbaucheEmp) ;
END
---- La procédure ci-dessous permettras l’affichage des enfants d’un employé ----
CREATE PROCEDURE P_AfficheEnfantSalarie (@MatriculeEmp varchar(6))
AS
BEGIN
Select Noms, Prenoms, Age
From T_EnfantEmploye where MatriculeEmp=@MatriculeEmp;
END

2-2 Création d’une procédure stockée en MySQL

Syntaxe de creation d’une procedure stockée MySQL
DELIMITER SymboleDuDelimiter
CREATE Procedure NomDeLaProcedure([ Param1 type1, Param2 type2,………., Paramn typen]))
Begin
Instructions SQL
End SymboleDuDelimiter
DELIMITER ;

5
Les différents modes de transmission des paramètres en SQL :
Dans MySQL, un paramètre a l’un des trois modes suivants: IN, OUT ou INOUT.
Paramètre in :
IN est le mode par défaut. la valeur d’un paramètre IN est protégée. Cela signifie que même si la valeur du
paramètre IN est modifiée dans la procédure stockée, sa valeur d’origine est maintenue à la fin de la
procédure stockée. En d’autres termes, la procédure stockée ne fonctionne que sur la copie du paramètre
IN.
Paramètres OUT
La valeur d’un paramètre OUT peut être modifiée dans la procédure stockée et sa nouvelle valeur est
renvoyée au programme appelant. Notez que la procédure stockée ne peut pas accéder à la valeur initiale
du paramètre OUT au démarrage.
Paramètres INOUT
Un paramètre INOUT est une combinaison de paramètres IN et OUT. Cela signifie que le programme
appelant peut passer l’argument et que la procédure stockée peut modifier le paramètre INOUT et renvoyer
la nouvelle valeur au programme appelant.
Exemple1 : ---- La procédure ci-dessous permettra l’affichage de tous les employés ----
DELIMITER |
CREATE PROCEDURE P_AfficheEmploye()
BEGIN
Select * from T_Employe ;
END |
Delimiter ;

Exemple2 : ---- La procédure ci-dessous permettra l’insertion des données dans la table T_Employe ----
DELIMITER |
CREATE PROCEDURE P_AjoutEmploye ( in pMatriculeEmp varchar(6), in pNomsEmp varchar(40),
In pPrenomsEmp varchar(40),in pDateNaissEmp date, in pDateEmbaucheEmp date)
AS
BEGIN
INSERT INTO T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp)
VALUES (pMatriculeEmp,pNomsEmp,pPrenomsEmp,pDateNaissEmp, pDateEmbaucheEmp) ;
End |
Delimiter ;
Exemple3 : ---- La procédure ci-dessous permettra l’insertion des données dans la table T_EnfantEmploye ----
DELIMITER |
CREATE PROCEDURE P_AjoutEnfant(in pNomsEnf varchar(40), in pPrenomsEnf varchar(40),in pAge integer,
in pMatriculeEmp varchar(40))
AS
BEGIN
INSERT INTO T_EnfantEmploye(Noms,Prenoms,Age,MatriculeEmp)
VALUES (pNomsEnf, pPrenomsEnf, pAge, pMatriculeEmp) ;
End |
Delimiter ;

Exemple4 : Procédure permettant de renvoyer le nombre des Employés enregistrés dans la table T_Employe
DELIMITER |
CREATE PROCEDURE P_GetNbreEmploye(out NbreEmploye integer)
Begin
Select count(*)
into NbreEmploye
from T_Employe;
End |
Delimiter ;

6
Exemple5 : Procédure permettant de renvoyer le nombre des enfants d’un employé
DELIMITER |
CREATE PROCEDURE P_GetNbreEnfEmp(in pMatriculeEmp varchar(6),out NbrEnf integer)
Begin
Select count(*)
into NbrEnf
from T_EnfantEmploye
where MatriculeEmp = pMatriculeEmp;
End |
Delimiter ;

3- Exécution d’une procedure stockée

3-1 Exécution d’une procédure stockée en SQL Server
L’exécution se fait par simple appel de leur nom ou par l’instruction EXECUTE ou EXEC.
Syntaxe : Exec[ute] Nom_Proc [ValueParam1, …, ValueParamn]
Exemple :
exec P_AfficheEmploye ;
exec P_AjoutEmploye 'EMP001','KOKOLO','Prisca', '1987-02-15','2015-03-23' ;

3-2 Exécution d’une procédure stockée en MySQL

L’exécution se fait par simple appel de leur nom ou par l’instruction CALL.
Syntaxe : CALL NomProcedure( [Parametres]) ;

Exemples : Exécution des trois procédures définies ci-haut

CALL P_AfficheEmploye() ; ou CALL P_AfficheEmploye;
CALL P_AjoutEmploye ('EMP001','KOKOLO','Prisca', '1987-02-15','2015-03-23')
CALL P_AjoutEnfant ('KOKOLO','Princesse', 5, 'EMP001');

CALL P_GetNbreEmploye(@NbEmp);
Select @NbEmp as [Nombre des employés disponible dans la base de données];
CALL P_GetNbreEnfEmp('EMP001',@NbEnf) ;
Select @NbEnf as [Nombre des enfant de l’employé EMP001];
4- Modification d’une procédure stockée :
4-1 Syntaxe SQL Server
Alter Proc[edure] Nom_Proc ( [ @Param1 as type1, @Param2 as type2,………., @Paramn typen])
As
Begin
Intructions SQL
End
Exemple:
On ajoute la colonne sexe de Employe, voici à quoi va correspondre la nouvelle procedure.

---- Ci-dessous la procédure modifiée qui permettra l’insertion des données dans la table T_Employe en tenant
compte de la nouvelle colonne----
Alter PROCEDURE P_AjoutEmploye (@MatriculeEmp varchar(6),@NomsEmp varchar(40),
@PrenomsEmp varchar(40),@DateNaissEmp date, @DateEmbaucheEmp date,@Sexe varchar(10))
AS
BEGIN
INSERT INTO T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp,Sexe)
VALUES (@MatriculeEmp,@NomsEmp,@PrenomsEmp,@DateNaissEmp, @DateEmbaucheEmp,@Sexe) ;
END

7
4-2 Syntaxe My SQL
DELIMITER SymboleDuDelimiter
Alter Procedure NomDeLaProcedure([ Param1 type1, Param2 type2,………., Paramn typen]))
Begin
Instructions SQL
End SymboleDuDelimiter
DELIMITER ;
Exemple:
On ajoute la colonne sexe de Employe, voici à quoi va correspondre la nouvelle procedure.

---- Ci-dessous la procédure modifiée qui permettra l’insertion des données dans la table T_Employe en tenant
compte de la nouvelle colonne----
DELIMITER |
Alter PROCEDURE P_AjoutEmploye ( in pMatriculeEmp varchar(6), in pNomsEmp varchar(40),
In pPrenomsEmp varchar(40),in pDateNaissEmp date, in pDateEmbaucheEmp date, in pSexe varchar(10))
AS
BEGIN
INSERT INTO T_Employe(MatriculeEmp, NomsEmp,PrenomsEmp,DateNaissEmp,DateEmbaucheEmp,Sexe)
VALUES (pMatriculeEmp,pNomsEmp,pPrenomsEmp,pDateNaissEmp, pDateEmbaucheEmp,) ;
End |
Delimiter ;

5- Suppression d’une procedure stockée :

Syntaxe SQL Server et MySQL: Drop Procedure Nom_Precedure ;
Exemple : Drop Procedure P_AjoutEmploye;

III- Langage de Programmation avec le SQL Server : le Transact SQL

Le langage T-SQL (Transact structured Query Language) permet de normaliser le développement d’applications
liées aux bases de données crée avec le Sql server. C’est une extension du langage Sql développé par IBM depuis
les années 1970.
1- Les directives du T-SQL :
Elles indiquent comment traiter les instructions du TSQL. Les principales directives sont :

Use NomBDD : permet de préciser sur quelle Print : est une instruction permettant d’afficher
base de données vont porter les instructions qui les données.
suivent. Exemple : Use Master ;
Ex: print @@version ;
GO : c’est un signal donné par le Sql server pour Exec[ute] : est utilisée pour exécuter une
l’exécution des instructions. fonction ou une procédure stockée.
La commande go termine un lot d’instruction.
Ex : use BDTest Ex : Exec getdate() ;
Select * from T_Nomtable
Go;
2- Les éléments de syntaxe :
2-0 : Les commentaires :
Commentaires sur une seule ligne : On utilise une succession des tirets (barre de 6) pour le faire :
Exemple : ---- Votre commentaire ici ----
Commentaires sur plusieurs lignes : ils sont encadrés par la barre oblique suivie du caractère *
Exemple : /**** Début du commentaire
Continuité du commentaire
Fin du commentaire ***/
2-1 : Type de données : Voir les types de données offert par Sql server.

8
 2-2 : Les identificateurs :
Ce sont les noms des objets de la base de données (base de données, tables, vues, triggers, procédures stockées,
fonctions, index, contrainte, …). On distingue :
Les identificateurs standards : ils peuvent contenir 1 à 128 caractères, notamment des lettres, des symboles (_,
@,#) et des nombres. La première lettre doit être alphabétique et aucun espace n’est autorisé dans le nom. Ils
ne doivent correspondre à aucun mot-clé du langage T-Sql.
Les identificateurs délimités :
Un identificateur qui ne respecte pas une ou plusieurs des règles de mise en forme des identificateurs standard
doit toujours être délimité. Les délimiteurs sont [ ] et les doubles quotes.
Le symbole @ commence le nom d’une variable locale et le symbole @@ commence le nom d’une variable
système. Le symbole # commence le nom d’une table temporaire.
2-3 Les variables :
Les variables utilisateur :
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. Dans SQL Server, les variables doivent être obligatoirement déclarées avant d’être utilisée.
Syntaxe : DECLARE @Nomvar typevar ;
Affectation d’une variable :
Syntaxe1 : Set @Nomvar= expresion ;
Syntaxe2 : Select @Nomvar=expression ;
Ex 1: voici la déclaration d’une variable nommée Id_Client de type Int :
DECLARE @IdClient int.
L’instruction suivante permet de valoriser cette variable via l’exécution d’une requête scalaire :
SELECT @IdClient = (SELECT Id_Client FROM Motors.dbo.Client WHERE Id_Client=1);
Ex2: Use BDANA3
Declare @EmpID int, @Name char(20)
Set @EmpID=100;
Select @Name=’NKELETELA’;

Les variables système :

Les variables système sont définis par le système et ne peuvent être disponibles qu’en lecture. Elles se
différencient syntaxiquement des variables utilisateur par le double @.
L’exemple le plus courant est la variable @@ERROR, qui est à 0 en temps normal, et à 1 lorsqu’une erreur est
levée.
2-4 Les blocs Begin …. End :Les blocs délimitent une série d’instructions
Syntaxe :
BEGIN
--Les blocs peuvent contenir
--Des instructions ou bien d'autres blocs
END
2-5 Les structures conditionnelles :
La fonction IF….[else] : La structure de condition IF permet de poser une condition à une instruction. Si la
condition est vraie, l’instruction sera exécutée. Dans le cas contraire, elle ne le sera pas.
Syntaxe : IF (Condition) Expression [else expression] ;
Voici un exemple d’utilisation de cette instruction :
SELECT * FROM Client
DECLARE @Variable int = 1
IF EXISTS (SELECT * FROM Client WHERE Id_Client = @Variable)
BEGIN
DELETE FROM Client WHERE Id_Client = @Variable
PRINT 'Le Client 11 a bien été supprimé !'
END
ELSE
PRINT 'Pas de Client pour cet Id !'
SELECT * FROM Client

9
2-6 Instruction Case :
Case Simple :
CASE input_expression
WHEN when_expression THEN result_expression [ ...n ]
[ ELSE else_result_expression ]
END
Exemple:
USE AdventureWorks2013;
GO
SELECT ProductNumber, Category =
CASE ProductLine
WHEN 'R' THEN 'Road'
WHEN 'M' THEN 'Mountain'
WHEN 'T' THEN 'Touring'
WHEN 'S' THEN 'Other sale items'
ELSE 'Not for sale'
END,
Name
FROM Production.Product
ORDER BY ProductNumber;
GO
Case Recherche
CASE
WHEN Boolean_expression THEN result_expression [ ...n ]
[ ELSE else_result_expression ]
END
Exemple :
USE GLA3;
GO
SELECT Matricule, Noms+Prenoms as [Noms et Prénoms], "Mention"=
CASE
WHEN MoyEtu between 10 and 11 THEN 'Passable'
WHEN MoyEtu between 12 and 13 THEN 'Assez bien'
WHEN MoyEtu between 14 and 15 THEN 'Bien'
WHEN MoyEtu between 16 and 17 THEN 'TB'
WHEN MoyEtu between 18 and 19 THEN 'Excellent'
ELSE 'Inssuffisant'
END, Adresse
FROM Etudiant
ORDER BY Mention ;
GO
2-7 La boucle WHILE
L’instruction WHILE est une structure algorithmique permettant d’exécuter un bloc d’instructions de manière
répétitive, en fonction d’une condition.
Exemple : /* recherche de tous les nombres multiples de 13 compris entre 1 à 1000 */
/* version ensembliste (requêtes) */
DECLARE @max int -- boucle d'insertion de 0 à 1000 nbres impaires
SET @max = 1000 DECLARE @i int,@max int
-- table temporaire de stockage des entiers de 1 à SET @i = 0
5000 WHILE @i < @max
CREATE TABLE #n (n int) BEGIN
INSERT INTO #n VALUES (@i)
SET @i = @i + 13
END ;

10
III- Langage de Programmation avec MySQL :
1- La fonction use :
Elle permet de se positionner sur la base de données sur laquelle on veut travailler, ceci pour ne pas de
tromper de base de données lorsqu’on manipule plusieurs bases de données sur son SGBD.
Syntaxe1 : Use NomBDD ;
Exemple :
Use BD_GestionComptesClients;
Select count(*) From T_Client;

On peut également utiliser directement le nom de la base de données suivi du point puis du nom de la
table.
Exemple :
Select count(*) FROM BD_GestionComptesClients.T_Client ;

2- Gestion des variables :

2- 1 Les variables systèmes
Les variables systèmes sont précédés de deux @@, elles sont déjà prédéfinies dans MySQL.
Le serveur MySQL conserve de nombreuses variables système configurées à une valeur par défaut. Ils
peuvent être de type GLOBAL , SESSION.
Les variables globales affectent le fonctionnement global du serveur, tandis que les variables de session
affectent son fonctionnement pour les connexions client individuelles.

Quelques variables systèmes :

Variable Signification
auto_increment_increment Valeur auto incrémentée
basedir Dossier d’installation de MySQL
version Version de MySQL
version_compile_os Version de l’OS
wait_timeout Time out
autocommit Option de validation des transactions
error_count Nombre d’erreur d’une session

Exemples :
Pour voir les valeurs actuelles utilisées par un serveur en cours d’exécution, utilisez l’instruction
SHOW VARIABLES //** Renvoie la liste des variables.
Select @@version ; //*** Renvoie la version courante installée sur la machine.
Select @@auto_increment_increment ; // ** Renvoie la valeur de l’auto_increment

2-2 Variables définies par l’utilisateur:

Elles sont définies par le DBA qui programme côté base de données.
MySQL, depuis la version 3.23.6, permet de déclarer des variables dans ses requêtes.
Les variables obéissent à certaines règles :
 Leurs noms commencent par "@" (ex : @total).
 Elles sont déclarées avec le mot SET, ou bien SELECT accompagné de l'opérateur d'assignation :=
ou de l’opérateur = ;
 Aussitôt déclaré, elles doivent recevoir des valeurs initiales.
La première méthode consiste à utiliser l’opérateur SET.
Syntaxe1 : Set @Nomvariable=valinit ; Set @Nomvariable :=valinit
Exemple :
SET @Solde1= 1000 ; Set @Solde2 = 500 ; Select @Solde1, @Solde2, @Total
Set @Total= @Solde1 + @Solde2 ;

11
On peut également consister une variable à partir d’une requête.
Syntaxe 2 : Select @NomVar := expression ;
Exemple :
Select @TotLigne :=(select count(*) from T_Client) ; Set @NumEmp=2 ;
Select * from T_Emprunt
Select @MaxEmprunt :=(select Max(MontantEmprunt) where NumEmprunt=@NumEmp;
from T_Emprunt) ;

2-3 Les variables locales :

Les variables locales sont celles qui sont définies dans un bloc d’instructions, elles permettent de stocker
et modifier des valeurs pendant le déroulement d’une procédure ou fonction.
Syntaxe : La déclaration d’une variable locale se fait avec l’instruction DECLARE comme suit
DECLARE nom_variable type_variable [DEFAULT valeur_defaut];
Exemple:
DELIMITER |
CREATE PROCEDURE aujourdhui_demain ()
BEGIN
DECLARE v_date DATE DEFAULT CURRENT_DATE();
SELECT DATE_FORMAT(v_date, '%W %e %M %Y') AS Aujourdhui;
SET v_date = v_date + INTERVAL 1 DAY;
SELECT DATE_FORMAT(v_date, '%W %e %M %Y') AS Demain;
END|
DELIMITER ;

CALL aujourdhui_demain () ;

Portée d’une variable locale :

Les variables locales n’existent que dans le bloc d’instructions dans lequel elles ont été déclarées. Dès que
le mot-clé END est atteint, toutes les variables locales du bloc sont détruites.
Exemple :
DELIMITER |
CREATE PROCEDURE test_portee1()
BEGIN
DECLARE v_test1 INT DEFAULT 1;
BEGIN
DECLARE v_test2 INT DEFAULT 2;
SELECT 'Imbriqué' AS Bloc;
SELECT v_test1, v_test2;
END;
SELECT 'Principal' AS Bloc;
SELECT v_test1, v_test2;
END|
DELIMITER ;

CALL test_portee1() ;

3- Les structures de contrôle :

3-1- La structure if :
Syntaxe :
IF condition THEN instructions Le cas le plus simple : Voici la structure minimale d’un IF
[ELSEIF autre_condition THEN instructions IF condition THEN
[ELSEIF ...]] Instructions
[ELSE instructions] END IF;
END IF;

12
Exemple :
DELIMITER // CREATE FUNCTION VerboseCompare (n INT, m
CREATE FUNCTION SimpleCompare(n INT, m INT)
INT) RETURNS VARCHAR(50)
RETURNS VARCHAR(20) BEGIN
BEGIN DECLARE s VARCHAR(50);
DECLARE s VARCHAR(20); IF n = m THEN SET s = 'equals';
IF n > m THEN SET s = '>'; ELSE
ELSEIF n = m THEN SET s = '='; IF n > m THEN SET s = 'greater';
ELSE SET s = '<'; ELSE SET s = 'less';
END IF; END IF;
SET s = CONCAT(n, ' ', s, ' ', m); SET s = CONCAT('is ', s, ' than');
RETURN s; END IF;
END // SET s = CONCAT(n, ' ', s, ' ', m, '.');
DELIMITER ; RETURN s;
END //
DELIMITER ;

3-2- La structure Case :

Syntaxe1 : Syntaxe 2 :
CASE valeur_a_comparer CASE
WHEN possibilite1 THEN instructions 3 WHEN condition THEN instructions
[WHEN possibilite2 THEN instructions] ... [WHEN condition THEN instructions] ...
[ELSE instructions] [ELSE instructions]
END CASE; END CASE ;
Exemple1 :
DELIMITER |
CREATE PROCEDURE p_NbEnLettres(in v integer)
BEGIN
CASE v
WHEN 1 THEN select 'un' as NbEnLettre;
WHEN 2 THEN select 'deux' as NbEnLettre;
WHEN 3 THEN select 'trois' as NbEnLettre;
WHEN 4 THEN select 'quatre' as NbEnLettre;
WHEN 5 THEN select 'Cing' as NbEnLettre;
WHEN 6 THEN select 'Six' as NbEnLettre;
WHEN 7 THEN select 'Sept' as NbEnLettre;
WHEN 8 THEN select 'Huit' as NbEnLettre;
WHEN 9 THEN select 'Neuf' as NbEnLettre;
ELSE
BEGIN
select 'Il s''agit d''un nombre supérieur à 9' as NbEnLettre;
END;
END CASE;
END |
DELIMITER ;

Exemple2 :
SELECT NumCli, MontantEmprunt,CodPer, DureeRemboursement,
CASE
WHEN DureeRemboursement between 0 and 9 THEN ' Prêt Court Terme'
WHEN DureeRemboursement between 10 and 120 THEN 'Prêt Moyen Terme'
ELSE 'Prêt Long Terme'
END AS CategoriePret
FROM T_Emprunt ;
13
3-3- La boucle While :
Syntaxe : Exemple :
WHILE condition DO DELIMITER |
Instructions ; CREATE PROCEDURE dowhile()
END WHILE BEGIN
DECLARE v1 INT DEFAULT 5;
WHILE v1 > 0 DO
SET v1 = v1 - 1;
Select v1 as valeuractuelle ;
END WHILE;
END |
DELIMITER ;

3-4- La boucle repeat :

Syntaxe : Exemple :
REPEAT delimiter //
statement_list CREATE PROCEDURE dorepeat( in p1 INT)
UNTIL search_condition BEGIN
END REPEAT SET @x = 0;
REPEAT
SET @x = @x + 1;
Select @x as valeuractuelle ;
UNTIL @x > p1
END REPEAT;
END //
DELIMITER ;

14