COURS SUR LA PRATIQUE DE SQL

Objectifs : Ce cours initie les étudiants à l'écriture des requêtes utilisant le langage SQL

Contenu :

Présentation de SQL
Les commandes de SQL
Les requêtes SQL
Création d’une Base de données

I. PRESENTATION DE SQL

Ce chapitre présente le langage SQL le langage de définition de données (LDD) et de la

manipulation des données(LMD) (insertion, mise-à-jour, destruction). La syntaxe est celle de
la norme SQL2 révisée en 1992, implantée plus ou moins complètement dans la plupart des
principaux SGBDR. SQL est un langage déclaratif qui permet d’interroger une base de données
sans se soucier de la représentation interne (physique) des données, de leur localisation, des
chemins d’accès ou des algorithmes nécessaires. A ce titre il s’adresse à une large communauté
d’utilisateurs potentiels (pas seulement des informaticiens) et constitue un des atouts les plus
spectaculaires (et le plus connu) des SGBDR. On peut l’utiliser de manière interactive, mais
également en association avec des interfaces graphiques, des outils de reporting ou, très
généralement, des langages de programmation. Ce dernier aspect est très important en pratique
car SQL ne permet pas de faire de la programmation au sens courant du terme et doit donc être
associé avec un langage comme le C, le COBOL ou JAVA pour réaliser des traitements
complexes accédant à une base de données.

1. les types de données

La norme SQL ANSI propose un ensemble de types qui sont donnés dans le tableau ci-
dessous. Ce tableau présente également la taille, en octets, des instances de chaque type, cette
taille n’étant ici qu’à titre indicatif car elle peut varier selon les systèmes.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 1

 2. Les contraintes

La création d’une table telle qu’on l’a vue précédemment est extrêmement sommaire
car elle n’indique que le contenu de la table sans spécifier les contraintes que doit respecter ce
contenu. Or il y a toujours des contraintes et il est indispensable de les inclure dans le schéma
pour assurer (dans la mesure du possible) l’intégrité de la base.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 2

 Voici les règles (ou contraintes d’intégrité) que l’on peut demander au système de
garantir:
Un attribut doit toujours avoir une valeur. C’est la contrainte NOT NULL vue
précédemment.
Un attribut (ou un ensemble d’attributs) constitue (nt)la clé de la relation.
Un attribut dans une table est lié à la clé primaire d’une autre table (intégrité
référentielle).
La valeur d’un attribut doit être unique au sein de la relation.
Enfin toute règle s’appliquant à la valeur d’un attribut (min et max par exemple).
Les contraintes sur les clés doivent être systématiquement spécifiées. La dernière
(clause CHECK) s’appuie en grande partie sur la connaissance du langage d’interrogation de
SQL et sera vue ultérieurement.

Clés d’une table :

Une clé est un attribut (ou un ensemble d’attributs) qui identifie(nt) de manière unique
un tuple d’une relation. Il peut y avoir plusieurs clés mais l’une d’entre elles doit être choisie
comme clé primaire. Ce choix est important: la clé primaire est la clé utilisée pour référencer
une ligne et une seule à partir d’autres tables. Il est donc assez délicat de la remettre en cause
après coup. En revanche les clés secondaires peuvent être créées ou supprimées beaucoup plus
facilement. La clé primaire est spécifiée avec l’option PRIMARY KEY.

Clés étrangères :
La norme SQL ANSI permet d’indiquer quelles sont les clés étrangères dans une table,
autrement dit, quels sont les attributs qui font référence à une ligne dans une autre table. On
peut spécifier les clés étrangères avec l’option FOREIGN KEY.

II. LES COMMANDES DE SQL

1. Gestion des bases de données

Créer une Base de données : CREATE DATABASE nomDeLaBD;

Afficher les bases de données existantes : SHOW DATABASES;
Utiliser une base de données : USE nomBD

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 3

 Effacer une base de données : DROP DATABASE nomDeLaBD;

2. gestion des tables

