Vous êtes sur la page 1sur 70

Support de cours

Systèmes de Gestion de Bases de


données

Elaboré par :

Dr. Mohamed HMIDEN


Dr. Tarek HAMROUNI

Année universitaire : 2016-2017.


Systèmes de gestion de bases de données

SYSTEMES DE GESTION DE BASES DE


DONNEES

DONNEES ORGANISATIONNELES

Diplôme : Licence en Informatique Multimédia


Etablissement : Institut Supérieur des arts multimédia
Université : Manouba
Niveau : deuxième Niveau
Modalité d’évaluation :
- Contrôle Continu : Test + Interrogation + Discipline
- Devoir Surveillé
- Examen Final
Année Universitaire : 2016/2017

Objectifs Généraux

- Maitriser les commandes SQL de définition et de manipulation de


données.
- Répondre à des requêtes simples et complexes
- Manipuler les commandes SQL via le système de gestion de bases
de données MYSQL.

Prérequis

 Base de données : Niveau conceptual

ii
Systèmes de gestion de bases de données

Table de matières

Chapitre 1 : Langage de Définition des ........................................................................................................................ 3


Données dans SQL ....................................................................................................................................................... 3
1. Introduction...................................................................................................................................................... 3
2. Les types de données ....................................................................................................................................... 3
3. Création des tables ........................................................................................................................................... 3
4. Les contraintes d’intégrité (C.I.) ...................................................................................................................... 4
4.1. Motivations de la mise en place des contraintes d'intégrité .....................................................................4
4.2. Contrainte NOT NULL ...........................................................................................................................5
4.3. Contrainte UNIQUE ...............................................................................................................................5
4.4. Contrainte PRIMARY KEY ...................................................................................................................5
4.5. Contrainte FOREIGN KEY ....................................................................................................................6
4.6. Contrainte CHECK .................................................................................................................................6
5. Modification de la structure d’une table ........................................................................................................... 6
5.1. Ajout d’un attribut ...................................................................................................................................7
5.2. Modification d’un attribut .......................................................................................................................7
5.3. Suppression d’un attribut ........................................................................................................................7
6. Mise à jour des contraintes d’intégrité ............................................................................................................. 7
6.1. Ajout d’une contrainte d’intégrité ...........................................................................................................7
6.2. Suppression d’une contrainte d’intégrité .................................................................................................7
7. Suppression d’une table ................................................................................................................................... 8
Chapitre 2 : Langage de Manipulation des Données dans SQL ................................................................................... 9
1. Présentation générale du langage SQL ............................................................................................................. 9
1.1. Définition de SQL ...................................................................................................................................9
1.2. Normes de SQL .......................................................................................................................................9
1.3. Trois composantes de SQL .....................................................................................................................9
2. Langage de Manipulation de Données ........................................................................................................... 10
2.1. Définition du LMD ............................................................................................................................... 10
2.2. Interrogation des données ..................................................................................................................... 10
2.3. Syntaxe simplifiée de la commande SELECT .................................................................................. 10
2.4. Syntaxe générale de la commande SELECT ..................................................................................... 12
2.4.1. La clause SELECT ....................................................................................................................... 12
2.4.2. La clause FROM .......................................................................................................................... 13
2.4.3. La clause WHERE ....................................................................................................................... 13
2.4.4. La clause GROUP BY.................................................................................................................. 14
2.4.5. La clause HAVING ...................................................................................................................... 15
2.4.6. La clause ORDER BY.................................................................................................................. 15
2.5. Alias de colonnes ou de tables .................................................................................................................. 15
2.6. Les jointures ............................................................................................................................................ 16
2.6.1. Définition d’une jointure.................................................................................................................. 16
2.6.2. Jointure naturelle ............................................................................................................................... 17

1
Systèmes de gestion de bases de données
2.6.3. Jointure d’une table à elle-même ...................................................................................................... 17
2.6.4. Jointure externe ................................................................................................................................ 18
2.7. Les sous-requêtes ..................................................................................................................................... 18
2.7.1. Une sous-requête renvoyant une seule valeur .............................................................................. 19
2.7.2. Une sous-requête renvoyant plusieurs valeurs ............................................................................. 19
2.7.3. Une sous-requête renvoyant plusieurs colonnes ........................................................................... 20
2.7.4. Les sous-requêtes corrélées ou synchronisées .............................................................................. 21
2.7.5. Les opérateurs EXISTS et NOT EXISTS .................................................................................... 22
3. Mise à jour des données ................................................................................................................................. 23
3.1. Insertion des données ........................................................................................................................ 23
3.2. Modification des données ................................................................................................................. 24
3.3. Suppression des données .................................................................................................................. 25
Chapitre 3 : Langage de Contrôle des ......................................................................................................................... 27
Données dans SQL ..................................................................................................................................................... 27
2. Introduction ................................................................................................................................................... 27
3. Les vues ......................................................................................................................................................... 27
2.1. Création d’une vue ....................................................................................................................................... 27
2..2. Mise à jour d’une table à travers une vue.................................................................................................... 28
3. Gestion des utilisateurs .................................................................................................................................. 30
3.1. Création d’un utilisateur........................................................................................................................ 30
3.2. Modification des attributs associés à un utilisateur ............................................................................... 30
4. Les privilèges .................................................................................................................................................. 31
4.1. Accord d’un droit .................................................................................................................................. 31
4.2. Retrait d’un droit .......................................................................................................................................... 32
TP N°1 ........................................................................................................................................................................ 34
Correction TP N°1 ...................................................................................................................................................... 36
TP N°2 ........................................................................................................................................................................ 41
Correction TP N°2 ...................................................................................................................................................... 43
TP N°3 ........................................................................................................................................................................ 48
Correction TP N°3 ...................................................................................................................................................... 50
TP N°4 ........................................................................................................................................................................ 54
Correction TP N°4 ...................................................................................................................................................... 57
TP N°5 ........................................................................................................................................................................ 62
Correction TP N°5 ...................................................................................................................................................... 65
TP N°6 ........................................................................................................................................................................ 68
Correction TP N°6 ...................................................................................................................................................... 69

2
Systèmes de gestion de bases de données

Chapitre 1 : Langage de Définition des


Données dans SQL

1. Introduction
Le Langage de Définition des Données (LDD) permet la création, la modification
et la suppression des tables.

2. Les types de données


Les types de données les plus utilisés sont :

Type Description
Chaîne de caractères de longueur fixe = n (n max 255). Une
CHAR(n)
chaîne plus courte sera complétée par des espaces.
Chaîne de caractères de longueur variable de taille maximale =
VARCHAR(n)
n (n max 255)
Entier codé sur 4 octets. Valeurs de :
INT
-2147483648 à 2147483647
FLOAT Réel codé sur 4 octets.
INT(n) Entier à n chiffres
DATE Date au format aaaa-mm-jj

3. Création des tables


La commande CREATE TABLE permet de créer une table en définissant le nom et le
type de chacune des colonnes de la table. La syntaxe est la suivante :
CREATE TABLE
nom_table (Attribut_1
Type_attribut_1,
Attribut_2
Type_attribut_2,
…….
Attribut_n Type_attribut_n) ;
3
Systèmes de gestion de bases de données

Exemple :
CREATE TABLE emp
(cin int(8),
Prenom VARCHAR
(30), Date_naissance
DATE);

4. Les contraintes d’intégrité (C.I.)


Une C.I. concerne une colonne de la table et peut être aperçue comme étant une condition que
doivent respecter les valeurs de cette colonne.

4.1. Motivations de la mise en place des contraintes d'intégrité


On utilise les contraintes pour :
 Appliquer des règles au niveau d’une table chaque fois qu’une ligne est insérée, mise
à jour ou supprimée de cette table. La contrainte doit être satisfaite pour que
l’opération réussisse.
 Empêcher la suppression d’une table s’il y a des dépendances entre elle et
d’autres tables.
Les types de contraintes dans MySQL sont :
o NOT NULL
o UNIQUE
o PRIMARY KEY
o FOREIGN KEY
o CHECK

4
Systèmes de gestion de bases de données

4.2. Contrainte NOT NULL


Cette contrainte interdit la présence de valeurs NULL dans la colonne à laquelle elle
s’applique.
Exemple :
CREATE TABLE emp
(cin INT (8) NOT NULL,
Prenom VARCHAR(30),
Date_naissance DATE);

4.3. Contrainte UNIQUE


Une contrainte d’intégrité de type UNIQUE appliquée à une colonne exige que chaque valeur
non nulle dans cette colonne soit unique (existe une seule fois).
Exemple :
CREATE TABLE emp
(cin INT(8),
Prenom VARCHAR(30),
Date_naissance DATE,
CONSTRAINT C2 UNIQUE (prenom));

4.4. Contrainte PRIMARY KEY


Une contrainte PRIMARY KEY crée une clé primaire pour la table.
Exemple :
CREATE TABLE emp
(cin INT (8),
Prenom VARCHAR(30),
Date_naissance DATE,
CONSTRAINT PK_C3 PRIMARY KEY (cin));

Remarque : PRIMARY KEY = UNIQUE + NOT NULL

5
Systèmes de gestion de bases de données

4.5. Contrainte FOREIGN KEY

La contrainte FOREIGN KEY, ou contrainte d’intégrité référentielle, désigne une colonne ou


une combinaison de colonnes comme étant une clé étrangère et établit une relation avec une
clé primaire d’une autre table.
Exemple :
CREATE TABLE emp
(cin INT (8),
Prenom VARCHAR(30),
Date_naissance DATE,
Num_dept INT(2),
CONSTRAINT PK_C3 PRIMARY KEY (cin),
CONSTRAINT FK_C4 FOREIGN KEY (Num_dept) REFERENCES
Dept(deptno));

4.6. Contrainte CHECK


Elle définit une condition que chaque ligne doit obligatoirement satisfaire (peut être assimilée
à une contrainte de domaine).
Exemple :
CREATE TABLE emp
(cin INT (8),
Prenom VARCHAR (30),
Date_naissance DATE,
Num_dept INT (2),
CONSTRAINT C5 CHECK (num_dept between 10 and 70));

5. Modification de la structure d’une table


La modification de la structure d’une table peut concerner :
o L’ajout d’attributs,
o La modification d’attributs,
o La suppression d’attributs.

6
Systèmes de gestion de bases de données

5.1. Ajout d’un attribut


La syntaxe est comme suit : ALTER TABLE nom_table ADD (Attr1 Type1, Attr2 Type2, …) ;
Exemple :
ALTER TABLE emp ADD (tel INT(8));
La colonne tel ajoutée est mise à NULL pour toutes les lignes de la table emp. Il en découle
qu’on ne peut pas appliquer une contrainte sur cette colonne lui interdisant d’avoir une valeur
NULL à moins qu’elle soit affectée à une valeur par défaut ou que la table soit vide. Il est à
noter que l’affectation d’une valeur par défaut s’effectue avec le mot clé DEFAULT.
Par exemple, affecter la valeur par défaut 71000000 au numéro de téléphone revient à
écrire la commande : ALTER TABLE emp ADD tel INT(8) DEFAULT 71000000;

5.2. Modification d’un attribut


La syntaxe est comme suit : ALTER TABLE nom_table MODIFY attr type ;
Exemple :
ALTER TABLE emp MODIFY prenom VARCHAR(50);

5.3. Suppression d’un attribut


La syntaxe est comme suit : ALTER TABLE nom_table DROP COLUMN attribut ;
Exemple :
ALTER TABLE emp DROP COLUMN date ;

6. Mise à jour des contraintes d’intégrité


6.1. Ajout d’une contrainte d’intégrité
La syntaxe est comme suit : ALTER TABLE nom_table ADD CONSTRAINT
nom_contrainte … ;
Exemple :
ALTER TABLE emp ADD CONSTRAINT DateUnique UNIQUE (Date_naissance) ;
Date_naissance est bien évidemment un des attributs de la relation emp.

6.2. Suppression d’une contrainte d’intégrité


La syntaxe est comme suit : ALTER TABLE nom_table DROP CONSTRAINT
nom_contrainte ;

7
Systèmes de gestion de bases de données

Exemple :
Rappelons que la contrainte C5 correspond à la contrainte suivante sur l’attribut num_dept de
la table emp : CONSTRAINT C5 CHECK (num_dept between 10 and 70)). Pour supprimer
cette contrainte, on écrit la commande suivante :
ALTER TABLE emp DROP CONSTRAINT C5 ;

7. Suppression d’une table


La suppression d’une table est effectuée par la requête DROP TABLE, celle-ci détruirait les
données et la structure de la table.
DROP TABLE nom_table ;
Exemple :
DROP TABLE emp ;

supprimera la table emp (structure et données).


Attention : « DROP TABLE » supprime la structure en plus des données si elles existent,
contrairement à « DELETE FROM » qui ne supprime que les données.

8
Systèmes de gestion de bases de données

Chapitre 2 : Langage de Manipulation des


Données dans SQL

1. Présentation générale du langage SQL

1.1. Définition de SQL

SQL (Structured Query Language) est un langage complet de gestion des BDR. Il a été conçu
par IBM dans les années 70. Il est devenu le langage standard pour les SGBDR.

