Chapitre 04-B - Langages de consultation.pdf

Chapitre 4 (2ième partie)
Langages de consultation
des bases de données
relationnelles

GPA-775 Chapitre 4 - Langages de
consultation
2
Le langage SQL
SQL : Structured Query Language.
♦ conçu par IBM Research comme interface pour le SGBD
relationnel en expérimentation : SYSTEM R.
♦ standardisé en 1986 (ANSI) et normalisé en 92 (SQL2)
♦ est maintenant l'interface de plusieurs SGBDs
commerciaux: DB2 de IBM, SQL/DS, ORACLE, INGRES,
UNIFY, MS-Access, etc…
♦ contient des fonctions qui sont utilisées pour définir,
accéder et maintenir les BDR.
Ø DDL : Langage qui définit les composante de la base
de données (relations, attributs)
Ø DML : Langage qui manipule les données (ajout,
supression, modification)

consultation
3
Le langage SQL
SQL…
♦non-procédural… ???
Ø Spécifie ce qui doit être fait
Ø Non, comment cela doit être fait
♦possède des facilités pour
Øla définition de vues sur la BD
Øla création des index sur les relations
Øl'encapsulation des instructions SQL dans un langage
évolué (ex: C, C++, Pascal, PL/1)

consultation
4
Avantages et désavantages du SQL
Avantages
Ø permet de réduire les coûts de formation des programmeurs
(langage standardisé)
Ø permet de porter les applications sur différents environnements
logiciels et physiques, i.e.:
• la communication peut se faire à partir de différents systèmes
• permet aux usagers d'utiliser une interface commune.
Ø permet d'assurer que les applications auront une durée de vie
suffisante.
Désavantages
Ø SQL comporte des limitations technologiques qui ne permettent pas
de réaliser le plein potentiel du modèle relationnel.
• la créativité visant à procurer la meilleure solution peut être interdite par
une solution moins bonne mais bien définie par le standard,

consultation
5
Définition des données dans SQL (DDL)
SQL utilise les termes :
Ø table pour une relation;
Ø ligne pour une tuple;
Ø colonne pour un attribut.
SQL comporte 3 commandes pour la manipulation des tables.
Ø CREATE TABLE
Ø DROP TABLE
Ø ALTER TABLE

consultation
6
CREATE TABLE
Ø permet de spécifier une nouvelle relation en donnant:
• son nom
• et en spécifiant chacun de ses attributs
w son nom,
w son domaine de valeurs ou type de données
w ses contraintes sur l'attribut.
Remarque (pas dans les notes):
Ø Les relations créées sont dites tables de base.
Ø La relation et ses tuples sont créés et stockés comme un fichier par
le SGBD.
Ø Les attributs dans les relations de base sont ordonnés dans l'ordre
spécifié dans la commande CREATE TABLE, mais les lignes
(tuples) ne sont pas considérées comme ordonnées.

consultation
7
CREATE TABLE : les types de données
Les types numériques :
Ø Entier (INTEGER ou INT, SMALLINT)
Ø Réel (FLOAT, REAL)
Ø Nombres avec format spécifié(DECIMAL (i,j) ou NUMERIC(i,j) ou
NUMBER(i,j))
Les chaînes de caractères :
Ø Longueur fixe : CHAR (n); n nombre de caractères
Ø Longueur variable : VARCHAR(n), n : nombre maximal
La date et l’heure :
Ø Date (DATE avec le format AAAA-MM-JJ)
Ø Heure (TIME avec les format HH:MM:SS)
Ø Date et Heure combinées (TIMESTAMP)

consultation
8
CREATE TABLE : les contraintes
Ø Clé primaire de la table (PRIMARY KEY)
Ø Clé étrangère (FOREIGN KEY… REFERENCES)
• Permet de définir le lien d’une table avec une autre table.
• Garantit l’intégrité référentielle de la BD
w Ex : Nous ne pouvons effacé un tuple d’une table, s’il y a une table
contenant un tuple qui y est associé par une clé étrangère.
Ø colonne à valeurs uniques (UNIQUE)
• Chaque ligne de la table doit avoir une valeur différente ou NULL pour
cette colonne.
Ø Aucunes valeurs nulles (NOT NULL)
• SQL permet NULL comme valeur d'attribut, mais une contrainte NOT
NULL peut aussi être spécifiée. En général, on doit spécifier NOT
NULL sur la valeur de la clé primaire pour chaque relation.

consultation
9
Exemples de CREATE TABLE
CREATE TABLE EMPLOYEE
( FNAME VARCHAR (15) NOT NULL,
MINIT CHAR (1),
LNAME VARCHAR (15) NOT NULL,
SSN CHAR (9) NOT NULL,
BDATE CHAR (9),
ADDRESS VARCHAR (30),
SEX CHAR (1),
SALARY INTEGER,
SUPERSSN CHAR (9),
DNO INTEGER NOT NULL,
PRIMARY KEY (SSN),
FOREIGN KEY (SUPERSSN) REFERENCES EMPLOYEE (SSN),
FOREIGN KEY (DNO) REFERENCES DEPARTEMENT (DNUMBER));
CREATE TABLE DEPARTMENT
( DNAME VARCHAR (15) NOT NULL,
DNUMBER INTERGER NOT NULL,
MGRSSN CHAR (9),
MGRSTARTDATE CHAR (9),
PRIMARY KEY (DNUMBER),
FOREIGN KEY (MGRSSN) REFERENCES EMPLOYEE (SSN),
UNIQUE (DNAME));

consultation
10
CREATE TABLE DEPT_LOCATIONS
( DNUMBER INTEGER NOT NULL,
DLOCATION VARCHAR (15) NOT NULL ,
PRIMARY KEY (DNUMBER, DLOCATION),
FOREIGN KEY (DNUMBER) REFERENCES DEPARTMENT (DNUMBER));
CREATE TABLE PROJECT
( PNAME VARCHAR (15) NOT NULL,
PNUMBER INTEGER NOT NULL,
PLOCATION VARCHAR (15),
DNUM INTEGER NOT NULL ,
PRIMARY KEY (PNUMBER),
FOREIGN KEY (DNUM) REFERENCES DEPARTMENT (DNUMBER),
UNIQUE (PNAME));
CREATE TABLE WORKS_ON
( ESSN CHAR (9) NOT NULL,
PNO INTEGER NOT NULL,
HOURS DECIMAL (3,1) NOT NULL ,
PRIMARY KEY (ESSN, PNO),
FOREIGN KEY (ESSN) REFERENCES EMPLOYEE (SSN),
FOREIGN KEY (PNO) REFERENCES PROJECT (PNUMBER));