Créer une table : CREATE TABLE nomDeLaTable

(nomDeLaColonneTypeDeValeursAttributDesValeurs,
nomDeLaColonneTypeDeValeursAttributDesValeurs, …);

Afficher les tables existantes SHOW TABLES;

Afficher la structure d'une table DESCRIBE nomDeLaTable;
Modifier une table :
 ALTER TABLE nomDeLaTable RENAME AS
nouveauNomDeLaTable; (renommer la table)
 ALTER TABLE nomDeLaTable ADD nomDeLaColonne TypeDe
Valeurs; (ajouter une colonne)
 ALTER TABLE nomDeLaTable CHANGE nomDeLaColonne
Nouveau NomDeLaColonne TypeDeValeurs; (changer le nom d’une
colonne)
 ALTER TABLE nomDeLaTable DROP COLUMN nomDeLaColonne;
(supprimer une colonne)
 Effacer une table DROP TABLE nomDeLaTable;

3. Gestions des données

Ajouter des données

 INSERT INTO nomDeLaTable VALUES (valeur1, valeur2, …);
 INSERT INTO nomDeLaTable (nomDeLaColonne,nomDeLaColonne2
, ...) VALUES (valeur1, valeur2, …);
Afficher des données
 SELECT nomDeLaColonne1, nomDeLaColonne2, ...
FROM nomDeLaTable WHERE certainnesColonnes =
CertainesValeurs GROUP BY nomDeLaColonne ORDER BY nomDeLaColonne Attribut
D'ordre;

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 4

 Mises à jour de données UPDATE nomDeLaTable SET nomDeLaColo
nne1=valeur1 nomDeLaColonne2 = valeur2, … WHERE certainnesColonnes
= CertainesValeurs;
Modifier l’affichage du nom de colonne SELECT … FROM … AS nomAlias;
Recherche d'un pattern. (Retourne ici ce qui commence par ‘a’) SELECT …
FROM … WHERE … LIKE ‘ a %’;
Effacer des données DELETE FROM nomDeLaTable WHERE

4. Fonctions

Fonctions mathématiques SUM (nomDeLaColonne), MIN (nomDeLaColonne), MAX

(nomDeLaColonne),AVG(nomDeLaColonne),COUNT(nomDeLaColonne), COUNT(
*)
Fonction génératrices de dates NOW (), CURDATE (), CURRENT_DATE
(), CURTIME ()
Fonctions pour extraire de l'information à partir des dates
YEAR( une Date) , MONTH( une Date) , DAYOFMONTH( une Date), TO_DAYS ( une Date)
Fonctions de concaténation CONCAT (nomDeLaColonne1, nomDeLaColonne2, ...)
La clause HAVING Finalement, on peut faire porter des conditions sur les groupes avec la
clause HAVING.

III. CREATION D’UNE BASE DE DONNEES

EQUIPES (CodeEquipe, NomEquipe, DirecteurSportif)

COUREURS (NuméroCoureur, NomCoureur, CodeEquipe*, CodePays*)
ETAPES (NuméroEtape, VilleDépart, VilleArrivée, NbKm)
TEMPS (NuméroCoureur*, NuméroEtape*, TempsRéalisé)
PAYS (CodePays, NomPays)

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 5

Create Database tourdafrique;

Create table PAYS (CodePays char (10) NOT NULL, NomPays varchar (20) NOT NULL,
primary key (CodePays)) ;

Create table EQUIPE (CodeEquipe char (10) NOT NULL primary key, NomEquipe varchar
(20) NOT NULL, DirecteurSportif varchar (20) NOT NULL);

Create table ETAPES (NumeroEtape int auto incrément, VilleDépart varchar(20), VilleArrivée
varchar(20), Nbkm int(10), primary key(NumeroEtape)) ;

Create table COUREUR (NuméroCoureur int auto increment NOT NULL, NomCoureur
varchar(20), CodeEquipe char(10), CodePays char(10), primary key(NumeroCoureur),
Foreignkey(CodeEquipe) references EQUIPE(CodeEquipe), Foreign key
(CodePays)references PAYS(CodePays)) ;