1.2. Normes de SQL

SQL a été normalisé plusieurs fois :

 1ère norme en 1986 (SQL86)

 2ème norme en 1992 (SQL2 ou SQL92)

 3ème norme (SQL3 = SQL2 + concepts inspirés de l’approche objet)

1.3. Trois composantes de SQL

SQL est un ensemble de commandes que nous pouvons diviser en 3 parties :


 Un langage de manipulation de données (LMD)
 Un langage de définition des données (LDD)
 Un langage de contrôle d’accès aux données (LCD

Nous nous intéressons dans ce cours à SQL2.


Le langage SQL est utilisé par les principaux SGBDR : Oracle, DB2, MySQL, etc.
Cependant, chacun de ces SGBDR a sa propre variante du langage SQL. Nous traitons dans
ce cours le langage SQL propre au SGBDR MySQL.

9
Systèmes de gestion de bases de données

2. Langage de Manipulation de Données

2.1. Définition du LMD

Le LMD permet l’ajout, la suppression et la modification de lignes, ainsi que la visualisation


(interrogation) du contenu des tables.

2.2. Interrogation des données

La commande SELECT constitue, à elle seule, le langage permettant d’interroger une base de
données. Elle permet de :
- sélectionner certaines colonnes d’une table (projection) ;
- sélectionner certaines lignes d’une table en fonction de leur contenu (sélection) ;
- combiner des informations venant de plusieurs tables (jointure, union, intersection,
différence et division) ;
- combiner entre ces différentes opérations.

Une requête (i.e. une interrogation) est une combinaison d’opérations portant sur des tables
(relations) et dont le résultat est lui-même une table dont l’existence est éphémère (ne dure
que le temps de la requête).

2.3. Syntaxe simplifiée de la commande SELECT

Une requête se présente généralement sous la forme :

SELECT [DISTINCT ] { * | attribut1, .., attributn}


FROM nomTable1, …, nomTablem
[ WHERE condition ] ;

- la clause SELECT permet de spécifier les attributs que l’on désire voir apparaître dans
le résultat de la requête ; le caractère étoile (*) récupère tous les attributs de la table
générée par la clause FROM de la requête ;
- la clause FROM spécifie les tables sur lesquelles porte la requête ;

10
Systèmes de gestion de bases de données

- la clause WHERE, qui est facultative, énonce une condition que doivent respecter les
tuples sélectionnés.
Exemple :
Soit la relation Emp (cin, prenom, age, ville, salaire, num_dept)
1) Afficher toutes les informations sur les employés.
SELECT *
FROM Emp ;
ou bien
SELECT cin, prenom, age, ville, salaire, num_dept
FROM Emp ;

2) Afficher les prénoms et les villes des employés qui travaillent au département 10.
SELECT prenom, ville
FROM Emp
WHERE num_dept=10;

3) Afficher les différents numéros de département de façon distincte.


SELECT DISTINCT num_dept
FROM Emp ;

Exercice :
Traduire les opérateurs de projection et de sélection de l’algèbre relationnelle en SQL.

- ∏ [A1, A2, …, An] relation se traduit tout simplement en SQL par la requête :
SELECT DISTINCT A1, A2, …, An FROM relation;
- σ [prédicat] relation se traduit tout simplement en SQL par la requête
:
SELECT * FROM relation WHERE prédicat ;

11
Systèmes de gestion de bases de données

2.4. Syntaxe générale de la commande SELECT

Voici la syntaxe générale d’une commande SELECT :


SELECT <liste de sélection>
FROM <une ou plusieurs
tables> [WHERE prédicat ]
[ GROUP BY <colonnes de groupement>
] [ HAVING <condition > ]

[ ORDER BY <colonne de tri> [ ASC | DESC ]…] ;

Remarque : En fait, la commande SELECT est composée de 6 clauses dont 4


sont optionnelles c.-à-.d. facultatives.

2.4.1. La clause SELECT


Cette clause permet de spécifier les attributs que l’on désire voir apparaître dans le résultat de
la requête. Cette clause peut contenir des fonctions de groupes ou d’agrégation :
o SUM() : somme des valeurs de l'argument (en général une colonne)
o AVG() : moyenne d'une colonne
o MAX() : maximum d'une colonne
o MIN() : minimum d'une colonne
o COUNT() : décompte le nombre de tuples (ou d’éléments/valeurs d’une colonne)

Exemple :
Soit la relation Emp(cin, prenom, age, ville, salaire, num_dept)
1) afficher le salaire moyen des employés
SELECT AVG(salaire)
FROM EMP ;

2) Afficher l’age minimal et la somme des salaires des employés


SELECT MIN(age), SUM(salaire)
FROM EMP ;

12
Systèmes de gestion de bases de données

2.4.2. La clause FROM


Cette clause spécifie les tables sur lesquelles porte la requête.

2.4.3. La clause WHERE


Cette clause permet de filtrer les tuples en imposant une condition à remplir pour qu’ils soient
présents dans le résultat de la requête.
Le prédicat est une expression logique (booléenne) pouvant inclure :
Des comparateurs : =, !=, >, <, >= et <=
Des connecteurs (opérateur logique) : AND (conjonction), OR (disjonction), NOT
(négation)
Des parenthèses
Les opérateurs SQL :
- IN, NOT IN (exp IN (exp1, exp2, …))
Exemple: WHERE age in (10, 20) WHERE age =10 or age=20
- BETWEEN, NOT BETWEEN (exp BETWEEN exp1 AND exp2)
Exemple: WHERE age between 10 and 20 WHERE age >=10 and age <=20
- IS NULL, IS NOT NULL (l’opérateur = ne peut pas être utilisé pour comparer une
valeur d’une colonne à NULL, il faut utiliser cet opérateur)
- LIKE, NOT LIKE : LIKE permet de comparer deux chaînes de caractères en
tenant compte des caractères jokers :
_ : remplace un caractère
% : remplace n caractères (n >= 0)
Exemple: WHERE prenom like ‘B%’
- Les opérateurs arithmétiques : +, -, *, /
Exemple : 12*salaire + prime
Exemple : Soit la relation Emp(cin, prenom, age, ville, salaire, num_dept)
1) Afficher la liste des employés des départements 10, 20 ou 30
SELECT *
FROM Emp
WHERE num_dept IN (10, 20, 30) ;
ou bien
SELECT *
FROM Emp
WHERE num_dept =10 OR num_dept= 20 OR num_dept= 30 ;

13
Systèmes de gestion de bases de données

2) Afficher la cin des employés ayant un salaire entre 100 et 300 et un age < 40
SELECT cin
FROM Emp
WHERE salaire BETWEEN 100 AND 300 AND age <40;

3) Liste des employés dont le prénom commence par A et se termine par F et contient H
en 3ème position
SELECT *
FROM Emp
WHERE prenom LIKE ‘A_H%F’;

4) Liste des employés (cin, prénom, revenu) qui ont des revenus annuels strictement
supérieurs à 50000.
SELECT cin, prénom, salaire * 12
FROM Emp
WHERE salaire * 12 > 50000 ;

2.4.4. La clause GROUP BY


Cette clause permet de définir des groupes par valeur de colonnes (c'est-à-dire diviser la
relation en groupes, chaque groupe étant l’ensemble des lignes ayant une valeur commune).
Exemple : “GROUP BY col1, col2” permet de grouper en un seul groupe tous les tuples ayant
la même valeur pour col1 et col2

Remarque : On ne peut mettre dans la clause SELECT que les fonctions d’agrégation et/ou
les colonnes qui suivent la clause GROUP BY.
Exemple : Soit la relation Emp (cin, prenom, age, ville, salaire, num_dept)
1) Afficher le salaire moyen et le nombre d’employés par département
SELECT num_dept, AVG(salaire), count(*)
FROM Emp
GROUP BY num_dept;
2) Afficher le minimum des salaires par age
SELECT age, MIN(salaire)
FROM Emp
GROUP BY age;

14
Systèmes de gestion de bases de données

2.4.5. La clause HAVING


Cette clause permet de spécifier un filtre (condition de regroupement des tuples) portant sur
les résultats (c'est-à-dire sélectionner certains groupes vérifiant une condition). Elle se place
après la clause GROUP BY.

Exemple : Soit la relation Emp (cin, prenom, age, ville, salaire, num_dept)
Afficher le salaire moyen par département ayant au moins 10 employés
SELECT num_dept, AVG(salaire)
FROM Emp
GROUP BY num_dept
HAVING count(*) > = 10;

Il est à noter que « Count(*) » permet de calculer le nombre de tuples pour chaque groupe.

2.4.6. La clause ORDER BY


Cette clause permet de trier les n-uplets du résultat. En l’absence de précision ASC ou DESC,
c’est l’ordre ascendant (ASC) qui est utilisé par défaut.
Quand plusieurs expressions, ou colonnes sont mentionnées, le tri se fait d’abord selon les
premières, puis suivant les suivantes pour les tuples qui sont égaux selon les premières.

Exemple : Soit la relation Emp (cin, prenom, age, ville, salaire, num_dept)
Afficher les employés ayant un salaire > 300 selon un ordre croissant sur l’attribut prénom.
SELECT *
FROM Emp
WHERE salaire >300
ORDER BY prenom ASC;

2.5. Alias de colonnes ou de tables

Il existe deux types d’alias qui sont fréquemment utilisés éventuellement ensemble : alias de
colonne et alias de table.

L’alias de colonne (appelé aussi renommage de colonne) tend à améliorer la lisibilité


d’un résultat d’une requête (utile pour expliciter le résultat d'une opération).
Exemple :
SELECT prenom, (salaire*2) AS ‘double du salaire’
FROM Emp ;

15
Systèmes de gestion de bases de données

Dans ce cas les « ‘’ » sont nécessaires à cause de l’espace entre « double » et « Salaire » et
sinon, on peut ne pas les mettre.

L’alias de table (appelé aussi renommage de tables) s’obtient en plaçant directement


un alias après le nom de table dans la clause FROM. Ce type d’alias est utile pour
raccourcir la longueur des requêtes. Cela est par contre nécessaire dans le cas d'une
jointure d'une table sur elle-même.
Exemple :
SELECT E.prenom, D.nomDept
FROM Emp E, Dept D
WHERE E.numDept = D.numDept ;

2.6. Les jointures


2.6.1. Définition d’une jointure
La jointure est une opération permettant de combiner des informations venant de plusieurs
tables. Elle modélise un lien entre les tables.
Une jointure se formule simplement en spécifiant plusieurs tables derrière le FROM de la
façon suivante :
SELECT ...
FROM table1, table2...
WHERE conditionJointure ......;
La condition de jointure est une comparaison entre des attributs des différentes tables.

Remarque : Si on ne précise pas de condition de jointure, le résultat obtenu sera le produit


cartésien des tables présentes derrière le FROM (résultat non souhaité en général).

Exemple : Soient les relations suivantes Enfant(Nom, Prénom, Age) et Cadeau(Nom,


AgeMaxC, Prix).
Afficher les noms et les prénoms des enfants ainsi que les noms des cadeaux qu’ils peuvent
utiliser.
SELECT Enfant.Nom, Prénom, Cadeau.Nom
FROM Enfant, Cadeau
WHERE Age <= AgeMaxC ;

16
Systèmes de gestion de bases de données

2.6.2. Jointure naturelle

La condition de jointure est un test d’égalité entre les deux attributs ayant le même nom dans
les tables, c’est-à-dire table1.Att1 = table2.Att1 (ou d’une manière générale, entre une clé
primaire et une clé secondaire).

Exemple : Soient les relations Emp(cin, prenom, salaire, numDept) et Dept(numDept, nomDept)
1) Afficher toutes les informations sur les employés du département commercial.
SELECT Emp.cin, Emp.prenom, Emp.salaire, Emp.numDept
FROM Emp, Dept
WHERE Emp.numDept = Dept.numDept and Dept.nomDept= ‘commercial’;
ou bien
SELECT cin, prenom, salaire, Emp.numDept
FROM Emp, Dept

WHERE Emp.numDept = Dept.numDept and Dept.nomDept = ’commercial’;

2) Afficher le prénom et le nom du département de chaque employé ayant un salaire >


300.
SELECT Emp.prenom, Dept.nomDept
FROM Emp, Dept
WHERE Emp.numDept = Dept.numDept AND Emp.salaire > 300;
ou bien
SELECT prenom, nomDept
FROM Emp, Dept
WHERE Emp.numDept = Dept.numDept AND salaire > 300;

2.6.3. Jointure d’une table à elle-même


Cette opération permet de rassembler des informations venant d’une ligne d’une table avec
des informations venant d’une autre ligne de la même table.
Il faut renommer au moins l’une des 2 tables afin de pouvoir préfixer sans
ambiguïté chaque nom de colonne.
Exemple : Soit la relation Emp(cin, nom, prenom, cinChef).
Afficher le nom de l’employé et le nom de son chef.

17
Systèmes de gestion de bases de données

SELECT Emp.nom AS Employe, S.nom AS Chef


FROM Emp, Emp S
WHERE Emp.cinChef = S.cin;

