Dr.

Nour El-Houda BENALIA

Responsable de la matière Informatique -
2ème année
Cycle préparatoire- ENP

Chapitre 04:

Langage SQL : Créer et

Interroger une Base de
Données
2 Vous allez apprendre:
 Composer des requêtes SQL .

Modèle Conceptuel

Modèle relationnel
normalisé

Algèbre relationnelle

Requêtes
AR
Composition des Requêtes

SQL
 3
Le Langage de manipulation relationnel
SQL
 Les SGBDr proposent un langage de requête appelé SQL.
 Considéré comme le langage d’accès normalisé aux bases de
données.

 Supporté par la plupart des produits commerciaux que ce soit par

les systèmes de gestion de bases de données micro tel que Access
ou par les produits plus professionnels tels que Oracle ou Sybase.

 Le succès du langage SQL est dû essentiellement à sa simplicité et

au fait qu’il s’appuie sur le conceptuel pour énoncer des requêtes en
laissant le SGBD responsable de la stratégie d’exécution.
 4 Le Langage de manipulation relationnel SQL

 SQL est un acronyme pour (« Sturctured Query Language », Langage de

requêtes structuré) qui a été conçu par IBM, et a succédé au langage
SEQUEL.

 SQL est un langage déclaratif à savoir qu’il permet à l’utilisateur de

spécifier le résultat qu’il attend, c’est au SGBD de trouver, ensuite, le moyen
d’aboutir à ce résultat.

 L’interpréteur SQL existe en de nombreuses versions, du fait que chaque

éditeur de SGBD-R adapte la norme SQL à son propre système (mySQL,
pSQL (de PostgreSQL), PL\SQL (d’Oracle). etc...).
 Le Langage de manipulation relationnel SQL
5
 Le langage SQL comporte :
 une partie sur la définition des données :
 Le (LDD) qui permet de définir des relations (créer des tables), des vues externes et des
contraintes d’intégrité ;
 une partie sur les requêtes :
 Le langage de manipulation de données (LMD) qui permet d’interroger une base de
données, d’insérer, de modifier ou de supprimer des données dans une table d'une base
de données relationnelle, sans se préoccuper de l’organisation physique des données.
 une partie sur le contrôle des données :Le Langage de manipulation relationnel SQL
 Le langage de contrôle de données
 (LCD) qui permet de contrôler la sécurité et les accès aux données.
 Typologie du langage :
 Il est possible d'inclure des requêtes SQL dans un programme écrit dans un autre
langage (en langage C par exemple), ainsi que d'envoyer directement les requêtes SQL
telles quelles au SGBD.
 6
Le Langage de manipulation relationnel
SQL

 SQL permet de:

 définir les données (CREATE. ALTER, DROP)

 interroger la base et formuler des requêtes (SELECT)
 manipuler les données (INSERT, UPDATE, DELETE)
 contrôler l’accès aux données (GRANT, REvOKE)

 SQL ne distingue pas majuscules ou minuscules et n’accepte

pas d’accents.
 7
A apprendre:

 Les principales requêtes de création de table et d’accès aux

données.

 Quelques fonctions d’agrégation (MAX, SUM, COUNT, ..).

 Les opérations de l’algèbre relationnelle et les traduisons en

requêtes SQL.
 8
Exemple de la base de données à utiliser
par la suite

 CLIENT (num-cli, nom-cli, adr-cli)

 PRODUIT (num-prod, des-prod, prix-un)
 COMMANDE (num-com, num-cli, date)
 DETAIL (num-com, num-prod, qte-com)
9
Règles d’écritures en SQL.
1. Nommage des objets en SQL

 Un nom d’objet (table, base, colonne, contrainte, vue, etc…)

doit avoir les caractéristiques suivantes :

 Ne pas dépasser 128 caractères

 Commencer par une lettre
 Etre composé de lettre, de chiffre, du caractère ‘_’
 Ne pas être un mot réservé en SQL à moins d’être mis entre
guillemets
 Pas de caractères accentués
 Règles d’écritures en SQL.
10
1. Nommage des objets en SQL

 Il faut noter que les noms d’objets sont insensibles à la casse.

Voici quelques exemples de noms bien et mal formés :
 11

 Les commentaires en mysql s’ecrivent à la manière C :