consultation
11
CREATE TABLE DEPENDENT
( ESSN CHAR (9) NOT NULL,
DEPENDENT _NAME CHAR (15) NOT NULL,
SEX CHAR (1),
BDATE CHAR (9),
RELATIONSHIP VARCHAR(8) ,
PRIMARY KEY (ESSN, DEPENDENT _NAME),
FOREIGN KEY (ESSN) REFERENCES EMPLOYEE (SSN));
• Pour de donner un nom aux contraintes, nous utilisons la
commande CONSTRAINT.
• L’avantage est qu’elle peut être détruite dans le futur et remplacer
par une nouvelle.
Exemple :
CREATE TABLE DEPT_LOCATIONS
( DNUMBER INTEGER NOT NULL,
DLOCATION VARCHAR (15) NOT NULL ,
CONSTRAINT DEP_LOC_PK PRIMARY KEY (DNUMBER, DLOCATION),
CONSTRAINT DNUM_FK FOREIGN KEY (DNUMBER) REFERENCES DEPARTMENT
(DNUMBER));

consultation
12
DROP TABLE
♦Permet de détruire une table de base quand elle est plus
nécessaire.
Exemple :
DROP TABLE DEPENDENT;
Remarque :
Si vous avez d’autres tables qui font référence à la table à
détruire, il faut détruire les références avant de détruire la
table.

consultation
13
ALTER TABLE
♦Permet d'ajouter une contrainte à une relation de base.
♦Permet d'ajouter un attribut à une relation de base.
ØLe nouvel attribut aura la valeur NULL dans tous les
tuples de la relation, juste après l'exécution de la
commande.
ØNOT NULL n'est pas permis pour ce nouvel attribut.
Exemple :
Pour garder la trace des fonctions des employés de la BD
COMPANY.
ALTER TABLE EMPLOYEE ADD JOB VARCHAR(12);

consultation
14
Manipulation des données dans SQL : DML
SQL possède plusieurs instructions pour effectuer
Øla recherche d'information,
Ødes consultations ,
Øde la manipulation de données…
dans une base de donnée.
Ces instructions sont :
ØSELECT
ØINSERT
ØDELETE
ØUPDATE

consultation
15
SELECT
Ø L’instruction de base pour effectuer la recherche d'information
Ø La forme de base est formée des 3 clauses:
SELECT <Liste d'attributs>: liste de noms d'attributs dont les valeurs
sont recherchées par la consultation.
FROM <Liste de tables>: liste de noms de relations nécessaires
pour traiter la consultation.
WHERE <Conditions>:Une expression logique qui identifie les
tuples recherchés par la consultation.
Remarques:
Ø L'instruction SELECT n'a aucune relation avec l'opération SELECTION de
l'algèbre relationnelle.
• SQL permet qu'une table possède une duplication de tuples.
Ø Lorsque la clause WHERE est omise, il n’y a aucune condition sur les
tuples. Tous les tuples spécifiés dans la clause FROM sont alors
sélectionnés.
• Ceci est équivalent à WHERE TRUE

consultation
16
Exemples avec SELECT
REQUÊTE 1 : Rechercher la date de naissance et l'adresse de l'employé
au nom de 'John B. Smith‘
R1 : SELECT BDATE, ADDRESS
FROM EMPLOYEE
WHERE FNAME = 'John' AND MINIT = 'B' AND LNAME = 'Smith'
1. implique seulement la relation EMPLOYEE listée dans la clause
FROM.
2. sélectionne les tuples de EMPLOYEE qui satisfont la condition
dans la clause WHERE,
3. fait une projection du résultat sur les attributs BDATE et
ADDRESS listés dans la cause SELECT.
Résultat de la consultation R1:
DBATE ADDRESS
09-JAN-55 731 Fondren, Houston, TX

consultation
17
R1 est similaire à l'expression de l'algèbre relationnelle :
π<BDATE, ADDRESS> (σfname = 'John' AND MINIT='B' AND LNAME = 'Smith' (EMPLOYEE))
Øune consultation SQL simple est similaire à la paire
SELECTION-PROJECTION des opérations de l'algèbre
relationnelle.
Remarque: La seule différence est que dans le résultat d’une
consultation SQL, on peut avoir une duplication de tuples.

consultation
18
REQUÊTE 2 : Rechercher le nom et l'adresse de tous les employés qui
travaillent pour le département 'Research'.
R2 : SELECT FNAME, LNAME, ADDRESS
FROM EMPLOYEE, DEPARTMENT
WHERE DNAME = 'Research' AND DNUMBER = DNO
Ø équivalente à la séquence SELECTION-PROJECTION-UNION des
opérations de l'algèbre relationnelle.
Ø DNAME = 'Research' est la condition de sélection
Ø DNUMBER = DNO est la condition de jointure.
Ø FNAME, LNAME, ADDRESS sont les colonnes de projection.
FNAME LNAME ADDRESS
John
Franklin
Ramesh
Joyce
Smith
Wong
Narayan
English
731, Fondren, Houston, TX
638, Voss, Houston, TX
975, Fire Oak, Humble TX
5631, Rice, Houston, TX

consultation
19
REQUÊTE 3 : Pour chaque projet situé à 'Stafford', lister le numéro de
projet, le numéro du département qui le contrôle et le nom, l'adresse et la
date de naissance du manager du département.
R3 : SELECT PNUMBER, DNUM, LNAME, ADDRESS, BDATE
FROM PROJECT, DEPARTMENT, EMPLOYEE
WHERE DNUM = DNUMBER AND
MGRSSN = SSN AND
PLOCATION = 'Stafford'
♦La condition de jointure DNUM = DNUMBER relie un projet au
département qui le contrôle et la condition de jointure MGRSSN = SSN
relie le département de contrôle à l'employé qui gère ce département.
♦la condition PLOCATION = 'Stafford' est la condition de sélection.
PNUMBER DNU LNAME ADDRESS BDATE
10
30
4
4
Wallace
Wallace
291, Berry, Bellaire, TX
291, Berry, Bellaire, TX
20-JUN-31
20-JUN-31

consultation
20
SELECT : Noms identiques
Ø le même nom peut être utilisé pour plusieurs attributs pourvu que
ces attributs soient dans des relations différentes.
Ø Dans une requête, on préfixe le nom de la relation au nom de
l'attribut en les séparant par un '.‘ .
Exemple:
Ø Supposons que les attributs DNO et LNAME de la relation
EMPLOYEE sont nommés DNUMBER et NAME,
Ø et que l'attribut DNAME de DEPARTMENT est aussi nommé
NAME.
Pour éviter l'ambiguïté, la consultation R2 est reformulée en R2A :
R2A: SELECT FNAME, EMPLOYEE.NAME, ADDRESS
WHERE DEPARTMENT.NAME='Research'
AND DEPARTMENT.DNUMBER = EMPLOYEE.DNUMBER

consultation
21
Ø Nous pouvons aussi utiliser un mécanisme d'alias.
Exemple : R2A peut être réécrite en R2B en réduisant les noms de
relations.
R2B: SELECT E.FNAME, E.NAME, E.ADDRESS
FROM EMPLOYEE E , DEPARTMENT D
WHERE D.NAME = 'Research'
AND D.DNUMBER = E.DNUMBER