2.6.4. Jointure externe


Soient les deux relations Emp(cin, prenom, age, ville, salaire, numDept) et Dept(numDept,
nomDept). Considérons cette requête :
SELECT nomDept, prenom
FROM Dept, Emp
WHERE Dept.numDept = Emp.numDept ;
Si un département n’a pas d’employé, il ne sera pas affiché dans le résultat.
Si on veut afficher tous les départements même ceux qui n’ont pas d’employés
en indiquant que la liste des employés est vide, on peut utiliser RIGHT JOIN
… ON ou LEFT JOIN … ON dans la requête.

SELECT nomDept, prenom


FROM Dept
LEFT JOIN Emp ON Emp.numDept=Dept.numDept ;

Avec un LEFT JOIN, on prendra en plus les enregistrements de la table écrite à gauche (car
LEFT) de l'expression LEFT JOIN et qui ne sont reliés à aucun enregistrement de celle de
droite.
ou bien
SELECT nomDept, prenom
FROM Emp
RIGHT JOIN Dept ON Emp.numDept=Dept.numDept ;
Si on permute dans les 2 requêtes précédentes les noms des tables, la sémantique change car
on s’intéressera alors à la liste de tous les employés même ceux n’ayant pas encore été affectés
à un département.

2.7. Les sous-requêtes


Une sous-requête est une requête incluse à l'intérieur d'une clause WHERE ou la clause
HAVING ou la clause FROM. Il existe plusieurs types de sous-requêtes.

18
Systèmes de gestion de bases de données

2.7.1. Une sous-requête renvoyant une seule valeur


Dans ce cas, on peut utiliser les opérateurs de comparaison et la clause WHERE possède la
forme suivante : WHERE exp1 op_comparaison (SELECT exp2 FROM…)
op_comparaison est un opérateur de comparaison (=, >, …..)
exp1 et exp2 doivent être cohérents (de type compatible).

Exemple : Soit la relation Emp(numEmp, prenom, salaire, numDept)


1) Afficher toutes les informations sur les employés ayant un salaire qui dépasse le
salaire moyen.
SELECT *
FROM Emp WHERE salaire > (SELECT AVG(salaire)
FROM Emp) ;
2) Afficher toutes les informations sur les employés qui travaillent dans le même
département que l’employé ayant 1 comme numEmp.
SELECT *
FROM Emp WHERE numDept = (SELECT numDept
FROM Emp
WHERE numEmp=1) ;
Refaire la requête 2) en ne considérant que le numEmp, le numDept et le salaire.

2.7.2. Une sous-requête renvoyant plusieurs valeurs


Dans ce cas, on peut utiliser :
Les opérateurs d’appartenance IN et NOT IN
WHERE exp1 IN (SELECT exp2 FROM ……….)
WHERE exp1 NOT IN (SELECT exp2 FROM ……….)
o exp2 peut être un attribut, une fonction arithmétique, etc. (mais pas de fonction
de groupe car cette dernière renvoie une valeur ! (utilisable toutefois avec
GROUP BY))

Les opérateurs de comparaison combinés avec ANY ou ALL


WHERE exp1 op_comparaison ANY (SELECT exp2 FROM……..)
WHERE exp1 op_comparaison ALL (SELECT exp2 FROM……..)
op_comparaison est un opérateur de comparaison (=, >, …..)

19
Systèmes de gestion de bases de données

ANY: la condition est vraie si la comparaison est vraie pour au moins une des valeurs
retournées.
ALL : la condition est vraie si la comparaison est vraie pour toutes les valeurs retournées.

Remarque : = ANY IN et != ALL NOT IN

Exemple : Soient les relations suivantes Emp (numEmp, nom, prenom, age, ville, salaire,
numDept) et Dept(numDept, nomDept).

1. Afficher toutes les informations sur les employés gagnant plus que tous les employés du
département 30.
SELECT *
FROM Emp
WHERE salaire > ALL (SELECT salaire
FROM Emp WHERE numDept=30);
2. Afficher le nom, le prénom et la ville des employés gagnant plus qu’au moins un employé
du département 30.
SELECT nom, prenom, ville
FROM Emp
WHERE salaire > ANY (SELECT salaire
FROM Emp WHERE numDept=30);

2.7.3. Une sous-requête renvoyant plusieurs colonnes


Dans ce cas, si la sous-requête renvoie une seule valeur (c.-à.-d. un n-uplet de n valeurs simples),
la clause WHERE possède la forme suivante : WHERE (exp1, exp2, …, expn)
op_comparaison_classique (SELECT col1, col2, …, coln) où op_comparaison_classique ne
peut être que = ou != (c.-à.-d. NI <=, NI, >=, NI <, NI >).
Exemple : (age, salaire) = (20, 3575.60)

Par contre, si la sous-requête renvoie plusieurs n-uplets, on peut utiliser :

Les opérateurs d’appartenance IN et NOT IN : dans ce cas, la clause WHERE possède la


forme suivante :

20
Systèmes de gestion de bases de données

WHERE (exp1, exp2, …, expn) IN (SELECT col1, col2, …, coln)


WHERE (exp1, exp2, …, expn) NOT IN (SELECT col1, col2, …, coln)
Les opérateurs de comparaison combinés avec ANY ou ALL
WHERE (exp1, exp2, …, expn) op_comp_classique ANY (SELECT col1, col2, …, coln)
WHERE (exp1, exp2, …, expn) op_comp_classique ALL (SELECT col1, col2, …, coln)

Exemple : Soit la relation Emp (numEmp, prenom, age, ville, salaire, numDept).
Afficher le nom des employés qui travaillent dans le même numéro de département et ayant le
même salaire que l’employé ayant 3 comme numEmp.
SELECT nom
FROM Emp
WHERE (numDept, salaire) = (SELECT numDept, salaire FROM Emp WHERE
numEmp=3) ;
Traiter des exemples avec ALL vs. ANY et IN vs. =ANY : Afficher le numEmp de
tout employé âgé de plus que 50 ans et ayant le même salaire et la même ville qu’un
employé de 25 ans.

2.7.4. Les sous-requêtes corrélées ou synchronisées


Une sous-requête corrélée est une sous-requête dont l’évaluation se fait pour chaque ligne de
la requête principale (c.-à.-d. que le résultat de la sous-requête dépend des données contenues
dans la ligne de la requête principale).

Exemple : Soient les relations suivantes Emp (numEmp, prenom, age, ville, salaire,
numDept) et
Dept(numDept, nomDept)

Afficher toutes les informations sur tout employé dont le salaire est supérieur au salaire
moyen de son département.

21
Systèmes de gestion de bases de données

SELECT *
FROM Emp E
WHERE salaire > (SELECT AVG (salaire) FROM Emp WHERE
E.numDept=Emp.numDept) ;

Le résultat dépend de E.numDept

L’exécution de cette requête se produit ainsi :


1. La requête principale fixe une ligne de la table Emp ayant pour alias E.
2. Ayant E.numDept la sous-requête est évaluée.
3. Ensuite, la condition de la clause WHERE de la requête principale est
évaluée. La ligne est alors retournée ou non suivant la valeur de la
condition.
4. Itération des étapes 1, 2 et 3 pour les lignes restantes de la table Emp.

2.7.5. Les opérateurs EXISTS et NOT EXISTS

Si la sous-requête renvoie au moins une valeur, la clause EXISTS (SELECT …) vaut True et
la clause NOT EXISTS (SELECT …) vaut False, et inversement dans le cas contraire (renvoi
d’aucune valeur).
La clause EXISTS est suivie d’une sous-requête et prend la valeur vraie s’il existe au moins une
ligne satisfaisant les conditions de la sous-requête. Inversement pour NOT EXISTS. Toutefois,
il est important de noter que le résultat en tant que tel de la sous-requête n’a aucune importance.
Ces clauses EXISTS et NOT EXISTS sont utiles pour exprimer l’opérateur de division de
l’algèbre relationnelle.
Exemple : Soient les relations Client (numClient, NomClient, VilleClient) et Commande
(numCommande, montant, #numClient)
1- Afficher toutes les informations sur les clients qui ont passé au moins une commande
SELECT *
FROM Client
WHERE EXISTS (SELECT * FROM Commande WHERE Client.numClient
= Commande.numClient);

22
Systèmes de gestion de bases de données

2- Afficher le nom et ville des clients qui n’ont passé aucune commande
SELECT *
FROM Client
WHERE NOT EXISTS (SELECT * FROM Commande WHERE
Client.numClient = Commande.numClient);

3. Mise à jour des données


3.1. Insertion des données

La commande INSERT permet d’insérer une ligne dans une table en spécifiant les valeurs à
insérer. La syntaxe est la suivante :
INSERT INTO nom_table [(col_1, col_2, ..., col_n)]
VALUES (val_1, val_2, ..., val_n) ;
La liste des noms de colonne est optionnelle. Si elle est omise, la liste des colonnes sera par
défaut la liste de l’ensemble des colonnes de la table dans l’ordre de la création de la table.
Si une liste de colonnes est spécifiée, les colonnes ne figurant pas dans la liste auront la valeur
NULL.

Il est possible d’insérer dans une table des lignes provenant d’une autre table. La syntaxe est
la suivante :
INSERT INTO nom_table [(col_1, col_2, ..., col_n)]
SELECT col_1’, col_2’, ..., col_n’
FROM ...
[WHERE ...];
avec col_i’ de type compatible avec col_i.

Remarque : Chaque ligne ajoutée doit respecter les contraintes d’intégrité (clé primaire, etc.)
et les contraintes de domaine de la relation où elle est ajoutée.

Exemple : Soient les relations Emp(cin, prenom, age, ville) et Archive(cinA, prenomA,
dateEmbauche, dateFinEmbauche).

23
Systèmes de gestion de bases de données

1. Insérer le tuple « 01, Ali, 20, Tunis » dans la relation Emp.


INSERT INTO Emp (cin, prenom, age, ville) VALUES (01, ‘Ali’, 20, ‘Tunis’) ;
ou bien

INSERT INTO Emp VALUES (01, ‘Ali’, 20, ‘Tunis’);

2. Insérer dans la relation Emp un employé dont sa cin est égal à 2, son prénom est
‘Mohamed’ et qui habite à ‘Tunis’.
INSERT INTO Emp (cin, prenom, ville) VALUES (01, ‘Mohamed’, ‘Tunis’) ;

3. Insérer dans la relation Archive les cins et prénoms des employés de Emp ayant plus de 60
ans.
INSERT INTO Archive(cinA, prenomA)
SELECT cin, prenom
FROM Emp
WHERE age > 60 ;

3.2. Modification des données

La commande UPDATE permet de modifier les valeurs d’une ou plusieurs colonnes, dans une
ou plusieurs lignes existantes d’une table. La syntaxe est la suivante :
UPDATE nom_table
SET nom_col_1 = {expression_1 | (SELECT …)},
nom_col_2 = {expression_2 | (SELECT …)},
...
nom_col_n = {expression_n | (SELECT …)}
[WHERE predicat];

Expression_i définit une valeur pour l’attribut i (elle peut être un ordre SELECT renvoyant
une valeur).
Les valeurs des colonnes nom_col_1, nom_col_2, ..., nom_col_n sont modifiées dans
toutes les lignes qui satisfont le prédicat « predicat ».
La clause WHERE est facultative. En l’absence d’une clause WHERE, toutes les lignes sont
mises à jour.

24
Systèmes de gestion de bases de données

Exemple : Soient les relations Emp(cin, prenom, age, ville, salaire, numDept) et
Dept(numDept, nomDept).
1) Faire passer Ali dans le département 10.
UPDATE Emp
SET numDept=10
WHERE prenom =‘Ali’ ;

2) Enlever l’âge d’Ali


UPDATE Emp
SET age=NULL
WHERE prenom = ‘Ali’ ;
3) Augmenter le salaire de 40 dinars des employés du département 20.
UPDATE Emp
SET salaire=salaire+40
WHERE numDept=20 ;
4) Modifier le numéro de département des employés des départements 10 et 15 par le
numéro de département le plus élevé de la relation Dept.
UPDATE Emp
SET numDept = (SELECT MAX(numDept) FROM Dept)
WHERE numDept = 10 OR numDept = 15;

3.3. Suppression des données


La commande DELETE permet de supprimer des lignes de la table et non la table elle-même.
La syntaxe est la suivante :
DELETE FROM nom_table
[WHERE predicat] ;

Toutes les lignes pour lesquelles predicat est évalué à vrai sont supprimées.
La clause WHERE est facultative. En l’absence de la clause WHERE, toutes les lignes de la
table sont supprimées (la relation existe mais sa population est vide).

25
Systèmes de gestion de bases de données

Exemple : Soit la relation Emp(cin, prenom, age, ville, salaire, numDept).


Supprimer les employés qui travaillent au département 10
DELETE FROM Emp
WHERE numDept=10 ;

26
Systèmes de gestion de bases de données

Chapitre 3 : Langage de Contrôle des


Données dans SQL

2. Introduction