/* mon commentaire sur
plusieurs lignes */

 Mais un commentaire sur une seule lignes est introduit par : ‘—

‘ ou ‘#’. Mais pour éviter toute confusion du caractère ‘—‘ avec
des opérations mathématiques avec le ‘-‘, préférez le ‘#’ pour
vos commentaires sur une seule ligne
12

2. Le langage de définition de données

(LDD)
 13 Création de schéma

 BD est définie par son schéma. SQL propose donc de créer

ce schéma avant de définir ses composants grâce à la
commande : CREATE

 Exemple : create schema BDCLIENT

 14
Création de domaines
 Domaines Il existe des domaines prédéfinis tels que :
- char(n) : chaîne de caractères de taille fixe n
- varchar(n) : chaîne de caractères de taille variable mais inférieure à n
- int : Entier (un sous ensemble fini des entiers, dépend de la machine)
- smallint : Entier. Sous ensemble de int
- numeric(p,d) : Réel codé sur p digits et max d digits pour partie à droite de la
décimale.
- real : Un réel flottant.
- date : YYYY-MM-DD (année, mois, jours)
- time : HH :MM :SS (heure, minute, seconde)

 On peut créer nos propres domaines avec la commande:

CREATE DOMAIN

Exemple : CREATE DOMAIN nom-client char(20)

 15 Création d’une table

 On utilise la clause CREATE TABLE

 Cette opération produit une table vide(c-à-dire sans ligne).

 Exemple: create table CLIENT ( num-cli int NOT NULL,

nom-cli varchar (15), adr-cli char (50))
16

Les contraintes
 Les contraintes d’intégrité sur les
17
colonnes de tables
 Les contraintes d’intégrités permettent aux SGBD-R de garantir la
cohérence des données lorsque ces dernières sont mises à jour.
 Ces contraintes correspondent à des contraintes du monde réel que la
base de données cherche à représenter.

 Exemple,
 le nom d’un mois doit être une chaine de caractères, ou l’âge un
nombre…
 Il y aussi les clés primaires et clés étrangères, mais aussi bien
d’autres contraintes que les bases de données peuvent exprimer.
Ainsi si une mise à jour viole une de ces contraintes, elle sera
alors tout simplement rejetée.
 18 Contrainte de non nullité (NOT
NULL)

 La contrainte de non nullité impose que la valeur d’un attribut

soit renseignée (la valeur du champ ne peut être à NULL).
 Exemple, la colonne intitule de la table cours. Il est cohérent
d’imposer que l’intitulé soit toujours renseigné.

 Commande de création de la table devient :

CREATE TABLE cours (
Intitule VARCHAR NOT NULL,
NbEtudiants INTEGER) ;
 19 Contrainte de vérification (CHECK)

 La contrainte de vérification est une contrainte qui permet de spécifier que la valeur
d’une colonne particulière doit satisfaire une expression booléenne.

 Attention : si l’expression booléenne compare deux valeurs de colonnes, et que

ces dernières contiennent la valeur NULL, elles ne seront pas considérées
comme égales.

 Exemple le nombre d’étudiants ne peut être que supérieur à zéro. La commande de

création de table devient donc :

CREATE TABLE cours (

Intitule VARCHAR NOT NULL,
NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants IS NULL) ;
20
Expression de l’identifiant primaire

 On complétera la déclaration de la table par la clause :

primary key

 Exemple :
CREATE TABLE client ( num-cli int NOT NULL ,
nom-cli varchar (15), adr-cli char (50), primary key
(num-cli))
 21 Expression d’une contrainte
référentielle (clé étrangère)
 La contrainte d’intégrité de référence est la contrainte de clé étrangère.
 On déclarera la clé étrangère et la table référencée par la clause : foreign key

 Exemple:
CREATE TABLE detail (num-com int NOT NULL,
num-cli int NOT NULL,
qte-com int,
PRIMARY KEY (num-com, num-cli),
FOREIGN KEY (num-com) references
commande,
FOREIGN KEY (num-cli) references CLIENT)
 Contrainte d’intégrité de référence
22
(REFERENCES)
 Colonne ou groupe de colonnes correspondent aux valeurs qui apparaissent
dans les lignes d’une autre table.

 Exemple, dans l’exemple de la table cours, pour préciser l’enseignant qui

