Systèmes d’information &

Bases de données relationnelles

Langage SQL
Pr. EL MOTAKI Saloua

1
Introduction du cours

• Apprendre les bases du langage SQL et des bases de données relationnelles.

• Exécuter des requêtes SQL simples à l'aide des instructions SELECT, INSERT,
UPDATE et DELETE.
• Créerez des tables et les chargerez de données.
• Filtrer, trier et agréger les résultats, ainsi qu'à utiliser les fonctions de base
de données intégrées.
• Ecrire des requêtes imbriquées et à joindre des données dans plusieurs
tables.

2
Langage SQL
• Structured Query Language (SQL)
• Langage intuitif et complet de gestion de bases de données relationnelles
(définir, manipuler et récupérer des données).
• SQL est plus un langage de commande que de programmation
• Conçu par IBM dans les années 70.
• Il est devenu le langage standard des SGBDR: Mysql, Oracle, DB2, SQL
Server…
Web Services

Applications Web
S SGBD Base de
Q données
Applications lourdes
L

3
Commandes SQL
Requête Type langage Définition (commandes)
SELECT LRD Langage de récupération de récupérer des données contenues dans une
données ou plusieurs tables de
la base
INSERT, UPDATE, DELETE, MERGE LMD Langage de manipulation de modifier
données les données de la base.

CREATE, ALTER, DROP, RENAME, LDD langage de définition de modifier la

TRUNCATE données structure de la base.
COMMIT, ROLLBACK, SAVEPOINT Ordre de contrôle de transaction administrer
les changements effectués par les
commandes DML

GRANT, REVOKE LCD Langage de contrôle des contrôler les accès utilisateur à la base de
données données.

4
Tables de la DB support du cours

• EMP: tables contenant les employés

 EMPNO, ENAME, JOB, HIREDATE, #SAL, COMM, #DEPTNO
• DEPT : tables contenant les départements
 DEPTNO, DNAME, LOC
• SALGRADE : tables contenant les grades et les salaires
 GRADE, LOSAL, HISAL

5
Commandes SQL

• Indépendantes de la case (SELECT =Select = select)

• Peuvent être écrites sur plusieurs lignes
• Les mots-clés ne peuvent pas être coupés ou abrégés
• Les ordres et les clauses les composant sont regroupées sur des lignes
séparées dans un soucis de lisibilité
• Terminées par« ; »

6
Types de données dans SQL:2003
SQL consiste en une grande variété de types, avec une prise en charge de
plusieurs variantes orthographiques.
Types de données SQL

Types de données Types définis par

Types de données prédéfinis
composites l’utilisateur (UDT)

Numeric Interval String Boolean Datetime

Exact Approximate Bit Blob Character

Date Time Timestamp

NUMERIC FLOAT
DECIMAL Fixed Varying Fixe Variable Clob
REAL
SMALLINT DOUBLE Ajouté dans SQL:1999 / SQL:2003
INTEGER
Supprimé dans SQL:2003
BIGINT
7
LDD: CREATE, DROP, ALTER, RENAME, TRUNCATE

 Pour créer une table, l'utilisateur doit avoir les privilèges adéquats, ainsi que l’espace de
stockage nécessaire.
• Syntaxe générale : CREATE TABLE nom_de_la_table (colonne1 type_donnees (option),
colonne2 type_donnees (option) ,
colonne3 type_donnees (option),….);
• Options/contraintes:
• NOT NULL : empêche d’enregistrer une valeur nulle pour une colonne.
• DEFAULT : attribuer une valeur par défaut si aucune données n’est indiquée pour cette colonne lors de
l’ajout d’une ligne dans la table.
• UNSIGNED: empêche d’enregistrer une valeur négative.
• …..

8
LDD: CREATE, DROP, ALTER, RENAME, TRUNCATE

 Exemple : Créer la table DEPT

CREATE TABLE dept

( deptno INT NOT NULL,
dname VARCHAR (14) ,
loc VARCHAR(13)) ;

SQL> describe dept ;

Name Null? Type

------- ----------- --------
DEPTNO NOT NULL NUMBER (2)
DNAME VARCHAR2 (14)
LOC VARCHAR2 (13 )