Afin d’assurer la sécurité et la confidentialité des données, les SGBD offrent la possibilité
d’utiliser deux mécanismes complémentaires :
- la création des vues, donnant un accès restreint aux données,
- la création de comptes utilisateurs caractérisés par un login et un mot de passe tout en
attribuant des privilèges (droits d’accès) particuliers à chaque utilisateur.
Ceci est réalisé moyennant un langage dit de Contrôle de Données (LCD).

3. Les vues

Une vue est une table virtuelle créée à partir d’une requête SELECT. Il est donc possible de
rassembler dans une vue des informations provenant de plusieurs tables. Cela permet
d’assurer plus de sécurité aux données puisque l'accès aux tables est restreint pour l'utilisateur
et permet de répondre plus au besoin de réutilisabilité.
2.1. Création d’une vue

La syntaxe de création d’une vue est la suivante :

CREATE VIEW nom_Vue [(nomCol1, …, nomColn)] AS


SELECT……
[WHERE…]

La spécification des noms de colonnes de la vue est facultative. Par défaut, les noms des
colonnes de la vue sont les mêmes que les noms des colonnes résultat du
SELECT. Toutefois, si certaines colonnes résultat du SELECT sont des expressions, il
est préférable de renommer ces colonnes dans le SELECT, ou de spécifier les noms de
colonnes de la vue.

Exemple : Soit la relation Emp(cin, prenom, age, ville, salaire, numDept)


1) Créer une vue qui sélectionne le prénom, l’âge et le salaire des employés du
département n°100.

27
Systèmes de gestion de bases de données

CREATE VIEW emp100 AS


SELECT prenom, age, salaire
FROM emp
WHERE numDept = 100 ;

2) Créer une vue qui sélectionne la moyenne, le max, le min des salaires des
employés du département n°100.

CREATE VIEW vue(moyenneSal, maxSal, minSal) AS


SELECT AVG(salaire), max(salaire), min(salaire)
FROM emp
WHERE numDept = 100 ;

Remarque :
- Une vue est une requête à laquelle on donne un nom :
- Elle est utilisable comme une table dans un SELECT. (SELECT * from nomVue ;)
- La vue est recalculée à chaque utilisation. (« SELECT max(salaire) from nomVue ; »
peut renvoyer 1500 et ensuite 2000, tout dépend du contenu de la table et du coup de
la vue)

2..2. Mise à jour d’une table à travers une vue


On distingue les conditions associées aux opérations d’insertions (INSERT) et de celles de
suppression (DELETE) et de celles de mise à jour (UPDATE) qu’on peut réaliser à travers
des vues sur la ou les tables d’où ont été extraites les données que contient la vue.

Pour les INSERT :


- le SELECT définissant la vue ne doit renvoyer que des colonnes appartenant à
une seule table,
- les colonnes résultat du SELECT doivent être des colonnes réelles et non pas des
expressions (pas de fonctions arithmétiques ou d’agrégation, ni d’utilisations des
opérateurs arithmétiques, etc.).

Pour les UPDATE :


- les colonnes modifiées à travers la vue doivent être des colonnes réelles et non
pas des expressions.

28
Systèmes de gestion de bases de données

Pour les DELETE :


- le SELECT associé à la vue ne doit pas contenir une jointure.

La syntaxe de INSERT, de UPDATE, et de DELETE appliquées à une vue est la même


que celles associées à une table. Par exemple :
La syntaxe d’insertion est comme suit :
INSERT INTO nom_Vue [(col_1, col_2, ..., col_n)]
VALUES (val_1, val_2, ..., val_n) ;
La syntaxe de mise à jour est comme suit :
UPDATE nom_Vue
SET nom_col_1 = {expression_1 | (SELECT …)},
nom_col_2 = {expression_2 | (SELECT …)},
...
nom_col_n = {expression_n | (SELECT …)}
[WHERE predicat];

Exemple :
Rajouter 50dt aux salaires du département 100 à travers la vue emp100.
UPDATE emp100
SET salaire = salaire +50;

Toutes les lignes de la table emp, telles que le contenu de la colonne numdept est égal à
100, seront modifiées.

Attention : Pas d'opération de mise à jour (insert/update/delete) directement sur une vue mais
seulement sur la table d’où elle retient le contenu.
Exemple :
create view view1 (numeroEmp, doubleSalaire)
AS select numEmp, 2*salaire
from emp
where commission IS NOT NULL;

CORRECT (car cela modifie la table emp) :


update view1 set numeroEmp = numeroEmp + 15
FAUX (car cela ne modifie aucune table):
update view1 set doubleSalaire = doubleSalaire + 15.89

29
Systèmes de gestion de bases de données

3.3. Suppression de vue

La syntaxe de suppression d’une vue est la suivante :

Exemple :
DROP VIEW Nom_Vue;
DROP VIEW emp100;

3. Gestion des utilisateurs


3.1. Création d’un utilisateur
Un utilisateur SQL est un profil de navigation doté de privilèges (autorisation d’exécution de
commandes sur des objets). La création d’un utilisateur se fait par la commande CREATE
USER. Elle permet de créer un nouvel enregistrement (un compte) dans la table mysql.user.
Le compte peut recevoir un mot de passe avec la clause optionnelle IDENTIFIED BY.

La syntaxe de création d’un utilisateur

CREATE USER nom_utilisateur [IDENTIFIED BY mot_de_passe] ;

Exemple :

CREATE USER admin IDENTIFIED BY "admin";

3.2. Modification des attributs associés à un utilisateur


La modification d’un utilisateur peut se faire en mettant à jour la table mysql.user (pour
connaître le contenu de cette table, il suffit de lancer la requête SELECT * from mysql.user).

UPDATE mysql.user SET nomAttr = nouvelle_valeur


WHERE……;
Exemple :
Pour modifier le mot de passe :
UPDATE mysql.user SET Password = 'administrateur'
WHERE User = 'admin';

On peut aussi changer le nom de l’utilisateur moyennant :


30
Systèmes de gestion de bases de données

UPDATE mysql.user SET user = 'admin1'

WHERE User = 'admin'

3. Suppression d’un utilisateur


La syntaxe de suppression d’un utilisateur est comme suit :

DROP USER nom_utilisateur;

Exemple : DROP USER admin ;

4. Les privilèges
Les privilèges sont les autorisations d’exécution de commandes qu’un utilisateur reçoit sur un
objet.

4.1. Accord d’un droit

La commande GRANT permet de donner à un utilisateur des droits d’accès à une table ou
une vue. La syntaxe est la suivante :
GRANT Liste_Privilèges (séparé par,)
ON {table | Vue | * | *.* | nomBase.*}
TO Liste_utilisateurs (séparé par ,)
[WITH GRANT OPTION];

L'option WITH GRANT OPTION permet de définir si l'utilisateur peut lui-même


accorder à un autre utilisateur les privilèges qu'on lui accorde sur les objets.

Afin d'éviter à avoir à saisir l'ensemble des utilisateurs dans le cas d'une autorisation
collective ou bien de citer l'ensemble des permissions, il est possible d'utiliser des mots clés :

- Le mot clé PUBLIC en lieu et place de la liste d'utilisateurs permet d'accorder


les privilèges sur un ensemble d’objets à l'ensemble des utilisateurs.

- Le mot clé ALL PRIVILEGES en lieu et place de la liste de permissions permet


d'accorder tous les privilèges aux utilisateurs présents dans la liste des
utilisateurs.

La liste des privilèges comporte les spécifications suivantes :

31
Systèmes de gestion de bases de données

Droit Signification
ALL PRIVILEGES Tous les droits sauf WITH GRANT OPTION.
ALTER Autorise l'utilisation de ALTER TABLE.
CREATE Autorise l'utilisation de CREATE TABLE.
CREATE VIEW Autorise l'utilisation de CREATE VIEW.
DELETE Autorise l'utilisation de DELETE.
DROP Autorise l'utilisation de DROP.
INSERT Autorise l'utilisation de INSERT.
SELECT Autorise l'utilisation de SELECT.
UPDATE Autorise l'utilisation de UPDATE.
GRANT OPTION Synonyme de WITH GRANT OPTION

Exemple :

1) Donner à tout le monde les droits de consultation de la table emp.


GRANT SELECT ON emp TO PUBLIC;

2) Donner à l’utilisateur « Admin» les droits de mise à jour et de suppression de


la table emp.
GRANT UPDATE,DROP ON emp TO Admin;

4.2. Retrait d’un droit

La commande REVOKE permet d’annuler un privilège donné à un utilisateur. La syntaxe est


la suivante :

REVOKE Liste_Privilèges
ON {table | Vue | * | *.* | nomBase.*}
FROM Liste_utilisateur;
Les mots clé PUBLIC et ALL PRIVILEGES de la commande GRANT reste valables
aussi pour la commande REVOKE.

Exemple : Supprimer à « Admin» le droit de mise à jour de la table emp.

REVOKE UPDATE
ON emp
FROM admin ;

32
Systèmes de gestion de bases de données

TP N°1

Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)
Dept(NumDept, NomDept, #NumDirecteur, Localisation)
Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Partie 1 : Exprimer les requêtes suivantes en SQL :

1) Afficher toutes les informations sur les employés.


2) Afficher les noms et les salaires des employés qui travaillent dans les départements
100, 200 et 400.
3) Afficher toutes les informations sur les employés dont la commission est entre 200 et
1000.
4) Afficher les noms des employés ayant d’une part un salaire > 1000 et d’autre part une
commission > 200 ou vendeur comme fonction.
5) Afficher les noms et les fonctions des employés qui travaillent dans les départements
100 et 400 ou bien ayant un salaire < 5000.
6) Afficher le nombre des départements ayant un nom qui contient la lettre ‘m’ ou ‘n’
dans la troisième position.
7) Afficher les noms, les salaires, les commissions, salaire+commission de tous les
comptables.
8) Afficher le nombre des employés qui travaillent dans le département 400.
9) Afficher le nombre de fonctions différentes.
10) Afficher le total des salaires des employés qui travaillent dans les départements 100 et
400.
11) Afficher les numéros des départements qui ont des ingénieurs.
12) Afficher le nombre des employés ayant une commission.
13) Afficher le nombre des employés comptables et directeurs.
34
Systèmes de gestion de bases de données

14) Afficher le salaire minimal des employés qui travaillent dans le département 100.
15) Afficher le salaire minimal et le salaire maximal du grade numéro 2.
16) Afficher le nombre de projets où intervient l’employé numéro 30.

Partie 2 : Exprimer les requêtes suivantes en SQL :

1) Afficher les noms, les fonctions et les commissions de tous les employés.
2) Afficher le salaire moyen à l’intérieur de chaque département.
3) Afficher le salaire moyen par fonction.
4) Afficher le nombre des employés par fonction.
5) Afficher les numéros des employés qui ne travaillent pas dans le département 100 et
102. Exclure les employés ayant une commission inférieure à la moitié de leurs
salaires.
6) Afficher les numéros des employés ayant un salaire supérieur à 3000 ou ayant un nom
contenant la lettre ‘o’ en deuxième position et se termine par la lettre ‘d’. Le résultat sera
trié selon le salaire dans un ordre décroissant.
7) Afficher les numéros des directeurs ayant un salaire compris entre 1300 et 1500.
8) Afficher le nombre des employés par département.
9) Afficher la moyenne des commissions à l’intérieur de chaque département. Exclure les
départements dont la moyenne des salaires >2000.
10) Afficher toutes les informations sur les ingénieurs par ordre croissant du salaire.
11) Afficher le salaire moyen par département ayant au moins 2 employés.
12) Afficher le nombre des employés et le salaire minimum pour chaque département
ayant au plus 2 employés.
13) Afficher les noms des ingénieurs travaillant dans les départements 100 et 400 par
ordre décroissant du salaire.
14) Afficher pour chaque type de fonction à l’intérieur de chaque département le salaire
maximum, le salaire minimum, la moyenne de salaires, la somme des salaires et le
nombre de salariés. Exclure les fonctions qui commencent par la lettre ‘r’.
15) Afficher le nombre d’employé par projet.
16) Afficher la somme des heures par projet. Exclure les projets contenant moins que 2
employés.

35
Systèmes de gestion de bases de données

Correction TP N°1

Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)
Dept(NumDept, NomDept, #NumDirecteur, Localisation)
Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Partie 1 : Exprimer les requêtes suivantes en SQL :

1) Afficher toutes les informations sur les employés.


Select *
From emp ;
2) Afficher les noms et les salaires des employés qui travaillent dans les départements
100, 200 et 400.

Select NomEmp, Salaire


From Emp
Where NumDepin (100,200,400) ;
3) Afficher toutes les informations sur les employés dont la commission est entre 200 et
1000.

Select *
From Emp
Where commission between 200 and 1000 ;
4) Afficher les noms des employés ayant d’une part un salaire > 1000 et d’autre part une
commission > 200 ou vendeur comme fonction.
Select NomEmp
From Emp
Where salaire >1000 and commission > 200
5) Afficher les noms et les fonctions des employés qui travaillent dans les départements
100 et 400 ou bien ayant un salaire < 5000.

36
Systèmes de gestion de bases de données