dispense le cours, il faut introduire une colonne id_enseignant qui fait
référence à la colonne id_personne de la table personne.

 Supprimer une ligne de la table personne, le SGBD doit vérifier qu’aucune

ligne de la table cours, par l’intermédiaire de l’attribut id_enseignant, n’a la
ligne qui doit être supprimée. Sinon (i.e. la ligne à supprimer se trouve dans la
table cours),
 trois situations sont possibles :
 Contrainte d’intégrité de référence
23
(REFERENCES)
 La suppression est interdite dans la table maître (personne) et dans la table
courante (ici cours) où la contrainte d’intégrité est définie comme suit :

CREATE TABLE cours (

Id_enseignant INTEGER
REFERENCES personne (id_personne) RESTRICT,
sigle CHAR(7) PRIMARY KEY,
Intitule VARCHAR NOT NULL,
NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants IS NULL) ;
 Contrainte d’intégrité de référence
24
(REFERENCES)

 La suppression se fait dans la table maitre (ici personne) ainsi que dans la
table courante (cours) dans laquelle la contrainte d’intégrité est comme suit :

CREATE TABLE cours (

Id_enseignant INTEGER
REFERENCES personne (id_personne) ON DELETE CASCADE,
sigle CHAR(7) PRIMARY KEY,
Intitule VARCHAR NOT NULL,
NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants IS
NULL) ;
 Contrainte d’intégrité de référence
25
(REFERENCES)
 La suppression se fait dans la table maitre (personne) mais dans la table courante
(cours), la valeur NULL est affectée dans la colonne id_enseignant pour toutes
les lignes qui vérifient l’identifiant supprimé dans la table maitre.

CREATE TABLE cours (

Id_enseignant INTEGER
REFERENCES personne(id_personne) ON
DELETE SET NULL,
sigle CHAR(7) PRIMARY KEY,
Intitule VARCHAR NOT NULL,
NbEtudiants INTEGER CHECK(NbEtudiants > 0 OR NbEtudiants IS
NULL) ;
 26 Les contraintes d’intégrité sur la table

 Les contraintes de tables portent sur plusieurs colonnes de la table.

Ces contraintes ont la syntaxe suivante :

 [ CONSTRAINT <nom_contrainte>
{ PRIMARY KEY (<nom_col>[, <nom_col>…]) |
FOREIGN KEY <nom_col>[, <nom_col>…])
REFERENCES <nom_tablel> [ (<nom_col>…) ]
[ ON DELETE {CASCADE |SET NULL} ]
CHECK (<condition>) }
 27 Les contraintes d’intégrité sur la table
 CONSTRAINT
Cette partie optionnelle permet de donner un nom à une contrainte de table.
Si la contrainte est violée, le nom de la contraint est présent dans les messages d’erreur.
 PRIMARY KEY
Cette contrainte permet de spécifier une clé primaire composée de plusieurs attributs.
 FOREIGN KEY ( <nom_col> [, …])
REFRENCES <table-maitre> [ ( <nom_col_maitre> [, …]) ]
[ ON DELETE {CASCADE | SET NULL | RESTRICT} ]
Cette contrainte permet de définit un ensemble d’attributs comme clés étrangères. Les
clés de la table maitres doivent être définies comme PRIMARY KEY ou UNIQUE.
 CHECK (<condition>)
Cette contrainte permet d’exprimer une condition qui doit exister entre plusieurs attributs
de la ligne.
 28 Rajout de contraintes

 Exemple:

CREATE TABLE detail (num-com in NOT NULL,

num-cli int NOT NULL,
qte-com int,
PRIMARY KEY (num-co, num-cli),
FOREIGN KEY (num-com) references commande,
FOREIGN KEY (num-cli) references client,
CHECK (num-com> 1) )
 29 Suppression d’une table

 Toute table peut être supprimée grâce à la commande ‘drop’.

Elle est désormais inconnue et son contenu est perdu.
 Exemple :

DROP TABLE commande

 30
Les vues
 Une vue peut être considérée comme une relation quelconque lors de l’expression des
requêtes. Une vue est une relation virtuelle dans le sens où elle ne contient pas
effectivement des « tuples ». Elles permettent de définir des relations virtuelles dans le
but de :
- Cacher certaines informations à des utilisateurs,
- Faciliter l'expression de certaines requêtes,
- Améliorer la présentation de certaines données.
 Une vue est définie par une expression de la forme :
CREATE VIEW V AS requête
Requête est une expression quelconque de requête et V est le nom de la vue.
 Exemple : Soit Emp (NumE, Salaire, Dept, Adresse) une relation, on crée la vue
suivante sur cette relation :
CREATE VIEW EmpGen AS ( SELECT NumE, Dept, Adresse
FROM Emp)
31

3. Le langage de manipulation de données

(LMD)
 32
Requête d'interrogation SQL

 La forme d'une requête d'interrogation SQL est la suivante:

SELECT [* | DISTINCT] att1 [, att2, att3, ...]

FROM Table1 [, Table2, Table3, ...]
[WHERE conditions de sélection et/ou de jointure]
[GROUP BY att1 [, att2, ...] [HAVING conditions de selection]]
[(UNION│INTERSECT│MINUS[ALL])<commande SELECT>]
[ORDER BY att1 [ASC | DESC] [, att2 [ASC | DESC], ...];

[ ] : optionnel | : ou
 33
Requête d'interrogation SQL
 la clause select décrit la relation résultat.
 L'expression d'attributs désigne soit une liste d'attributs, soit une expression
fonctionnelle obtenue à l'aide des fonctions
sum (somme), avg (moyenne), count (compte), min, max.
 Le mot clé distinct permet d'éliminer les doubles après une projection.
 La clause from désigne les relations concernées par la requête, avec éventuellement une
ou plusieurs variables synonymes pour chaque relation désignée.
 La clause where, optionnelle, spécifie les critères de sélection.
 La condition de sélection est une expression logique spécifiant les prédicats de
restriction ou de jointure à satisfaire par la réponse.
 La sous-question peut être n'importe quelle question SQL, ce qui permet de générer une
série de questions imbriquées.
 Le group by partitionne la relation selon les valeurs de la liste des attributs spécifiée.
 La clause having exprime une condition sur le groupe d’enregistrements associé à
chaque valeur du groupage.
 La clause order by permet de trier les résultats obtenus.
 34
Requête d'interrogation SQL
 Le principe général de l'évaluation d'une requête permet de comprendre la
sémantique que SQL attribue aux requêtes.
 Ce principe est le suivant:
 35
Requête d'interrogation SQL
 Remarque :
Seules les clauses select et from sont obligatoires. Dans le cas d'une requête ne
contenant que ces clauses, le résultat est le produit cartésien des relations
mentionnées dans la clause from.
 Exemple :
1) Donner les noms des clients.
a) résultat avec doublons :
SELECT nom-cli
FROM client
 36
