LANGAGE SQL

1. Introduction
SQL qui est l'abréviation de Structured Query Language est un langage d'interrogation structuré de
bases de données relationnelles proche de l'utilisateur et de sa façon de poser les requêtes :

- C'est un langage qui utilise des mots anglais et une formulation proche de la langue
naturelle.

- Les requêtes sont du type :

"Je veux telles choses
à prendre de telles sources
ayant telles caractéristiques
et ordonnées de telles manières"
- SQL, de part son aspect structuré, est facile à apprendre pour rédiger des requêtes, les lire et
les comprendre. Il est fait pour être utilisé par :
o Les non informaticiens pour interroger la base de données sans être tributaire
(asservir) d'un spécialiste;
o L'informaticien pour le développement de ses applications en lui assurant une
meilleure productivité;
o Le responsable de la base pour s'acquitter de ses tâches de gestion.
- SQL est associé aux bases de données qui relèvent du modèle relationnel et par conséquent
tout est basé sur l'emploi d'informations présentées sous forme de tables qui est une vision
très proche de l'utilisateur.

- SQL se veut assertionnel, donc non procédural. En effet, l'utilisateur spécifie ce qu'il veut
obtenir sans dire comment le faire.

- SQL contient l'aspect:

 Langage de Manipulation de Données (LMD)
SELECT, UPDATE, INSERT, DELETE,
 Langage de Définition de Données (LDD)
CREATE, DROP,
 Langage pour gérer la sécurité
GRANT, REVOKE,
- SQL peut être utilisé en interactif ou comme ordres incorporés dans un langage hôte (COBOL,
FORTRAN, C, PASCAL, ASSEMBLEUR)

Pr. H. BENNIS -1- Langage SQL

2. LMD de SQL : sélection des tuples
La requête de sélection du langage SQL permet d'interroger la base de données en composant les
projections, les restrictions, les jointures...
Le résultat d'une sélection est représenté sous la forme d'une table d'une ou plusieurs colonnes. La
syntaxe générale est :
SELECT <clause d'unicité>
<liste de colonnes>
FROM <liste de tables>
WHERE <critère de sélection>
GROUP BY <liste de colonnes>
HAVING <critère de sélection>
ORDER BY <critère d'ordre>
INTO [TEMP] <nom_de_table>
Dans la suite du cours nous utiliserons la base de données relationnelle ayant pour schéma :
Livre = (noliv, titre, auteur, genre, prix)
Personne = (nopers, nom, prenom)
Emprunt = (nopers, noliv, sortie, retour)

Chaque requête de sélection contient au minimum la forme :

SELECT <liste de colonnes>
FROM <liste de tables>
L'ordre d'apparition des mots clés (c'est à dire SELECT, FROM, WHERE,...) dans la requête, doit
être identique à celui défini dans la syntaxe.
La <clause d'unicité> est définie au moyen des mots réservés "ALL" et "DISTINCT". L'option
"ALL" a pour effet de ne pas rejeter du résultat les tuples en double. Lorsque "DISTINCT" est
spécifié, un seul exemplaire des tuples en double est retenu dans le résultat de la requête. Dans le
cas où elle n'est pas spécifiée, l'option "ALL" est prise par défaut.
La <liste de colonnes> composée d'une étoile "*" indique que toutes les colonnes sont retenues.
Dans le cas où les noms de colonnes sont donnés explicitement, il faut les séparer par des virgules.
Le nom de chaque colonne est soit :
- le nom d'une colonne d'une relation ou d'une vue (par exemple: "titre");
- le nom d'une colonne préfixé du nom de la relation (ou de la vue dans laquelle elle se trouve
(par exemple: "Personne.nom");
- le nom d'une colonne préfixé d'un alias d'un nom de relation (ou de vue) donné dans la <liste
de tables>;
- une valeur calculée (par exemple: MIN).

Pr. H. BENNIS -2- Langage SQL

Remarque:
Préfixer un nom de colonne est obligatoire lorsque plusieurs relations (ou vues) ont des noms de
colonnes identiques. Cela permet d'éviter une ambiguïté de nomage.
La <liste des tables> est composée de noms de relations (ou vues) séparées par des virgules.
Chaque nom peut être associé à un synonyme; Par exemple: "Personne p, Livre" indique deux noms
de relations: "Personne" ayant pour alias "p" et "Livre".
Le <critère de sélection> est une expression booléenne vraie ou fausse. L'évaluation de ce critère
conditionne le choix ou le rejet du tuple sur lequel il s'applique.
Le <critère d'ordre> est constitué:
- d'une liste de noms de colonnes séparées par des virgules (c'est à dire <liste de colonnes»);
- d'une liste de numéros séparés par une virgule. Chaque numéro correspond au rang d'une
colonne dans la liste de colonne de la clause" SELECT".