Select NomEmp
From Emp
Where NumDept in (100, 400) or salaire < 5000 ;
6) Afficher le nombre des départements ayant un nom qui contient la lettre ‘m’ ou ‘n’
dans la troisième position.

Select count(*)
From dept
Where nom like ‘%m%’ or ‘%n%’;

7) Afficher les noms, les salaires, les commissions, salaire+commission de tous les
comptables.
Select nomEmp, Salalire , commission , salaire + commission as revenu
From Emp
Where fonction = ‘comptable’ ;

8) Afficher le nombre des employés qui travaillent dans le département 400.


Select count(*)
From Emp
Where Numdept = 400;
9) Afficher le nombre de fonctions différentes.
Select count (distinct fonction )
From Emp ;
10) Afficher le total des salaires des employés qui travaillent dans les départements 100 et
400.

Select sum(salaire)
From Emp
Where numdep in (100, 400);

11) Afficher les numéros des départements qui ont des ingénieurs.
Select distinct NumDept
From Emp
Where fonction = ‘ingénieur’ ;
12) Afficher le nombre des employés ayant une commission.
Select count(*)
From emp
Where commission >0 ;
13) Afficher le nombre des employés comptables et directeurs.

Select count(*)
From Emp
Where fonction in ( ‘comptable’, ‘ingénieur’) ;

37
14) Afficher le salaire minimal des employés qui travaillent dans le département 100.
Select min(salaire)
From Emp
Where Numdept = 100 ;
15) Afficher le salaire minimal et le salaire maximal du grade numéro 2.
Select min(salaire) asminsal, max(salaire) as maxSal
From Emp E , Grade G
Where salaire E.salaire between salairemin and salairemax ;
16) Afficher le nombre de projets où intervient l’employé numéro 30.

Select count(NumProjet)
From travaillerSur
Where numEMp = 30 ;

Partie 2 : Exprimer les requêtes suivantes en SQL :

1) Afficher les noms, les fonctions et les commissions de tous les employés.
Select nom, fonction, commission
From Emp ;
2) Afficher le salaire moyen à l’intérieur de chaque département.
Select NumDept, Avg(salaire) as salaireMoyen
From Emp
Group by NumDept ;
3) Afficher le salaire moyen par fonction.
Select Fonction, Avg(salaire) as salaireMoyen
From Emp
Group by Fonction;

4) Afficher le nombre des employés par fonction.


Select Fonction, count(*) as salaireMoyen
From Emp
Group by Fonction;

5) Afficher les numéros des employés qui ne travaillent pas dans le département 100 et
102. Exclure les employés ayant une commission inférieure à la moitié de leurs
salaires.

38
Select NumEmp
From Emp
Where NumDept not in (100, 102) and commission < salaire/2

5) Afficher les numéros des employés ayant un salaire supérieur à 3000 ou ayant un nom
contenant la lettre ‘o’ en deuxième position et se termine par la lettre ‘d’. Le résultat
sera trié selon le salaire dans un ordre décroissant.
Select NumEmp
From Emp
Where Nom Like ‘_o%t’
Order by salaire desc ;

6) Afficher les numéros des directeurs ayant un salaire compris entre 1300 et 1500.
Select numEmp
From Emp E, Dept D
Where E. NumDept = D.NumDept
And E.NumEmp = D.NumDirecteur
And salaire between 1300 and 1500;

7) Afficher le nombre des employés par département.


Select NumDept, count(*) as nbrEmployé
From Emp
Group by NumDept;
8) Afficher la moyenne des commissions à l’intérieur de chaque département. Exclure les
départements dont la moyenne des salaires >2000.
Select Numdept, Avg(commission) as commissionMoyenne
From Emp
Group by NumDept
Having avg(commission) <=2000;
9) Afficher toutes les informations sur les ingénieurs par ordre croissant du salaire.
Select *
From Emp
Where function = ‘ingénieur’
Order by salaire ;
10) Afficher le salaire moyen par département ayant au moins 2 employés.
Select numdept , avg(salaire)
From Emp
Group by numdept
Having count(*) >2;

39
12) Afficher le nombre des employés et le salaire minimum pour chaque département
ayant au plus 2 employés.
Select numdept, count(*) as nbEmp, min(salaire) as minSal
From Emp
Group by numdept
Having count(*) >= 2;

13) Afficher les noms des ingénieurs travaillant dans les départements 100 et 400 par
ordre décroissant du salaire.
Select nomEmp,
From Emp
Where fonction = ‘ingénieur’
And numdept in (100,400)
Order by salaire desc;

14) Afficher pour chaque type de fonction à l’intérieur de chaque département le salaire
maximum, le salaire minimum, la moyenne de salaires, la somme des salaires et le
nombre de salariés. Exclure les fonctions qui commencent par la lettre ‘r’.
Select numdept, fonction , max(salaire) as maxSal, avg(salaire) as SalMoyen,
Sum(salaire) as salaireTotal, count(*)
From Emp
Where function not like ‘r%’
Group by numdept, fonction ;

15) Afficher le nombre d’employé par projet.

Select NumProjet , count(*)


From travaillerSur
Group by NumProjet ;
16) Afficher la somme des heures par projet. Exclure les projets contenant moins que
employés.

Select NumProjet , Sum(NbrH) as NBrHtotal


From travaillerSur
Group by NumProjet
Having count(*)>2

40
TP N°2
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)

Projet(NumProjet, NomProjet, Local, #NumDept)


TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Ecrire les requêtes suivantes en SQL :

1. Afficher les adresses des employés et les adresses de leurs départements où ils travaillent.
Utiliser l’alias ADREmp pour l’adresse de l’employé et l’alias ADRDept pour l’adresse
du département ainsi qu’un alias pour chacune des tables utilisées dans la requête.

2. Afficher le nom et le prénom de chaque employé travaillant dans le département


‘Informatique’ et touchant une commission.

3. Afficher les noms, les prénoms et les grades des directeurs des départements.

4. Afficher le nom et le prénom de chaque employé travaillant sur le projet intitulé ‘Web’.

5. Afficher le nombre d’heures total par projet.

6. Afficher les noms et les prénoms des employés travaillant dans le département
‘Informatique’ et opérants sur le projet numéro 10.

7. Afficher pour chaque projet situé à ‘Charguia’ son numéro, le nom du département qui le
contrôle ainsi que le nom et le prénom du directeur de ce département.

41
8. Afficher pour chaque employé, n’étant pas un comptable, son nom, son prénom, ainsi que
le nom et le prénom de son chef s’il est âgé plus que son chef.
9. Afficher les noms des projets ainsi que les noms des départements associés.

10. Afficher le salaire moyen des employés par grade en les ordonnant par salaire moyen
décroissant.

11. Afficher les noms, les salaires et les fonctions des employés de grade 3.

12. Afficher les noms des départements où travaillent des employés dont leurs prénoms
contiennent la lettre c en troisième position.

13. Afficher toutes les informations sur les employés qui ont travaillé sur un projet situé à
‘Charguia’.

14. Afficher les noms des départements contenant des employés de grade 1 et 2.

15. Afficher le nombre d’employés qui ont travaillé dans le département ‘Informatique’ ou
qui ont le grade 2.

16. Afficher les noms de tous les départements et les locaux des projets associés en
considérant même les départements n’ayant aucun projet. Donner 2 versions possibles
pour cette requête.

17. Afficher les noms de tous les projets, affectés ou non à un département, ainsi que, pour
ceux affectés, les adresses des départements associés. Donner 2 versions possibles pour
cette requête.

18. Afficher le nom, la fonction et la somme de la commission et du salaire (avec l’alias


RevenuMensuel) et le nom du grade de tout employé du département ‘Production’ et dont
le grade est 1 ou l’adresse est ‘Tunis’ ou le prénom commence par ‘A’.

19. Afficher toutes les informations sur les projets où travaille un employé habitant à ‘Le
Bardo’ et travaillant comme ‘DG’.

20. Afficher le nom et le prénom de tout employé ayant le même âge et le double du salaire
d’un autre employé ne travaillant pas dans le même département que lui.

42
Correction TP N°2
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)

Projet(NumProjet, NomProjet, Local, #NumDept)


TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Ecrire les requêtes suivantes en SQL :

1. Afficher les adresses des employés et les adresses de leurs départements où ils travaillent.
Utiliser l’alias ADREmp pour l’adresse de l’employé et l’alias ADRDept pour l’adresse
du département ainsi qu’un alias pour chacune des tables utilisées dans la requête.
Select E.adresse as ADREmp , D.adresse as ADRDept
From Emp E, Dept D
Where E.numdept = d.numdept

2. Afficher le nom et le prénom de chaque employé travaillant dans le département


‘Informatique’ et touchant une commission.
Select E.nomEmp, E.prenomEmp
From Emp E, Dept D
Where E

3. Afficher les noms, les prénoms et les grades des directeurs des départements.
Select nomEmp, prenomEmp , Nomgrade
From Emp E, Dept D, grade G
Where E.numEmp= D.NumDirectuer
And Salaire between salairemin and salairemax ;

43
4. Afficher le nom et le prénom de chaque employé travaillant sur le projet intitulé ‘Web’.
Select nomEMp, prenomEmp
From Emp E, travaillerSur T, projet P
Where E.numEmp = T.numEmp
And T.numProjet = P.NumProjet
And nomprojet =’Web’;

5. Afficher le nombre d’heures total par projet.


Select numProjet, Sum(NbrH) as NbrTotal
From TravaillerSur
Group bynumProjet ;

6. Afficher les noms et les prénoms des employés travaillant dans le département
‘Informatique’ et opérants sur le projet numéro 10.

Select nomEmp, prénomEmp


From Emp E, dept D, travaillerSur T
Where E.numdept= D.Numdept
And E.numEmp = T.NumEmp
And NomDept = ‘Informatique”
And NumProjet = 10;

8. Afficher pour chaque projet situé à ‘Charguia’ son numéro, le nom du département qui le
contrôle ainsi que le nom et le prénom du directeur de ce département.

Select NumProjet, NumDept , NomEmp, PrénomEmp


From Projet P, Dept D, Emp E
Where P.NumDept = D.NumDept
And E.NumEmp= D.NumDirecteur
And Local = ‘charguia’ ;
9. Afficher pour chaque employé, n’étant pas un comptable, son nom, son prénom, ainsi que le
nom et le prénom de son chef s’il est âgé plus que son chef.

Select E.NomEmp, E.prénomEmp , E1.NomEmp as nomCHef, E1.prénomEmp as


PrénomCHef
From EMp E, Emp E1
Where E.Numchef = E1.NumEmp
And E.dateNaiss <E1.datenaiss;
10. Afficher les noms des projets ainsi que les noms des départements associés.

Select NomProjet , Nomdept


From Projet P , Dept D
Where P.numdept = D.Numdpet ;

44
11. Afficher le salaire moyen des employés par grade en les ordonnant par salaire moyen
décroissant.
Select numgrade, avg(salaire)
From Emp E, Grade G
Where E.salaire between SalaireMin and SalaireMax
Group by numgrade;
12. Afficher les noms, les salaires et les fonctions des employés de grade 3.
Select NomEmp, salaire , fonction
From Emp E, Grade G
Where E.salaire between SalaireMin and SalaireMax
And numgrade = 3;

13. Afficher les noms des départements où travaillent des employés dont leurs prénoms
contiennent la lettre c en troisième position.
Select NomDept
From dept , Emp E
Where D.numdept = E.Numdept
And substring(NomEmp, 3,1)=’c’ ;
14. Afficher toutes les informations sur les employés qui ont travaillé sur un projet situé à
‘Charguia’.

Select E.*
From Emp E, TravaillerSur T, Projet P
Where E.numEmp= T.NumEmp
And T.NumProjet = P.numProjet
And Local =’charguia’ ;

15. Afficher les noms des départements contenant des employés de grade 1 et 2.

Select NomDept
From Dept D, Emp E, grade G
Where D.numDept = E.NumDept
And E.salaire between salaireMin and SalaireMax;
Andgrade in (1,2);

16. Afficher le nombre d’employés qui ont travaillé dans le département ‘Informatique’ ou qui
ont le grade 2.

Select count(*)
From Emp E, Dept D , Grade G
Where E.NumDept = D.NumDept
And salaire between salaireMin and salaireMax ;
And nomDept = ‘informatique;

45
17. Afficher les noms de tous les départements et les locaux des projets associés en
considérant même les départements n’ayant aucun projet. Donner 2 versions possibles
pour cette requête.

V1 : Select NomDept , Local


From Dept D left join Projet P on D.numdept = P.Numdept ;
V2 Select NomDept , Local
From Projet P right join Dept D on D.numdept = P.Numdept ;

18. Afficher les noms de tous les projets, affectés ou non à un département, ainsi que, pour
ceux affectés, les adresses des départements associés. Donner 2 versions possibles pour
cette requête.

Select NomProjet , D.adresse


From Projet P left join Dept D on P.Numdept = D.Numdept
19. Afficher le nom, la fonction et la somme de la commission et du salaire (avec l’alias
RevenuMensuel) et le nom du grade de tout employé du département ‘Production’ et dont le
grade est 1 ou l’adresse est ‘Tunis’ ou le prénom commence par ‘A’.

Select NomEmp, Fonction , Commission+ salaire as RevenuMensuel, Nomgrade


From Emp E, Dept , grade G
Where E.NumDept = D.NumDept
And E.salaire between salaireMin and SalaireMax
And Nomdept =’production’
And (Grade=’1 or E.adresse =’Tunis’ or prénom like ‘A%’) ;
20. Afficher toutes les informations sur les projets où travaille un employé habitant à ‘Le
Bardo’ et travaillant comme ‘DG’.

Select P.*
From projet P, Emp E, travaillerSurT
Where P.numProjet = T.NumProjet
And E.NumEmp= T.NumEmp
And E.adresse = ‘bardo’
And fronction ‘DG’;

21. Afficher le nom et le prénom de tout employé ayant le même âge et le double du salaire d’un
autre employé ne travaillant pas dans le même département que lui.
Select E.NomEmp, E.PrénomEmp
From Emp E, Emp E1
Where Year(E.datenaiss) = year(E1.datenaiss)
And E.numdept <> E1.Numdept
E.salaire = 2+E1.salaire ;

46
SGBD 2IM

TP N°3
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)