consultation
22
L'ambiguïté apparaît aussi quand une consultation fait référence deux fois
à la même relation.
REQUÊTE 4 : Pour chaque employé, rechercher le nom et le prénom ainsi
que le nom et le prénom de son superviseur immédiat.
R4: SELECT E.FNAME, E.LNAME, S.FNANE, S.LNAME
FROM EMPLOYEE E S
WHERE E.SUPERSSN = S.SSN
Résultat de la requête 4:
E. FNAME E. NAME S. FNAME S. LNAME
John
Franklin
Alicia
Jennifer
Ramesh
Joyce
Ahmad
Smith
Wong
Zelage
Wallace
Narayan
English
Jabbar
Franklin
James
Jennifer
James
Franklin
Franklin
Jennifer
Wong
Borg
Wallace
Borg
Wong
Wong
Wallace
E et S sont
séparés par un
blanc et non
d'une virgule
E représente
EMPLOYEE
dans le rôle de
supervisé,
S représente
EMPLOYEE
dans le rôle de
superviseur.
la jointure se fait entre la
relation avec elle-même
en sélectionnant les tuples
qui satisfont la condition
E.SUPERSSN = S.SSN.

consultation
23
SELECT : Utilisation de ‘ * ’
Ø Permet de spécifier tous les attributs d’une table
Exemple: La consultation R6A représente le produit cartésien entre
EMPLOYEE et DEPARTMENT.
R6A : SELECT *
Exemple: La consultation R7 retrouve toutes les valeurs d'attributs des
tuples EMPLOYEE qui travaillent pour le DEPARTMENT #5
R7: SELECT *
FROM EMPLOYEE
WHERE DNO = 5
Résultat de R7 :
FNAME MINIT LNAME SSN BDATE ADDRESS S SALARY SUPERSSN DNO
John
Franklin
Ramesh
Joyce
B
T
K
A
Smith
Wong
Narayan
English
123456789
333445555
666884444
453453453
09-JAN-55
08-DEC-45
15-SEP-52
31-JUL-62
731, Fondren, Houston, TX
638 Voss, Houston, TX
975, Fire Oak, Humble, TX
5631 Rice, Houston, TX
M
M
M
F
30000
40000
38000
25000
333445555
888665555
333445555
333445555
5
5
5
5

consultation
24
SELECT : L’instruction DISTINCT
Ø SQL n'élimine pas automatiquement les duplications dans les
résultats de consultations.
Ø Si on désire éliminer les duplications, on utilisera l’instruction
DISTINCT dans la clause SELECT.
Ex: Rechercher le salaire de chaque
employé. Les tuples identiques sont
dupliqués tel qu’illustré sur la figure.
R9 : SELECT SALARY
FROM EMPLOYEE
Résultat de R9:
S A L A R Y
30000
40000
25000
43000
38000
25000
25000
55000
Ex: Si on est intéressé par
seulement les salaires distincts, on
utilise la consultation R9A.
R9A: SELECT DISTINCT SALARY
FROM EMPLOYEE
Résultat de R9A:
S A L A R Y
3 0 0 0 0
4 0 0 0 0
2 5 0 0 0
4 3 0 0 0
3 8 0 0 0
5 5 0 0 0

consultation
25
SELECT : UNION, MINUS, INTERSECT
Certaines opérations de l'algèbre relationnelle peuvent être incorporées:
Ø UNION
Ø MINUS (différence)
Ø INTERSECT
Remarque : Par souci de compatibilité, les relations impliquées doivent avoir les
mêmes attributs apparaissant dans le même ordre.
Ex: Produire une liste de tous les # de projets impliquant un employé, dont le nom
est 'Smith' comme un travailleur ou un manager du département qui contrôle le
projet.
R10 :
( SELECT PNUMBER
FROM PROJECT, DEPARTMENT, EMPLOYEE
WHERE DNUM = DNUMBER AND MGRSSN = SSN AND LNAME = 'Smith')
UNION
( SELECT PNUMBER
FROM PROJECT, WORKS_ON, EMPLOYEE
WHERE PNUMBER = PNO AND ESSN = SSN AND LNAME = 'Smith' )
Le premier « select » retrouve les projets
impliquant 'Smith' comme manager du
département qui contrôle le projet.
le second retrouve
les projets
impliquant 'Smith'
comme travailleur
sur le projet.

consultation
26
SELECT : Consultations imbriquées et
comparaisons d'ensembles
Certaines consultations nécessitent que les valeurs existantes dans la BD
doivent être retrouvées puis utilisées dans la conditions de comparaison.
Ø l'imbrication avec des consultations complètes de type SELECT-
FROM, WHERE.
Ex: La consultation R10 est reformulée en R10A pour utiliser l'imbrication.
R10A: SELECT DISTINCT PNUMBER
FROM PROJET
WHERE PNUMBER IN
( SELECT PNUMBER
FROM PROJECT,DEPARTMENT, EMPLOYEE
WHERE DNUM = DNUMBER AND MGRSSN=SSN
AND LNAME='Smith' )
OR PNUMBER IN
( SELECT PNO
FROM WORKS_ON, EMPLOYEE
WHERE ESSN=SSN AND LNAME='Smith' )
1. La première consultation
imbriquée sélectionne les #
de projets dont 'Smith' est
impliqué comme manager.
2. La seconde consultation
imbriquée sélectionne les #
de projets dont 'Smith' est
impliqué comme travailleur.
3. Dans la
consultation
externe on
sélectionne le
tuple projet si la
valeur de
PNUMBER est
soit dans le 1er
résultat, soit
dans le second

consultation
27
On peut avoir plusieurs niveaux d'imbrication, pour différencier les attributs
dans les consultations, il faut suivre la règle suivante:
Règle : Une référence à un attribut non qualifié se rapporte à la relation
déclarée dans la consultation imbriquée la plus interne.
Exemple
R11: Retrouver le nom de chaque employé qui possède un dépendant
ayant le même prénom et le même sexe que lui.
R11 : SELECT E.FNAME, E.LNAME
FROM EMPLOYEE E
WHERE E.SSN IN ( SELECT ESSN
FROM DEPENDENT
WHERE ESSN = SSN
AND FNAME = NAME
AND SEX = E.SEX )
Résultat: FNAME LNAME
On doit qualifier
E.SEX car SEX
est un attribut
de EMPLOYEE
et de
DEPENDENT

consultation
28
Lorsqu’une condition de la clause WHERE d'une consultation imbriquée
fait référence aux attributs d'une consultation externe, on dit qu'elles sont
corrélées.
Ø la consultation imbriquée interne est évaluée une fois pour chaque
tuple dans la consultation externe.
Une consultation imbriquée de la forme SELECT, FROM, WHERE utilisant
= ou IN comme opérateur de comparaison peut être exprimée par une
consultation d’un seul bloc.
Ex: La consultation R11 est réécrite en R11A
R11A : SELECT E.FNAME, E.LNAME
FROM EMPLOYEE E, DEPENDENT D
WHERE E.SSN = D.ESSN AND
E.SEX = D.SEX AND
E.FNAME = D.NAME