Create table TEMPS (NuméroCoureur int, NumeroEtape int, TempsRealise TIME primary key
(NumeroCoureur,NumeroEtape),Foreignkey(NuméroCoureur),references
COUREUR(NuméroCoureur), Foreign key (NumeroEtape)references ETAPES(NumeroEtape
)) ;

EXERCICE :

Créer la base de données sur les stations dont le schéma relationnel est décrit ci-dessous
en suite chargée là avec les valeurs des tables présentes dans le support de cours sur
(ref chapitre5_L_algebre_relationnelle.pdf)

Station (nomStation, capacité,lieu, région,tarif)

Activite (nomStation, libellé, prix)
Client (id, nom,prénom,ville,région,solde)
Séjour (idClient, station, début, nbPlaces)

IV. LES REQUETES SQL

Dans toute cette partie, on va prendre l’exemple de la (petite) base de données présentée
dans le chapitre sur l’algèbre.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 6

 Station (nomStation, capacité, lieu, région, tarif)
Activite (nomStation, libellé, prix)
Client (id, nom, prénom, ville, région, solde)
Séjour (idClient, station, début, nbPlaces)

4.1 Requêtes simples SQL.

 Commençons par les requêtes les plus simples : Station et Activite. Première
requête : On souhaite extraire de la base le nom de toutes les stations se
trouvant aux Antilles.
SELECT nomStation
FROM Station
WHERE region = ’Antilles’
Ce premier exemple montre la structure de base d’une requête SQL, avec les
trois clauses SELECT, FROM et WHERE.
– FROM indique la (ou les) tables dans lesquelles on trouve les attributs utiles
à la requête. Un attribut peut être ’utile’ de deux manières (non exclusives) :
(1) on souhaite afficher son contenu, (2) on souhaite qu’il ait une valeur
particulière (Une constante ou la valeur d’un autre attribut).
– SELECT indique la liste des attributs constituant le résultat.
– WHERE indique les conditions que doivent satisfaire les n-uplets de la base
pour faire partie du résultat.

Renommage
Les noms des attributs sont par défaut ceux indiqués dans la clause SELECT, même
quand il y a des expressions complexes. Pour renommer les attributs, on utilise le mot-clé AS.
4.2 La clause WHERE.

Dans la clause WHERE, on spécifie une condition booléenne portant sur les attributs
des relations du FROM. On utilise pour cela de manière standard le AND, le OR, le NOT et
les parenthèses pour changer l’ordre de priorité des opérateurs booléens.
Par exemple :
SELECT nomStation, libelle
FROM Activite

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 7

WHERE nomStation = ’Santalba’
AND (prix > 50 AND prix < 120)
Les opérateurs de comparaison sont ceux du Pascal pour exprimer la différence (est
également possible). Pour obtenir une recherche par intervalle, on peut également utiliser le
mot-clé BETWEEN. La requête précédente est équivalente à :
SELECT nomStation, libelle
FROM Activite
WHERE nomStation = ’Santalba’
AND prix BETWEEN 50 AND 120
SQL fournit des options pour les recherches par motif (pattern matching) à l’aide de la
clause LIKE. Le caractère ’_’ désigne n’importe quel caractère, et le ’%’ n’importe quelle
chaîne de caractères. Par exemple, voici la requête cherchant toutes les stations dont le nom
termine par un ’a’.
SELECT nomStation
FROM Station
WHERE nomStation LIKE ’%a’
Quelles sont les stations dont le nom commence par un ’V’ et comprend exactement 6
caractères ?
SELECT nomStation
FROM Station
WHERE nomStation LIKE ’V’
Une autre différence avec l’algèbre est la possibilité de manipuler des dates. En fait
tous les systèmes proposaient bien avant la normalisation leur propre format de date, et la
norme préconisée par SQL2 n’est de ce fait pas suivie par tous. Une date est spécifiée en
SQL2 par le mot-clé DATE suivi d’une chaîne de caractères au format ’aaaa-mm-jj’, par
exemple DATE ’1998-01-01’. Les zéros sont nécessaires afin que le mois et le quantième
comprennent systématiquement deux chiffres. On peut effectuer des sélections sur les dates à
l’aide des comparateurs usuels. Voici par exemple la requête ’ID des clients qui ont
commencé un séjour en juillet 1998’.
SELECT idClient
FROM Sejour
WHERE debut BETWEEN DATE ’1998-07-01’ AND DATE ’1998-07-31’

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 8

 4.3 Valeurs nulles