Projet(NumProjet, NomProjet, Local, #NumDept)


TravaillerSur(#NumEmp, #NumProjet, NbreH)
Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Ecrire les requêtes suivantes en SQL :

1. Afficher les noms et les prénoms des employés qui travaillent sur les mêmes projets
où l’employé de prénom "Ali" et de nom "Mabrouk" opère.
2. Afficher les numéros des employés dont le salaire est strictement plus petit que celui
de l’employé de prénom "Olfa" et de nom "Ghédira".
3. Afficher le nom, l’âge et le salaire des employés qui ont le plus grand salaire de leur
département.
4. Afficher le numéro de grade de l’employé dont le salaire est le plus petit.
5. Afficher les numéros des grades des employés dont le salaire est supérieur à la
moyenne des salaires de leur département associé.
6. Afficher les noms et les prénoms des employés qui travaillent dans le même
département où un ingénieur travaille.
7. Afficher la somme des salaires des employés qui ont le même chef et le même âge que
l’employé de nom "Ben Youssef".
8. Afficher les numéros des départements qui n’ont pas d’employés.
9. Afficher les noms et les prénoms des employés qui ne travaillent pas sur un projet sur
lequel travaille l’employé de prénom "Jaafar" et de nom "Yaakoubi".

48
SGBD 2IM

10. Afficher les numéros des grades qui sont absents dans la hiérarchie administrative des
employés.
11. Afficher les numéros des départements dont tous les employés ont une commission.
12. Afficher les noms et les prénoms des employés qui ne travaillent pas sur des projets.
13. Afficher les noms des projets dont le local est différent des adresses de tous les
départements.
14. Afficher les noms et numéros de grades des employés dont le salaire est différent de
ceux de tous les ingénieurs. Refaire cette requête en considérant la condition « est
différent de celui d’au moins un des ingénieurs » et ensuite la condition « est plus
grand que les salaires de tous les ingénieurs ».
15. Afficher les numéros des départements qui ont à la fois des ingénieurs et des
comptables.
16. Afficher les noms des départements qui comprennent le nombre le plus élevé
d’employés.
17. Afficher les fonctions ayant la plus grande moyenne des salaires.
18. Afficher les numéros des employés qui ont travaillé sur tous les projets.
19. Afficher toutes les informations sur les départements ayant le même nombre
d’employés que le département où travaille l’employé numéro 10. Il est à noter que,
dans le résultat de la requête, les informations concernant le département où tra vaille
l’employé numéro 10 ne doivent pas apparaître.
20. Afficher les noms des départements ayant un des employés dont la fonction est
"Directeur" dont le salaire est plus grand qu’au moins un des employés dont la
fonction est "Directeur Général".
21. Afficher les noms des départements dont les employés ont les différents types de
grades.
22. Afficher toutes les informations sur les employés du département "Comptabilité"
ayant la même fonction qu’un employé du département où travaille l’employé dont le
prénom est "Achraf" et dont le nom est "Ben Youssef".

49
Correction TP N°3
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)

Projet(NumProjet, NomProjet, Local, #NumDept) TravaillerSur(#NumEmp, #NumProjet,


NbreH) Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

Ecrire les requêtes suivantes en SQL :

Afficher les noms et les prénoms des employés qui travaillent sur les mêmes projets où l’employé de prénom "Ali"
et de nom "Mabrouk" opère.

Select NomEmp, PrénomEmp


From Emp E, TsravaillerSur T
Where E.numEmp = T.numEmp
And exists (Select 1
From Emp E1, TravaillerSur T1
Where E1.numEmp= T1.Numemp
And E1.numEmp <> E.NumEmp
And Nomemp = ‘mabrouk’
And prenomEmp = ‘Ali’
And T.Numrpojet =T1.NumProjet);
Afficher les numéros des employés dont le salaire est strictement plus petit que celui de
l’employé de prénom "Olfa" et de nom "Ghédira".

Select NumEmp
From Emp
Where exists ( Select 1 from Emp E1
Where Nom=’ghédira’ and prénom = ‘olfa’ and E.salaire < E1.salaire) ;
3. Afficher le nom, l’âge et le salaire des employés qui ont le plus grand salaire de leur
département.

50
Select NomEmp, Year(date())-year(dateNaiss) as age , salaire
From Emp E
Where not exists ( select 1
From Emp E1
Where E.Numdept = E.numDept
And E1.Salaire >E.Salaire) ;

4. Afficher le numéro de grade de l’employé dont le salaire est le plus petit.


Select Numgrade

From grade , Emp E


Where Salaire between salaireMin and salairemax
Where not exists (Select 1 from Emp E1 where E1.salaire<=E.salaire);
6. Afficher les numéros des grades des employés dont le salaire est supérieur à la
moyenne des salaires de leur département associé.

Select Numgrade
From grade G, Emp E
Where salaire between SalaireMin and SalaireMax
And salaire >( select avg(salaire)
From Emp E1
Where E1.numDept = E.Numdept);
7. Afficher les noms et les prénoms des employés qui travaillent dans le même
département où un ingénieur travaille.

Select NomEmp, prénomEmp


From Emp
Where exists ( Select 1 from Emp E1 where E1.numDept = E.Numdept and fonction =
‘ingénieur’) ;
8. Afficher la somme des salaires des employés qui ont le même chef et le même âge que
l’employé de nom "Ben Youssef".

Select Sum(salaire)
From Emp E
Where exists ( Select 1 from Emp E1 where Nom = ‘Ben Youssef’ and E.numchef =
E1.Numchef and year(E.dateniass) = year(E1.dateniass) ) ;
9. Afficher les numéros des départements qui n’ont pas d’employés.

Select numdept
From dept
Where not exists ( select 1 from Emp E where E.numdept = D.numdept) ;

51
10. Afficher les noms et les prénoms des employés qui ne travaillent pas sur un projet
sur lequel travaille l’employé de prénom "Jaafar" et de nom "Yaakoubi".

Select NomEmp, prénomEmp


From Emp E , travaillerSur T
Where E.NumEmp = T.NumEmp
And not exists ( Select 1 from Emp E1, TravaillerSur T1
Where E1.NumEmp = T1.NumEmp
And prénom = ‘jaafar’ and nom = ‘yaakoubi’
And t.numProjet = T1.NumProjet);

11. Afficher les numéros des grades qui sont absents dans la hiérarchie administrative des
employés.

Select numgrade
From grade
Where not exists ( select 1 from Emp where Salaire between salaireMin and
Salairemax) ;
12. Afficher les numéros des départements dont tous les employés ont une commission.

Select NumDemp
Where not exists ( select 1 from Emp where E.numdept = D.numdept and commission =
0) ;
13. Afficher les noms et les prénoms des employés qui ne travaillent pas sur des projets.

Select nomEmp, prénomEmp


From Emp E
Where Not exists ( Select 1 From travaillerSur T where T.NumEmp= E.NumEmp);
14. Afficher les noms des projets dont le local est différent des adresses de tous les
départements.

Select NomProjet
From Projet
Where not exists ( Select 1 from dept D where Local = D.adresse) ;
15. Afficher les noms et numéros de grades des employés dont le salaire est différent de ceux
de tous les ingénieurs. Refaire cette requête en considérant la condition « est différent de
celui d’au moins un des ingénieurs » et ensuite la condition « est plus grand que les salaires
de tous les ingénieurs ».

52
Select NomEmp, Numgrade
From Emp E, grade G
Where salaire between SalaireMin and salairemax
And not exists ( select 1 from Emp E1 where E1.fonction = ‘ingénieur’ and E.salaire =
E1.salaire);
15. Afficher les numéros des départements qui ont à la fois des ingénieurs et des
comptables.

Select NumDept
From dept D
Where Exists ( Select 1 from Emp E where D.numdept = E.numdept and fonction =
‘ingénieur’ )
And Exists ( Select 1 from Emp E where D.numdept = E.numdept and fonction =
‘compatble’ ) ;

16. Afficher les noms des départements qui comprennent le nombre le plus élevé
d’employés.
17. Afficher les fonctions ayant la plus grande moyenne des salaires.
18. Afficher les numéros des employés qui ont travaillé sur tous les projets.
19. Afficher toutes les informations sur les départements ayant le même nombre
d’employés que le département où travaille l’employé numéro 10. Il est à noter que, dans le
résultat de la requête, les informations concernant le département où tra vaille l’employé numéro
10 ne doivent pas apparaître.
20. Afficher les noms des départements ayant un des employés dont la fonction est
"Directeur" dont le salaire est plus grand qu’au moins un des employés dont la fonction
est "Directeur Général".
21. Afficher les noms des départements dont les employés ont les différents types de grades.
22. Afficher toutes les informations sur les employés du département "Comptabilité" ayant
la même fonction qu’un employé du département où travaille l’employé dont le prénom est
"Achraf" et dont le nom est "Ben Youssef".

53
2IM

TP N°4
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp, NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)


Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)
Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)
Candidat(numDos, nomC, prenomC, DNaissance, Adresse, Sexe, poste, nbrAnneeExp,
dateD, accep)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

La table « Candidat » sert à enregistrer les demandes d’emploi. Les attributs de cette table ont
la signification suivante :
- numDos : c’est le numéro du dossier déposé par un candidat. On garde ce
même numéro pour l’employé s’il est accepté.
- nomC, prenomC, DNaissance, Adresse, Sexe : informations personnelles
concernant le candidat,
- poste : c’est la fonction à laquelle le candidat postule,
- nbrAnneeExp : nombre d’années d’expérience du candidat,
- dateD : date du dépôt du dossier de candidature sous la forme d’un entier de 8
chiffres jjmmaaaa (par exemple 16072011),
- accep : ce champ vaut 0 si le candidat n’est pas accepté, et 1 s’il est accepté.

Exprimer en SQL les requêtes suivantes :


1) Ajouter les départements suivants :
- Le département n°600 de « Formation » à l’adresse « Centre Ville » sous la
direction de l’employé n°20.
- Le département « Commercial » n°700 à l’adresse « Charguia2 ».

2) Accepter tous les candidats pour les postes d’ingénieur et qui ont une expérience de
plus de 2 ans. Modifier ainsi l’attribut accep pour avoir la valeur 1.
54
2IM
3) Ajouter les employés suivants :

- N° 80 : l’ouvrier « Ahmed Elhedi» qui habite au Centre Ville avec un salaire de


500dt au département n° 300.

- N° 90 : le comptable « Mohamed Babel » au département n°500 sous la direction


de l’employé n° 20 avec un salaire de 1000.

- N° 100 : la technicienne « Asma Amri » avec un salaire de 1000dt avec une


commission de 100dt au département n°100, son chef est le directeur du
département.

- Tous les ingénieurs dans la table Candidat qui sont acceptés (qui ont l’attribut
accep à 1) au département n°100 sous la direction de l’employé n°10.

3) Affecter le comptable « Ramzi Gasmi » au département n° 500.

4) Réaffecter les employés de grade 1 au département ressource humaine (RH), tout en


ne considérant pas les techniciens parmi eux.

5) Modifier le salaire des ingénieurs ayant l’attribut salaire à NULL pour avoir le salaire
minimal du grade 2.
6) Donner aux employés qui n’ont pas de commission une valeur de 0.1% de leur salaire.

7) Promouvoir le PDG pour avoir un salaire égal au plafond du grade 3.

9) Promouvoir l’employé « Kacem Bousseta » en ingénieur principal et en lui ajoutant


200dt à son salaire.
11) Augmenter les salaires des employés de grade 1 de 5%.
12) Transférer tous les employés du département « Comptabilité » au département n°700.

13) Enlever le département Comptabilité.

14) Rajouter la somme de 50dt au salaire minimal de tous les grades.


15) Modifier le salaire minimal du grade 1 pour avoir le minimum des salaires des
employés du département n°300.