Requête d'interrogation SQL
 b) résultat sans doublons :
SELECT DISTINCT (nom-cli)
FROM CLIENT

2) Donner la liste des clients.

SELECT *
FROM CLIENT

3) Donner le numéro des clients de nom Mohammed.

SELECT num-cli
FROM CLIENT
WHERE nom-cli=’ Mohammed’
 Requête d'interrogation SQL
37

 Cette forme générale de requête peut être étendue de plusieurs

façons:

 1) En introduisant explicitement certains opérateurs ensemblistes

tels que l'union et l'intersection. On peut ainsi formuler plusieurs
sous-requêtes dont les résultats sont reliés par ces opérateurs. La
syntaxe simplifiée est la suivante:
 38 Requête d'interrogation SQL

 où except représente l'opération de différence ensembliste

notée également par minus.

 Exemple : Donnez les numéros des produits qui ne sont pas

commandés.
SELECT num-prod From PRODUIT
MINUS SELECT num-prod
FROM DETAIL
 39 Requête d'interrogation SQL

 2) En introduisant les notions de requête imbriquée et de

comparaison ensembliste. La requête externe sélectionne un
ensemble de tuples qui sont comparés avec l'ensemble de tuples
sélectionné par la requête imbriquée à l'aide des prédicats in,
not in, all, any, exists, not exists.

 On peut avoir une cascade de sous-requêtes imbriquées.

 40
Requête d'interrogation SQL

 a) IN: Permet de tester la présence d’une valeur particulière dans un

ensemble.
 Exemple : Donner num-prod et des-prod des produits commandés.
SELECT num-prod, des-prod
FROM PRODUIT
WHERE num-prod IN
SELECT num-prod
FROM DETAIL
 41 Requête d'interrogation SQL