consultation
29
SELECT : Fonction EXISTS
Ø utilisées en conjonction avec une consultation imbriquée corrélée.
• EXISTS(Q) : retourne TRUE s’il existe au moins un tuple dans le
résultat de la consultation Q.
• NOT EXISTS(Q) : retourne TRUE s’il n’y a pas de tuples dans le
résultat de la consultation Q.
Ex: La consultation R11 est reformulée en R11B
SELECT E.FNAME, E.LNAME
FROM EMPLOYEE E
WHERE EXISTS( SELECT *
FROM DEPENDENT
WHERE E.SSN=ESSN AND
SEX = E.SEX AND
E.FNAM = DEPENDENT.NAME )
Retrouver le nom
de chaque employé
qui possède un
dépendant ayant le
même prénom et le
même sexe que lui.

consultation
30
SELECT : Fonction EXISTS
R12 : Retrouver les noms des employés qui n'ont aucun dépendant.
SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE NOT EXISTS( SELECT *
FROM DEPENDENT
WHERE SSN=ESSN)
R13 : Lister les noms des «managers» qui ont au moins un dépendant.
SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE EXISTS( SELECT *
FROM DEPENDENT
WHERE SSN=ESSN )
AND
EXISTS( SELECT *
FROM DEPARTMENT
WHERE SSN=MGRSSN )
Vérifie que
l’employé a un
dépendant.
Vérifie que
l’employé est
un «managers».

consultation
31
SELECT : Fonction CONTAINS
Ø compare deux ensembles de valeurs. Il retourne TRUE si l'un
contient tous les éléments de l'autre.
Remarque: Ce n’est pas toutes les implantations commerciales de SQL
qui possèdent cet opérateur.
R14 : Retrouver le nom de chaque employé qui travaille sur tous les
projets contrôlés par le département #5.
SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE ( ( SELECT PNO
FROM WORKS_ON
WHERE SSN=ESSN )
CONTAINS
( SELECT PNUMBER
FROM PROJECT
WHERE DNUM=5 ) )
1.Retrouve tous les
numéros de projets
par employé.
2.Retrouve tous les
numéros de projets du
département #5.
3. Conserve les
noms et prénoms
des employé qui
ont tous les
projets du
département #5.

consultation
32
SELECT : Fonction CONTAINS
On peut remplacer CONTAINS, par les fonctions EXISTS et NOT EXISTS.
La requête R14 peut être ré-écrite en R14A
SELECT LNAME, FNAME
FROM EMPLOYEE
WHERE NOT EXISTS( SELECT *
FROM WORKS_ON B
WHERE ( B.PNO IN ( SELECT PNUMBER
FROM PROJECT
WHERE DNUM=5
)
AND
NOT EXISTS( SELECT *
FROM WORKS_ON C
WHERE C.ESSN=SSN
AND
C.PNO=B.PNO )
)
Sélectionner chaque
employé pour lequel
il n'existe aucun
projet contrôlé par le
département 5 et
que cet employé ne
travaille pas dessus.
Sélectionne tout tuple de
WORKS_ON (B) dont PNO
désigne un projet contrôlé
par département 5…
…et où il n'y a aucun tuple WORKS_ON
(C) avec le même PNO et le même SSN
que celui de l'employé en considération
dans la consultation externe

consultation
33
SELECT : Ensembles explicites et NULL
Ensemble explicites
On peut utiliser un ensemble de valeurs explicites dans la clause
“WHERE” à la place d'une consultation imbriquée.
R15 : Retrouver les numéros de sécurité social de tous les employés qui
travaillent sur les projets #1, 2 ou 3.
SELECT DISTINCT ESSN
FROM WORKS_ON
WHERE PNO IN ( 1, 2, 3 )
Null
SQL permet de vérifier si une valeur est NULL. On utilise IS et ISNOT au
lieu des signes '=' et '<>‘.
R16: Retrouver les noms de tous les employés qui n'ont pas de
superviseurs.
SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE SUPERSSN IS NULL
FNAME LNAME
James Borg

consultation
34
SELECT : Fonctions d'agrégation
Ø L'agrégation et le groupement sont nécessaires dans plusieurs
applications.
Ø SQL possède des primitives pour incorporer ces concepts:
• COUNT : le nombre de valeurs;
• SUM : la somme des valeurs;
• MAX : la valeur maximum;
• MIN : la valeur minimum;
• AVG : la valeur moyenne.
Remarque: Ces fonctions peuvent être utilisées dans la clause
SELECT seulement, ou dans la clause HAVING.
Exemples:
R17 : Trouver la somme des salaires de tous les employés, le salaire
maximum, le salaire minimum et le salaire moyen.
SELECT SUM(SALARY), MAX(SALARY),
MIN(SALARY), AVG(SALARY)
FROM EMPLOYEE

consultation
35
R18 : Si on veut avoir les mêmes valeurs que la consultation précédente mais
seulement pour les employés du département 'Research':
SELECT SUM(SALARY), MAX(SALARY),
MIN(SALARY), AVG(SALARY)
WHERE DNO=DNUMBER AND
DNAME='Research‘
R19 : Retrouver le nombre total d’employés dans la compagnie.
SELECT COUNT(*)
FROM EMPLOYEE
R20 : Retrouver le nombre d’employés dans le département 'Research'.
SELECT COUNT(*)
WHERE DNO=DNUMBER AND
DNAME= 'Research'
Ici, «*» réfère aux tuples, alors COUNT(*) retourne le nombre de lignes retenues
par la condition de la requête.
Certains SQL ne
permettent pas plus
d'une fonction dans la
clause SELECT; dans
ce cas, on doit écrire 4
consultations.

consultation
36
COUNT peut être utilisé pour compter les valeurs dans une colonne au
lieu des tuples.
Ex: Compter le nombre de valeurs “distinctes” de salaires dans la BD.
R21: SELECT COUNT (DISTINCT SALARY)
FROM EMPLOYEE
Les fonctions d’agrégation peuvent être utilisé pour sélectionner des tuples
particuliers. Il faut alors utiliser une consultation imbriquée corrélée avec la
fonction désirée.
Ex : Retrouver les noms des employés qui ont au minimum 2 dépendants.
R22: SELECT LNAME, FNAME
FROM EMPLOYEE
WHERE(SELECTCOUNT(*)
FROM DEPENDENT
WHERE SSN=ESSN ) > 2

consultation
37
SELECT : Fonctions GROUP BY
Ø Permet d’appliquer les fonctions d'agrégation aux sous-groupes
de tuples d’une relation, basés sur certaines valeurs d'attributs.
Ex: Pour chaque département, retrouver le numéro du département, le
nombre d'employés et leur salaire moyen.
R23 : SELECT DNO, COUNT(*),AVG(SALARY)
FROM EMPLOYEE
GROUP BY DNO
Attribut de
regroupement
FNAME MINIT LNAME SSN *** SALARY SUPERSSN DNO
John B Smith 123456789 30000 333445555 5
Franklin T Wong 333445555 40000 888665555 5
Ramesh K Narayan 666884444 38000 333445555 5
Joyce A English 453453453 25000 333445555 5
Alicia J Selaya 999887777 25000 987654321 4
Jennifer S Wallace 987654321 43000 888665555 4
Ahmad V Jabbar 987987987 25000 987654321 4
James E Bong 88866555
***
55000 null 1
Regroupement des tuples EMPLOYEE en se basant sur le DNO
DNO COUNT (*)
AVG
(SALARY)
5 4 33250
4 3 31000
1 1 55000
Résultat de R23
}
}
la clause SELECT inclut
seulement les attributs de
regroupement et les
fonctions à appliquer sur
chaque groupe de tuples.
2. Les fonctions
COUNT et AVG
sont appliquées
aux groupes
séparément.
1. Les tuples de la table
EMPLOYEE sont
divisés en groupes,
sur la base de la
valeur de DNO.