2.1 Les projections

Faire une projection consiste à définir un sous ensemble des colonnes de la liste de tables.
Projection : T = <A, B, C> (R) Ou T = PROJECT (R / A, B, C)
T ne contient que les attributs A, B et C de R.
Exemples:
a) La requête ci-dessous sélectionne la relation "Livre" tout entière:
SELECT *
FROM livre
Les requêtes suivantes lui sont équivalentes :
SELECT noliv, titre, auteur, genre, prix
FROM livre
SELECT livre.noliv, livre.titre, livre.auteur, livre.genre, livre.prix
FROM livre
SELECT l.noliv, l.titre, l.auteur, l.genre, l.prix
FROM livre 1
b) projection sur "auteur" : PROJ (livre/auteur)
SELECT auteur
FROM livre
Pour éliminer les tuples en double on utilise la clause d'unicité "DISTINCT" :
SELECT DISTINCT auteur
FROM livre

Pr. H. BENNIS -3- Langage SQL

 2.2 Les restrictions
Une restriction correspond à un choix des tuples à sélectionner. Le résultat peut comporter zéro, un
ou plusieurs tuples. Chacun des tuples sélectionné vérifie le critère de sélection.
Restriction : T = RESTRICT (R / C)
T ne contient que les attributs de R qui satisfont la condition C.
Exemples :
a) select (livre/auteur = "ZOLA")
SELECT *
FROM livre
WHERE auteur = 'ZOLA';
b) select (livre/prix> 100)
SELECT *
FROM livre
WHERE prix > l00;
Le critère de sélection prend une des formes suivantes:
Exp opérateur de comparaison exp
exp [NOT] BETWEEN exp AND exp1
exp [NOT] IN (liste de valeurs)
Nom_de_colonne [NOT] LIKE "chaîne"
Nom_de_colonne IS [NOT] NULL "chaîne"
Où
- exp désigne une expression qui est un nom de colonne, une constante ou une combinaison des
deux reliés par des opérateurs arithmétiques (+, -, *, /).
- opérateur de comparaison peut être: =, <>, <, >, <=, >=.
- Les conditions peuvent être reliées par AND, OR, NOT et des parenthèses.
Exemples:
a) SELECT titre, auteur
FROM livre
WHERE prix - 100 >= 0;
b) SELECT titre, auteur, prix * (1-5/100)
FROM livre
WHERE prix >= 100;
c) SELECT *
FROM livre
WHERE prix >= 100 AND auteur = 'ZOLA';

Pr. H. BENNIS -4- Langage SQL

d) SELECT *
FROM livre
WHERE auteur = 'ZOLA' OR auteur = 'BALZAC';
e) SELECT *
FROM livre
WHERE NOT (auteur = 'ZOLA' OR auteur = 'BALZAC');
f) SELECT *
FROM livre
WHERE prix BETWEEN 80 AND 100;
g) SELECT *
FROM livre
WHERE prix IN (80, 90, 100);
h) SELECT *
FROM Emprunt
WHERE retour IS NULL;
i) SELECT *
FROM livre
WHERE titre LIKE "LES LET %"; {i,e: "'%" = une chaîne,"-" = une lettre}

2.3 Les restrictions ordonnées

La clause "ORDER BY" permet de trier les tuples d'une requête selon un ou plusieurs critères.
Exemples :
a) SELECT *
FROM livre
ORDER BY auteur, titre ;
b) SELECT noliv, titre, auteur, genre, prix
FROM livre
ORDER BY 3,2;
Les mots clés ASC (ordre croissant ; par défaut) et DESC (ordre décroissant) peuvent être placés
après les critères d'ordre.
c) SELECT *
FROM livre
ORDER BY auteur DESC, titre ;

Pr. H. BENNIS -5- Langage SQL

 2.4 Les fonctions