b) NOT IN: Permet de tester l’absence d’une valeur particulière dans un
ensemble.

Exemple :
Donner num-prod et des-prod des produits non commandés.

SELECT num-prod, des-prod

FROM PRODUIT
WHERE num-prod NOT IN
SELECT num-prod
FROM DETAIL
 42
Requête d'interrogation SQL
c) ALL: Compare chacune des valeurs de l’ensemble à une valeur particulière et
retourne ‘VRAI’ si la comparaison est évaluée pour chacun des éléments. Les
comparateurs sont : <, <=, >, >=, =, !=

 Exemple1: Donner le produit de prix maximal.

SELECT num-prod
FROM PRODUIT
WHERE prix-un >= ALL SELECT prix-un
FROM PRODUIT
 43
Requête d'interrogation SQL
d) ANY: Compare chacune des valeurs de l’ensemble à une valeur particulière et retourne ‘VRAI’ si la
comparaison est évaluée à ‘VRAI’ pour au moins un des éléments.

 Exemple1: Donner les produits dont le prix n’est pas minimal.

SELECT num-prod
FROM PRODUIT
WHERE prix-un > ANY SELECT prix-un
FROM PRODUIT

 Exemple2 : Donner les numéros des clients qui ont commandé des produits en quantité > 60

SELECT n°cli
FROM COMMANDE
WHERE n°com= ANY SELECT n°com
FROM DETAIL
WHERE qcom >60
 44
Requête d'interrogation SQL
e) EXISTS : Retourne ‘VRAI’ si la sous-interrogation (requête imbriquée) ramène au
moins une ligne.

Exemple: Donner les numéros des clients qui ont commandé au moins un produit en
quantité supérieure à 100.

SELECT n°cli
FROM COMMANDE
WHERE EXISTS (SELECT *
FROM DETAIL
WHERE n°com= COMMANDE.n°com
And qcom > 100)
 45
Requête d'interrogation SQL

f) NOT EXISTS: Teste si l'ensemble est vide.

 Exemple: Donner les numéros de produit qui ne sont pas commandés.

SELECT n°pro
FROM PRODUIT
WHERE NOT EXISTS (SELECT * FROM DETAIL
WHERE n°pro= PRODUIT.n°pro)
 46 Requête d'interrogation SQL
 3) En introduisant les connecteurs AND et OR entre sous-requêtes. On peut
réaliser des formules très complexes.
 47
Requête d'interrogation SQL
Exemple : Donnez les noms des clients qui ont commandé des produits ayant
pour désignation ‘amox’ et commandés en quantité > 100

Select nom-cli
From CLIENT
Where num-cli in select num-cli
From COMMANDE
Where num-com in (select num-com
From DETAIL
Where qte-com>100 and num_prod in select num-prod
From PRODUIT
Where des-prod=’amox’)
 48
Requête d'interrogation SQL
4) Opération JOINTURE (équijointure)

4) Opération JOINTURE (équijointure)

En SQL, il est possible d'enchaîner plusieurs jointures dans la même instruction SELECT.

SELECT *
FROM table1, table2, table3, ...
WHERE table1.attribut1=table2.attribut1
AND table2.attribut2=table3.attribut2 AND ...;

Exemple :
SELECT *
FROM Produit, Détail
WHERE Produit.CodePrd=Détail.CodePrd ;

ou en utilisant des alias pour les noms des tables :

SELECT *
FROM Produit A, Détail B WHERE A.CodePrd=B.CodePrd ;
 49 Requête d'interrogation SQL
Exemple1: Donner la somme des quantités commandées de chaque
produit. (Il faut partitionner l'ensemble des tuples de DETAIL en sous-
ensembles (ou groupes) par numéro de produit)

SELECT n°pro, SUM (qcom)

FROM Détail
GROUP BY n°pro

Exemple 2: Donnez les numéros des produits de chaque client.

SELECT num-cli, num-pod

FROM COMMANDE, DETAIL
WHERE COMMANDE.num-com= DETAIL.num-com
GROUP BY num-cli
 50
Requête d'interrogation SQL

où $ désigne n'importe quelle relation de comparaison logique.

La clause HAVING ne s’emploie qu’avec un ‘GROUP BY’. Elle exprime une condition
sur le groupe d’enregistrements associé à chaque valeur du groupage.