Autre spécificité de SQL par rapport à l’algèbre : on admet que la valeur de certains
attributs soit inconnue, et on parle alors de valeur nulle, désignée par le mot-clé NULL. Il est
très important de comprendre que la ’valeur nulle’ n’est en fait pas une valeur mais une
absence de valeur, et que l’on ne peut donc lui appliquer aucune des opérations ou
comparaisons usuelles.
– Toute opération appliquée à NULL donne pour résultat NULL.
– Toute comparaison avec NULL donne un résultat qui n’est ni vrai, ni faux mais une
troisième valeur booléenne, UNKNOWN.
Les conditions exprimées dans une clause WHERE sont évaluées pour chaque tuple,
et ne sont conservés dans le résultat que les tuples pour lesquels cette évaluation donne
TRUE. La présence d’une valeur nulle dans une comparaison a donc souvent (mais pas
toujours !) le même effet que si cette comparaison échoue et renvoie FALSE.
Voici une instance de la table SEJOUR avec des informations manquantes.

La présence de NULL peut avoir des effets surprenants. Par exemple la requête suivante
SELECT station
FROM Sejour
WHERE nbPlaces <= 10 OR nbPlaces >= 10
Devrait en principe ramener toutes les stations de la table. En fait ’Santalba’ ne figurera pas
dans le résultat car nbPlaces est à NULL. Autre piège : NULL est un mot-clé, pas une
constante. Donc une comparaison comme nbPlaces = NULL est incorrecte. Le prédicat pour
tester l’absence de valeur dans une colonne est IS NULL (et son inverse IS NOT NULL). La
requête suivante sélectionne tous les séjours pour lesquels on connaît le nombre de places.
SELECT *
FROM Sejour
WHERE nbPlaces IS NOT NULL

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 9

 La présence de NULL est une source de problèmes : dans la mesure du possible il
faut l’éviter en spécifiant la contrainte NOT NULL ou en donnant une valeur par défaut.
4.4 Requêtes sur plusieurs tables.

Les requêtes SQL décrites dans cette section permettent de manipuler simultanément
plusieurs tables et d’exprimer les opérations binaires de l’algèbre relationnelle : jointure,
produit cartésien, union, intersection, différence.

4.4.1 Jointures

La jointure est une des opérations les plus utiles (et donc une des plus courantes)
puisqu’elle permet d’exprimer des requêtes portant sur des données réparties dans plusieurs
tables. La syntaxe pour exprimer des jointures avec SQL est une extension directe de celle
étudiée précédemment dans le cas des sélections simples : on donne simplement la liste des
tables concernées dans la clause FROM, et on exprime les critères de rapprochement entre ces
tables dans la clause WHERE. Prenons l’exemple de la requête suivante : donner le nom des
clients avec le nom des stations où ils ont séjourné. Le nom du client est dans la table Client,
l’information sur le lien client/station dans la table Sejour. Deux tuples de ces tables peuvent
être joints s’ils concernent le même client, ce qui peut s’exprimer à l’aide de l’identifiant du
client. On obtient la requête:
SELECT nom, station
FROM Client, Sejour
WHERE id = idClient
On peut remarquer qu’il n’y a pas dans ce cas d’ambiguïté sur les noms des attributs :
nom et id viennent de la table Client, tandis que station et idClient viennent de la table Sejour.
Il peut arriver (il arrive de fait fréquemment) qu’un même nom d’attribut soit partagé par
plusieurs tables impliquées dans une jointure. Dans ce cas on résout l’ambigüité en préfixant
l’attribut par le nom de la table. Exemple : afficher le nom d’une station, son tarif
hebdomadaire, ses activités et leurs prix.
SELECT nomStation, tarif, libelle, prix
FROM Station, Activite
WHERE Station.nomStation = Activite.nomStation
Comme il peut être fastidieux de répéter intégralement le nom d’une table, on peut
lui associer un synonyme et utiliser ce synonyme en tant que préfixe. La requête précédente

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 10

