TP1 : Requêtes SQL(LDD+LMD)sous SQL

Server

Soit la base de données GestionBanque qui permet la gestion des agences et le suivi des clients
d'une banque. Le schéma de GestionBanque est le suivant :
Agence(NAg, Nom, Ville)
Client(NClt, Nom, Ville)
Compte(NCpt, #NAg, #NClt, Solde)
Opereration(NOpt,#NAg, #NClt ,Type,Montant)
Agence(Ag) Client(Clt)
NAg Nom Ville NClt Nom Ville
1 Atlas Beni Mellal 1 Karimi Beni Mellal
2 Takadoum Beni Mellal 2 Hamza Salé
3 Nassime Casablanca 3 Younes Beni Mellal
4 Hay Riad Rabat 4 Sabiri Rabat
5 Hay Salame Salé 5 Halimi Casablanca
6 Mohitt Rabat 6 Saadaoui Salé
7 Farah Salé 7 Derkaoui Beni Mellal
8 Ismaili Casablanca
Operation(Opt)
NOpt NAg NClt Montant Type
Compte(Cm) 1 1 1 500 Retrait
NCpt NAg NClt Solde 2 1 2 1000 Dépôt
1 1 1 4500 3 1 1 800 Dépôt
2 2 1 6000 4 3 4 900 Dépôt
3 1 2 10055 5 2 5 2000 Retrait
4 3 3 11000 6 3 7 1500 Dépôt
5 4 5 1100 7 2 8 1700 Retrait
6 5 4 3200 8 4 7 1200 Dépôt
7 3 6 50500 9 2 5 600 Dépôt
8 6 5 3000 10 4 3 700 Retrait
9 2 8 22000 11 6 6 10000 Retrait
10 4 4 11022 12 6 8 3000 Dépôt
11 1 6 32100 13 2 1 1000 Dépôt
14 5 2 1000 Retrait
15 6 5 20000 Dépôt
EMSI Casablanca A.U 2020/2021.
 En utilisant le langage SQL, Programmer les requêtes suivantes :
1. Créer les tables de la base de données GestionBanque.
2. Insérer toutes les lignes de chaque table.
3. Dupliquer l'opération 15 sans montant.
4. Modier le montant de l'opération 16 en introduisant la somme 1000.
5. Ajouter 10% aux comptes qui ont un solde inférieur strictement à 12000Dhs.
6. Acher le nombre des clients habitant à Casablanca.
7. Acher le numéro et le solde moyen des comptes-clients de chaque agence.
8. Acher les noms des clients qui ont un compte à Rabat (Il ne faut pas acher un même
client plusieurs fois, acher 3 premiers).
9. Acher les noms des clients qui n'ont jamais réalisé l'opération de type Dépôt.
10. Acher la somme des montants déposées par chaque client.
11. Supprimer, dans la table Compte, Les comptes de Monsieur Karimi. (En utilisant deux
méthodes)
12. Supprimer dans la relation Agence, toutes les agences sans client.

2
 Correction TP 1 SQL SERVER
--Q1
--bonjour, le tp 1 correction, ce tp contient deux languages de SQL
--LDD+LMD
-- pour une BD, il faut taper create database [nom de la BD]
create database [gestion banque]
go
--go est un lot qui facilite l'execution des requetes sql dans un ordre
sequentiel
use [gestion banque]
/*par defaut, lors de la connexion sur sql server la BD est master pour
cela
il faut tapez use la BD avant de creer les tables dans la BD*/
go
--la creation la table
--nous commencons par les tables qui contiennent pas des clés etrangéres
create table agence(Nag int identity primary key, Nom varchar(20), Ville
varchar(20))
go
create table Client(NClt int identity primary key, Nom varchar(20), Ville
varchar(20));
gp
create table compte(Ncpt int identity primary key, Nag int, Nclt int,
solde money, foreign key(Nag) references agence(Nag)
On Delete cascade
on Update cascade
foreign key(NClt) references client(Nclt)
on delete cascade
on update cascade)
go
create table Operation(Nopt int identity primary key, Nag int, NClt int,
Montant money, Type varchar(20),
foreign key(Nag) references Agence(Nag)
On Delete cascade
on Update cascade
foreign key(NClt) references Client(NClt)
On Delete cascade
on Update cascade);
go
-- le type int identity pour l'autoincrement cad insertion+incrementation
automatique au
--champ autoincrement
-- chaque clé etrangere doit avoir les contraintes on delete cascade on
update cascade
--Q2
--lors de l'insertion des lignes, il faut commencer par les tables
--qui contiennent pas des clé etrangere+ les champs ayant le type identity
sont remplies
-- automatiquement
insert into Agence
values('Atlas','BeniMellal'),('Takadoum','BeniMellal'),('Nassime','Casblanc
a');
select * from Agence
go
insert into Agence values('hay riad','rabat'),('hay
salam','salé'),('Mohitt','rabat'),('farah','salé');
Select * from Agence
go
insert into client
values('karimi','benimellal'),('hamza','salé'),('youness','benimellal'),
('sabiri','rabat'),('halimi','casa'),('saadaoui','salé'),('derkaoui','benim
ellal'),('ismaili','casablanca');
select * from client;
go
insert into compte
values(1,1,4500),(2,1,6000),(1,2,11050),(3,3,11000),(4,5,1100),(5,4,3200),(
3,6,50500),(6,5,3000),(2,8,22000),(4,4,11022),(1,6,32100);
select * from compte
go
insert into operation
values(1,1,5000,'Retrait'),(1,2,1000,'depot'),(1,1,800,'depot'),(3,4,900,'d
epot'),(2,5,2000,'retrait'),(3,7,1500,'depot'),(2,8,1700,'retrait'),(4,7,12
00,'depot'),(5,2,600,'depot'),(4,3,700,'retrait'),(6,6,10000,'retrait'),(6,
8,3000,'depot'),(2,1,1000,'depot'),
(5,2,2500,'Retrait'),(6,5,20000,'depot');
select * from operation;
go
--pour inserer toutes les lignes à la fois, il faut taper
--insert into nom de la table values(ligne1),(ligne2),(ligne3),......
--notez bien les types varchar et date doivent etre entre quote
--Q3
--dupliquer c copier la ligne de l'operation 15 a savoir Nag,NClt, type,
--le montant doit avoir la valeur null, il faut specifier les champs a
remplir apres insert
insert into operation(Nag, NClt, Type)
select Nag, NClt, TYPE from operation
where Nopt=15
--affichage verifier le resultat
select * from operation;

--Q4
--modifier le montant null par 1000
update operation set montant=1000 where Nopt=16
select * from operation;
--Q5

--Montantttc=montant+montant*TVA/100
--solde=solde+slode*10/100
--=solde+solde*0.1
--solde*(1+0.1)
--solde*1.1
update compte set solde=solde*1.1 where solde<12000;
select * from compte

--Q6
-- utiliser l'alias as pour nommer le champ count
select * from client
select COUNT(*) as [nombre client]
from client where ville like'casa%'

--Q7
--afficher l'avg(solde) des comptes de chaque agence
select Nag, AVG(Solde) as [Solde moyen] from compte group by Nag;
-- transactions
--exemple de transaction avec commit qui confirme la transaction
--pour annuler il utiliser rollback au lieu de commit toujours
-- vous devez commencer par utiliser begin transaction, puis vous ecrivez
les transactions
--(insert, update, delete)
 begin transaction
insert into client values('Ahmed', 'rabat')
select * from client
commit
select * from client
--creation de vue
--pour creer une vue vous devez taper create view (nom de la vue)
as(requete de selection)
create view v1 as (select * from client)
--la vue est un objet BD, c comme une table virtuelle
--vous pouvez l'utiliser par la suite dans des requetes de
selection(simple+jointure+imbriquée)
select * from v1
-- Q8
--ici nous devons utiliser la requete interne inner , sinon vous pouvez
utiliser
--la requete select c.nom from client c, compte cm where c.Nclt=cm.Nclt
and a.ville like'rabat'
-- top affiche un nombre d'enregistrement que vous voulez afficher
--ici nous voulons afficher une seule enregostrement nous utilisons top 1
select distinct top 1 c.nom from client c inner join compte cm on
c.Nclt=cm.Nclt
inner join agence a on a.Nag=cm.Nag
where a.ville like'rabat';
--Q9
--ici nous utilisons une sous-requete avec not in
select NClt,nom from client where NClt not in
(select Nclt from operation where TYPE='depot')
--Q10
--Afficher la somme montant par NClt
select NClt, SUM(montant) as [somme montant] from operation
where TYPE='Depot' group by NClt

--truncate table client

--notez que avec les tables que leurs clé primaires sont etrangeres dans
une autre
-- vous devez pas utiliser truncate
-- trancate nous utilisons avec les tables qui contiennent des clés
etrageres
select * from client
delete from client where nom='hamza'
select * from compte
select * from operation
--Q11
-- La methode 1(Sous requete/ requete imbriquée)
delete from compte
where Nclt in (select Nclt from client where nom='karimi')
--La methode 2(jointure inner)
delete compte from compte cm inner join client c
on cm.NClt=c.NClt where c.nom='karimi';
--ou bien la jointure
delete compte from compte cm, client c
where cm.NClt=c.NClt c.nom='karimi';
--Q12
--suppresion
delete from agence where Nag not in (select Nag from compte)
select * from agence
 TP2 : Requêtes SQLsous SQL Server (ALTER+
SELECT)

Soit le modèle relationnel suivant pour la gestion des étudiants :

Etudiant(cin,nom, prenom , datenaiss, adr, ville, tel, pays)
Inscription(num, liere, dateinscr, #cin)
Modules(num, libellé)
Formateurs(num, nom, prenom, salaire)
Examens(#ninscr, #nmod, #nform, note)

En utilisant le langage SQL, Programmer les requêtes suivantes :

1. Créer les tables de la base de données Gestion Etudiant.
2. Donner le diagramme correspondant.
3. Dénir les contraintes suivantes en utilisant la requête Alter :
(a) Ajouter à la table formateur les champs datenaissance et grade.
(b) Modier la taille du champ adresse.
(c) Le salaire des formateurs doit être supérieur à 10000.
(d) Le numéro de formateur doit être unique.
(e) La date d'inscription ne doit pas recevoir une valeur manquante.
(f) La valeur de champs pays par défaut est Maroc.
(g) Modier le nom de la BD.
4. Modier le nom du champ lière par spécialité.
5. Modier le nom de la table formateur par enseignant.
6. Insérer toutes les lignes de chaque table.
7. Ache les étudiants (nom et le prénom) par module(num).
8. Acher les étudiants ayant un age de 25 ans ou plus.
9. Quels sont les étudiants qui ont la même date de naissanceannée de naissance en ordre
décroissant(nom).
10. Acher les enseignants par nom, prénom, salaire ayant assistés l'examen de biologie.
11. Quel est le salaire max des enseignants et pour quel grade ?
12. Acher les nom des professeurs qu'ils n'ont assistés à aucun examen.
EMSI Casablanca A.U 2020/2021.
 Correction TP 2 SQL SERVER
--Q1
--creation de la BD et les tables de la BD toujours vous devez commencer
-- par les tables qui ne contiennent pas des clés etrangeres
-- le type money c monetaire
-- pour creer la BD avec espace, vous devez utiliser []
create database [gestion etudiant]
go
use [gestion etudiant]
go
create table etudiant(cin varchar(10) primary key,
nom varchar(20),
prenom varchar(20),
[date naissance] date,-- ici le champ [date naissance] contient l'espace
adresse varchar(50),
ville varchar(20),
tel bigint,
pays varchar(20));
go
create table inscription(num int identity primary key,
specialité varchar(30), [date inscription] date,
cin varchar(10),
foreign key(cin) references etudiant(cin)
on delete cascade
on update cascade)
go
create table module(num int identity primary key, libellé varchar(20))
go
create table formateur(num int identity primary key,
nom varchar(20), prenom varchar(20), salaire money)
go
create table examens(ninscr int, nmod int , nfor int, note float,
constraint cpk primary key(ninscr,nmod,nfor),
foreign key(ninscr) references inscription(num)on delete cascade
on update cascade,
foreign key(nmod) references module(num) on delete cascade
on update cascade,
foreign key(nfor) references formateur(num)
on delete cascade
on update cascade)
go
--Q2
-- creer le diagramme par clique droit sur le dossier schema de la BD
--Q3
--syntaxe
-- alter table nom de la table
--add nomchamp type
--a
--ajouter le champ [date naissance] avec le type date
alter table formateur
add [date naissance] date
--ajouter le champ le champ grade de type varchar(20) et taille 20
alter table formateur
add grade varchar(20)
--b
--alter table nom de la table
--alter column nom champs nouveau type
alter table etudiant
alter column adresse varchar(100)
--c
-- une containte check
--alter table nom de la table
--add constraint nom de contrainte check()
alter table formateur
add constraint c1 check(salaire>10000)
--d
--alter table nom de la table
--add constraint nom contrainte unique(champ)
alter table formateur
add constraint c2 unique(num)
--e
--alter table nom de la table
--alter column champ type not null;
--ou bien vous pouvez utiliser check
--alter table inscription
--add constraint c4 check(specialité is not null)
alter table inscription
alter column [date inscription] date not null
--f
--alter table nomde la table
-- add constraint nom de contrainte default 'valeur par defaut' for nom
champ
alter table etudiant
add constraint c3 default 'maroc' for pays
--g
--la premiere methode
--alter database nom de la base
--modify name ='nouveau nom'
alter database [gestion etudiant]
modify name = etudiant
-- ou bien utiliser la procedure systeme stockée qui se trouve dans
-- le dossier programmabilté qui contient un dossier qui s'appelle
-- procedure stockée(stored procedure sp)
-- la procedure sp_renamedb est utilisé pour renommer les base de données
exec sp_renamedb 'etudiant', 'etudaint1'
--Q4
-- la procedure sp_rename est utilisé pour renommer les tables et les
colonnes
sp_rename 'inscription.specialité', 'filiere', 'COLUMN';
--Q5
-- la procedure sp_rename est utilisé pour renommer la table implicitement
sans specifier
-- le type de l'objet
sp_rename 'formateur', 'enseignant'
--Q6
-- insertion nous commencons par les table qui ne contiennt pas des clés
etrangéres
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('A345678','nawali', 'Amal', '01/04/1989','15,bd
anwal','casablanca',0625147896)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('AZ234567','souktani','Salim', '01/05/1998','54,hay
elhouda','Rabat',0625147893)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('B123456', 'Samih','Ahmed','01/01/1988','28,rue
qods','rabat',0668617745)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('E457890', 'elradi','Mohamed','01/05/1997','25,hay
enour','rabat',0625147892)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('ER678954', 'elouali','Adam','04/10/1998','45,hay lala
aicha','rabat',0625147896)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('FA456789','nijari','Nabil','02/06/1992','56,QODS','rabat',062514789
5)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('Q456789','yaccoubi','Zahrae','04/07/1991','45,takadoum','rabat',060
5241879)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('IC234516','nouri','Kamal','03/07/1998','14 hay
elmassira','rabat',0623568974)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('TE456732','elhadi','Asmae','01/08/1998','23,hana
2','Casablanca',0615487215)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('WA234576','allaoui', 'Soumia','05/04/1996','34,rue
farah','benimellal',0659847215)
insert into etudiant(cin,nom,prenom,[date naissance],adresse, ville, tel)
values('ZA234567','Samadi', 'Karima','07/12/1998','78,hay
elnasr','rabat',0636365489)
-- inserer les inscription
select * from etudiant
insert into inscription values
('droit prive','01/10/2015','A345678'),
('Biologie','01/09/2014','AZ234567')
insert into inscription values
('Chimie','01/09/2015','B123456'),
('Math info','01/09/2016','E457890')
insert into inscription values
('Geologie','01/09/2014','ER678954'),
('Economie', '01/10/2015','ER678954')
insert into inscription values
('droit prive','01/10/2017','ZA234567'),
('physique','01/10/2014','Q456789')
insert into inscription values
('droit prive','01/10/2014','ZA234567'),
('chimie','01/10/2014','WA234576')
insert into inscription values
('Math info','05/11/2013','TE456732')
select * from inscription
insert into module values
('math'),('biologie'),('geologie'),('droit'),
('physique'),('chimie generale'),('statistique'),('info'),
('biochimie'),('microbiologie'),('microeconomie'),('macroeconomie'),('angla
is'),('LC'),('BD'),('Environement'),
('biologie cellulaire')
insert into module values ('biologie
animlae'),('Java'),('C'),('C++'),('UML'),('Merise'),('Analyse de donnees')
select * from module
insert into enseignant values
('sekak','Hanae',12000,'01/08/1979','PA'),
('jelloul', 'asmae',15000,'05/09/1978','PA'),
('salaheddine' ,'Ahmed',15000,'04/05/1970','PA'),
('chafi','mohamed',14000, '04/07/1969','PA'),
('aitali' ,'karim',18000,'03/11/1970','PH'),
('chafik','abdelhadi',19000,'04/02/1987','PH'),
('naseredine','salah',16200,'05/05/1984','PH'),
('naima','nouri','34568','05/05/1984','PES')
select * from enseignant
--insertion table examens
--insertion table examens
insert into examens values
(11,19,2,13),(2,4,4,12),(1,3,5,12),
(3,2,3,13),(9,17,4,12),
(9,12,1,13),(7,3,6,12),
(8,2,2,14),(11,1,2,16),
(2,1,1,13),(1,4,2,15),(6,5,6,17),
(8,3,2,11),(4,14,4,17),(5,2,5,18),
(3,6,4,19),(1,23,6,13),(2,22,7,15),(11,20,3,14)
select * from examens
--N.B : les types varchar et date entre quote lors de l'insertion
--Q7
-- la clause group by regroupe avec les 3 champs a la fois
select e.nom, e.prenom,ex.nmod from etudiant e, inscription i, examens ex
where i.cin=e.cin and i.num=ex.ninscr
group by (e.nom, e.prenom,ex.nmod);
-- la fonction cube donne toutes les possibilités de groupement
--<nom, prenom, nmod>
--<nom, prenom>
--<prenom, nmod>
--<nom, nmod>
--<nom>
--<prenom>
--<nmod>
--<>
--2^3 groupes
select e.nom, e.prenom,ex.nmod from etudiant e, inscription i, examens ex
where i.cin=e.cin and i.num=ex.ninscr
group by cube(e.nom, e.prenom,ex.nmod);
-- la fonction rollup donne toutes 4 groupe
--<nom, prenom, nmod>
--<nom, prenom>
--<nom, nmod>
--<nom>
--<>
--4 groupes
select e.nom, e.prenom,ex.nmod from etudiant e, inscription i, examens ex
where i.cin=e.cin and i.num=ex.ninscr
group by rollup(e.nom, e.prenom,ex.nmod);
--la fonction grouping sets regroupe chaque champ independamment des autres
--<nom>
--<prenom>
--<nmod>
select e.nom, e.prenom,ex.nmod from etudiant e, inscription i, examens ex
where i.cin=e.cin and i.num=ex.ninscr
group by grouping sets(e.nom, e.prenom,ex.nmod);
--Q8
--pour afficher la date d'aujourd'hui
-- il faut taper select getdate() ou bien print getdate()
-- select sert aussi a afficher les messagessous forme de tableau
-- exemple select 'bonjour'
-- print 'bonjour'
-- la fonction getdate() est une fonction systeme qui se trouver dans le
dossier
-- functions/fonctions qui se trouve dans programmability(programmabilité)
-- aussi la fonction CURRENT_TIMESTAMP affiche la date d'aujourd'hui
-- la fonction year pour recupere les année dans des dates
select year(GETDATE())
select CURRENT_TIMESTAMP
-- Correction
select * from etudiant where year(GETDATE())-year([date naissance])>=25;
--Q9
--ici nous utilisons l'autojointure car nous cherchons dans la meme table
select e.nom, e1.nom, year(e.[date naissance]) as annéenaissance
from etudiant e, etudiant e1
where e.cin<>e1.cin and year(e.[date naissance])=year(e1.[date naissance])
order by e.nom DESC;
--Q10
--ici soit nous utilisons une jointure ou une requete imbriquée
--solution avec la jointure
select e.nom, e.prenom, e.salaire from enseignant e, examens ex, module m
where e.num=ex.nmod and m.num=ex.nfor and m.libellé='biologie';
--solution 2 Avec requete imbriquée
select e.nom, e.prenom, e.salaire from enseignant e where e.num in
(select nfor from examens
where nmod in
(select num from module where libellé='biologie'))
--Q11
-- requete imbriquée
select grade,salaire from enseignant
where salaire =(select MAX(salaire) from enseignant)
--Q12
-- requete imbriquée+not in
select nom from enseignant where num not in(select nfor from examens)
select * from enseignant
select * from examens
 TP4 : Programmation BD sous SQL Server (Les
procédures+Les fonctions+Les curseurs+Les
exceptions)2 séances

Ce TP est divisé en trois partie :

Partie I : Les procédures et les fonctions.
Partie II : Les curseurs.
Partie III : Les exceptions.

Partie I :Les procédures et les fonctions

Soit le schéma de la BD [Gestion Entreprise] suivant :

Employé(Idemployé, Nom, Prénom, Adresse, Ville, Date Naissance, Date Recrutement, Grade,
Salaire, #Iddept)

Département(Iddept, Nom)

Travail à faire :

 Q1) Écrire une procédure qui permet d'acher les employé.

 Q2)Écrire une procédure qui calcule le nombre des employés dans une département donnée
en paramètre.
 Q3)Écrire une fonction qui retourne les noms et prénoms des employés avec le nom des
département auxquelles ils appartiennent.
 Q4)Écrire une fonction qui calcule l'ancienneté d'un employé.
 Q5)Ecrire une procédure qui augmente le salaire d'un employé selon ancienneté.
 plus de 10 ans 20%
 moins de 10 ans 15%
EMSI Casablanca A.U 2020/2021.
Indices de réponse :

Syntaxe :
Procédure stockée :
declaration
Create/ Alter procedure (Nomde procédure)(paramètres)
as
set nocount ON
begin
traitement
end
Execution
EXEC (Nomde procédure)(paramètres)
Syntaxe
declaration
Create/ Alter function (nom de la fonction)
(parametres)
returns type de retour/ table
corps de la fonction
return
Execution
fonction qui retourne une valeur(fonction scalaire)
select dbo.Nom de fonction(paramètres)
fonction qui retourne une table(fonction table)
select * from nomdefonction

Partie II :Les curseurs

Travail à faire :

 Q1) Récupérer la liste des employé de l'entreprise en utilisant un curseur.

 Q2) Calculer l'ancienneté de chaque employé en utilisant un curseur.
 Acher le message sous forme de :
l'employé+(son nom)+ a l'ancienneté+(son ancienneté).
 Q3) Écrire un curseur qui ache le nom prénom et nom de département des employé faire
dans procédure. Proposer deux solutions.

Indices de réponse :

declaration
declare nomdecurseur cursor for requête
declarer le curseur
open nomdecurseurouvrir le curseur
fetch next from nomdecurseur acher la premiere ligne recuperer par le curseur
while(@@F ET CHS T AT U S = 0)verier s'il y des enregistrement dans le curseur

2
begin debut de boucle
fetch next from cursorstudent ache des lignes ligne par ligne
end n de boucle
close nomdecurseur fermer le curseur
deallocate nomdecurseur deasallouer le curseur

3
 Correction tp4
use [Gestion Entreprise]
go
--Partie I: Fonctions et procedures
--Q1)-------------------------------------------------------------------------
-----------------------------------
--une procedure stockée normale sans parametres
create procedure affichageemployé
as
set nocount ON
begin
select * from Employé
end
--L'excution d'une procedure normale s'effectuer de la maniére suivante:
EXEC affichageemployé
--Q2)
------------------------------------------------------------------------------
---------------------------------------
-- Solution1: procedure avec parametres d'entree
-- @nbre int
create procedure nbreemployé(@nbre int)
as
set nocount on
begin
select count(*) as nbreemployé from Employé where iddept=@nbre
end
---- l'execution nomprocedure + parametres
EXEC nbreemployé 6
--Solution 2: procedure avec parametres d'entrees et sortie
-- @nbre int output
-- @id int (entree)
--autre facon
------------------------------------------------------------------------------
----------------------------------------
create procedure caculemp(@nbre int output, @id int)
as
set nocount on
begin
select @nbre=COUNT(*) from Employé where iddept=@id
end
--execute
-- execution s'effectue de la maniere suivante :
declare @nbre int
set nocount on
exec caculemp @nbre output, 5
select @nbre
------ l'affichage soit par :
--- select @nbre
------ l'affichage soit par :
---- print @nbre
------------------------------------------------------------------------------
------------------------------------------
---solution 3 : avec return
create procedure caculemp1(@id int)
as
begin
return (select COUNT(*) from Employé where iddept=@id)
end
--- execution
-- l'excution s'effectue de la maniere suivante:
declare @nbre int
set nocount on
exec @nbre=caculemp1 10
print @nbre
------------------------------------------------------------------------------
--------------------------------
------------------------------------------------------------------------------
---------------------------------
--Q3)Solution 1: Un fonction table: les fonctions table sont utilisées
lorqu'on a des fonction qui retourne le resultat d'une requete select
create function fct()
returns table
as
return select e.[nom prenom], d.nom from Employé e, Departement d where
e.iddept=d.iddept
------------------------------------------
---execution d'une fonction table est:
--- select * from nomdelafonction(parametre)
select * from fct()
--Q3: solution 2 : fonction table avec fonction temporiare: faites attention
au nombre de champs recuperer par la requete
-- il doit etre le meme que dans la table temporaire @t table
-- on declare une table temporaire @nomdetable table(champ1 type, champ2
type,..........)
-- puis on insere dans cette table le resultat recuperé par la requete.
create function ajouteremployé()
returns @t table(nom varchar(20), adresse varchar(50))
as
begin
insert into @t select [nom prenom],adresse from Employé
return
end
--- execution d'une fonction table
select * from ajouteremployé()
------------------------------------------------------------------------------
----
create function fct1()
returns @t table(nomprenom varchar(20), nom1 varchar(50))
as
begin
insert into @t select e.[nom prenom], d.nom from Employé e, Departement d
where e.iddept=d.iddept
return
end
------------------------------------------------------------------------
------------execution
select * from fct1()
--- les procedures crees se trouvent dans le dossier programmablité de la BD
[Gestion Entreprise] plus precisement dans le dossier procedures stockées
----- et les fonction table aussi se trouvent dans le dossier programmabilité
dans le dossier fonction/ fonction table
--Q4
---fonction scalaire qui retourne une valeur
create function calculancienté(@idemp int)
returns int
as
begin
declare @a int
select @a=datediff(year,[date recrutement],getdate()) from Employé where
idemp=@idemp
return @a
end
---------------execution d'une fonction scalaire
-- soit avec select dbo.nomdelafct(parametre)
---- soit avec print dbo.nomdelafct(parametre)
select dbo.calculancienté(1)
--------------------------------------------------------------
-- fonction scalaire est cree au niveau de dossier programmabilité/ fonction/
fonction scalaire
-- lors de l'eexcution il faut mentionner le schema dbo ou le schema dans
lequel la fonction est crée
--Q5
---------------procedure avec input qui fait appel à la fonction scalaire
dbo.dbo.calculancienté(@idemp)
create procedure calculsalaire(@idemp int)
as
begin
declare @a int
select @a=dbo.calculancienté(@idemp)
if(@a<10)
begin
update Employé set salaire=salaire*1.1 where idemp=@idemp
end
else
begin
update Employé set salaire=salaire*1.2 where idemp=@idemp
end
end
-----------------execution
EXEC calculsalaire 1
select * from Employé
--partie II : Les curseurs aussi les curseurs sont des espaces temporaires
--Q1
declare curseur1 cursor for select * from Employé -- declarer cursuer
open curseur1-- ouvrir curseur
fetch next from curseur1-- recuperer la premiere ligne du curseur
while(@@FETCH_STATUS=0) -- verifier si le curseur n'est pas vide
begin
fetch next from curseur1-- recuperer les autre lignes du curseur
end
close curseur1-- fermer le curseur
deallocate curseur1-- desallouer le curseur
-- Q2
-- appel a la fonction ancienete
-- declarer la fonction ancienete(@idemp int)
create function ancienete(@idemp int)
returns int
as
begin
declare @a int
select @a =datediff(year,[date recrutement],getdate()) from employé where
idemp=@idemp
return @a
end
select dbo.ancienete(1) as anc
-- le curseur
declare @a int-- declaration de deux variables @a pour recuperer idemp
declare @b int -- @b pour recuperer la valeur retourner par la fonction
scalaire ancienete(@a)
declare curseur1 cursor for select idemp from Employé -- declaration curseur
open curseur1
fetch next from curseur1 into @a --recuperer la valeur idemp du premier
employé et affecter au variable @a
select @b=dbo.ancienete(@a)
print 'Employé Numéro='+cast(@a as varchar(10))+' a l''ancienté'+cast(@b as
varchar(10))
while(@@FETCH_STATUS=0)
begin
fetch next from curseur1 into @a
select @b=dbo.ancienete(@a)
print 'Employé Numéro='+cast(@a as varchar(10))+' a
l''ancienté'+convert(varchar(10), @b)
end
close curseur1
deallocate curseur1
--Q3 solution 1 avec print
-- procedure normale
create procedure proceduret
as
begin
declare @a varchar(20)--------- pour recuperer le nomprenom
declare @b varchar(20)-------------pour recuperer le nom de departement
declare curseur2 cursor for select e.[nom prenom], d.nom from departement d,
employé e where d.iddept=e.iddept
open curseur2
fetch next from curseur2 into @a,@b
print 'l''employé'+@a+'travaille dans le departement'+@b
while(@@FETCH_STATUS=0)
begin
fetch next from curseur2 into @a,@b
print 'l''employé'+@a+'travaille dans le departement'+@b
end
close curseur2
deallocate curseur2
end
------------------------------------------------------------------------------
----------------------------------
-- solution 2 : avec fetch du curseur
declare curseur2 cursor for select e.[nom prenom], d.nom from departement d,
employé e where d.iddept=e.iddept
open curseur2
fetch next from curseur2
while(@@FETCH_STATUS=0)
begin
fetch next from curseur2
end
close curseur2
deallocate curseur2
 Examen blanc : SQL
Server(LDD+LMD+Programmation DB)

Soit le modèle relationnel suivant pour la BD gestion bibliothèque :

Étudiant(cin, nom prénom, date naissance, adresse, ville, tel, pays,)
Responsable(cin, nom prénom, date naissance, adresse, salaire )
Livre(idlivre,nom de livre, date d'édition, maison d'édition)
Emprunt(#idlivre, #cin responsable, #cin étudiant, date d' emprunt, date de retour,
réglé('oui', 'en cours', 'non'))

En utilisant le langage SQL, Programmer les requêtes suivantes :

Q1-) Créer la BD [Gestion Bibliothèque].
Q2-) Créer la table Emprunt .
Q3-) Dupliquer le livre'Programmer en C' sans maison d'édition (id livre est auto-incrément).
Q4-) Quels sont les livres édités par la même maison d'édition?
Q5-) Quels sont les livres qui ont édité en 2000 ?
Q6-) Pour chaque responsable(cin)acher le nombre de livre emprunté.
Q7-) Quels sont les étudiants(cin) qui ont dépassé la date de retour de livre(durée d'emprunt de
livre=3 jours)?
Q8-) Quels sont les étudiants(nom,prénom, adresse) qui ont emprunté le livre 'Analyse 2' ?
Q9-) Quels sont les livres(nom de livre) qui ne sont pas empruntés par aucun étudiant ?
Q10-) Supprimer les emprunts expirés (réglé='oui') .
Q11-) Écrire une fonction qui calcule la durée d'emprunt d'un livre.
Q12-) Écrire une fonction qui retourne la liste des étudiants.
Q13-) Écrire une procédure qui calcule le nombre d'emprunt d'un étudiant.
Q14-) Acher les noms, prénoms et l'age des étudiants utiliser un curseur.
Bonne Chance .