consultation
38
SELECT : Fonctions GROUP BY
Ø Nous pouvons utiliser une condition de jonction en conjonction avec
GROUP BY.
Ø Le groupement et les fonctions d’agrégations sont appliqués
seulement après la jonction des deux relations.
REQUÊTE 24: Pour chaque projet, retrouver le # du projet, le nom du
projet ainsi que le nombre d'employés qui travaillent sur ce projet.
R24 : SELECT PNUMBER, PNAME, COUNT(*)
FROM PROJECT, WORKS_ON
WHERE PNUMBER=PNO
GROUP BY PNUMBER, PNAME

consultation
39
SELECT : Clause HAVING
Ø Permet de retrouver les données pour seulement les groupes qui
satisfont certaines conditions.
Ø Ne s’utilise qu’avec la clause GROUP BY.
Ø Seuls les groupes qui satisfont la condition de HAVING seront
retrouvés.
Ex: Pour chaque projet sur lequel travaillent plus de deux employés,
retrouver le # du projet, le nom du projet et le nombre d'employés qui
travaillent sur ce projet.
R25 : SELECT PNAME, COUNT(*)
FROM PROJECT, WORKS_ON
WHERE PNUMBER=PNO
GROUP BY PNUMBER, PNAME
HAVING COUNT(*)>2

consultation
40
C e s g r o u p e s n e s o n t
p a s s é l e c t i o n n é s p a r
l a c o n d i t i o n
« H A V I N G » d e R 2 5
P N A M E P N U M B E R * * * E S S N P N O H O U R S
P r o d u c t X 1 1 2 3 4 5 6 7 8 9 1 3 2 . 5
P r o d u c t X 1 4 5 3 4 5 3 4 5 3 1 2 0 . 0
P r o d u c t Y 2 1 2 3 4 5 6 7 8 9 2 7 . 5
P r o d u c t Y 2 4 5 3 4 5 3 4 5 3 2 2 0 . 0
P r o d u c t Y 2 3 3 3 4 4 5 5 5 5 2 1 0 . 0
P r o d u c t Z 3 6 6 6 8 8 4 4 4 4 3 4 0 . 0
P r o d u c t Z 3 3 3 3 4 4 5 5 5 5 3 1 0 . 0
C o m p u t e r i z a t i o n 1 0 3 3 3 4 4 5 5 5 5 1 0 1 0 . 0
R e o r g a n i z a t i o n 2 0 3 3 3 4 4 5 5 5 5 2 0 1 0 . 0
R e o r g a n i z a t i o n 2 0 9 8 7 6 5 4 3 2 1 2 0 1 5 . 0
R e o r g a n i z a t i o n 2 0 8 8 8 6 6 5 5 5 5 2 0 n u l l
N e w b e n e f i t s 3 0 9 8 7 9 8 7 9 8 7 3 0 5 . 0
N e w b e n e f i t s 3 0 9 8 7 6 5 4 3 2 1 3 0 2 0 . 0
N e w b e n e f i t s 3 0 9 9 9 8 8 7 7 7 7 3 0 3 0 . 0
A v a n t a p p l i c a t i o n d e l a c l a u s e “ H A V I N G ”
}
}
}
}
}
}
P N A M E P N U M B E R E S S N P N O H O U R S
ProductY 2 1 2 3 4 5 6 7 8 9 2 7.5
ProductY 2 4 5 3 4 5 3 4 5 3 2 20.0
ProductY 2 3 3 3 4 4 5 5 5 5 2 10.0
C o m p u t e r i z a t i o n 1 0 3 3 3 4 4 5 5 5 5 1 0 10.0
R e o r g a n i z a t i o n 2 0 3 3 3 4 4 5 5 5 5 2 0 10.0
R e o r g a n i z a t i o n 2 0 9 8 7 6 5 4 3 2 1 2 0 15.0
R e o r g a n i z a t i o n 2 0 8 8 8 6 6 5 5 5 5 2 0 null
N e w b e n e f i t s 3 0 9 8 7 9 8 7 9 8 7 3 0 5.0
N e w b e n e f i t s 3 0 9 8 7 6 5 4 3 2 1 3 0 20.0
N e w b e n e f i t s 3 0
* * *
9 9 9 8 8 7 7 7 3 0 30.0
A p r è s a p p l i c a t i o n d e l a c l a u s e “ H A V I N G ”
} P N A M E C O U N T
(*)
P r o d u c t Y 3
C o m p u t e r i z a t i o n 3
R e o r g a n i z a t i o n 3
N e w b e n e f i t s 3
R e s u l t a t d e R 2 5
( P N U M B E R n o n a f f i c h é )
}
}
}

consultation
41
Note: les conditions de sélection dans la clause WHERE limitent les tuples
pour lesquelles les fonctions sont appliquées, tandis que la clause
HAVING limite les groupes en entier. On doit faire attention quand on
applique deux conditions.
Ex: Supposé qu'on veut compter le nombre total des employés ayant des
salaires supérieurs à 40 000$ dans chaque département, mais seulement
pour les départements ayant plus de 5 employés.
Supposons qu'on écrive la consultation incorrecte suivante :
SELECT DNAME, COUNT(*)
FROM DEPARTMENT, EMPLOYEE
WHERE DNUMBER=DNO AND SALARY > 40 000
GROUP BY DNAME
HAVING COUNT(*)>5
Attention: Cette consultation sélectionne seulement les départements qui
ont plus de 5 employés ayant un salaire de plus de 40 000$.

consultation
42
La règle est :
• La clause WHERE est exécutée en premier pour sélectionner les
tuples individuellement,
• la clause HAVING est exécutée après, pour sélectionner les
groupes de tuples séparément.
Une façon d'écrire correctement la consultation précédente :
R26 : SELECT DNAME, COUNT(*)
WHERE DNUMBER = DNO AND
SALARY > 40 000 AND
DNO IN( SELECT DNO
FROM EMPLOYEE
GROUP BY DNO
HAVING COUNT(*) > 5 )
GROUP BY DNAME