2.4.1 Fonction COUNT
Elle donne le nombre de tuples répondant à un certain critère.
Exemples:
a) SELECT COUNT (*)
FROM livre
b) SELECT COUNT (DISTINCT auteur)
FROM livre
c) SELECT COUNT (DISTINCT auteur)
FROM livre
WHERE genre = 'ROMAN'
2.4.2. Fonction SUM
Elle donne la somme des valeurs d'une colonne numérique.
Exemples :
a) SELECT SUM (prix)
FROM livre
c) SELECT SUM (prix)
FROM livre
WHERE genre = 'ROMAN'

2.5 Groupement des données

La clause "GROUP BY" permet de partitionner une relation. Chaque partition possède une même
valeur pour les attributs spécifiés après le terme "GROUP BY".
Elle est généralement utilisée conjointement avec les fonctions de calcul (COUNT, MIN, ...).
Exemples:
a) Calculer le nombre de livres répertoriés pour chaque auteur.
SELECT auteur, COUNT (*)
FROM livre
GROUP BY auteur
b) Donner pour chaque auteur, les prix des livres les plus chers et les moins chers.
SELECT auteur, MAX (prix), MIN (prix)
FROM livre
GROUP BY auteur
La clause "GROUP BY" peut être combinée avec "HAVING". L'expression "HAVING" est liée à
"GROUP BY".

Pr. H. BENNIS -6- Langage SQL

La clause "HAVING" sélectionne un sous ensemble de groupe en fonction d'un critère de la même
manière que la clause "WHERE" sélectionne un nombre de tuples.
c) Afficher le nom de l'auteur, le prix du livre le plus cher et le prix du livre le moins cher pour cet
auteur, ceci pour les auteurs ayant écrit plus d'un livre.
SELECT auteur, MAX (prix), MIN (prix)
FROM livre
GROUP BY auteur
HAVING count (*) > 1

2.6 Sauvegarde du résultat dans une table temporaire

Le résultat d'une requête peut être rangé dans une table temporaire grâce à la clause "INTO TEMP".
Exemple :
SELECT auteur, MAX (prix) maxi, MIN (prix) mini
FROM livre INTO TEMP Tl
Les attributs de Tl sont: auteur, maxi, mini.

2.7 Les jointures

Elles permettent de regrouper des informations provenant de plusieurs relations (ou vues) en
fonction d'un critère de comparaison d'attributs.
Jointure naturelle : T = R >< S ou T = JOIN (R, S)
Exemples :
a) Sélectionner l'ensemble des livres empruntés :
Join (livre, emprunt/livre.noliv=emprunt.noliv et retour = vide)
SELECT noliv, titre, auteur
FROM livre l, emprunt e
WHERE l.noliv=e.noliv AND retour IS NULL;
Ce type de jointure est appelé équi-jointure car la comparaison des deux attributs est effectuée avec
l'opérateur d'égalité. Elle est la plus fréquemment utilisée. Cependant, l'utilisation des autres
comparateurs comme ">" "<" "<>" "<=" ou ">=" est autorisée.
b) Trouver les titres des livres empruntés et le nom de leur emprunteur.
SELECT titre, nom
FROM livre l, personne p, emprunt e
WHERE l.noliv=e.noliv AND e.nopers=p.nopers AND retour IS NULL

Pr. H. BENNIS -7- Langage SQL

c) Lister les livres les plus souvent empruntés, triés par ordre décroissant des nombres d'emprunts.
SELECT titre, COUNT (*)
FROM livre 1, emprunt e
WHERE l.noliv=e.noliv
GROUP BY titre
ORDER BY 2 DESC; (ORDER BY va opérer sur le résultat de la requête et non sur les
tables d’origines livre et emprunt)
Une auto-jointure est une jointure d'une table avec elle même.
d) Lister les couples de livres dont le premier est égal à 2 fois celui du deuxième.
SELECT x.noliv, x.prix, y.noliv, y.prix
FROM livre x, livre y
WHERE x.prix=2*y.prix;

2.8 Les requêtes imbriquées