devient par exemple : 2
SELECT S.nomStation, tarif, libelle, prix
FROM Station S, Activite A
WHERE S.nomStation = A.nomStation

4.4.2 Union, intersection et différence.

L’expression de ces trois opérations ensemblistes en SQL est très proche de l’algèbre
relationnelle. On construit deux requêtes dont les résultats ont même arité (même nombre de
colonnes et mêmes types d’attributs), et on les relie par un des mots-clés UNION, INTERSECT
ou EXCEPT.

Trois exemples suffiront pour illustrer ces opérations.

1. Donnez tous les noms de région dans la base.
SELECT region FROM Station
UNION
SELECT region FROM Client
2. Donnez les régions où l’on trouve à la fois des clients et des stations.
SELECT region FROM Station
INTERSECT
SELECT region FROM Client
3. Quelles sont les régions où l’on trouve des stations mais pas des clients ?
SELECT region FROM Station
EXCEPT
SELECT region FROM Client

4.3 Requêtes imbriquées.

Jusqu’à présent les conditions exprimées dans le WHERE consistaient en

comparaisons de valeurs scalaires. Il est possible également avec SQL d’exprimer des
conditions sur des relations. Pour l’essentiel, ces conditions consistent en l’existence d’au moins
un tuple dans la relation testée, ou en l’appartenance d’un tuple particulier à la relation. La
relation testée est construite par une requête SELECT. FROM. WHERE que l’on appelle sous-
requête ou requête imbriquée puisqu’elle apparaît dans la clause WHERE

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 11

Conditions portant sur des relations.

Une première utilisation des sous-requêtes est d’offrir une alternative syntaxique à
l’expression de jointures. Les jointures concernées sont celles pour lesquelles le résultat est
constitué avec des attributs provenant d’une seule des deux tables, l’autre ne servant que pour
exprimer des conditions. Prenons l’exemple suivant : on veut les noms des stations où ont
séjourné des clients parisiens. On peut obtenir le résultat avec une jointure classique.
SELECT station
FROM Sejour, Client
WHERE id = idClient
AND ville = ’Paris’
Ici, le résultat, station, provient de la table SEJOUR. D’où l’idée de séparer la requête
en deux
parties : (1) on constitue avec une sous-requête les ids des clients parisiens, puis (2) on utilise
ce résultat dans la requête principale.
SELECT station
FROM Sejour
WHERE idClient IN (SELECT id FROM Client
WHERE ville = ’Paris’)
Le mot-clé IN exprime clairement la condition d’appartenance de idClient à la relation
formée par la requête imbriquée. On peut remplacer le IN par un simple ’=’ si on est sûr que
la sous-requête ramène un et un seul tuple. Par exemple :
SELECT nom, prenom
FROM Client
WHERE region = (SELECT region FROM Station
WHERE nomStation = ’Santalba’)
est (partiellement) correct car la recherche dans la sous-requête s’effectue par la clé. En
revanche il se peut qu’aucun tuple ne soit ramené, ce qui génère une erreur.
Voici quelques exemples
- Où (station, lieu) ne peut-on pas faire du ski ?
SELECT nomStation, lieu
FROM Station
WHERE nomStation NOT IN (SELECT nomStation FROM Activite

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 12

WHERE libelle = ’Ski’)
- Quelle station pratique le tarif le plus élevé ?
SELECT nomStation
FROM Station
WHERE tarif >= ALL (SELECT tarif FROM Station)
- Dans quelle station pratique-t-on une activité au même prix qu’à Santalba ?
SELECT nomStation, libelle
FROM Activite
WHERE prix IN (SELECT prix FROM Activite
WHERE nomStation = ’Santalba’)

