Beruflich Dokumente
Kultur Dokumente
Elaboré par :
DONNEES ORGANISATIONNELES
Objectifs Généraux
Prérequis
ii
Systèmes de gestion de bases de données
Table de matières
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
1. Introduction
Le Langage de Définition des Données (LDD) permet la création, la modification
et la suppression des tables.
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
Exemple :
CREATE TABLE emp
(cin int(8),
Prenom VARCHAR
(30), Date_naissance
DATE);
4
Systèmes de gestion de bases de données
5
Systèmes de gestion de bases de données
6
Systèmes de gestion de bases de données
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 ;
8
Systèmes de gestion de bases de données
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.
9
Systèmes de gestion de bases de 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).
- 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;
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
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 ;
12
Systèmes de gestion de bases de données
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 ;
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
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.
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;
Il existe deux types d’alias qui sont fréquemment utilisés éventuellement ensemble : alias de
colonne et alias de table.
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.
16
Systèmes de gestion de bases de données
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
17
Systèmes de gestion de bases de données
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.
18
Systèmes de gestion de bases de données
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.
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);
20
Systèmes de gestion de bases de données
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.
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) ;
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);
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
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 ;
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’ ;
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
26
Systèmes de gestion de bases de données
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 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.
27
Systèmes de gestion de bases de données
2) Créer une vue qui sélectionne la moyenne, le max, le min des salaires des
employés du département n°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)
28
Systèmes de gestion de bases de données
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;
29
Systèmes de gestion de bases de données
Exemple :
DROP VIEW Nom_Vue;
DROP VIEW emp100;
Exemple :
4. Les privilèges
Les privilèges sont les autorisations d’exécution de commandes qu’un utilisateur reçoit sur un
objet.
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];
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 :
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 :
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.
REVOKE UPDATE
ON emp
FROM admin ;
32
Systèmes de gestion de bases de données
TP N°1
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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.
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
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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’ ;
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 ;
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;
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;
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 ;
40
TP N°2
Soit le schéma relationnel suivant d’une BD :
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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.
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’.
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.
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 :
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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
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’;
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.
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.
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.
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 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 :
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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 :
Remarque : Les clés primaires sont soulignées et les clés étrangères sont marquées par #.
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 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) ;
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 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".
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 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 :
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é.
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 :
- 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.
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.
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.
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 :
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é.
57
2IM
- 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’;
Update Emp
Set fonction = ‘ingénieur principal’ , salaire = salaire+200
Where nom =’Bousseta’ and prénom =’Kacem’ ;
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);
Update emp
Set numdept = 700
Where numdept = select numdept from dept where nomdept = ‘comptabilité’;
59
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’ ».
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.
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 :
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.
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
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 :
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.
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));
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’) ;
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 :
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 :
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;
70