Les requêtes imbriquées sont utilisées dans une requête pour effectuer une comparaison avec des
valeurs provenant d'une autre requête (sous requête). La sous requête est une requête de sélection
entre parenthèse.
Remarque :
Le résultat de la sous requête doit avoir une seule colonne sauf si la comparaison s'effectue avec le
prédicat" EXISTS".
Une condition de sous requête peut être formulée selon l'une des possibilités suivantes :
WHERE exp opérateur_de_comparaison {ALL / [ANY / SOME]} (requête select) WHERE
exp [NOT] IN (requête select)
WHERE [NOT] EXISTS (requête select)
ALL : la condition est vraie si la comparaison est vraie pour chacune des valeurs retournées.
ANY : la condition est vraie pour au moins une valeur retournée.
IN : la condition est vraie si la comparaison est vraie pour une des valeurs retournées.
EXISTS : envoi le booléen vrai ou faux. Si l'évaluation de la sous requête donne lieu à une ou
plusieurs tuples, la valeur retournée est vraie; elle est fausse sinon.
Exemples :
a) Rechercher tous les livres dont le prix est supérieur au prix moyen.
SELECT *
FROM livre
WHERE prix> (SELECT AVG (prix)
FROM livre)

Pr. H. BENNIS -8- Langage SQL

b) Sélectionner tous les livres qui ont été emprunté.
SELECT *
FROM livre
WHERE noliv IN (SELECT noliv
FROM emprunt);
c) Rechercher les titres des livres ayant une personne de même nom.
SELECT *
FROM livre
WHERE titre = ANY (SELECT nom
FROM personne); (i.e : ANY: = SOME)
d) Sélectionner les livres ayant été empruntés au moins une fois.
SELECT *
FROM livre l
WHERE EXISTS (SELECT *
FROM emprunt e
WHERE l.noliv=e.noliv);
2.9 Union de requête
Le langage SQL fournit la possibilité d'effectuer une union ensembliste entre les résultats de deux
requêtes.
Union : T = R  S ou T = UNION (R, S)
R et S doivent avoir même schéma.
<Requête de sélection> UNION <requête de sélection>
Les données redondantes sont supprimées par défaut sauf si l'option" ALL" est indiquée.
Elle peut comporter une seule clause "ORDER BY" située à la fin et se référant à la colonne par son
numéro.
Les relations impliquées dans l'union doivent impérativement avoir le même schéma (les colonnes
correspondantes sont de même type)
Exemple :
SELECT auteur
FROM livre
UNION
SELECT nom
FROM personne
ORDER BY 1

Pr. H. BENNIS -9- Langage SQL

 2.9 Intersection
Intersection : T = R  S ou T = INTERSECT (R, S)
R et S doivent avoir même schéma.
Exemple : Permet de trouver les livres communs aux catalogues de deux bibliothèques.

2.10 Différence
Différence : T = R - S ou T = MINUS (R, S)
R et S doivent avoir même schéma.
Exemple : Permet de retirer les livres de la relation S existant dans la relation R.

2.11 Produit cartésien

Produit cartésien : T = R x S ou T = PRODUCT (R, S)
Associe chaque tuple de R à chaque tuple de S.
Exemple :

Noliv titre NumFour

100 BD
 F1

110 Programmation C F2

Noliv titre NumFour

100 BD F1
110 Programmation C F1
100 BD F2
110 Programmation C F2

2.12 Division
Division : T = R ÷ S ou T = DIVISION (R, S)
R (A1, A2… An) et S (Ap+1… An)
T (A1, A2, …, Ap) contient tous les tuples tels que leur concaténation à chacun des tuples de S
donne toujours un tuple de R.

Pr. H. BENNIS -10- Langage SQL

Exemple :
Noliv Nopers Sortie Noliv Sortie
100 P1 01/01/2000 100 01/01/2000


110 P1 02/01/2000 110 02/01/2000
100 P2 03/01/2000 =
100 P2 10/01/2000 Nopers
P1

3. LMD de SQL : mise à jour des données

3.1 Insertion de tuples
La requête d'insertion ajoute un ou plusieurs tuples dans une relation.
Syntaxe :
INSERT INTO <nom d'une relation ou d'une vue> (<liste des colonnes>)
VALUES (<liste des valeurs>)
ou
INSERT INTO <nom d'une relation ou d'une vue> <liste des colonnes>)
<requête select>