9
LDD: CREATE, ALTER, DROP, RENAME, TRUNCATE

 Pour modifier une table, on utilise la requête ALTER:

• Syntaxe générale : ALTER TABLE nom_table
instructions
• Instructions:
 Ajouter une colonne: ADD nom_colonne type_donnees
 Supprimer une colonne: DROP nom_colonne
 Modifier le type d’une colonne: MODIFY nom_colonne type_donnees
 Modifier le nom d’une colonne: CHANGE ancien_nom nouveau_nom type_donnees
 Pour supprimer une table: DROP TABLE nom_table

10
LDD: CREATE, ALTER, DROP, RENAME, TRUNCATE

 RENAME permet de changer le nom d'une table et d'autres objets ORACLE (vue,
synonymes, sequences, ...)
 Seul le propriétaire de l'objet peut faire cette opération
 Exemple : RENAME dept TO department;
Table renamed.

 TRUNCATE permet de vider une table sans la détruire.

 Plus rapide qu'un DELETE FROM table.
 Libère l'espace de stockage.
 Exemple :
TRUNCATE TABLE dept;
Table truncated.

11
LDD: Contraintes

• Les contraintes sont des règles définies dans la DB au niveau d'une table ou d'une ou
plusieurs colonnes de cette table.
• Les contraintes régissent les valeurs que peuvent prendre certaines colonnes ou les
relations entre tables.
• Différents types: • Syntaxe :
 NOT NULL CREATE TABLE table
( coll DATATYPE [DEFAULT exprl [COLUMN_CONSTRAINT] ,
 UNIQUE KEY
...
 PRIMARY KEY colN DATATYPE [DEFAULT expr] [COLUMN_CONSTRAINT}
 FOREIGN KEY [TABLE CONSTRAINT]) ;

 CHECK
 TYPE CONSTRAINT

12
LDD: Contraintes

NOT NULL UNIQUE KEY

 Cette contrainte interdit  Cette contrainte interdit deux valeurs
d'insérer des valeurs identiques dans la même colonne OU
NULL dans une colonne plusieurs mêmes combinaisons de
 Exemple : valeurs dans plusieurs colonnes
 Exemple :
SQL> CREATE TABLE emp SQL> CREATE TABLE dept
2 ( empno INTEGER , 2 (deptno INTEGER,
3 ename VARCHAR (10) NOT NULL, 3 dname VARCHAR (14),
4 job VARCHAR (9) , 4 loc VARCHAR(13),
5 Comm INTEGER, 5 CONSTRAINT dept_dname_UK UNIQUE (dname) ) ;
6 deptno INTEGER NOT NULL);

13
LDD: Contraintes
La clé primaire (PRIMAR KEY) peut être créée :
• En même temps que la table:
 CREATE TABLE Nom_table ( colonne1 type_colonne1 PRIMARY KEY ,
colonne2 type_colonne2,
colonne3 type_colonne3,...,);
 CREATE TABLE Nom_table ( colonne1 type_colonne1 ,
colonne2 type_colonne2,
colonne3 type_colonne3,.
CONSTRAINT [symbole_contrainte]] PRIMARY KEY (colonne_id))
• Après la création de la table:
 ALTER TABLE nom_table
ADD [CONSTRAINT [symbole_contrainte]] PRIMARY KEY (colonne_id);
• Pour supprimer la clé primaire :
 ALTER TABLE nom_table
DROP PRIMARY KEY [CASCADE]

14
LDD: Contraintes
La clé étrangère (FOREING KEY) peut être créée :
• Lors de la création de la table:
 CREATE TABLE Nom_table ( colonne1 type_colonne1,
colonne2 type_colonne2 FOREIGN KEY REFERENCES Table_ref(colonne_ref),
colonne3 type_colonne3,...,);
 CREATE TABLE Nom_table ( colonne1 type_colonne1 ,
colonne2 type_colonne2,…,
CONSTRAINT [symbole_contrainte] FOREIGN KEY
(liste_colonnes)) REFERENCES Table_ref(colonne_ref1, colonne_ref2,…);
• Après la création de la table:
 ALTER TABLE nom_table