4.5 Agrégration.

Toutes les requêtes vues jusqu’à présent pouvaient être interprétées comme une suite
d’opérations effectuées tuple à tuple. De même le résultat était toujours constitué de valeurs
issues de tuples individuels. Les fonctionnalités d’agrégation de SQL permettent d’exprimer
des conditions sur des groupes de tuples, et de constituer le résultat par agrégation de valeurs
au sein de chaque groupe. La syntaxe SQL fournit donc :
1. Le moyen de partitionner une relation en groupes selon certains critères.
2. Le moyen d’exprimer des conditions sur ces groupes.
3. Des fonctions d’agrégation.
Il existe un groupe par défaut : c’est la relation toute entière. Sans même définir de
groupe, on peut utiliser les fonctions d’agrégation.

4.5.1 Fonctions d’agrégation.

Ces fonctions s’appliquent à une colonne, en général de type numérique. Ce sont :

1. COUNT qui compte le nombre de valeurs non nulles.
2. MAX et MIN.
3. AVG qui calcule la moyenne des valeurs de la colonne.
Exemple d’utilisation de ces fonctions :
SELECT COUNT(nomStation), AVG(tarif), MIN(tarif), MAX(tarif)
FROM Station

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 13

Remarque importante : on ne peut pas utiliser simultanément dans la clause SELECT des
fonctions d’agrégation et des noms d’attributs (sauf dans le cas d’un GROUP BY, voir plus
loin). La requête suivante est incorrecte (pourquoi ?).
SELECT nomStation, AVG (tarif)
FROM Station
A condition de respecter cette règle, on peut utiliser les ordres SQL les plus complexes.
Exemple : Combien de places a réservé Mr Kerouac pour l’ensemble des séjours ?
SELECT SUM (nbPlaces)
FROM Client, Sejour
WHERE nom = ’Kerouac’
AND id = idClient

4 .5.2La clause GROUP BY.

Dans les requêtes précédentes, on appliquait la fonction d’agrégation à l’ensemble du

résultat d’une requête (donc éventuellement à l’ensemble de la table elle-même). Une
fonctionnalité complémentaire consiste à partitionner ce résultat en groupes, et à appliquer la
ou les fonction(s)à chaque groupe. On construit les groupes en associant les tuples partageant
la même valeur pour une ou plusieurs colonnes. Exemple : afficher les régions avec le nombre
de stations.
SELECT region, COUNT (nomStation)
FROM Station
GROUP BY region
Donc ici on constitue un groupe pour chaque région. Puis on affiche ce groupe sous la
forme d’un tuple, dans lequel les attributs peuvent être de deux types:
1. les attributs dont la valeur est constante pour l’ensemble du groupe, soit précisément les
attributs du GROUP BY. Exemple ici l’attribut region ;
2. Le résultat d’une fonction d’agrégation appliquée au groupe : ici COUNT (nomStation).
Bien entendu il est possible d’exprimer des ordres SQL complexes et d’appliquer un GROUP
BY au résultat. De plus, il n’est pas nécessaire de faire figurer tous les attributs du GROUP
BY dans la clause
SELECT.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 14

Exemple : on souhaite consulter le nombre de places reservées, par client.
SELECT nom, SUM (nbPlaces)
FROM Client, Sejour
WHERE id = idClient
GROUP BY id, nom
L’interprétation est simple : (1) on exécute d’abord la requête SELECT . FROM.
WHERE, puis (2) on prend le résultat et on le partitione, enfin (3) on calcule le résultat des
fonctions.
A l’issue de l’étape (2), on peut imaginer une relation qui n’est pas en première forme
normale : on y trouverait des tuples avec les attributs du GROUP BY sous forme de valeur
atomique, puis des attributs de type ensemble (donc interdits dans le modèle relationnel).
C’est pour se ramener en 1FN que l’on doit appliquer des fonctions d’agrégation à ces
ensembles.