- La <liste des colonnes> peut être omise. Dans ce cas, chaque colonne du tuple de la relation
concernée sera affectée. Si la <liste des colonnes> est précisée, les colonnes doivent être séparées
par une virgule.
- La <liste des valeurs> doit contenir autant de valeurs que de colonne concernées par l'insertion.
Une <requête select> peut remplacer la <liste des valeurs>. Le nombre et le type des colonnes
choisis dans la <requête select> doivent correspondre avec celles de <liste des colonnes>. De plus,
la <requête select> ne doit contenir ni "ORDER BY" ni "INTO TEMP".
L'insertion d'un tuple peut être rejetée:
- si les contraintes d'unicité sur les attributs ne sont pas respectées;
- si une colonne déclarée "NOT NULL" (lors de la création de la table) n'est pas instanciée lors de
l'insertion.
Exemples :
a) INSERT INTO livre VALUES (20, 'INFOGUIDE UNIX', 'CHOUCHENA', 'INFORMATIQUE',
368)
b) INSERT INTO personne (nopers, nom) VALUES (15, 'TOTO LHOUCINE')

Pr. H. BENNIS -11- Langage SQL

c) supposons qu'on a crée une table nommée "livre_rom" qui ne contient que les romans et dont le
schéma est : (noliv, titre, auteur, prix),
INSERT INTO livre_rom
SELECT noliv, titre, auteur, prix
FROM livre
WHERE genre = 'ROMAN';

3.2 Modification de tuples

La requête de modification permet de changer les valeurs de la relation ou de la vue désignée dans
<nom d'une relation ou d'une vue>.
Syntaxe:
UPDATE <nom d'une relation ou d'une vue> SET <nom de colonne = exp,...>
[ ( <liste de colonne> ) * = ( <liste exp> ) ] [WHERE <critère de sélection>]
La clause "WHERE" permet de réduire l'ensemble des tuples concernés par la modification.
1) La requête qui permet de modifier une ou plusieurs colonnes d'une façon classique est la
suivante:
UPDATE <nom d'une relation ou d'une vue> SET nom de colonne = exp,... [WHERE <critère de
sélection>]
Exemples :
a) Augmenter de 5% le prix de tous les livres.
UPDATE livre SET prix = prix * 1.05
b) modifier le nom et prénom de la personne nopers=10.
UPDATE personne SET nom = 'BENALI', prenom = 'AMINE'
WHERE nopers = 10;
2) La requête qui permet de modifier des données en groupant dans la clause" SET" les noms de
colonnes d'un côté et les valeurs de l'autre.
UPDATE <non1 d'une relation ou d'une vue> SET (<liste de colonne>) = ( <liste exp> )
[WHERE <critère de sélection>]
Exemples:
a) modifier le nom et prénom de la personne n° 10.
UPDATE personne SET (nom, prenom) = ('BENALI', 'HAMID')
WHERE nopers = 10
b) modifier les dates d'emprunt du livre 7 par la personne 3 sorti le 15/09/92 à la date de sortie
30/09/92 et la date retour 15/10/92.
UPDATE emprunt SET * = (3,7,'30/09/92','15/10/92')

Pr. H. BENNIS -12- Langage SQL

WHERE nopers = 3 AND noliv= 7 AND sortie='15/09/92'
3) La requête permettant de modifier des données à partir des expressions issues de requêtes
SELECT.
UPDATE <nom d'une relation ou d'une vue>
SET ( <liste de colonne> ) 1 = ( <liste exp> ) [WHERE <critère de sélection>]
La <liste exp> est composée soit d’expressions séparées par une virgule soit d'une requête SELECT
ramenant une seule ligne et un nombre de valeurs correspondant à la <liste de colonnes>.
Exemple:
a) Affecter au livre 8 le double du prix du livre 5.
UPDATE livre SET prix = ( SELECT 2*prix FROM livre WHERE noliv= 5 ) WHERE noliv=8

3.3 Suppression de tuples

La requête de suppression efface zéro, un ou plusieurs tuples d'une relation.
Syntaxe:
DELETE FROM <nom de relation ou vue> [WHERE <critère de sélection>]

En l'absence de la clause" WHERE" tous les tuples de la relation ou de la vue sont détruits.
Exemple:
a) Effacer tous les tuples de la relation "livre_rom".
DELETE FROM livre_rom.
b) Effacer tous les livres de poésie de la relation livre.
DELETE FROM livre WHERE genre ='POESIE'

Pr. H. BENNIS -13- Langage SQL