Exemple: Donner la somme des quantités commandées des produits qui ont été
commandés au moins deux fois.

SELECT n°pro, SUM (qcom)

FROM DETAIL
GROUP BY n°pro
HAVING COUNT (*) >= 2
 51 Requête d'interrogation SQL

 Remarque

La clause 'HAVING < condition >’ permet de sélectionner les

groupes qui satisfont une condition. Cette condition porte sur
l'ensemble des tuples, (contrairement à la clause WHERE <
condition > qui porte sur un tuple).
 52
Requête d'interrogation SQL

6) On peut ordonner les tuples du résultat en utilisant : ORDER BY.

Exemple : Donner la liste des produits par ordre décroisant des prix.

SELECT *
FROM PRODUIT
ORDER BY prix-un/desc
 53 Requête d'interrogation SQL
7) On peut faire de la recherche avec des conditions sur les ensembles

a) CONTAINS : Test d'inclusion

< ens1> CONTAINS < ens2>
signifie que l'ensemble 1 contient ( ou est égal) à l'ensemble 2

Exemple1: Quels sont les clients qui ont commandés tous les produits?

SELECT n°cli
FROM COMMANDE
WHERE (SELECT n°pro
FROM DETAIL
WHERE n°com= COMMANDE.n°com)
CONTAINS
(SELECT n°pro
FROM PRODUIT)
 54
Requête d'interrogation SQL

Exemple2: Donner les numéros des commandes où figurent tous les produits.

SELECT num-com
FROM DETAIL
GROUP BY num-com HAVING SET (num-prod)
CONTAINS
SELECT num_prod
FROM PRODUIT
55
Requête d'interrogation SQL

 b) NOT CONTAINS : Test de non inclusion

 (Négation de la précédente) c-à-dire elle est vraie si un
élément de l'ensemble 2 n'appartient pas à l'ensemble
 56
Requête d'interrogation SQL
Fonction d’agrégation

 Agrégat : fonction définie en SQL qui permet de calculer un résultat

atomique (un entier ou un réel) à partir d'un ensemble de valeurs.

 Ces fonctions sont sum, min, max, avg et count. Elles peuvent apparaître
aussi bien dans la clause select que dans la clause Having. Les formes les
plus générales sont les suivantes:
57 Requête d'interrogation SQL

 où les A et B sont des listes d'attributs.

 On peut aussi avoir la forme suivante où on ne veut retenir que
les partitions dont la fonction de calcul choisie satisfait un
certain critère:
 58 Requête d'interrogation SQL
 Après l'exécution de la clause where (qui peut ne pas exister), la relation
R1 est d'abord triée et partitionnée selon le critère B, puis l'une des
fonctions de calcul choisie dans la clause select est appliquée à chaque
partition.

 Le résultat de la requête est un ensemble de tuples de cardinal égal à celui

de l'ensemble des partitions et dont les valeurs sont les résultats de la
fonction pour chaque partition.

 Il faut noter que les attributs B sur lesquels se fait le partitionnement des
relations doivent nécessairement apparaître dans la clause select pour une
bonne interprétation externe des résultats des fonctions de calcul.
 Requête d'interrogation SQL
59
Fonction d’agrégation
 a) COUNT(expr) : dénombre les lignes sélectionnées.
 Exemple :
SELECT COUNT(num_prod)
FROM PRODUIT

 b) SUM(expr): additionne les valeurs de type numérique.

 c) MIN (expr) : retourne la valeur minimale d’une colonne de type caractère ou
numérique.
 d) MAX(expr): retourne la valeur maximale d’une colonne de type caractère ou
numérique.
 e) AVG (expr) : calcule la moyenne d’une colonne de numérique.

 Remarques :
1) On peut préfixer expr par les mots clés [DISTINCT] [ALL]
2) Ces fonctions peuvent apparaître dans la clause SELECT ou dans la clause HAVING.
60 Requête d'interrogation SQL
 Lien entre algèbre relationnelle et SQL
61  Soit le schéma de base de données relationnel suivant :
R1 (A, B) R2 (C, D) R3 (A, E) R4 (B)
 Lien entre algèbre relationnelle et SQL
62
 63 Mise à jour des relations
 1) Insérer des tuples :