Exercice : pourquoi grouper sur id, nom ? Quels sont les autres choix possibles et leurs
inconvénients ?

4.5.3. La clause HAVING

Finalement, on peut faire porter des conditions sur les groupes avec la clause
HAVING. La clause WHERE ne peut exprimer des conditions que sur les tuples pris un à un.
Exemple : on souhaite consulter le nombre de places réservées, par client, pour les clients
ayant réservé
plus de 10 places.
SELECT nom, SUM (nbPlaces)
FROM Client, Sejour
WHERE id = idClient
GROUP BY nom
HAVING SUM(nbPlaces) >= 10
On voit que la condition porte ici sur une propriété de l’ensemble des tuples du groupe,
et pas de chaque tuple pris individuellement. La clause HAVING est donc toujours exprimée
sur le résultat de fonctions d’agrégation.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 15

 4.6 Mises-à-jour

Les commandes de mise-à-jour (insertion, destruction, modification) sont

considérablement plus simples que les requêtes.

4.6.1 Insertion

L’insertion s’effectue avec la commande INSERT dont la syntaxe est la suivante :

INSERT INTO R (A1, A2, ... An) VALUES (v1, v2, ... vn)
R est le nom d’une relation, et les A1, ... An sont les noms des attributs dans lesquels on
souhaite placer une valeur. Les autres attributs seront donc à NULL (ou à la valeur par
défaut). Tous les attributs spécifiés NOT NULL (et sans valeur par défaut) doivent donc
figurer dans une clause INSERT. Les v1, ... vn sont les valeurs des attributs.

Exemple de l’insertion d’un tuple dans la table Client. INSERT INTO Client (id, nom,
prenom)
VALUES (40, ’Moriarty’, ’Dean’)
Donc, à l’issue de cette insertion, les attributs ville et region seront à NULL. Il est
également possible d’insérer dans une table le résultat d’une requête. Dans ce cas la partie
VALUES ... est remplacée par la requête elle-même. Exemple : on a créé une table Sites (lieu,
region) et on souhaite y copier les couples (lieu, region) déjà existant dans la table Station.
INSERT INTO Sites (lieu, region)
SELECT lieu, region FROM Station
Bien entendu le nombre d’attributs et le type de ces derniers doivent être cohérents.

4.6.2 Destruction

R est bien entendu la table, et condition est toute condition valide pour une clause
WHERE. En d’autres termes, si on effectue, avant la destruction, la requête
SELECT * FROM R
WHERE condition
on obtient l’ensemble des lignes qui seront détruites par DELETE. Procéder de cette
manière est un des moyens de s’assurer que l’on va bien détruire ce que l’on souhaite.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 16

Exemple : destruction de tous les clients dont le nom commence par ’M’.
DELETE FROM Client
WHERE nom LIKE ’M%’

4.6.3 Modification.

La modification s’effectue avec la clause UPDATE. La syntaxe est proche de celle du

DELETE:
UPDATE R SET A1=v1, A2=v2, ... An=vn
WHERE condition
R est la relation, les Ai sont les attributs, les vi les nouvelles valeurs et condition est toute
condition valide pour la clause WHERE.

Exemple: augmenter le prix des activités de la station Passac de 10%.

UPDATE Activite
SET prix = prix * 1.1
WHERE nomStation = ’Passac’
Une remarque importante : toutes les mises-à-jour ne deviennent définitives qu’à
l’issue d’une validation par commit. Entre temps elles peuvent être annulées par rollback.
Voir le cours sur la concurrence d’accès.

COURS DE NDJOBOT ENGO DANY CLAUDE 2020-2021 17