55
2IM
15) Supprimer tous les candidats dont les demandes ont été déposées en 2011 et qui n’ont
pas été acceptés ainsi que les candidats qui ont moins de 2 ans d’expériences. Il est à
noter que vous avez la possibilité d’utiliser LIKE pour comparer les entiers. Par
exemple, pour localiser les dates ayant 2012 comme année, vous pouvez mettre
« dateD LIKE ‘ 2012’ ».
16) Ajouter le projet n° 6 « Un simulateur de pilotage » au département informatique, le
local de ce projet étant à la même adresse que celui du département informatique.

17) Attribuer le projet n°6 aux ingénieurs du département informatique en répartissant


équitablement 200 heures entre eux.
Insert into travaillerSur as
18) Rajouter le technicien qui a la plus grande commission du département
informatique aux projets affectés à son département avec un nombre d’heure égal à 100h.

18) Récompenser les employés qui ont travaillé sur tous les proje ts en leur rajoutant 50dt à
leur salaire.
19) Récompenser chaque employé qui a travaillé sur le plus grand nombre de projets en
lui rajoutant 50dt à sa commission.
21) Récompenser chaque employé qui a travaillé le plus sur des projets (en nombre
d’heures) en lui donnant le salaire maximal associé à son grade.
22) Retirez 50dt de la commission des employés qui travaillent dans le département
informatique et qui ont opéré sur un projet localisé à « Charguia ».
23) Rajouter 5dt aux employés qui sont né en 1970 et qui ont travaillé sur un projet,
exclure le PDG s’il vérifie ces conditions. La date est un entier de 8 chiffres sous la
forme jjmmaaaa.
24) Nommer les employés qui ont le max du salaire (dans leur département) comme
directeur de leur département.
25) Supprimer les départements qui n’ont pas d’employé, ni de projets.
26) Supprimer l’employé « Kacem Bousseta » des projets qui lui sont attribués à
Hammamet.

56
2IM

Correction TP N°4
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp, NomEmp, PrenomEmp, DateNaiss, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)

Dept(NumDept, NomDept, #NumDirecteur, Adresse)


Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)
Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)
Candidat(numDos, nomC, prenomC, DNaissance, Adresse, Sexe, poste, nbrAnneeExp,
dateD, accep)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.

La table « Candidat » sert à enregistrer les demandes d’emploi. Les attributs de cette table ont
la signification suivante :
- numDos : c’est le numéro du dossier déposé par un candidat. On garde ce
même numéro pour l’employé s’il est accepté.
- nomC, prenomC, DNaissance, Adresse, Sexe : informations personnelles
concernant le candidat,
- poste : c’est la fonction à laquelle le candidat postule,
- nbrAnneeExp : nombre d’années d’expérience du candidat,
- dateD : date du dépôt du dossier de candidature sous la forme d’un entier de 8
chiffres jjmmaaaa (par exemple 16072011),
- accep : ce champ vaut 0 si le candidat n’est pas accepté, et 1 s’il est accepté.

Exprimer en SQL les requêtes suivantes :


1) Ajouter les départements suivants :
- Le département n°600 de « Formation » à l’adresse « Centre Ville » sous la
direction de l’employé n°20.
Insert into dept (600, ‘formation’, ‘centre ville’, 20)

57
2IM

- Le département « Commercial » n°700 à l’adresse « Charguia2 ».


Insert into dept(numdpet, nomdept, adresse) values (700,
‘Commercial, ‘Charguia2’)
8) Accepter tous les candidats pour les postes d’ingénieur et qui ont une expérience de
plus de 2 ans. Modifier ainsi l’attribut accep pour avoir la valeur 1.
Update candidat
Set accept = ‘1’
Where poste = ‘ingénieur’
And nbrAnneexp >=2 ;
3) Ajouter les employés suivants :

- N° 80 : l’ouvrier « Ahmed Elhedi» qui habite au Centre Ville avec un salaire de


500dt au département n° 300.
Insert into (numEmp, nomEmp, prenomEmp, adresse, salaire, numdept) values
(80, ‘Elhedi’, ‘Ahmed’, ‘centre ville’, 500, 300) ;
- N° 90 : le comptable « Mohamed Babel » au département n°500 sous la direction
de l’employé n° 20 avec un salaire de 1000.
Insert into (numEmp, fonction, nomEmp, prenomEmp, numdept , numchef,
salaire) values
(90, ‘comptable’, ‘Babel’, ‘Mohamed’, 500, 20, 1000) ;

- N° 100 : la technicienne « Asma Amri » avec un salaire de 1000dt avec une


commission de 100dt au département n°100, son chef est le directeur du
département.
Insert into (numEmp, fonction, nomEmp, prenomEmp,salaire, commission,
numdept , numchef) values ( 100, ‘technicienne’, ‘Amri’, ‘Asma’, 1000, 100,
100, select numEmp, from dept where numdirectur = 100) ;

- Tous les ingénieurs dans la table Candidat qui sont acceptés (qui ont l’attribut
accep à 1) au département n°100 sous la direction de l’employé n°10.
Insert into emp (numEmp, nomEmp, prenomEmp, fonction, datenaiss,
numdept, numchef) as
select numDos, nomC, prenomC, ‘ i n g e n i eu r ’ , DNaissance, 100, 10
From condidat
Where accept = ‘1’ ;
9) Affecter le comptable « Ramzi Gasmi » au département n° 500.
Update Emp
Set numdept = 500
Where nomEmp = ‘Gasmi’ and prénom = ‘Ramzi’;

58
2IM

10) Réaffecter les employés de grade 1 au département ressource humaine (RH), tout en
ne considérant pas les techniciens parmi eux.
Update Emp
Set numdept = (select numdept from dept where nomdept =’RH’)
Where fonction <>’technicien’;

11) Modifier le salaire des ingénieurs ayant l’attribut salaire à NULL pour avoir le salaire
minimal du grade 2.
Update Emp
Set salaire = select salairemin from grade where numgrade = 2
Where function = ‘ingénieur” and salaire is null;

12) Donner aux employés qui n’ont pas de commission une valeur de 0.1% de leur salaire.

Update Emp
Set commission = 0.1*salaire /100
Where commission is null or commission = 0 ;
13) Promouvoir le PDG pour avoir un salaire égal au plafond du grade 3.

Update Emp
Set salaire = select salairemax from grade where numgrade = 3
Where function =’PDG’;

9) Promouvoir l’employé « Kacem Bousseta » en ingénieur principal et en lui ajoutant


200dt à son salaire.

Update Emp
Set fonction = ‘ingénieur principal’ , salaire = salaire+200
Where nom =’Bousseta’ and prénom =’Kacem’ ;

20) Augmenter les salaires des employés de grade 1 de 5%.

Update Emp
Set salaire = salaire + salaire*5/100
Where salaire >= (select salairemin from grade where numgrade = 1)
And salaire <= (select salairemax from grade where numgrade = 1);

21) Transférer tous les employés du département « Comptabilité » au département n°700.

Update emp
Set numdept = 700
Where numdept = select numdept from dept where nomdept = ‘comptabilité’;

59
2IM

22) Enlever le département Comptabilité.

Delete * from dept


Where nomdept =’comptabilité’ ;

23) Rajouter la somme de 50dt au salaire minimal de tous les grades.


update grade
set salaireMin = salaireMin+ 50 ;
24) Modifier le salaire minimal du grade 1 pour avoir le minimum des salaires des
employés du département n°300.
Update grade
Set salaireMin = ( select min(salaire) from Emp where numdept = 300) ;

15) Supprimer tous les candidats dont les demandes ont été déposées en 2011 et qui n’ont
pas été acceptés ainsi que les candidats qui ont moins de 2 ans d’expériences. Il est à
noter que vous avez la possibilité d’utiliser LIKE pour comparer les entiers. Par
exemple, pour localiser les dates ayant 2012 comme année, vous pouvez mettre
« dateD LIKE ‘ 2012’ ».
25) Ajouter le projet n° 6 « Un simulateur de pilotage » au département informatique, le
local de ce projet étant à la même adresse que celui du département informatique.
Insert into projet (numprojet, nomprojet, numdept, lcoal) values (6, ‘simulateur de
pilotage’, select adrresse from dept where nomdept = ‘informatique’)
26) Attribuer le projet n°6 aux ingénieurs du département informatique en répartissant
équitablement 200 heures entre eux.
Insert into travaillerSur as
Select numEmp, 6 , 200/(select count(*) from Emp where numdept = (select
numdept from dept where nomemp=’informatique’)
From Emp
Where numdept = (select numdept from dept where nomdept = ‘informatique’;
18) Rajouter le technicien qui a la plus grande commission du département informatique
aux projets affectés à son département avec un nombre d’heure égal à 100h.
27) Récompenser les employés qui ont travaillé sur tous les proje ts en leur rajoutant 50dt à
leur salaire.
Update Emp
Set salaire = salaire + 50
Where not exists (select 1 from projet P
Where not exists (select 1 from travaillerSur T where P.numprojet = T.Numprojet
And Emp.numEmp = T.numEmp));

60
2IM

28) Récompenser chaque employé qui a travaillé sur le plus grand nombre de projets en
lui rajoutant 50dt à sa commission.
Update Emp
Set commission = commission + 50
Where (select count(*) from travaillerSUr T where numEMp = Emp.numemp) >=all
( select count(*) from TravaillerSur T1 group by numEmp ) ;

21) Récompenser chaque employé qui a travaillé le plus sur des projets (en nombre
d’heures) en lui donnant le salaire maximal associé à son grade.
Update Emp
Set salaire = (select salaireMax from grade where salaire between salaireMin and
salairemax ) where (select sum(nbrh) from travaillerSUr T where numEMp =
Emp.numemp) >=all ( select sum(nbrh) from TravaillerSur T1 group by numEmp ) ;

22) Retirez 50dt de la commission des employés qui travaillent dans le département
informatique et qui ont opéré sur un projet localisé à « Charguia ».
Update Emp
Set commission = commission – 50
Where numdept = (select numdept from Dept where nomdept =’informatique’ and exists
(select 1 from travaillerSUr T where Emp.numEMp = T.numEMp);

23) Rajouter 5dt aux employés qui sont né en 1970 et qui ont travaillé sur un projet,
exclure le PDG s’il vérifie ces conditions. La date est un entier de 8 chiffres sous la
forme jjmmaaaa.
24) Nommer les employés qui ont le max du salaire (dans leur département) comme
directeur de leur département.
25) Supprimer les départements qui n’ont pas d’employé, ni de projets.
Delete * from dept where not exists (select 1 from Emp where Emp.numdept =
dept.numdept )
And not exists ( select 1 from projet P where P.numdept = dept.numdept);
26) Supprimer l’employé « Kacem Bousseta » des projets qui lui sont attribués à
Hammamet.

Delete * from travaillerSur T


Where numEmp = (select numEmp where nom = ‘bousseta’ and prenom =
‘Kacem’) and numProjet in ( select numProjet from projet where Local
=’hammamet ‘)

61
SGBD 2IM

TP N°5

Avant de commencer chaque exercice, vous devez créer la base de données (BD) qui va contenir les
différentes tables qui seront créées par la suite. Pour cela, la création de la BD se fait avec
l’instruction : CREATE DATABASE nomBD ;
Il est à noter que la suppression d’une BD se fait avec l’instruction DROP DATABASE nomBD ;

Exercice 1 :

1. Créez la table DEPARTMENT d’après le tableau suivant :


Colonne ID NAME
Type de données INT VARCHAR
Longueur 2 25

Insert into departement (id int(2), varchar(25)) ;


2. Créez la table EMPLOYEE d’après le tableau suivant.
Colonne ID LAST_NAME FIRST_NAME DEPT_ID
Type de données INT VARCHAR CHAR INT
Longueur 7 25 20 2

3. Modifier la table EMPLOYEE pour pouvoir allonger le nom de famille (LAST_NAME) des
employés pour que ça tienne sur une chaîne de longueur variable de taille maximale 50.

4. Ajouter une contrainte PRIMARY KEY au niveau de la table EMPLOYEE sur l’attribut ID.
5. Ajouter une contrainte PRIMARY KEY au niveau de la table DEPARTMENT au niveau de
l’attribut ID.
6. Ajouter une clé étrangère dans la table EMPLOYEE qui permettra de contrôler que
l’employé n’est pas associé à un département inexistant.
Alter table add foreign key
7. Modifier la table EMPLOYEE en ajoutant une colonne SALARY dont le type est INT avec
une longueur de 7.
Alter table employee add salary int(7) ;

62
SGBD 2IM

8. Ajouter à la table EMPLOYEE une contrainte ne tolérant pas la répétition du même nom
(correspondant au champ LAST_NAME) pour deux employés différents.

9. Supprimer la table EMPLOYEE.

Drop table Employee ;