INSERT INTO
- insérer un tuple : INSERT INTO nom de relation Values <tuple constant>
- insérer un ensemble de tuples : INSERT INTO nom de relation :
 < requête SELECT dont le résultat a même schéma que la relation nom relation>
 Exemple1 : insérer le tuple (P10, desp, 100) dans PRODUIT.

INSERT INTO PRODUIT Values ( ‘P10’, desp’, 100)

 Exemple2 : rajouter le catalogue de schéma : CATALOGUE (np, nomp, pu)

INSERT INTO CATALOGUE values (np, ‘nomp’, pu);

 64 Mise à jour des relations
 2) Supprimer des tuples :
DELETE
DELETE nom relation [WHERE condition]

 - si la clause ‘WHERE condition est présente, seuls les tuples satisfaisant la condition
sont supprimés.

 - si la clause ‘WHERE condition’ est absente, alors tous les tuples sont supprimés ; la
relation continue d’exister, mais sa population est vide.

 Exemple : supprimer les produits de désignation :amox

DELETE PRODUIT
WHERE desg=’amox’
 65 Mise à jour des relations
 3) Mettre à jour un (des) attribut(s) :

UPDATE
UPDATE nom relation
SET nom attribut1=<expression1 qui définit une valeur pour l’attribut1> …. …..
SET nom attributn=<expression n qui définit une valeur pour l’attribut n>
[WHERE condition]

 Exemple: augmenter le prix des produits dont le prix est inférieur à 100 de 20.

UPDATE PRODUIT
SET prix-un= prix-un +20
WHERE prix-un <100
 Remarque : La condition qui suit la clause WHERE peut être une requête SQL.
66
67 Exercice d’application AR & SQL
 Soit la base de données de schéma suivant:

ETUDIANT( num-et, nom-et, âge, nom-institut, ville)

EMP-TEMPS( num-et, groupe, salle, jour, heure, durée, module)

Exprimer à l'aide des opérations de l'algèbre relationnelle puis SQL les requêtes suivantes:

1) Quels sont les jours où a cours l’étudiant de numéro ‘E10’ ?

2) Donnez les numéros et le nom de tous les étudiants.
3) Quels sont les étudiants qui font partie des groupes 1 ou 5 ou 6 ?
4) Quels sont les étudiants qui ne font pas partie des groupes 1, 5 et 6 ?
5) Quels sont les étudiants qui ont cours le Samedi, le Lundi et le Jeudi ?
Donner deux solutions.
6) Trouvez les étudiants qui n'ont pas cours le Samedi.
7) Trouvez les étudiants qui suivent tous les modules.
8) Quels sont les étudiants qui suivent au moins les modules suivis par Mohammed ?
9) Quels sont les étudiants qui suivent exactement les mêmes modules que Mohammed ?
68 Algèbre Relationnelle vs SQL

1) Quels sont les jours où a cours l’étudiant de numéro ‘E10’ ?

2) Donnez les numéros et le nom de tous les étudiants.

 69
Algèbre Relationnelle vs SQL
3) Quels sont les étudiants qui font partie des groupes 1 ou 5 ou 6 ?

4) Quels sont les étudiants qui ne font pas partie des groupes 1, 5 et 6 ?
 Algèbre Relationnelle vs SQL
70

5) Quels sont les étudiants qui ont cours le Samedi, le Lundi et le Jeudi ?
 71
Algèbre Relationnelle vs SQL

5) Quels sont les étudiants qui ont cours le Samedi, le Lundi et le Jeudi ?
 Algèbre Relationnelle vs SQL
72

6) Trouvez les étudiants qui n'ont pas cours le Samedi.

7) Trouvez les étudiants qui suivent tous les modules.

 73 Algèbre Relationnelle vs SQL

8) Quels sont les étudiants qui suivent au moins les modules suivis par Mohammed ?
 74 Algèbre Relationnelle vs SQL

9) Quels sont les étudiants qui suivent exactement les mêmes modules que Mohammed ?
R1=ETUDIANT[nom-et = Mohammed]
R2=R1[module]
R3=EMP-TMPS[module]
R4= ETUDIANT[nom-et, module]
R5=R3-R2
R6=R5[module]ETUDIANT
R7=R6[nom-et]
R8=DIVISION(R4,R2)
R9= R8-R7