ADD CONSTRAINT [symbole_contrainte] FOREIGN KEY (liste_colonnes) REFERENCES Table_ref(colonne_ref1,
colonne_ref2,…);
• Pour supprimer la clé étrangère :
 ALTER TABLE nom_table
DROP FOREIGN KEY symbole_contrainte;
15
LDD: Contraintes

 CHECK : Ce type de contrainte permet de définir une condition que doit respecter un
enregistrement ou la valeur d'une colonne.
 Exemple :
SQL> CREATE TABLE emp
2 ( empno INTEGER ,
3 ename VARCHAR(10) NOT NULL,
4 job VARCHAR(9) ,
5 Comm INTEGER
6 deptno INTEGER NOT NULL,
7 CONSTRAINT emp_deptno_ck CHECK (deptno BETWEEN 10AND 99));

16
LDD: Contraintes

Désactiver une contrainte Réactiver une contrainte

 Désactiver une contrainte ne supprime pas sa  Utiliser la commande ALTER TABLE + ENABLE
définition; seule sa vérification par le SGBD
est suspendue. Elle peut être réactivée à SQL>ALTERTABLE dept
volonté. 2 ENABLE CONSTRAINT emp_empno_PK;
 Utiliser la commande ALTER TABLE + DISABLE
 Utiliser la clause CASCADE pour désactiver les
contraintes associées
SQL> ALTER TABLE dept
2 DISABLE CONSTRAINT emp_empno_PK
CASCADE;

17
LDD: Contraintes

Exercice
1) Créer la table Etudiant avec les attributs: CodeEtud int primary key, nom varchar()
prénom varchar(), dn date, email varchar(), note int.
2) Modifier le nom de l'attribut 'dn' en `datenaiss’
3) Modifier le type de l'attribut 'note' de int à Decimal.
4) Permettre une auto incrémentation automatique de la valeur de l'attribut CodeEtud
5) Ajouter une contrainte qui empêche la saisie d'une note hors de l'intervalle [0,20]
6) Créer la table Filière avec les attributs: CodeFil et NomFil (Deviner les types de
données et les contraintes.
7) Modifier la table Etudiant pour créer une liaison avec la table Filière .

18
LMD: INSERT, UPDATE, DELETE

Pour insérer des données dans une table, il y a 2 syntaxes principales :

• Insérer une ligne en spécifiant toutes les colonnes:
 INSERT INTO nom_table  Remarque : Insertion des NULL:
VALUES ('valeur 1', 'valeur 2', ...);
 implicitement, sans préciser la colonne
• Insérer une ligne en spécifiant certaines colonnes:
 INSERT INTO nom_table
et la valeur associée
(nom_colonne_1, nom_colonne_2, ...)
SQL> INSERT INTO dept (deptno, dname) 2
VALUES ('valeur 1', 'valeur 2', ...); VALUES (70, 'FINANCE');
• Exemple :
SQL> INSERT INTO dept (deptno,dname,loc)  explicitement, en précisant le mot-clé NULL
2 VALUES (50,'DEVELOPMENT','DETROIT'); SQL> INSERT INTO dept (deptno,dname,loc)
2 VALUES (70,'FINANCE',NULL);

19
LMD: INSERT, UPDATE, DELETE
• Pour modifier les lignes dans une table, on utilise la requête suivante :
 UPDATE nom_table
SET colonne_1 = 'valeur 1’,
colonne_2 = 'valeur 2’,
colonne_3 = 'valeur 3’
 Remarque : La mise à jour de données, peut
WHERE condition
être apportée sur une ou plusieurs colonnes,
• Pour supprimer les lignes dans une table: dans un ou plusieurs enregistrements.
 DELETE FROM nom_table
WHERE condition
 Une seule ligne
SQL> UPDATE emp SET deptno = 20
2 WHERE empno = 7782;

 Plusieurs lignes
SQL> UPDATE emp SET deptno = 20;

20
WHERE (selection)