Exercice 2 :
Soit le schéma relationnel suivant :
Etudiant (NumEtudiant, Nom, Prenom, Age)
Matiere (CodeMat, LibelleMat, CoeffMat)
Evaluation (#NumEtudiant,#CodeMat, Note)
Remarque : les clés primaires sont soulignées et les clés étrangères sont marquées par #.
Nous avons les caractéristiques suivantes des attributs des tables susmentionnées :
- NumEtudiant et CodeMat sont des entiers à 2 chiffres.
- Nom, Prenom et LibelleMat sont des chaînes de caractères de longueur 20.
- Note est un réel.
- Age est un entier qui varie entre 18 et 30.
- CoeffMat peut être soit 1, 2 ou 3
1. Donner les commandes SQL de création des tables et des contraintes associées.
2. Ecrire la commande SQL permettant d’ajouter la colonne Tel à la table Etudiant qui est un
entier sur 8 chiffres.

Exercice 3 :
1. Créer une table Client avec les attributs :
- Numero, entier de longueur 6, clé primaire et supérieur strictement à 0,
- Nom, une chaîne de caractères de longueur variable (au maximum 63 caractères), les valeurs
nulles ne sont pas autorisées,
La contrainte NOT NULL peut être mise sur la même ligne où est déclaré l’attribut en
question de façon à avoir : nomAttribut typeAttribut NOT NULL
- Prenom, une chaîne de caractères de longueur fixe égale à 63,
- Naissance, indiquant la date de naissance du client et est de type date,
- Ville, une chaîne de caractères de longueur variable (au maximum 50 caractères). Il est à
noter que les villes concernées dans cette base sont Tunis, Sousse, Sfax, et Djerba.

63
SGBD 2IM

2. Créer une table Commande ayant les attributs suivants :


- Numero, un nombre de taille 8, clé primaire et supérieur strictement à 0,

- DateCommande, de type date,


- NumClient, un entier de taille 6 auquel est associée une clé étrangère référençant le numéro
du client dans la table Client.
3. Ajouter une colonne Code_Postal dans la table Client : chaîne de caractères de taille fixe
égale à 4.
4. Modifier l’attribut stockant le nom du client pour qu’il soit de taille 50 et pour qu’il
contienne éventuellement des valeurs nulles.
5. Ajouter une contrainte d’unicité à la colonne DateCommande de la table Commande.
6. Insérer des tuples dans les tables Client et Commande. Vérifier les contraintes d’intégrité
référentielle (contrainte de clé étrangère).

64
SGBD 2IM

Correction TP N°5

Avant de commencer chaque exercice, vous devez créer la base de données (BD) qui va contenir les
différentes tables qui seront créées par la suite. Pour cela, la création de la BD se fait avec
l’instruction : CREATE DATABASE nomBD ;
Il est à noter que la suppression d’une BD se fait avec l’instruction DROP DATABASE nomBD ;

Exercice 1 :

1. Créez la table DEPARTMENT d’après le tableau suivant :


Colonne ID NAME
Type de données INT VARCHAR
Longueur 2 25

Insert into departement (id int(2), varchar(25)) ;


2. Créez la table EMPLOYEE d’après le tableau suivant.
Colonne ID LAST_NAME FIRST_NAME DEPT_ID
Type de données INT VARCHAR CHAR INT
Longueur 7 25 20 2

Create table Employee ( Id int(7), last_name varchar(25), firstname char(20) , dep_id int(2)) ;

3. Modifier la table EMPLOYEE pour pouvoir allonger le nom de famille (LAST_NAME) des
employés pour que ça tienne sur une chaîne de longueur variable de taille maximale 50.
Alter table Employee modify last_name varchar(25) ;
4. Ajouter une contrainte PRIMARY KEY au niveau de la table EMPLOYEE sur l’attribut ID.
Alter table employee add constraint primary key (id);
5. Ajouter une contrainte PRIMARY KEY au niveau de la table DEPARTMENT au niveau de
l’attribut ID.
Alter table Departement add constraint primary key (ID) ;
6. Ajouter une clé étrangère dans la table EMPLOYEE qui permettra de contrôler que
l’employé n’est pas associé à un département inexistant.
Alter table add foreign key
Alter table employee add constraint foreign key(dept_id) references
department(id);

65
SGBD 2IM
7. Modifier la table EMPLOYEE en ajoutant une colonne SALARY dont le type est INT avec
une longueur de 7.
Alter table employee add salary int(7) ;
8. Ajouter à la table EMPLOYEE une contrainte ne tolérant pas la répétition du même nom
(correspondant au champ LAST_NAME) pour deux employés différents.
9. Alter table employee add constraint unique (last_name); ;
10. Supprimer la table EMPLOYEE.

Drop table Employee ;

Exercice 2 :
Soit le schéma relationnel suivant :
Etudiant (NumEtudiant, Nom, Prenom, Age)
Matiere (CodeMat, LibelleMat, CoeffMat)
Evaluation (#NumEtudiant,#CodeMat, Note)
Remarque : les clés primaires sont soulignées et les clés étrangères sont marquées par #.
Nous avons les caractéristiques suivantes des attributs des tables susmentionnées :
- NumEtudiant et CodeMat sont des entiers à 2 chiffres.
- Nom, Prenom et LibelleMat sont des chaînes de caractères de longueur 20.
- Note est un réel.
- Age est un entier qui varie entre 18 et 30.
- CoeffMat peut être soit 1, 2 ou 3
1. Donner les commandes SQL de création des tables et des contraintes associées.
Create table etudiant (numEtudiant int(2) primary key, nom varchar(20), prenom
varchar(20) , age int(2) , Constraint C1 check age between 18 and 30) ) ;

Create table matiere ( codeMat int(2) primary key, LbelleMat varchar(20), coefmat
int(1), constraint c2 check coefmat in (1,2,3));

Create Table evaluation ( numetudiant int(2) foreign key references


etudiant(numetudiant), codemat int(2) foeign key references matiere (codeMat),
note real , constraint C1 primary key (numEtudiant, codeMAt) );
2. Ecrire la commande SQL permettant d’ajouter la colonne Tel à la table Etudiant qui est un
entier sur 8 chiffres.
Alter table etudiant add Tel int(8) ;

Exercice 3 :
1. Créer une table Client avec les attributs :
- Numero, entier de longueur 6, clé primaire et supérieur strictement à 0,
- Nom, une chaîne de caractères de longueur variable (au maximum 63 caractères), les valeurs
nulles ne sont pas autorisées,

66
SGBD 2IM
La contrainte NOT NULL peut être mise sur la même ligne où est déclaré l’attribut en
question de façon à avoir : nomAttribut typeAttribut NOT NULL
- Prenom, une chaîne de caractères de longueur fixe égale à 63,
- Naissance, indiquant la date de naissance du client et est de type date,
- Ville, une chaîne de caractères de longueur variable (au maximum 50 caractères). Il est à
noter que les villes concernées dans cette base sont Tunis, Sousse, Sfax, et Djerba.
Create table client ( numero int(6) primary key , nom varchar(63) not null , prenom
char(63), naissance date , ville varchar(50) , Constraint c_check check numero>0,
constraint c_in check ville in (‘tunis, sousse, sfax, djerba’) ;

2. Créer une table Commande ayant les attributs suivants :


- Numero, un nombre de taille 8, clé primaire et supérieur strictement à 0,
- DateCommande, de type date,
- NumClient, un entier de taille 6 auquel est associée une clé étrangère référençant le numéro
du client dans la table Client.
Create table commande ( numero int(8) primary key , dateCommande date,
Numclient int(6) foreign key references client(numero), constraint c-check check
numero>0) ;
3. Ajouter une colonne Code_Postal dans la table Client : chaîne de caractères de taille fixe
égale à 4.
Alter table client add (code_Postal char(4)) ;

4. Modifier l’attribut stockant le nom du client pour qu’il soit de taille 50 et pour qu’il
contienne éventuellement des valeurs nulles.
Alter table client modify (nom varchar(50)) ;
5. Ajouter une contrainte d’unicité à la colonne DateCommande de la table Commande.
Alter table commande add constraint C-unique Unique(datecommande) ;
Insérer des tuples dans les tables Client et Commande. Vérifier les contraintes d’intégrité
référentielle (contrainte de clé étrangère).

67
SGBD 2IM
TP N°6
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp, NomEmp, PrenomEmp, DNaissance, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)
Dept(NumDept, NomDept, #NumDirecteur, Adresse)
Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
Exprimer en SQL les requêtes suivantes :
1) Créer une vue « DeptInfo » associée aux employés du département informatique.
2) Rajouter 50dt aux employés du département informatique ayant une commission inférieure à
1000 et ceci en utilisant la vue « DeptInfo ».
3) Ajouter l’ingénieur n°1000 « Mohsen Ali » qui habite à Tunis au département informatique
en utilisant la vue « DeptInfo » avec un salaire de 1050dt sous la direction de l’employé
n°10.
4) Créer une vue « V_sal_moy » donnant le salaire moyen par département.
5) Créer une vue « V_ inf» donnant les employés qui ont un salaire inférieur ou égal au salaire
moyen de leur département.
6) Créer une vue contenant les départements qui contiennent au moins un comptable.
7) Utiliser la vue de la question précédente pour créer une vue contenant tous les employés
(leurs numéros et leurs noms) travaillant dans un département qui possède au moins un
comptable.
8) Supprimer la vue « V_sal_moy ».
9) Donner à tous les utilisateurs le droit d’ajout d’un employé.
10) Créer l’utilisateur « ID123 » avec le mot de passe « PASSID321 ».
11) Modifier le mot de passe de l’utilisateur « ID123 » en « ID123pass ».
12) Donner les privilèges de mise à jour et de suppression à l’utilisateur « ID123 » sur les tables
emp, dept et grade.
13) Donner à tout le monde le droit de suppression et d’ajout sur les tables travaillersur et
projet, en excluant l’utilisateur « ID123 ».
14) Retirer à l’utilisateur « ID123 » le droit de mettre à jour la table grade.
15) Supprimer l’utilisateur « ID123 ».

68
SGBD 2IM

Correction TP N°6
Soit le schéma relationnel suivant d’une BD :

Emp(NumEmp, NomEmp, PrenomEmp, DNaissance, Adresse, Sexe, Fonction, Salaire,


Commission, #NumChef, #NumDept)
Dept(NumDept, NomDept, #NumDirecteur, Adresse)
Projet(NumProjet, NomProjet, Local, #NumDept)
TravaillerSur(#NumEmp, #NumProjet, NbreH)

Grade(NumGrade, NomGrade, SalaireMin, SalaireMax)

Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
Exprimer en SQL les requêtes suivantes :
1) Créer une vue « DeptInfo » associée aux employés du département informatique.
Create view DeptInfo as
Select * from Emp
Where numdept = (select numDept from dept where nomdept =’informatique’);

2 ) Rajouter 50dt aux employés du département informatique ayant une commission inférieure à
1000 et ceci en utilisant la vue « DeptInfo ».
Update deptInfo
Set commission = commission + 50
Where commission <1000 ;
3) Ajouter l’ingénieur n°1000 « Mohsen Ali » qui habite à Tunis au département informatique
en utilisant la vue « DeptInfo » avec un salaire de 1050dt sous la direction de l’employé
n°10.
Insert deptInfo values (1000, ‘mohsen’, ‘Ali’, ‘tunis’, (select numdept from Dept where
nomdept = ‘informatique’) , 1050, 10) ;
4 ) Créer une vue « V_sal_moy » donnant le salaire moyen par département.
Create view v_sal_moy as
select numdept, avg(salaire) as salaire_moyen
from Emp
group by numdept ;

5 ) Créer une vue « V_ inf» donnant les employés qui ont un salaire inférieur ou égal au salaire
moyen de leur département.
Create View V_inf as
Select * from Emp E
Where salaire <( select salaire_moyen from v_sal_moy SM where SM.numdept =
E.numdept) ;

69
SGBD 2IM

6 ) Créer une vue contenant les départements qui contiennent au moins un comptable.
Create view V_comptable
As select * from dept D where exists ( select 1 from Emp where fonction = ‘comptable’
and E.numdept = D.numdpet) ;

7 ) Utiliser la vue de la question précédente pour créer une vue contenant tous les employés
(leurs numéros et leurs noms) travaillant dans un département qui possède au moins un
comptable.
Create view V_Emp as
select E.*
from Emp E, V_comptable VC
where E.numdept = VC.num_dept;

1) Supprimer la vue « V_sal_moy ».


Drop view V_sal_moy ;
9) Donner à tous les utilisateurs le droit d’ajout d’un employé.
Grant insert on emp to all ;
Créer l’utilisateur « ID123 » avec le mot de passe « PASSID321 ».
Create user ‘ID123’ identified by ‘PASSid321’ ;
11) Modifier le mot de passe de l’utilisateur « ID123 » en « ID123pass ».
Update System.user set password = ‘ID123pass’ where user = ‘ID123’
12) Donner les privilèges de mise à jour et de suppression à l’utilisateur « ID123 » sur les tables
emp, dept et grade.
Grant [ update, delete] on [emp, dept, grade] to ID123;
13) Donner à tout le monde le droit de suppression et d’ajout sur les tables travaillersur et
projet, en excluant l’utilisateur « ID123 ».
Grant [insert, delete] on travaillerSur to all ;
Revoke [insert , delete] on travaillersur from ID123;
14) Retirer à l’utilisateur « ID123 » le droit de mettre à jour la table grade.
Revoke update on grade from ID123 ;
15) Supprimer l’utilisateur « ID123 ».

Delete * from system.user where user = ‘ID123’;

70