consultation
43
SELECT : Comparaison de chaînes
Ø Utilisé dans la clause WHERE
Ø L’instruction LIKE est utilisé comme opérateur de comparaison.
Ø % ou * : remplace une chaînes de caractères de longueur quelconque
Ø '_' ou ? : remplace un caractère arbitraire
Ex: Retrouver tous les employés dont l'adresse est dans Houston,Tx.
R27: SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE ADDRESS LIKE '% Houston,Tx% ’
Ex: Retrouver les employés qui sont nés durant les années 1950. On suppose que
'5' doit être le 9e caractère de la chaîne représentant la date de naissance qui a le
format JJ-MM-AAAA
R28 : SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE BDATE LIKE '_______5_'
Votre requêtes ne
fonctionnera plus en
2050!!!
Noter que le
“ % ” et le “ _ ”
font partie du
ANSI de SQL.

consultation
44
SELECT : OPERATEURS ARITHMETIQUES
Les opérateurs arithmétiques sont permis dans les consultations et
peuvent être appliqués aux valeurs numériques du résultat de la
consultation:
Ø +, - ,* , /
Ex: Supposé qu'on veut voir l'effet de donner à tous les employés qui
travaillent sur 'PRODUCT X' une augmentation de 10%.
SELECT FNAME, LNAME, 1.1*SALARY
FROM EMPLOYEE, WORKS_ON, PROJECT
WHERE SSN=ESSN AND PNO=PNUMBER
AND PNAME = 'Product X ’

consultation
45
SELECT : Ordre de tri
Ø SQL permet de trier les tuples dans le résultat de la consultation sur la
base d'un ou plusieurs attributs,
Ø la clause se nomme ORDER BY
Ø Le tri est ascendant (ASC) par défaut et on utilise le mot clé DESC
si on désire un ordre descendant
Ex: Retrouver le liste des employés et les projets sur lesquels ils travaillent. La
liste doit être ordonnée par département et dans chaque département, ordonnée
alphabétiquement par nom.
R30 : SELECT DNAME, LNAME, FNAME, NAME
FROM DEPARTMENT, EMPLOYEE, WORKS_ON,
PROJECT
WHERE DNUMBER=DNO AND SSN=ESSN AND
PNO=PNUMBER
ORDER BY DNAME, LNAME, FNAME
Ex: Si on veut un ordre descendant sur DNAME et ascendant sur LNAME et
FNAME, la clause ORDER BY de R30 devient:
ORDER BY DNAME DESC, LNAME ASC, FNAME ASC

consultation
46
Sommaire des éléments d’une consultation SQL
Une consultation SQL contient jusqu'à 6 clauses. Mais seulement les
deux premières sont obligatoires . ( [ ] signifie optionnel)
SELECT <Liste d'attributs>
FROM <Liste de tables>
[WHERE <Conditions>]
[GROUP BY <Attributs de groupement>]
[HAVING <Condition groupe>]
[ORDER BY <Liste d'attributs>]
Liste des attributs ou
fonctions à retrouver
Spécifie toutes les relations
nécessaires dans la
consultation, mais pas celles
qui sont nécessaires dans les
consultations imbriquées.
Spécifie les
conditions pour
sélectionner les
tuples à partir
des relations.
Spécifie les attributs de
groupement.
Spécifie la condition sur les
groupes à sélectionner, et
non pas sur les tuples
individuelles
spécifie l'ordre d'affichage du
résultat de la consultation.

consultation
47
Sommaire des éléments d’une consultation SQL
Rappel:
ØLes fonctions d'agrégations : COUNT, SUM, MIN, MAX
et AVG sont utilisées en conjonction avec le
groupement.
ØUne consultation est évaluée en appliquant en 1er la
clause WHERE, ensuite GROUP BY et HAVING.
ØChaque SGBD possède des routines d'optimisation pour
réaliser une consultation.
ØEn général, il y a plusieurs façons de décrire la même
consultation en SQL.

consultation
48
INSERT
♦ utilisée pour ajouter un tuple à une relation.
♦ On doit spécifier le nom de la relation et la liste des valeurs du tuple.
1. Toutes les valeurs sont listées dans le même ordre que les attributs spécifiés
dans la commande CREATE TABLE.
U1 :INSERT INTO EMPLOYEE
VALUES( 'Richard', 'K', 'Marini', '653 298 653', '30-DEC-52',
'98 BAR FOREST, Katy, TX','M', 37 000, '987654321',4)
2. Certaines valeurs sont listées en spécifiant explicitement le nom des attributs
correspondants.
Ø Ainsi, les attributs à valeurs NULL sont ignorés.
U1A : INSERT INTO EMPLOYEE ( FNAME, LNAME, SSN )
VALUES ( 'Richard', 'Marini', '654 248 653')

consultation
49
INSERT
Il est important de garder l'intégrité référentielle.
Exemple: dans la consultation U2, SQL va réaliser l'insertion, même s'il n'y
a pas de département ayant le numéro 2 (DNUMBER=2). C'est sous la
responsabilité de l'utilisateur de vérifier si les contraintes sont violées. (À
moins d’avoir préalablement créé vos contraintes)
U2 : INSERT INTO EMPLOYEE ( FNAME, LNAME, SSN, DNO )
VALUES ( 'Robert', 'Hatcher','980760540', 2 )
Par contre, SQL va rejeter une commande d'insertion dans laquelle un
attribut déclaré NOT NULL ne reçoit pas de valeur. Ainsi, U2A sera rejeté
puisque l’attribut SSN a été déclaré NOT NULL.
U2A: INSERT INTO EMPLOYEE (FNAME, LNAME, DNO)
VALUES ( 'Robert', 'Hatcher', 2 )
Manque
SSN

consultation
50
INSERT
♦permet d'insérer des tuples multiples dans une relation en utilisant une
consultation qui s’occupe du chargement de la table.
Ex: Supposé qu'on veuille créer une table temporaire qui possède le nom,
le nombre d'employés et le salaire total de chaque département.
La table DEPTS_INFO est créée par U3A:
U3A: CREATE TABLE DEPTS_INFO( DEP_NAME VARCHAR(15),
NO_OF_EMPS INTEGER,
TOTAL_SAL INTEGER );
Elle est chargée par le résultat de la consultation U3B:
U3B: INSERT INTO DEPTS_INFO ( DEPT_NAME, NO_OF_EMPS,
TOTAL_SAL )
SELECT DNAME, COUNT(*), SUM(SALARY)
WHERE DNUMBER = DNO
GROUP BY DNAME;