Exercice
1-Créer la table suivante.
2-Insérer les données.
3-Modifier la note de TAKI à 16,5.
4-Ajouter 2 points aux étudiants de GI.
5-Donner la note 10 aux étudiants ayant une note
entre 8 et 10.
6-Modifier la date de naissance de l'étudiant 7
à `2002-04-16' et sa filière à GI.
7-Supprimer les étudiants échoués

21
Commande SELECT

L’ordre SELECT possède trois capacités :

• Sélection : Sélection d’une ou plusieurs
ligne(s)
• Projection : Sélection d’une ou plusieurs
colonne(s).
• Jointure : Sélection de deux colonnes
dans deux tables différentes, créant
ainsi une relation entre les données des
deux colonnes.

22
Commande SELECT
Modèle de requête de base
• Sélectionner à partir de l'endroit
• Groupement et agrégation
• Dispositions et ordonnancement
• Élimination des doublons
Exemple:
• SELECT Fname, Affil, Location
FROM Participant AS R,
Locale AS S
WHERE R.LID=S.LID;
Participant
SELECT [DISTINCT] <column_list>
FROM [<table_list> |
<table1> [RIGHT | LEFT | FULL] JOIN
<table2> ON <condition>]
[WHERE <predicate>]
[GROUP BY <column_list>]
[HAVING <grouping predicate>]
[ORDER BY <column_list> [ASC | DESC]]
πFname,Affil,Location
σP.LID=L.LID
Location
23
Commande SELECT
• La commande SELECT sert à extraire les données de la base de données.
• Syntaxe: SELECT Attribut_1 AS alias_1, …, Atrribut_n AS Alias_n FROM table;
• Remarques:
 On peut mettre une étoile * pour demander tous les attributs.
 Attribuer des entêtes aux colonnes.
Exemple: Sélectionner toutes les colonnes et toutes les lignes d'une table:
SQL> SELECT *
2 FROM dept;
DEPTNO DNAME LOC

10 ACCOUNTING NEW YORK

20 RESEARCH DALLAS
30 SALES CHICAGO
40 OPERATIONS BOSTON

24
Commande SELECT
• La commande SELECT sert à extraire les données de la base de données.
• Syntaxe: SELECT Attribut_1 AS alias_1, …, Atrribut_n AS Alias_n FROM table;
• Remarques:
 On peut mettre une étoile * pour demander tous les attributs.
 Attribuer des entêtes aux colonnes.
Exemple: Sélectionner quelques colonnes et toutes les lignes d'une table:
SQL> SELECT deptno, loc FROM dept;
DEPTNO LOC

10 NEW YORK
20 DALLAS
30 CHICAGO
40 BOSTON

25
Expressions arithmétiques
• Les données extraites de la DB peuvent être des données calculées partir des
informations stockées;
• Uniquement pour des données de type « NOMBRE » ou « DATE»
• pour effectuer les opérations sur les date et les nombre, on utilise :
Opérateur signification
= Egal à
< Inférieur à
<= Inférieur ou égal à
> Supérieur à
>= Supérieur ou égal à
<> Différent de

26
Expressions arithmétiques
 Exemple 1  Exemple 2
!SQL> SELECT ename,sal,sal+300 SQL> SELECT ename,sal,12*(sal+300)
2 FROM emp; 2 FROM emp;

ENAME SAL SAL+300

ENAME SAL 12*(SAL+300)
SMITH 800 1100
ALLEN 1600 1900 SMITH 800 13200
WARD 1250 1550 ALLEN 1600 22800
JONES 2975 3275 WARD 1250 18600
MARTIN 1250 1550 JONES 2975 39300
... MARTIN 1250 18600
14 rows selected …
14 rows selected.

27
Valeur NULL
• En plus de I' intervalle naturel de valeurs propre un type de donnée, tout champ
d'une table peut stocker une valeur particulière précisant I' absence d'information:
NULL
• NULL ne vaut PAS ZERO pour un nombre.
• NULL n'est PAS une chaine de caractères VIDE ou ne contenant que des espaces.
• Dans une expression arithmétique, toute valeur NULL joue Ie rôle d'absorbant; Ie
résultat retourné vaut NULL

 Exemple 1 SELECT ename, JOB,

2 comm, 2*SAL+comm ENAME JOB COMM 2*SAL+COMM
3 FROM emp;
SMITH CLERK NULL NULL
ALLEN SALESMAN 300 1400
…

28
ALIAS

• Dans un SELECT, permet de donner un autre nom une colonne ou à une

expression.
• Surtout utile pour une expression.
• alias =chaine de caractères, entre guillemets si contient des espaces ou
caractères spéciaux ou si la case est importante.
• Exemple:
• SELECT ename AS nom FROM emp;
• SELECT ename, sal AS ’’Salaire annuel’’ FROM emp;
• SELECT ename, (sal+comm) ‘’Salaire & Commission’’ ...
• Le mot-clé « AS » est facultatif.

29
CONCATENATION

• L'operateur « II » permet de construire de nouvelles chaines de caractères par

la juxtaposition d'autres.

 Exemple
SQL> SELECT ename || ’-’ || job AS "Employés"
2 FROM emp;

Employés
------------------
SMITH-CLERK
ALLEN-SALESMAN
WARD-SALESMAN
…

30
Eliminer les doublons
• L'operateur «DISTINCT» permet de ne retenir que les valeurs strictement
différentes les une des autres.

 Exemple
DEPTNO
-------
SQL> SELECT DISTINCT deptno SQL> SELECT deptno 20
2 FROM emp; 2 FROM emp; 30
30
DEPTNO 20
------ 30
10 30
20 10
30 20
10

31
WHERE (selection)
• La clause WHERE correspond à une sélection en algèbre relationnelle.
• Elle restreint la requête aux enregistrements qui respectent les conditions.
• Syntaxe: SELECT liste_attributs FROM table WHERE condition(s);
• Une condition est une expression composée d’opérateurs (arithmétiques, logiques…) et d’opérandes
(constantes ou attributs).
 Exemple : Extraire tous les employés travaillant dans le département 10 en utilisant la clause WHERE:
SQL> SELECT ename, job, deptno 2
FROM emp
3 WHERE deptno=10;
ENAME KING JOB DEPTNO
CLARK MILLER PRESIDENT 10
3 rows selected. MANAGER 10
CLERK 10

32
WHERE (selection)
• En plus des opérateurs arithmétiques (slide 12), La clause WHERE utilise d’autres opérateurs pour
définir les prédicats de sélection.
• Opérateur BETWEEN
 Permet d'extraire les enregistrements dont les valeurs d'une colonne se trouvent dans un intervalle
 Syntaxe: WHERE nom_colonne BETWEEN limite_inf AND limite_sup;
 Les limites peuvent être des nombres, des caractères, des dates. (limites incluses)
 N.B: les limites doivent être placées entre simples côtes (caractères ou dates).
ENAME SAL
----------------------------
 Exemple : Quels sont MARTIN 1250
SQL> SELECT ename, saI 2 FROM emp
les employés touchant un 3 WHERE sal BETWEEN 1000 AND 1500;
WARD 1250
salaire compris dans une TURNER 1500
fourchette de 1000 à ADAMS 1100
1500 ? MILLER 1300

5 rows selected
33
WHERE (selection)
• En plus des opérateurs arithmétiques (slide 12), La clause WHERE utilise d’autres opérateurs pour
définir les prédicats de sélection.
• Opérateur IN
 Permet d'afficher des enregistrements appartenant à une liste de valeurs.
 Syntaxe: WHERE nom_colonne IN (valeur_1, valeur_2,..,valeur_n);
 Les valeurs de la liste peuvent être des nombres, des caractères, des dates.
 Les caractères ou dates doivent être placées entre simples côtes.
ENAME MGR
 Exemple : Quels sont les ----------------------------
employés travaillant pour SQL> SELECT ename, mgr TURNER 7788
les manager 7902, 7566 2 FROM emp ADAMS 7566
et 7788 ? 3 WHERE mgr IN (7902, 7566, 7788); MILLER 7566

3 rows selected

34
WHERE (selection)
• En plus des opérateurs arithmétiques (slide 12), La clause WHERE utilise d’autres opérateurs pour
définir les prédicats de sélection.
• Opérateur LIKE
 Permet d'extraire les enregistrements dont les valeurs d'une colonne de type chaîne de caractères
correspondent à un masque de recherche;
 Syntaxe: WHERE nom_colonne LIKE ’expression’;
 Le masque utilise les caractères génériques par défaut suivant:
 % correspond à 0 ou plusieurs caractères.
 _ correspond à un seul caractères.
Exemple 1 : Quels sont les employés dont le nom commence par' S ' ?
SQL> SELECT ename Exemple 2 : Quels sont les employés engagés en 1981?
2 FROM emp
SQL> SELECT ename, hiredate 2 FROM
3 WHERE ename LIKE ‘S%’ ;
emp
3 WHERE hiredate LIKE '%81';

35
WHERE (selection)
• En plus des opérateurs arithmétiques (slide 12), La clause WHERE utilise d’autres opérateurs pour
définir les prédicats de sélection.
• Opérateur IS NULL
 Permet d'afficher les enregistrements dont le champ en terme contient une valeur nulle.
 Syntaxe: WHERE nom_colonne IS NULL;
 Pour rappel, « colonne = NULL » n'est JAMAIS vrai.

Exemple : Quels sont les employés dont la date d’embauche est nulle?
SQL> SELECT ename
2 FROM emp
3 WHERE HIREDAT IS NULL;

36
WHERE (selection)
• Une clause WHERE peut être construite en combinant plusieurs conditions à l'aide d'opérateurs
logiques
• Opérateur Logique
 AND : retourne « true» si les toutes conditions sont « true»
 OR : retourne « true» si une des conditions vaut « true»
 NOT : retourne l'inverse logique

Exemple 1 : Quels sont les
employés exerçant le job' CLERK '
ET gagnant plus de 1000 ?
SQL> SELECT empno, ename, 2
job, saI FROM emp
3 WHERE saI>1000 AND job =
4 'CLERK';
Exemple 2 : Quels sont les
employés exerçant le job'
CLERK' OU dont le salaire
est supérieur à 1000 ?
SQL> SELECT empno,
2ename, job, saI
3 FROM emp
4 WHERE job = 'CLERK' OR saI>
5 1000;
Exemple 3 : Quels sont les employés
n'exerçant ni le job , CLERK ' ni le job'
MANAGER' ?
SQL> SELECT empno, ename, job, saI
2 FROM emp
3 WHERE job NOT IN (‘CLERK’,
4 ‘MANAGER’);

37
WHERE (selection)
• En plus des opérateurs arithmétiques (slide 12), La clause WHERE utilise d’autres opérateurs pour
définir les prédicats de sélection.
• Règles de priorité des opérateurs
Ordre d’évaluation Opérateur
1 Opérateurs arithmétiques
2 Opérateurs de concaténations
3 Les conditions de comparaison
4 IS [NOT] NULL, LIKE, [NOT] IN
5 [NOT] BETWEEN
6 Condition logique NOT
Remarque : il est preferable
d’utiliser les parenthèses afin
7 Condition logique AND
de forcer l'ordre de priorité et
8 Condition logique OR
de rendre le code plus lisible.

38
WHERE (selection)
Exercice
1-Sélectionner les Masculins.
2-Sélectionner les Féminins de la filière GI.
3-Sélectionner les étudiants dont la note est comprise
entre 10 et 14 de la filière GE.
4-Sélectionner les féminins réussies de GE.
5-Sélectionner les GM nés en 2002-06-30.
6-Sélectionner les étudiants dont le nom commence par A.
7-Sélectionner le nom, le prénom et la notes des étudiants de
la filière GM.
8-Sélctionner les étudiants dont le nom se termine par I.
9-Sélectionner les féminin dont la note n'est pas
comprise entre 10 et 14.

39
Ordre SELECT
• Ordonner la clause SELECT
• Afficher des enregistrements sélectionnés dans l’ordre croissant ou décroissant.
• L’ordre par défaut est croissant.
• Syntaxe: SELECT * FROM table WHERE condition(s) ORDER BY {colonne | expression} [ASC | DESC]

 Exemple !SQL> SELECT ename,sal, ENAME SAL

2 FROM emp;
3 ORDER BY SAL ASC SMITH 800
WARD 1250
MARTIN 1550
ALLEN 1600
JONES 2975
...
14 rows selected

40
Ordre SELECT
• Il est possible de trier suivant une colonne qui n’a pas été sélectionnée dans la clause SELECT.
Syntaxe: SELECT colonne1, colonne2 FROM table WHERE Condition(s) ORDER BY colonne3;
• Il est possible de trier suivant plusieurs colonnes.
Syntaxe: SELECT col1, col2, col3 FROM table WHERE condition(s) ORDER BY col1[ASC |DESC],
col3[ASC | DESC]
 Exemple 1 ENAME
 Exemple 2

!SQL> SELECT ename !SQL> SELECT ename SAL ENAME SAL

SMITH 2 FROM emp;
2 FROM emp;
3 ORDER BY SAL ASC; WARD 3 ORDER BY SAL ASC, SMITH 800
MARTIN 4 ename ASC ; MARTIN 1250
ALLEN
WARD 1550
JONES
ALLEN 1600
... JONES 2975
14 rows selected

41
Regroupement et agrégation (GROUP BY …)
• Les options regroupement et agrégation peuvent être appliquées aux colonnes de résultats de
requête pour organiser les données de résultats en regroupements logiques ou résumés.
• En ajoutant le regroupement et l'agrégation, on peut automatiquement obtenir des informations
récapitulatives sur vos données et afficher vos données de manière plus logique.
• les fonctions de groupe calculent un résultat à partir de plusieurs enregistrements. On distingue les
fonctions d’agrégation suivantes:
 AVG : retourne la moyenne
 COUNT : retourne le nombre d'enregistrements
 MAX : retourne la valeur maximum
 MIN : retourne la valeur minimum
 STDDEV : retourne l'écart-type
 SUM : retourne la somme retourne la variance
 VARIANCE : retourne la variance
42
Regroupement et agrégation (GROUP BY …)
 Les fonctions AVG, SOM, MIN,MAX ignorent les valeurs NULL.

SQL> SELECTAVG(sal),MAX(sal),MIN(sal),SUM(sal) AVG(SAL) MAX (SAL) MIN (SAL) SUM(SAL)

2 FROM emp ----------------------------------------------------------------
3 WHERE job LlKE‘SALE%‘; 1400 1600 1250 5600

 Nombre total des enregistrements dans une table

COUNT(*)
--------------
1245

 le nombre d'employés du département 30

COUNT(*)
--------------
6

43
Regroupement et agrégation (GROUP BY …)

 Permet de regrouper certains enregistrements en fonction de valeurs (colonnes, expressions)

 Les fonctions de groupes produisent alors autant de résultats qu'il n'y a de groupes

 Regrouper sur plusieurs colonnes

 Exemple :

44
Regroupement et agrégation (GROUP BY …)

 Il est important de séparer les fonctions d'agrégation des éléments non agrégés tels que les
colonnes, les fonctions de ligne unique et les expressions.
 Requêtes invalides :

SQL> SELECT deptno,COUNT(ename)

2 FROM emp ; SQL> SELECT deptno,COUNT(ename)
2 FROM emp
3 GROUP BY deptno;

SQL> SELECT deptno, AVG (saI)

2 FROM emp
3 WHERE AVG(saI) > 2000
4 GROUP BY deptno;
SQ L> SELECT deptno, AVG (saI)
2 FROM emp
3 GROUP BY deptno;
4 HAVING AVG(saI) > 2000;

45
Sélection de données-Requêtes imbriquées
 Une requête imbriquée utilise le résultat d'une autre requête.
 La requête à l’intérieure (ou sous-requête) retourne une ou des valeurs qui sont utilisées par la requête
extérieure (ou requête principale).

 Syntaxe: Requête principale:

SELECT list_colonne
FROM table Quels sont les employés ayant un salaire
supérieur à celui de ‘Mohammed’?
WHERE expression opérateur (SELECT
liste_colonne FROM table ) ;
Sous-requête:

Quel est le salaire de Mohammed?

46
Types de sous-requêtes
Il existe deux types de sous requêtes:
 Single_row: Retourne une valeur contenue dans une colonne
Requête principale
retourne Ex: ingénieur
Sous_requête valeur

 Multiple_row: Retourne plusieurs valeurs contenues dans une colonne

Requête principale
retourne Ex: -ingénieur
Sous-requête valeurs
-technicien

47
Types de sous-requêtes
Single_row: Utilise les opérateurs de comparaison de single-row (=>, >=, <, <=, <>).

Requête principale
retourne
Sous_requête valeur

 Exemple : Pour trouver les employés ayant un salaire supérieur à la moyenne des salaires, on peut utiliser la
requête suivante.
!SQL> SELECT ename ENAME SAL
2 FROM emp; ALLEN 1600
3 WHERE SAL > (SELECT avg(SAL) JONES 2975
4 FROM emp); ...
7 rows selected

48
Types de sous-requêtes
Remarque:
• Plusieurs sous-requêtes peuvent être mises en place dans une requête.

Syntaxe :
SELECT liste_colonne
FROM table
WHERE expression single-row_operateur_comparison (SELECT select_list FROM table )
AND expression multiple-row_operateur_comparison ( SELECT select_list FROM table ) ;

49
Types de sous-requêtes
Multiple_row:
• Retourne une liste de valeurs qui seront comparés à une seule valeur dans la requête principale.
• Utilise les opérateurs de comparaison de lignes multiples (NOT IN, ANY, ALL, BETWEEN).
• Des fonctions de groupes ainsi que la clause HAVING peuvent être utilisées dans une sous-requête.

 Exemple : Pour trouver les employés dont le salaire est égale au salaire minimal d’un département à partir
de la table ‘employé’, on peut utiliser la requête suivante.
!SQL> SELECT ename, empno
FROM emp
WHERE sal IN ( SELECT MIN(sal) FROM emp
GROUP BY deptno);

50
Types de sous-requêtes

Exercices
1.Ecrire la requête qui affiche les employés dont la fonction et la même que celle de l’employé numéro 1230.
2.Ecrire la requête qui affiche les employés dont la fonction est la même que celle de l’employé numéro 1230
et dont le salaire correspond au salaire minimal.
3.Ecrire la requête qui affiche les employés « non ingénieur » et dont le salaire est plus petit que celui de tout
ingénieur à partir de la table ‘employé’.
4.Ecrire la requête qui affiche les employés « non ingénieur » et dont le salaire est plus petit que celui d’un
ingénieur quelconque à partir de la table ‘employé’.

51
Requêtes sur des tables multiples : Jointures
• Une jointure permet d'extraire des données se trouvant dans deux ou plusieurs tables
différentes.
• Il s'agit de la combinaison inconditionnelle des enregistrements de deux ou plusieurs tables.

SQL> SELECT emp.empno,emp.ename,dept.loc

2 FROM emp,dept
3 WHERE emp.deptno=dept.deptno;
Requêtes sur des tables multiples : Equi-Jointure
• Equi-jointure : Il s'agit d'une condition d'égalité entre colonnes de tables jointes permettant de
réaliser une relation temporaire entre deux tables
• Souvent, relation entre une clé primaire et une clé étrangère.

 Mécanisme:

SQL> SELECT emp.empno,emp.ename,

2 dept.loc X
3 FROM emp,dept
4 WHERE emp.deptno=dept.deptno;
Produit cartésien
Résultat
Requêtes sur des tables multiples : Equi-Jointure

• Lorsque de tables jointes possèdent des colonnes de même nom, il faut absolument préfixer le
nom des colonnes par le nom de la table (dot notation).
• Ne pas préfixer par le nom de la table peut induire l'interpréteur SQL en erreur; cela diminue de
plus les performances
• On peut également utiliser des alias pour distinguer deux colonnes portant le même nom ou
pour écrire des ordres SQL trop long

SQL> SELECT a.empno,a.ename,b.loc

2 FROM emp a,dept b
3 WHERE a .deptno=b.deptno;
Requêtes sur des tables multiples : Non Equi-Jointure
• On peut réaliser des conditions de jointure basées sur d'autres opérateurs de comparaison.

SQL> SELECT e.empno,e.ename, s.grade ,salgrade

2 FROM emp e,saIgrade s
3 WHERE e.sal BETWEEN s.losal AND s.HISAL;
Requêtes sur des tables multiples : self-Jointure
• On parle d’une self-joiture lorsque qu’on a une jointure d'une table avec elle-même, autrement
dit, lorsqu'il existe une relation récursive.

• Exemple: afficher le manager des employés.

SQL> SELECT w.ename "Employé",m.ename "Manager"
2 FROM emp w,emp m
3 WHERE w.mgr = m.empno;

56