EMSI Casablanca A.U 2020/2021.

 Correction Examen blanc
-- Mettez le fichier 'gestionbiblio.bak' dans C:\Program Files\Microsoft SQL
Server\MSSQL10_50.MSSQLSERVER\MSSQL\Backup
--restore database [Gestion bibloitheque] from disk='gestionbiblio.bak'
use [Gestion Bibliotheque]
go

--Q1
create database [Gestion Biblio]
go
use [Gestion Biblio]
go
--Q2
create table Emprunt2(idlivre int, cinresp varchar(10), cinetd varchar(10),
[date emprunt] date, date_retour date, reglé varchar(20),
constraint c23 primary key(idlivre, cinresp, cinetd),
foreign key(idlivre) references livre
on delete cascade
on update cascade,
foreign key(cinresp) references responsable
on delete cascade
on update cascade,
foreign key(cinetd) references etudiant
on delete cascade
on update cascade)
--Q3
insert into livre(nomlivre, [date edition])
select nomlivre,[date edition] from livre where nomlivre='programmer en C'
select * from livre
--Q4
select l1.nomlivre, l2.nomlivre, l2.[maison edition]
from livre l1, livre l2
where l1.idlivre<>l2.idlivre
and l1.[maison edition]=l2.[maison edition]
--Q5
select * from livre
select * from livre where YEAR([DATE edition])=2000
--Q6
select cinresp, COUNT(*) as nbrelivre from Emprunt group by cinresp
select r.[nom prenom], COUNT(*) as nbrelivre from Emprunt e, Responsable r
where e.cinresp=r.cin group by r.[nom prenom]
--Q7
select cinetd,DATEDIFF(day,[date emprunt],[date retour])as nbrejour
from Emprunt where DATEDIFF(day,[date emprunt],[date retour])>3
------------------------------------------------------------------------
select etd.[nom prenom],DATEDIFF(day,[date emprunt],[date retour])as nbrejour
from Emprunt e, Etudiant etd where e.cinetd=etd.cin and
DATEDIFF(day,[date emprunt],[date retour])>3
--Q8
select etd.[nom prenom], etd.adresse from etudiant etd, Emprunt e, livre l
where etd.cin=e.cinetd and l.idlivre=e.idlivre and l.nomlivre='Analyse2'
--Q9
select nomlivre from livre where idlivre not in (select idlivre from Emprunt)
--Q10
delete from Emprunt where reglé='oui'
------- programmation BD
------- programmation BD
--Q11
-- fonction scalaire
--input : @idliv int
create function durée(@idliv int)
returns int
as
begin
---corps de la fct
declare @duree int
select @duree=datediff(day,[date emprunt],[date retour])
from Emprunt
where idlivre=@idliv
return @duree
end
---------------------execution
select dbo.durée(1) as nbrejour
print dbo.durée(1)
--Q12
-- fonction table
create function affichetd()
returns table
return select * from etudiant
----execution
select * from affichetd()
--------------------------------
--Q13
create procedure calculemp(@cinetd varchar(10), @nbre int output)
as
begin
select @nbre=COUNT(*) from Emprunt where cinetd=@cinetd
end
-------execution
declare @nbre int
exec calculemp 'A1234567', @nbre output
--select @nbre as nbreemprunt
print @nbre
--Q14
-- tout d'abord, il faut declarer la fonction qui calcul l'age puis le curseur
ou on appelle cette fonction
-- fct qui calcule l'age
--datediff(year,[date naissance], getdate())
create function calculage(@cin varchar(10))
returns int
as
begin
declare @age int
select @age=datediff(year,[date naissance],getdate())
from Etudiant where cin=@cin
return @age
end
----
select * from etudiant
select dbo.calculage('A1234567') as age
print dbo.calculage('A1234567')
-------------
declare c1 cursor for select cin,[nom prenom], [date naissance]
from etudiant
declare @cin varchar(20)
declare @nompr varchar(20)
declare @daten date
declare @age int
open c1
fetch next from c1 into @cin,@nompr,@daten
select @age=dbo.calculage(@cin)
print'l''etudiant'+@nompr+'a l''age'+cast(@age as varchar(20))
while(@@FETCH_STATUS=0)
begin
fetch next from c1 into @cin,@nompr,@daten
select @age=dbo.calculage(@cin)
print'l''etudiant'+@nompr+'a l''age'+convert(varchar(20), @age)
end
close c1
deallocate c1