consultation
51
DELETE
La commande DELETE
Øpermet de supprimer des tuples d'une relation.
Øutilise la clause de sélection WHERE pour sélectionner
les tuples à supprimer.
ØLes tuples sont supprimés que d'une seule table à la
fois.
ØSi la clause WHERE est omise, tous les tuples de la
relation seront supprimés. Par contre, la table reste
dans la BD comme vide.
• Pour supprimer une table complètement, on doit utiliser la
commande DROP TABLE.

consultation
52
DELETE
Ex: Si on veut supprimer 1 ou plusieurs tuples de la relation
EMPLOYEE:
U4A : DELETE FROM EMPLOYEE
WHERE LNAME = 'Brown'
U4B : DELETE FROM EMPLOYEE
WHERE SSN='123456789'
U4C : DELETE FROM EMPLOYEE
WHERE DNO IN ( SELECT DNUMBER
FROM DEPARTMENT
WHERE DNAME = 'Research')
U4D : DELETE FROM EMPLOYEE
Détruit tous les
employés du
département
recherche.
Détruit tous les
tuples de la table
EMPLOYEE.

consultation
53
UPDATE
♦utilisée pour modifier les valeurs d'attributs d'un ou plusieurs
tuples sélectionnés.
♦la clause SET spécifie les attributs à modifier.
♦la clause WHERE sélectionne les tuples d'une relation à
modifier.
Ex: Changer le lieu et le # du département du projet #10 à
'Bellaire' et 5, respectivement.
U5 : UPDATE PROJECT
SET PLOCATION = 'Bellaire', DNUM=5
WHERE PNUMBER=10

consultation
54
UPDATE
♦Il est possible de modifier plusieurs tuples avec une seule
commande UPDATE.
Ex: Donner à tous les employés du département 'Research'
une augmentation de salaire de 10%.
Noter : Deux références à l'attribut SALARY sont nécessaires.
U6 : UPDATE EMPLOYEE
SET SALARY = SALARY * 1.1
WHERE DNO IN ( SELECT DNUMBER
FROM DEPARTMENT
WHERE DNAME = 'Research' )

consultation
55
Les vues
Ø Table virtuelle dérivée à partir d’autres tables (elle n’existe pas
physiquement)
Ex:Si on émet fréquemment des consultations qui recherchent le nom
de l'employé et les noms des projets sur lesquels il travaille…
Au lieu de spécifier à chaque fois la jonction de EMPLOYEE,
WORKS_ON et PROJECT;
nous pouvons définir une vue qui contient le résultat de ces
jonctions.
Les consultations peuvent maintenant se faire sur la vue, qui est
une seule table au lieu de deux jonctions impliquant 3 tables.
On appelle les tables EMPLOYEE, WORKS_ON, PROJECT : Tables de
définition de la vue...
Les autres tables sont des
tables de base ou des vues
précédemment définies.

consultation
56
Spécification des vues
CREATE VIEW
V1: CREATE VIEW WORKS_ON_1
AS SELECT FNAME, LNAME, PNAME, HOURS
FROM EMPLOYEE, PROJECT, WORKS_ON
WHERE SSN = ESSN AND PNO = PNUMBER;
La consultation des vues se fait de la même façon que les
autres tables.
Ex: Retrouver le nom et le prénom de tous les employés qui
travaillent sur le projet 'PROJECTX‘.
QV1: SELECT FNAME, LNAME
FROM WORKS_ON_1
WHERE PNAME = 'ProjectX';
Nom de la vue
Consultation

consultation
57
Spécifications des vues
Ø Si les attributs résultent de fonctions appliquées ou d’opérations
arithmétiques, nous devons spécifier les attributs de la vue.
V2 : CREATE VIEW DEPT_INFO ( DEPT_NAME,
NO_OF_EMPS,TOTAL_SAL)
AS SELECT DNAME, COUNT(*), SUM(SALARY)
WHERE DNUMBER = DNO
GROUP BY DNAME;
NOTE : Une vue est toujours mise à jour. Si on modifie les tuples dans
les tables de base sur lesquelles la vue est définie, la vue reflète
automatiquement ces changements.
La vue n'est pas réalisée au moment de la définition de la vue, mais plutôt
au moment où on spécifie une consultation sur la vue.
Liste
d’attributs

consultation
58
Élimination des vues
DROP VIEW
Ex:
DROP VIEW WORKS_ON;
DROP VIEW DEPT_INFO;

consultation
59
Mise à jour sur une vue
La mise à jour d’une vue est compliquée et peut être ambiguë.
Ø Vue définie sur une seule table: la mise à jour peut correspondre à
la mise à jour de la table de base correspondante.
Ø Vue impliquant des jonctions: la mise à jour peut correspondre à la
mise à jour des tables de base, selon plusieurs façons.
Exemple: Transférer l’employé “John Smith” du projet “Product X” au
projet “Product Y”.
Si on considère la vue WORKS_ON_1, il s’agit de faire la mise à jour de
l'attribut PNAME de 'ProductX' à 'Product Y' lorsque l’employé “John
Smith” est impliqué.
UV1 : UPDATE WORKS_ON_1
SET PNAME = 'ProductY ’
WHERE LNAME = 'Smith' AND FNAME = 'John'
AND PNAME = 'ProductX ’

consultation
60
Cette mise à jour peut correspondre à différentes modifications sur les
relations de base.
a) UPDATE WORKS_ON
SET PNO = ( SELECT PNUMBER
FROM PROJECT
WHERE PNAME = 'ProductY' )
WHERE ESSN=( SELECT SSN
FROM EMPLOYEE
WHERE LNAME ='Smith’ AND
FNAME = 'John' )
AND
PNO = ( SELECT PNUMBER
FROM PROJECT
WHERE PNAME = 'ProductX' )
b) UPDATE PROJECT
SET PNAME = 'Product Y’
WHERE PNAME= 'ProductX‘
Modifie le tuple 'ProductX' dans
la relation PROJECT en
'ProductY’. Tous les employés
qui travaille pour le projet
ProductX vont être assignés
sur le projet ProductY.
relie 'John
Smith' au
tuple
'Product Y'
à la place
de
'ProductX'.

consultation
61
Certaines mises à jour de vue n'ont pas de sens.
Ex: Modifier l'attribut TOTAL_SAL dans DEPT_INFO.
UV2: UPDATE DEPT_INFO
SET TOTAL_SAL = 100 000
WHERE DNAME = 'Research';
NOTE : Le thème de mise à jour des vues est encore un domaine de
recherche très actif, notez que certains chercheurs ont défini des
algorithmes pour choisir qu’elle mise à jour sont les plus vraisemblables,
d’autres préfèrent avoir le choix de l'utilisateur.
Représente la somme
des salaires!

consultation
62
INDEX
Ø sont des chemins d'accès physiques; spécifiés sur certains attributs
nommés : Attributs d’indexation.
Ø permettent de rendre l'accès aux tuples plus efficace.
Ø font parties du DDL
Création d’index
Ex :
I1 : CREATE INDEX LNAME_INDEX
ON EMPLOYEE( LNAME );
Les index sont croissants sur les valeurs d'attributs indexés. Si on veut
désigner l'ordre décroissant: DESC.
I2 : CREATE INDEX NAME_INDEX
ON EMPLOYEE( LNAME ASC, FNAME DESC, MINIT );

consultation
63
INDEX
On peut aussi spécifier un attribut comme clé :
I3 : CREATE UNIQUE INDEX SSN_INDEX
ON EMPLOYEE( SSN );
Note : Spécifier une clé est recommandé avant que les tuples ne soient
insérées dans la relation, de telle façon que le système puisse renforcer la
contrainte.
L’option “CLUSTER” permet de spécifier un index de regroupement; ce qui
rend plus efficace les conditions de sélection et de jonction.
Ex: On veut que les enregistrements de EMPLOYEE soient indexés et
regroupés par le # de département.
I4 :CREATE INDEX DNO_INDEX
ON EMPLOYEE(DNO) CLUSTER;

consultation
64
INDEX
Élimination d’index
DROP INDEX
Ex: Pour supprimer l'index DNO_INDEX
I5 : DROP INDEX DNO_INDEX
Note : Attention de ne pas supprimer un index clé!

consultation
65
Intégration de SQL dans les langages évolués
SQL peut être utilisé en conjonction avec un langage évolué:
Ø C, C++, Pascal, COBOL, PLI.
Ex 1: A) Invocation SQL directe :
SELECT FNAME, LNAME
FROM EMPLOYEE
WHERE DNO = ‘5’;
B) Invocation à partir d’un programme
(Pro C/C++)
char fname[20], lname[20];
EXEC SQL SELECT FNAME , LNAME
INTO :fname, :lname
FROM EMPLOYEE
WHERE DNO = ‘5’;
Ici, les mots
réservés EXEC
SQL du langage
Pro C/C++ permet
l'appel d'une
fonction SQL.
Les variables sont
préfixées avec
“ : ”; Ce qui permet
de faire le lien
entre le langage
hôte et le SGBD
en introduisant le
résultat de la
consultation dans
ces variables.

consultation
66
Intégration de SQL dans les langages évolués
Ex 2: consultation SQL à partir d'un langage comme Pascal
Begin
writeln('entrez votre numéro d'assurance sociale:');
readln(numAssSociale);
$SELECT NOM, ADRESSE, SALAIRE
INTO %E.NOM, %E.ADRESSE, %E.SALAIRE
FROM EMPLOYÉ
WHERE NAS = %numAssSociale;
writeln (E.NOM, E.ADRESSE, E.SALAIRE);
Note :
• $ indique la commande SQL.
• Les variables Pascal sont préfixées de % dans la clause INTO.

consultation
67
Le langage QBE (Query By Example)
Caractéristiques:
Øa été mis au point dans les laboratoires de recherche de
la compagnie IBM.
Øfait partie du système de base de données DB2.
Øpossède une syntaxe bidimensionnelle:
• nécessite une surface (canevas), et non un espace linéaire,
pour s'exprimer.
Øeffectue des recherches au moyen d'un exemple que lui
fournit l'utilisateur au lieu d'utiliser une procédure.
Øforte analogie entre QBE et le calcul relationnel sur
domaine.

consultation
68
Le langage QBE
Canevas d’une base de données bancaire
L'utilisateur sélectionne les schémas qui lui conviennent, en
fonction de la recherche qu'il désire effectuer.
Banque Agence Avoirs Ville
Clientèle Client Rue Localité
Crédit Agence Prêt Client Montant
Dépôt Agence Compte Client Position

consultation
69
Le langage QBE
Ex 1 : Trouver l'ensemble des clients qui ont un compte à
Perryridge.
où
P. veut dire Print
_x désigne une variable que le système utilise.
L'objectif essentiel des variables que manipule le langage
QBE est de forcer les valeurs de certains tuples à être
identiques sur certains attributs.
Perryridge P._x

consultation
70
Le langage QBE
Ex 2 : Trouver l'ensemble des clients qui ont un compte à
Perryridge ainsi que la ville où ils résident.
Utilisation des canevas des relations Crédit et Clientèle
Perryridge _x
Clientèle Client Rue Localité
P._x P._y

consultation
71
Le langage QBE
Contrairement à SQL ou QUEL, il élimine automatiquement
les doublons.
Ex 3 : Cet exemple illustre comment on peut les conserver.
La commande ALL permet d’afficher les doublons
Perryridge P.ALL._x

consultation
72
Le langage QBE
Ex 4: Trouver les clients qui ont à la fois un compte à
Perryridge et à Redwood.
L’opération ET sur une seule relation
Perryridge
Redwood
P._x
_x

consultation
73
Le langage QBE
Ex 5 : Trouver les clients de Perryridge qui ont un compte et
un prêt.
L’opération ET sur plusieurs relations
Perryridge P._x
Perryridge _x

consultation
74
Le langage QBE
Ex 6 : Trouver les clients qui ont un compte à Perryridge, à
Redwood ou aux deux.
L’opération OU sur une seule relation
Perryridge
Redwood
P._x
P._y

consultation
75
Le langage QBE
Ex 7 : Trouver les comptes qui ont un solde supérieur à
1200$.
L’opération plus grand que : >
P._x > 1200

consultation
76
Le langage QBE
Ex 8 :Trouver les clients qui ont un compte à Perryridge mais
pas de prêt.
L’opération de négation : ¬
Perryridge P._x
¬ Perryridge _x

consultation
77
Le langage QUEL
Caractéristiques:
Ølangage de consultation du système de base de
données Ingres (Interactive Graphics and Retreival
System).
Ømis au point à l'université de Berkeley en Californie dans
les années 70.
ØIl est distribué par RTI (Relational Technology, Inc)
depuis les annnées 80 et inclue un éventail de
fonctionnalité similaire à SQL.
ØLa structure de ce langage est très proche de celle du
calcul relationnel sur tuples.

consultation
78
Le langage QUEL
La structure de base d'une expression QUEL comporte trois
clauses:
Range of t1 is r1
Range of t2 is r2
Range of tm is rm
Retrieve ti1.aj1, ti2.aj2, tim.ajm
WHERE p
Où
Øt = variable de tuple,
Ør = relation,
Øa = attribut,
Øp = prédicat.

consultation
79
Le langage QUEL
Ex : Trouver l'ensemble des personnes qui ont un prêt de
Perryridge ainsi que leur ville de résidence :
Range of t is Crédit
Range of s is Clientèle
Retrieve ( t.client, s.localité )
WHERE ( t.agence = Perryridge ) and
( t.client = s.client )

Chapitre 04-B - Langages de consultation.pdf

Recommandé

Recommandé

Contenu connexe

Similaire à Chapitre 04-B - Langages de consultation.pdf

Similaire à Chapitre 04-B - Langages de consultation.pdf (20)

Plus de RihabBENLAMINE

Plus de RihabBENLAMINE (20)

Chapitre 04-B - Langages de consultation.pdf