Support de Cours Langage de Gestion SQL. G3 Info

UNIKIN/FAC DES SCIENCES/G3 INFO
CHAP I : NOTIONS PRELIMINAIRES
Il est impératif, pour quiconque se veut manipuler le langage SQL, de connaitre

et de comprendre les notions qui s’avèrent capitales pour ôter toute confusion ou
mauvaise appréciation.
1.1 QUELQUES DEFINITIONS
a. Entité (Table)
C’est l’ensemble d'éléments informatif relatif à un même concept dans un
modèle. Cet ensemble correspond généralement à une table dans l'univers des bases de
données.
Exemple : Entité Etudiant
b. Attribut
C’est la propriété d'une entité dans un modèle correspondant généralement à
une colonne dans une table de la base.
Exemple : Date de Naissance, Nom,… pour l’entité Etudiant
c. Colonne
C’est l’élément vertical dans une table représentant un ensemble de valeurs
d'un attribut.
Exemple : Les différentes dates de naissance des étudiants
d. Ligne
C’est l’élément horizontal dans une table représentant une énumération des
valeurs des différents attributs (colonne) pour une même référence (identifiant).
Exemple : Les différentes informations renseignées comprenant le nom, le postnom, la

date de naissance,… pour l’entité ETUDIANT concernant un individu.
e. Clef (Clé ou Clef primaire)

C’est l’identifiant d'une table composée d'un ou de plusieurs attributs ou
colonnes. Possédant des valeurs uniques, une clef permet de retrouver sans ambiguïté la
ligne dans une table.
Exemple : Le Numéro matricule d’un étudiant
f. Clef étrangère
C’est la colonne, ou groupe de colonnes représentant une clef d'une table,
insérée dans une autre table afin d'assurer la relation entre les deux tables.
Exemple : L’attribut Produit_id peut être considéré comme clé étrangère pour l’entité
Commande qui, à son tour, possède l’attribut Numéro_commande comme
clé primaire.
1
Langage de Gestion : Le Langage SQL
g. Relation
C’est le lien logique entre deux entités, représentées dans l'univers des SGBDR
par l'insertion d'une clef étrangère.
h. Contrainte et intégrité référentielle

C’est le mécanisme assurant la cohérence et la dépendance de données entre
les différentes tables. Ainsi un contrôle de validité des données interdira l'insertion de
données violant les différentes contraintes établies.
Exemple : On ne peut commander un produit qui existe dans l’entrepôt
i. Violation (de contrainte, de clef)

C’est l’erreur générée lorsque l'on tente d'insérer une ligne avec une valeur de
clef déjà utilisée (violation de clef), ou pour des valeurs de colonne hors des contraintes
définies (violation de contrainte).
j. Transaction
C’est le mécanisme permettant de cumuler différentes instructions qui seront
vues comme une tâche unique, dont l'enchaînement est structuré, et pour laquelle chaque
instruction est indissociable.
k. Clause
C’est la partie d'un ordre SQL précisant un fonctionnement particulier. La clause
ORDER BY, par exemple, est la dernière clause de tout ordre SQL et ne doit figurer qu'une
seule fois dans le SELECT, même s'il existe des requêtes imbriquées ou des requêtes
ensemblistes.
l. Prédicat
C’est la construction logique dont la valeur peut être évaluée à vrai ou faux.
m. SQL
Structured Query Language, en sigle, SQL signifie en français langage de
requête structurée, un langage informatique normalisé servant à exploiter des bases de
données relationnelles.
n. Microsoft SQL Server

C’est le système de gestion de base de données relationnelle SGBDR développé
et commercialisé par la société Microsoft.
2
1.2 LES REGLES DE NOMENCLATURE D’UN IDENTIFICATEUR
Dans Microsoft SQL Server, par exemple, tous les éléments (serveurs, bases de
données, tables, vues, colonnes, procédures, contraintes, etc,…) peuvent avoir un
identificateur. L'identificateur d'un objet est donc créé lors de la définition de l'objet et est
ensuite utilisé pour référencer l'objet. Il existe deux classes d'identificateurs :
 Identificateurs réguliers
Les identificateurs réguliers sont ceux qui respectent les règles relatives au
format des identificateurs.
Exemple: TableX
 Identificateurs délimités
Les identificateurs délimités sont mis entre guillemets (") ou entre crochets ([ ])
et sont utilisés pour ceux qui ne respectent pas les règles de nomenclature.
SELECT *
FROM [My Table]
WHERE [order] = 10
Règles pour les identificateurs réguliers

Les noms des objets doivent toujours respecter les règles suivantes :
1. L'identificateur ne doit pas être un mot réservé de SQL ;
2. Qu'ils soient réguliers ou délimités, les identificateurs doivent contenir de 1 à
128 caractères ;
3. Le premier caractère doit être l'un des caractères suivants :
o Les caractères latins de a à z et de A à Z ainsi que des caractères
alphabétiques d'autres langues.
o Les symboles trait de soulignement (_), arobase (@) ou dièse (#) ;
4. Le nom d’un objet peut contenir les caractères suivants :

o Des chiffres.
o L'arobase, le symbole dollar ($), le symbole dièse ou le trait de
soulignement.
5. Les espaces incorporés ou les caractères spéciaux ne sont pas autorisés.
Ainsi, les noms des objets d'un modèle ou d'un schéma devront être significatifs
et pertinents. Ils devront être constitué uniquement des caractères suivants :[a .. z] + [A
.. Z] + [0 .. 9] +[ _ ] avec les annotations suivantes suivant le SGBD:
 Ne pas dépasser 128 caractères
 Ne pas commencer par un chiffre
 Ne peut avoir plusieurs caractères "blanc souligné" de suite
 La casse n'a pas d'importance
 Le nom ne doit pas être un mot réservé de SQL
3
NOTA: Les caractères de ponctuation (, ; : ! ? ...) et autres caractères spéciaux, comme le

blanc, sont proscrits dans la nomenclature d’un objet ; certaines versions SQL
acceptent les caractères accentués (é à ù ï É ...), les "kanas" (ç œ ...).
Exemples :
Objet Commentaire
_ETUDIANT Autorisé
123Client Interdit
Nom__Clent Interdit
_etudiant Autorisé (mais identique au premier)
NB : Liste de mots réservés de SQL, voir Annexe
1.3 ORDRE DE CREATION DE COLONNES
L'ordre de création et de description des colonnes devra répondre aux règles

suivantes pour une bonne visibilité :
 Les colonnes les plus significatives et les plus utilisées seront situées en tête de la
description ;
 Les colonnes composant la clef primaire de la table devront être les premières
colonnes décrites de la table ;
 Les colonnes composant les clefs étrangères devront être les suivantes ;
 Les colonnes doivent être regroupées lorsqu'ils font partie d'un sous-ensemble
significatif de la table.
1.4 DOCUMENTATION, ERGONOMIE, ET ECRITURE
Les règles ci-dessous établissent la manière dont les requêtes doivent s’écrire
ainsi que le code afférent aux objets d'une base de données.
 Les commandes ou requêtes sont séparées par des points-virgules ;

 Les séparateurs (fin de lignes, espaces et tabulations) ne servent qu’à rendre la
commande plus visible et plus lisible ;
 Chaque clause de requête devra être indentée :
Exemple :
SELECT CLI_ID, CLI_NOM, CLI_ENSEIGNE, CLI_PRENOM
FROM T_CLIENT
WHERE CLI_ADR_PAYS = 'F' AND CLI_ENSEIGNE IS NULL OR CLI_ENSEIGNE =''
ORDER BY CLI_NOM;
Contre-exemple:
SELECT CLI_ID, CLI_NOM, CLI_ENSEIGNE,
CLI_PRENOM FROM T_CLIENT WHERE CLI_ADR_PAYS = 'F'
AND CLI_ENSEIGNE IS NULL OR CLI_ENSEIGNE =''ORDER BY CLI_NOM
4
 Toutes les colonnes renvoyées devront être nommées :

Exemple:
SELECT PRODUCT_ID, PTTC, PTTC*1.26 AS PHT
FROM PRODUIT
 Les noms des colonnes renvoyées ne doivent pas comporter de doublons (en
particulier l'usage de l'étoile dans la clause SELECT est à utiliser avec délicatesse) :
Exemple :
SELECT CLI.CLI_ID, CLI.CLI_NOM, CLI.CLI_PRENOM, FAC.FAC_ID, FAC.FAC_DATE,
FAC.FAC_PROD
FROM T_CLIENT_CLI CLI
INNER JOIN T_FACTURE_FAC FAC ON CLI.CLI_ID = FAC.CLI_ID
Contre-exemple :
SELECT *
FROM T_CLIENT_CLI CLI
INNER JOIN T_FACTURE_FAC FAC
ON CLI.CLI_ID = FAC.CLI_ID
1.5 COMMENTAIRES EN SQL
Les commentaires sont importants pour mieux se retrouver lorsqu’on traite des
requêtes complexes. On procède de plusieurs façons pour commenter les requêtes SQL,
bien sûr en tenant compte notamment du Système de Gestion de Base de Données
(SGBD) utilisé et de sa version.
a. Commentaire double tiret : –-

Le double tiret permet de faire un commentaire juste à la fin de la ligne.
Certains SGBD, comme MySQL, acceptent le caractère # pour ce faire.
Exemple :
SELECT Product_name --- sélectionner le nom du produit
FROM produit ----- dans la table "produit"
b. Commentaire multi-ligne : /* et */
Le commentaire multi-ligne à l’avantage de pouvoir indiquer où commence et
où se termine le commentaire. Il est donc possible de l’utiliser en plein milieu d’une
requête SQL sans problème.
Exemple :
SELECT product_name /* tout sélectionner */
FROM produit /* dans la table "produit" */
WHERE PU = /* exemple en milieu de la requête
sur plusieurs lignes */ 50000
5
1.6 TYPE DE DONNEES
A chaque colonne, variable locale, expression et paramètre correspond un type

de données qui est à son tour un attribut spécifiant le type de données que l'objet peut
contenir. Ainsi nous résumons ci-dessous quelques types de données acceptées sous SQL.
Character (ou Char) :

Ce type de données permet de stocker des chaînes de caractères de longueur
fixe
Character Varying (ou Varchar ou char varying) :

Ce type de données permet de stocker les valeurs alphanumériques de
longueur maximale fixée. On doit spécifier la longueur de la chaîne.
Exemple :
NOM_CLIENT CHAR(32)
OBSERVATIONS VARCHAR2(1500)
Numeric (ou Decimal ou dec) :

Ce type de données permet de stocker des données numériques à la fois
entières et réelles avec une précision de 1000 chiffres significatifs.
Number :
Ce type de données permet de stocker les entiers ainsi que les réels, sans
précision aucune
Integer (ou Int):

Ce type de données permet de stocker les entiers longs signés
Smalling :
Ce type de données permet de stocker les entiers courts
Float :
Ce type de données permet de stocker les valeurs réelles à virgule flottante,
échelle et précision obligatoire
Real :
Ce type de données permet de stocker les valeurs réelles à virgule flottante de
faible précision
Date :
Ce type de données permet de stocker des données constituées de dates
Time :
Ce type de données permet de stocker les données constituées de l’heure sur
24 heures
6
Timestamp :
Ce type de données permet de stocker les données constituées d’une date et
d’une heure
NB : Pour le type date, le standard ISO adopté pour le SQL repose sur le format AAAA-
MM-JJ. Il est ainsi valable jusqu'en l'an 9999 ou AAAA est l'année sur 4 chiffres, MM
le mois sur deux chiffres, et JJ le jour.
Exemple : 2015-07-08 correspond au 8 Juillet 2015.
Boolean:
Ce type de données permet de stocker des valeurs booléennes
Money :
Ce type de données permet de stocker des valeurs monétaires avec une échelle
maximale et une précision de deux chiffres après la virgule.
Text :
Ce type de données permet de stocker des chaînes de caractères de longueur
variable
7
CHAP II : LES SUBDIVISIONS DU LANGAGE SQL
Le langage SQL comporte quatre grandes parties qui permettent :
 La définition des éléments d'une base de données : Langage de définition de

données ou Data Definition Language (LDD ou DDL) ;
 La manipulation des données : langage de manipulation de données ou Data

Manipulation Language (LMD ou DML) ;
 La gestion des droits d'accès aux données : Langage de contrôle de données ou

Data Control Language (LCD ou DCL) ;
 La gestion des transactions : Langage de contrôle de transactions ou Transaction

Control Language (LCT ou TCL).
2.1 LE LANGAGE DE DEFINITION DE DONNEES
Grâce aux commandes de base : CREATE, ALTER, DROP ; le Langage de

Définition de Données permet de créer les bases de données, des tables, des index, des
contraintes ou encore modifier, supprimer un élément de la base.
2.1.1 LA COMMANDE CREATE

La commande CREATE permet de créer la base de données, les tables, les
vues, les domaines, etc…
a. CREATION DE LA BASE DE DONNEES

Bien que les systèmes de Gestion de Base de Données soient souvent utilisés
pour créer une base, il convient de noter que la création d’une base de données en SQL
est possible en ligne de commande.
Syntaxe : CREATE DATABASE nom_de_la_base ;
Exemple : CREATE DATABASE GESTION_ETUDIANT ;
b. CREATION DES TABLES

La création d’une table sert à définir les colonnes, le type de données pour
chaque colonne, les contraintes pour les différentes colonnes si c’est pertinent. Ainsi, de
manière générale, la syntaxe de création d’une table se présente de la manière ci-
dessous :
CREATE TABLE nom_table
(Colonne1 type_données|contrainte_de_la_colonne,
Colonne2 type_données|contrainte_de_la_colonne,
Colonne3 type_données|contrainte_de_la_colonne,…) ;
Pour chaque colonne, il sera question de préciser :
- Le nom de la colonne ;
- Le type de données ;
- Les contraintes liées à la colonne.
8
Exemple : CREATE TABLE T_ETUDIANT

(ET_NOM CHAR (32),
ET_PRENOM VARCHAR(32)) ;
B.1 LES CONTRAINTES AU SEIN D’UNE TABLE

Les différentes contraintes sont soit verticales (portant sur une seule colonne)
soit horizontales (contrainte sur plusieurs colonnes). Une colonne peut recevoir les
contraintes suivantes :
b.1.1 NULL / NOT NULL

La contrainte NULL/NOT NULL précise si une valeur doit obligatoirement être
renseignée dans la colonne ou pas. Autrement dit, en cas de NOT NULL, la colonne devra
toujours être renseignée lors des ordres d’insertion INSERT et de modification UPDATE.
Exemple
CREATE TABLE T_PERSONNE1
(PRS_ID INTEGER NOT NULL
PRS_NOM VARCHAR(32) NOT NULL,
PRS_PRENOM VARCHAR(32) NULL,
PRS_DATE_NAISSANCE DATE)
Exemple : --insertion et modification acceptées :

INSERT INTO T_PERSONNE1 VALUES (1, 'MBO', NULL, NULL)
INSERT INTO T_PERSONNE1 (PRS_ID, PRS_NOM) VALUES (2, 'MPIA')
Exemple : -- insertion et modification refusées :

INSERT INTO T_PERSONNE1 VALUES (3, NULL, 'Marcel', NULL)
b.1.2 DEFAULT
La contrainte DEFAULT permet de préciser une valeur qui sera insérée par
défaut en l'absence de précision d'une valeur explicite dans un ordre d'insertion. Seule une
valeur explicite, un marqueur NULL ou la valeur retournée par les fonctions suivantes sont
acceptées : CURRENT_DATE, CURRENT_TIME[(p)], CURRENT_TIMESTAMP[(p)],
LOCALTIME[(p)], LOCALTIMESTAMP[(p)], USER, CURRENT_USER, SESSION_USER,
SYSTEM_USER.
Exemple
(PRS_ID INTEGER,
PRS_NOM VARCHAR(32),
PRS_PRENOM VARCHAR(32),
PRS_SEXE CHAR(1) DEFAULT 'M',
PRS_DATE_NAISSANCE DATE DEFAULT CURRENT_DATE)
Nota : Il n'est pas possible de préciser une valeur par défaut qui soit le résultat d'une
expression de requête.
9
Exemple
(PRS_ID INTEGER DEFAULT (SELECT MAX(PRS_ID) + 1
FROM T_PERSONNE3),
PRS_PRENOM VARCHAR(32)) ;
b.1.3 PRIMARY KEY

Cette contrainte précise que la colonne est la clef de la table. La contrainte
PRIMARY KEY peut être posée sur une colonne (contrainte verticale) ou sur plusieurs
colonnes en contrainte de ligne (horizontale).
Exemple
(PRS_ID INTEGER NOT NULL PRIMARY KEY,
Ou
(PRS_ID INTEGER PRIMARY KEY NOT NULL,
Dans le cas de plusieurs colonnes constituant la clef, la syntaxe est :
CONSTRAINT nom_contrainte PRIMARY KEY (liste_colonne)
Exemple
--- clef primaire sur PRS_NOM et PRS_PRENOM
(PRS_NOM VARCHAR(32) NOT NULL,
PRS_PRENOM VARCHAR(32) NOT NULL,
PRS_TELEPHONE CHAR(14),
CONSTRAINT PK_PRS PRIMARY KEY (PRS_NOM, PRS_PRENOM)) ;
b.1.4 UNIQUE
La contrainte d'unicité exige que toutes les valeurs explicites contenues dans la
colonne soient uniques au sein de la table à l'exception du marqueur NULL car la colonne
peut ne pas être renseignée.
Exemple
(PRS_NOM VARCHAR(32),
PRS_PRENOM VARCHAR(32),
PRS_TELEPHONE CHAR(14) UNIQUE) ;
10
INSERT INTO T_PERSONNE7 VALUES ('Konde', 'Eric', '08989891000') ;

INSERT INTO T_PERSONNE7 VALUES ('Amani', 'Thierry', NULL) ;
INSERT INTO T_PERSONNE7 VALUES ('Zulu', 'Papy', '08989891001') ;
INSERT INTO T_PERSONNE7 (PRS_NOM) VALUES ('Kalala') ;
INSERT INTO T_PERSONNE7 VALUES ('Mukendi', 'Alfred', '08989891000') ;
Dans cet exemple Mukendi n'a pas été inséré car son numéro de téléphone est identique à
Durand.
b.1.5 CHECK
La contrainte CHECK permet de définir un prédicat complexe, basé sur une
comparaison pouvant contenir une requête de type SELECT. Pour valider la contrainte, le
prédicat doit être évalué à TRUE ou UNKNOWN (présence de NULL).
Exemple
(PRS_ID INTEGER CHECK (VALUE > 0),
PRS_NOM VARCHAR(32) CHECK (CHARACTER_LENGTH(VALUE) > 2),
PRS_PRENOM VARCHAR(32) CHECK (COALESCE(SUBSTRING(VALUE, 1, 1), 'X')
BETWEEN 'A' AND 'Z'),
PRS_SEXE CHAR(1) CHECK (VALUE IN ('M', 'F')),
PRS_TELEPHONE CHAR(14) CHECK (VALUE >0);
Sous Oracle
(PRS_ID INTEGER CHECK (PRS_ID > 0),
PRS_NOM VARCHAR(32) CHECK (LENGTH(PRS_NOM) > 2),
PRS_PRENOM VARCHAR(32) CHECK (COALESCE(SUBSTR(PRS_PRENOM, 1, 1), 'X')
BETWEEN 'A' AND 'Z'),
PRS_SEXE CHAR(1) CHECK (PRS_SEXE IN ('M', 'F')),
PRS_TELEPHONE CHAR(14) CHECK (PRS_TELEPHONE >0));
Les contraintes définies ci-dessus indiquent:

- La colonne PRS_ID ne peut avoir de valeurs inférieures à 0 ;
- La colonne PRS_NOM doit avoir des valeurs contenant au moins 2 caractères ;
- Le premier caractère de la colonne PRS_PRENOM, si elle est renseignée, doit être
compris entre A et Z ;
- La colonne PRS_SEXE peut avoir exclusivement les valeurs M ou F;
- La colonne PRS_TELEPHONE ne peut avoir de valeurs inférieures à 0.
En cas de contrôle de validation multi-colonnes au sein de la table, la syntaxe

devient :
CONSTRAINT nom_contrainte CHECK (prédicat)
11
Exemple
CREATE TABLE T_COMPTE
(CPT_ID INTEGER,
CPT_DATE DATE,
CPT_CREDIT DECIMAL (16,2),
CPT_DEBIT DECIMAL (16,2),
CLI_ID INTEGER,
CONSTRAINT CHK_OPERATION CHECK((CPT_CREDIT >= 0 AND CPT_DEBIT IS NOT
NULL) OR (CPT_DEBIT >= 0 AND CPT_CREDIT IS NOT NULL)))
Toute tentative d'insérer une ligne avec des valeurs non renseignées pour les colonnes
debit et credit, ou bien avec des valeurs négative se soldera par un refus.
b.1.6 FOREIGN KEY :

La contrainte de type FOREIGN KEY permet de mettre en place une intégrité
référentielle entre une (ou plusieurs) colonnes d'une table et la (les) colonne(s)
composant la clef d'une autre table afin d'assurer les relations existantes et joindre les
tables dans le requête selon le modèle relationnel que l'on a défini.
Exemple
CREATE TABLE T_FACTURE1
(FTC_ID INTEGER,
PRS_ID INTEGER FOREIGN KEY REFERENCES T_PERSONNE5 (PRS_ID),
FCT_DATE DATE,
FCT_MONTANT DECIMAL(16,2)) ;
Sous Oracle
CREATE TABLE T_FACTURE1

(FTC_ID INTEGER,
PRS_ID INTEGER REFERENCES T_PERSONNE5 (PRS_ID),
FCT_DATE DATE,
FCT_MONTANT DECIMAL(16,2)) ;
La table T_FACTURE1 est liée à la table T_PERSONNE5 et ce lien se fait entre la clef
étrangère PRS_ID de la table T_FACTURE1. Cette même colonne, PRS_ID, est aussi
renseignée comme clef de la table T_PERSONNE5. Toute tentative d'insertion d'une
facture dont la référence de client est inexistante se soldera par un échec. De même toute
tentative de supprimer un client pour lequel les données d'une ou de plusieurs factures
sont présente se soldera par un arrêt sans effet de l'ordre SQL.
REMARQUE : Les noms des colonnes de jointure, lorsqu’ils sont identiques facilitent,
comme nous le verrons plus tard, le NATURAL JOIN ; mais cette règle de
nomenclature n’est pas obligatoire.
NB : Toutes les contraintes vues ici être placées dans plusieurs colonnes, à l'exception de
la contrainte de clef PRIMARY KEY qui ne peut être placée que sur une seule
colonne.
12
Exemple
CREATE DOMAIN D_NUM_ID INTEGER
CONSTRAINT C_CLEF CHECK (VALUE > 0);
CREATE DOMAIN D_ALFA_FIX_32 CHAR(32);
CREATE DOMAIN D_ALFA_VAR_32 VARCHAR(32);
CREATE TABLE T_CLIENT

(CLI_ID D_NUM_ID NOT NULL PRIMARY KEY,
CLI_NOM D_ALFA_FIX_32 NOT NULL,
CLI_PRENOM D_ALFA_VAR_32);
Une table de clients similaire à l'exemple précédente à base de domaines mais la clef ne
peut être négative.
Exemple
CREATE TABLE T_CLIENT
(CLI_ID INTEGER NOT NULL PRIMARY KEY,
CLI_NOM CHAR(32) NOT NULL CHECK (SUBSTRING(VALUE, 1, 1) <> ' ' AND
UPPER(VALUE) = VALUE),
CLI_PRENOM VARCHAR(32) REFERENCES TR_PRENOM (PRN_PRENOM)) ;
Une table de clients dont le nom ne peut commencer par un blanc, doit être en majuscule
et dont le prénom doit figurer dans la table de référence TR_PRENOM à la colonne
PRN_PRENOM.
Exemple
CREATE TABLE T_VOITURE
(VTR_ID INTEGER NOT NULL PRIMARY KEY,
VTR_MARQUE CHAR(32) NOT NULL,
VTR_MODELE VARCHAR(16),
VTR_IMMATRICULATION CHAR(10) NOT NULL UNIQUE,
VTR_COULEUR CHAR(16) CHECK (VALUE IN ('BLANC', 'NOIR', 'ROUGE', 'VERT',
'BLEU')))
Une table de voiture avec immatriculation unique et couleur limitée à 'BLANC', 'NOIR',
'ROUGE', 'VERT', 'BLEU'.
b.2 MODE GESTION DE L’INTEGRITE

Pour la gestion des employés par exemple, nous considérons les tables créées
de la manière ci-dessous :
CREATE TABLE categorie (
id INT NOT NULL AUTO_INCREMENT,
libelle VARCHAR(30) NOT NULL,
PRIMARY KEY(id));
13
CREATE TABLE souscategorie (

Idcategorie INT NOT NULL,
id INT NOT NULL,
PRIMARY KEY(idcategorie, id),
CONSTRAINT FK_SOUSCATEGORIE FOREIGN KEY (idcategorie)
REFERENCES categorie (id));
CREATE TABLE employe (

idsouscategorie INT DEFAULT NULL,
nom VARCHAR(40) NOT NULL,
PRIMARY KEY(id),
CONSTRAINT FK_EMPLOYE FOREIGN KEY (idsouscategorie)
REFERENCES souscategorie (id));
La logique de traitement est la suivante : On peut ajouter des catégories, des

sous-catégories à une catégorie existante ; On peut créer un employé et l’affecter à une
sous-catégorie. Dans le même ordre d’idée, on peut supprimer un employé, une sous-
catégorie si aucun employé ne lui est affecté, et une catégorie si elle ne possède pas de
sous-catégorie. Ainsi, la fonctionnalité de suppression d’une catégorie supprimera toutes
les sous-catégories avant de supprimer la catégorie.
L’intégrité référentielle, utile pour la cohérence des données, peut être gérée en
plusieurs modes à savoir :
b.2.1 ON DELETE NO ACTION / ON UPDATE NO ACTION

Aucun traitement particulier n'est entrepris en cas de mise à jour ou
suppression d'informations référencées. Autrement dit, il y a blocage du traitement car le
lien d'intégrité ne doit pas être brisé.
b.2.2 ON DELETE CASCADE / ON UPDATE CASCADE

En cas de suppression ou modification d'un élément, les éléments qui le
référencent sont aux aussi supprimés ou modifiés afin de maintenir l’intégrité.
Contrairement à l’employé, une sous-catégorie n’a aucun sens à elle toute

seule. Ce coup-ci, il faudra utiliser la clause ON DELETE CASCADE. Ainsi, pour la
suppression d’une catégorie, la base supprimera toutes les sous-catégories s’y référant. Le
code pour créer la table souscategorie devient :
CREATE TABLE souscategorie (

idcategorie INT NOT NULL,
id INT NOT NULL,
PRIMARY KEY(idcategorie, id),
CONSTRAINT FK_SOUSCATEGORIE FOREIGN KEY (idcategorie)
REFERENCES categorie (id)
ON DELETE CASCADE);
14
b.2.3 ON DELETE SET NULL / ON UPDATE SET NULL

En cas de suppression ou modification d'un élément, les éléments qui le
référencent voient leur clef étrangère posséder le marqueur NULL. Le lien d'intégrité est
alors brisé. L'intérêt d'une telle manœuvre est de permettre la suppression des lignes
devenues orphelines de manière différée.
Considérant les tables créées ci-dessus, si la suppression d’une sous-catégorie

ne doit entraîner que la désaffectation de l’employé de ladite catégorie, il suffit alors
d’utiliser la clause ON DELETE SET NULL. Ainsi lors de la suppression d’une sous-
catégorie, tous les employés affectés à cette sous-catégorie verront leur champ
idsouscategorie modifié en NULL. Le code pour créer la table employe devient:
CREATE TABLE employe (

idsouscategorie INT DEFAULT NULL,
nom VARCHAR(40) NOT NULL,
PRIMARY KEY(id),
CONSTRAINT FK_EMPLOYE FOREIGN KEY (idsouscategorie)
REFERENCES souscategorie (id)
ON DELETE SET NULL);
b.2.4 ON DELETE SET DEFAULT / ON UPDATE SET DEFAULT

En cas de suppression comme en cas de mise à jour de la clef référencée, la
référence passe à la valeur par défaut définie lors de la création de la table. Ce mode
permet l'insertion d'un client générique, possédant un identifiant particulier (par exemple 0
ou -1) afin de ne jamais briser le lient d'intégrité référentielle.
b.2.5 ON DELETE RESTRICT / ON UPDATE RESTRICT

Mêmes effets que NO ACTION, mais pré opératoire.
NOTA : Certains SGBDR n'ont pas implémenté le mode de gestion de l'intégrité. C'est le
cas en particulier de MS SQL Server. En revanche, il est courant de trouver dans
les SGBDR des options plus limitées que celles fournies par la norme.
c. CREATION DE VUES
Les vues ne sont autres que des requêtes instanciées. Elles sont nécessaires
pour gérer finement les privilèges, pour masquer la complexité de certains modèles
relationnels et pour restreindre l'accès aux données.
Une vue peut être utilisée comme une table dans toute requête de type
SELECT. Mais à la différence des tables, une vue peut être mise à jour (INSERT, UPDATE,
DELETE) que si elle obéit à un certain nombre de conditions :
 Ne porter que sur une table (pas de jointure)
 Ne pas contenir de dédoublonnage (pas de mot clef DISTINCT) si la table n'a pas
de clef
 contenir la clef de la table si la table en a une
15
 ne pas transformer les données (pas de concaténation, addition de colonne, calcul

d'agrégat...)
 ne pas contenir de clause GROUP BY ou HAVING
 ne pas contenir de sous requête
 répondre au filtre WHERE si la clause WITH CHECK OPTIONS est spécifiée lors de
la création de la vue
Une vue peut porter sur une autre vue et pour que la nouvelle vue construite à
partir d'une autre vue puisse être modifié, il faut que les deux vues répondent aussi à ces
critères.
Voici la syntaxe SQL pour définir une vue :
CREATE VIEW nom_vue [(nom_col1, [, nom_col2 ...])]

AS requête_select
[WITH CHECK OPTIONS];
Exemple -- vue restreignant l'accès aux colonnes

-- soit la table suivante :
CREATE TABLE T_EMPLOYE
(EMP_ID INTEGER PRIMARY KEY,
EMP_MATRICULE CHAR(8),
EMP_TITRE VARCHAR(4),
EMP_NOM VARCHAR(32),
EMP_PRENOM VARCHAR(32),
EMP_DATE_NAIS DATE,
EMP_SALAIRE FLOAT,
EMP_STATUT CHAR(8),
EMP_MAIL VARCHAR(128),
EMP_TEL CHAR(16))
-- permet de stocker les employés de l'entreprise
-- pour le syndicat, on pourra définir la vue suivante :

CREATE VIEW V_EMP_SYNDICAT AS
SELECT EMP_MATRICULE, EMP_TITRE, EMP_NOM, EMP_PRENOM, EMP_DATE_NAIS,
EMP_MAIL, EMP_TEL
FROM T_EMPLOYE
-- elle ne peut être mise à jour car la clef ne s'y trouve pas
-- pour le carnet d'adresse on pourra définir la vue suivante

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_ID, EMP_TITRE || ' ' || EMP_PRENOM || ' ' || EMP_NOM AS
EMP_NOM_COMPLET, EMP_MAIL, EMP_TEL
FROM T_EMPLOYE
-- elle ne peut être mise à jour à cause des transformations de données (concaténation au
niveau du nom)
16
-- pour le service comptable, on pourra définir la vue suivante :

CREATE VIEW V_EMP_SYNDICAT
AS
SELECT EMP_ID, EMP_PRENOM, EMP_NOM, EMP_SALAIRE
FROM T_EMPLOYE
WHERE STATUT = 'ETAM'
WITH CHECK OPTIONS
-- elle pourra être mis à jour uniquement pour les salariés de type 'ETAM'
La clause WITH CHECK OPTION implique que si la vue peut être mise à jour,
alors les valeurs modifiées insérées ou supprimées doivent répondre à la validation de la
clause WHERE comme s'il s'agissait d'une contrainte.
Par exemple dans le cadre de la vue pour le service comptable, il n'est pas possible de
faire :
UPDATE T_EMPLOYE
SET EMP_SALAIRE = EMP_SALAIRE + 100
WHERE STATUT = 'CADRE'
2.1.2 LES COMMANDES ALTER ET DROP

L’ordre ALTER est utilisé pour modifier le contenu d’une table par contre l’ordre
DROP joue le rôle de la suppression. Ainsi, l’ordre ALTER associé avec DROP permettent :
 De supprimer une colonne, une contrainte,…

 D’ajouter une colonne, une contrainte,…
 D’ajouter une contrainte de ligne DEFAULT
Ils ne permettent pas:

 De changer le nom d'une colonne
 De changer le type d'une colonne
 D’ajouter une contrainte de ligne NULL / NOT NULL
D’une manière générale, l’ordre ALTER est utilisé de la manière suivante :

ALTER TABLE nom_de_la_table
Instructions ;
Instructions ici désigne la(les) commande(s) supplémentaire(s) selon l’action que l’on
souhaite effectuer : Modification, Suppression ou Ajout
a. SUPPRIMER UNE BASE DE DONNEES

DROP DATABASE ma_Base ;
Cela a comme conséquence la suppression de toutes les tables ainsi que de

toutes les données. Par défaut si le nom de la base utilisé n’existe pas, la requête
retournera un message d’erreur. Pour éviter cela, il est possible d’utiliser l’option IF
EXISTS. La syntaxe devient alors :
DROP DATABASE IF EXISTS ma_base ;

17
b. SUPPRIMER UNE TABLE

DROP TABLE nom_de_la_table ;
Cela a comme conséquence la suppression de toutes les données, les éventuels

indexes, contraintes et autres éléments associés à cette table.
c. SUPPRIMER UNE COLONNE

La suppression d’une colonne peut se faire de deux façons à savoir :
ALTER TABLE nom_table
DROP nom_colonne ;
Ou
DROP COLUMN nom_colonne ;
d. AJOUTER UNE COLONNE

ADD nom_colonne type_données|contraintes ;
Exemple :
ALTER TABLE Utilisateur
ADD adresse_rue varchar(250) NOT NULL;
Remarque : Il n’est conseillé d’ajouter une colonne avec l’attribut ou contrainte NOT
NULL lorsque la table contient déjà de données
e. AJOUTER UNE CONTRAINTE

ALTER TABLE T_CLIENT
ADD CLI_DATE_NAISSANCE DATE,
ALTER TABLE T_CLIENT

ADD CONSTRAINT CHK_DATE_NAISSANCE
CHECK (CLI_DATE_NAISSANCE BETWEEN '1880-01-01' AND '2020-01-01')
f. MODIFIER UNE COLONNE

Pour modifier une colonne, soit par exemple changer le type de données, il y a
différentes syntaxes selon le type de SGBD.
MYSQL
MODIFY nom_colonne TYPE type_de_données ;
POSTGRESQL
ALTER COLUN nom_colonne TYPE type_de_données ;
Ici type_de_données est à remplacer par un type de données tel que INT, VARCHAR,
DATE,…
18
g. RENOMMER UNE COLONNE

Pour renommer une colonne, il convient d’indiquer l’ancien nom de la colonne
ainsi que le nouveau nom de celle-ci.
MYSQL
CHANGE colonne_ancien_nom colonne_nouveau_nom type de données
Remarque : En cas d’une modification d’une table contenant déjà des données, les
éléments ci-dessous doivent être pris en compte :
- il faut se rassurer que le nouveau type soit compatible avec les données
existantes dans la colonne ;
- il convient de s'assurer que la colonne ne fait l'objet d'aucune référence
interne (contraintes de table par exemple) ou externe (vue, triggers...). Si
c'est le cas, il faut impérativement modifier, désactiver ou supprimer ces
éléments avant la modification de la colonne.
2.2 LE LANGAGE DE MANIPULATION DE DONNEES

C'est la partie du SQL qui s'occupe du traitement les données : insertion,
modification, suppression, extraction des données, etc… Elle comporte les commandes de
base suivantes : SELECT, INSERT, UPDATE, DELETE, DECLARE, OPEN, FETCH, CLOSE.
Elle permet aussi de manipuler des curseurs (DECLARE, OPEN, FETCH, CLOSE) afin
d'intégrer les données des tables d'une base au sein d'un langage de programmation hôte.
2.2.1 LA COMMANDE SELECT

Le SELECT est la commande de base du SQL destinée à extraire des données
d'une base ou calculer de nouvelles données à partir de données existantes. Voici sa
syntaxe générale :
SELECT [DISTINCT ou ALL] * ou liste de colonnes

FROM nom de table ou de la vue ou des tables
[WHERE prédicats]
[GROUP BY ordre des groupes]
[HAVING condition]
[ORDER BY ordre des colonnes]
Exemple
SELECT CLI_NOM, CLI_PRENOM
FROM T_CLIENT
WHERE TIT_CODE = 'M'
19
a. LA CLAUSE SELECT
a.1 L'opérateur *
L'utilisation du caractère étoile ramène dans la réponse toutes les colonnes de
la table ou de différentes tables utilisées en cas de jointures. Dans le cas contraire il faut
expressément nommer chacune des colonnes et les séparer par des virgules.
Exemple
SELECT *
FROM T_CLIENT
WHERE TIT_CODE = 'M'
a.2 L'opérateur DISTINCT

Lorsque le moteur construit la réponse, il rapatrie toutes les lignes
correspondantes, généralement dans l'ordre où il les trouve, même si ces dernières sont
en double. L’opérateur DISTINCT permet donc d'éliminer les doublons dans la réponse.
Exemple
SELECT distinct CLI_PRENOM
FROM T_CLIENT
WHERE TIT_CODE = 'M.'
a.3 L’opérateur AS
En principe l'opérateur AS sert à donner un nom à de nouvelles colonnes créées
par la requête.
Exemple
SELECT CLI_NOM as NOM, 'homme' as SEXE
FROM T_CLIENT
WHERE TIT_CODE = 'M.'
a.4 L’Opérateur de concaténation

L'opérateur || (double barre verticale) permet de concaténer des champs de
type caractères
Exemple
SELECT TIT_CODE ||' '|| CLI_PRENOM || ' ' || CLI_NOM as NOM FROM T_CLIENT
a.5 Les Opérateurs mathématiques

Les opérateurs mathématiques de base (+,-,*,/) sont utilisés pour combiner
différentes colonnes.
Exemple
SELECT CHB_ID, TRF_CHB_PRIX * 1.206 AS TARIF_TTC
FROM TJ_TRF_CHB
WHERE TRF_DATE_DEBUT = '2001-01-01'
20
a.6 L’Opérateur CASE

Dans le langage SQL, la clause « CASE … WHEN … » permet d’utiliser des
conditions de type « si / sinon » (cf. if / else) similaire à un langage de programmation
pour retourner un résultat disponible entre plusieurs possibilités.
Voici la syntaxe nécessaire pour comparer une colonne à un set

d’enregistrement :
CASE a
WHEN 1 THEN 'un'
WHEN 2 THEN 'deux'
WHEN 3 THEN 'trois'
ELSE 'autre'
END
Il est possible d’établir des conditions plus complexes pour récupérer un

résultat ou un autre. Cela s’effectue en utilisant la syntaxe suivante:
CASE
WHEN a=b THEN 'A égal à B'
WHEN a>b THEN 'A supérieur à B'
ELSE 'A inférieur à B'
END
Exemple
SELECT id, nom, postnom, CASE
WHEN age<18 THEN 'Mineur'
WHEN age>=18 and age <=120 THEN 'Majeur'
ELSE 'Encore vivant!'
END Age
FROM T_Etudiant
Ou
SELECT id, nom, postnom, CASE age

WHEN <18 THEN 'Mineur'
WHEN >=18 and <=120 THEN 'Majeur'
ELSE 'Encore vivant!'
END statut
FROM T_Etudiant
Remarque : Il est possible d’utiliser une autre requête dans la clause case
Exemple :
SELECT id, nom, postnom,
CASE WHEN id in (SELECT id FROM T_Client WHERE age<18) THEN 'Mineur'
Else 'Majeur'
END statut
FROM T_Etudiant
21
b. LA CLAUSE FROM
Après la clause FROM il est question de lister la(es) table(s) interrogée(s). Les
tables mentionnées dans la clause FROM peuvent être soient des tables proprement dites,
soient des tables résultant d'une requête spécifiée entre parenthèses. Il est possible de
surnommer une table dans la clause FROM, dans ce cas, la syntaxe de la partie FROM de
la commande SELECT est la suivante :
FROM nom_de_table ou nom_de_la_vue as surnom

Ou
FROM nom_de_table ou nom_de_la_vue surnom
Nous verrons dans quel cas ce renom est nécessaire ou obligatoire.
Remarque : En lieu et place d’une table après la clause FROM, Il est aussi possible
qu’une requête proprement dite la remplace.
Exemple :
From (SELECT CLI_NOM, CLI_PRENOM, CLI_SEXE
From T_CLIENT
where CLI_SEXE='M')
NOTA: Comme cela a été dit précédemment, après la clause FROM, plusieurs tables
peuvent être référencées. Cela sera étudié ultérieurement dans la partie
consacrée sur les JOINTURES.
c. LA CLAUSE WHERE
La commande WHERE dans une requête SQL permet d’extraire les lignes d’une
base de données qui respectent une condition. Cela permet d’obtenir uniquement les
informations désirées.
Syntaxe : WHERE prédicats
Le prédicat doit contenir n’importe quelle expression logique renvoyant une valeur vraie.
Les opérateurs
Il existe plusieurs opérateurs de comparaisons pour le prédicat simple et le
prédicat composé. Un prédicat simple peut être le résultat de la comparaison de deux
expressions simples au moyen de l'un des opérateurs suivants : =, <>, <, <=, >, >=, IN,
BETWEEN, LIKE, IS NULL, IS NOT NULL,…
Les prédicats simples peuvent être combinés au sein d'expressions logiques en utilisant les
opérateurs logiques AND (et logique), OR (ou logique) et NOT (négation logique).
NB : - Dans certains moteurs de requête SQL l’opérateur (<>) s’écrit != ;
- Pour les erreurs, il faut penser à utiliser des parenthèses lorsque c’est
nécessaire.
22
Exemple
FROM T_CLIENT
WHERE CLI_NOM >= 'A' AND CLI_NOM <'E'
ou

FROM T_CLIENT
WHERE (CLI_NOM >= 'A') AND (CLI_NOM <'E') plus lisible !
Ici on obtient tous les noms et prénoms des clients dont le nom commence par les lettres
A, B, C ou D.
c.1 L’opérateur IN
L'opérateur IN permet de rechercher si une valeur se trouve dans un ensemble
donné.
Exemple
SELECT TIT_CODE, CLI_NOM, CLI_PRENOM
FROM T_CLIENT
WHERE TIT_CODE IN ('Mme', 'Melle')
Remarque:
- Cette syntaxe peut être associée à l’opérateur NOT pour recherche toutes les
lignes qui ne sont pas égales à l’une des valeurs stipulées ;
- Le contenu de la parenthèse peut être remplacé par le résultat d'une requête
possédant une colonne unique. Dans ce cas on parle de requêtes imbriquées, ce
que nous verrons plus loin.
Exemple:
SELECT Cli_id, nom, postnom,
From Client
WHERE Cli_id in (SELECT Cli_id FROM T_Commande WHERE C_code=18)
c.2 L’opérateur BETWEEN

L'opérateur BETWEEN permet de rechercher si une valeur se trouve dans un
intervalle donné. L’intervalle peut être constitué de chaînes de caractères, de nombres ou
de dates.
Exemple
FROM T_CLIENT
WHERE CLI_NOM BETWEEN 'A' AND 'E'
23
c.3 L’opérateur LIKE

L'opérateur LIKE permet d’effectuer une comparaison partielle pour les
colonnes contenant des données de type alpha. Il utilise souvent les joker % et _. Le joker
% remplace n'importe quelle chaîne de caractères, y compris la chaîne vide.
Exemple
FROM T_CLIENT
WHERE CLI_NOM LIKE 'B%'
Remarque : Si les données sont susceptibles de contenir un des deux caractères joker,
alors il faut recourir à une séquence d’échappement à l’aide du mot clef
ESCAPE
Exemple
SELECT *
FROM T_CLIENT
WHERE CLI_ENSEIGNE LIKE '%_%'
SELECT *
FROM T_CLIENT
WHERE CLI_ENSEIGNE LIKE '%#_%' ESCAPE '#'
Pour traiter ce cas, on définit « # » comme caractère d’échappement. Le caractère qui suit
ce caractère d’échappement est donc interprété comme un caractère et non comme un
joker.
NOTA : L’opérateur LIKE effectue une recherche en tenant compte de la différence entre
lettres majuscules et minuscules. Si vous voulez effectuer une recherche en ne
tenant aucunement compte de la différence entre majuscules et minuscules, il
convient d’utiliser les opérateurs LOWER et UPPER (voir ci-dessous).
c.4 L’opérateur EXISTS

Dans le langage SQL, la commande EXISTS s’utilise dans une clause
conditionnelle pour savoir s’il y a une présence ou non de lignes lors de l’utilisation d’une
sous-requête. Cette commande n’est pas à confondre avec la clause IN qui vérifie la
concordance d’une à plusieurs données. La commande EXISTS vérifie si la sous-requête
retourne un résultat ou non. Dans ce cas la requête externe s’exécutera uniquement si la
requête interne retourne au moins un résultat.
Syntaxe
SELECT nom_colonne1
FROM table1
WHERE EXISTS (
SELECT nom_colonne2
FROM table2
WHERE nom_colonne3 = 10
)
24
Dans l’exemple ci-dessus, s’il y a au moins une ligne dans table2 dont nom_colonne3
contient la valeur 10, alors la sous-requête retournera au moins un résultat. Dès lors, la
condition sera vérifiée et la requête principale retournera les résultats de la colonne
nom_colonne1 de table1.
Exemple
Soient les tables suivantes :
Table commande (C_id, C_date_achat, C_produit_id, c_ qu an tite _ produ it)
Table produit (p_ id, p_ n om, p_ da te _ ajou tn p_ prix )
Il est possible d’effectuer une requête SQL qui affiche les commandes pour lesquels il y a
effectivement un produit. Cette requête peut être interprétée de la façon suivante :
SELECT *
FROM commande
WHERE EXISTS (SELECT *
FROM produit
WHERE c_produit_id = p_id )
c.5 L’opérateur ALL

Dans le langage SQL, la commande ALL permet de comparer une valeur dans
l’ensemble de valeurs d’une sous-requête. En d’autres mots, cette commande permet de
s’assurer qu’une condition est « égale », « différente », « supérieure », « inférieure »,
« supérieure ou égale » ou « inférieure ou égale » pour tous les résultats retourné par
une sous-requête.
Syntaxe
Cette commande s’utilise dans une clause conditionnelle entre l’opérateur de condition et
la sous-requête. L’exemple ci-dessous montre un exemple basique :
SELECT *
FROM table1
WHERE condition > ALL (SELECT *
FROM table2
WHERE condition2)
NB : Les opérateur conditionnels peuvent être les suivants : =, <, >, <>, !=, <=, >=, !>
ou !<.
Exemple : Imaginons une requête similaire à la syntaxe de base présentée précédemment

SELECT colonne1
FROM table1
WHERE colonne1 > ALL (SELECT colonne1
FROM table2)
Avec cette requête, si nous supposons que dans table1 il y a un résultat avec la valeur
10, voici les différents résultats de la condition selon le contenu de table2 :
25
 La condition est vrai (cf. TRUE) si table2 contient {-5,0,+5} car toutes les valeurs
sont inférieure à 10
 La condition est fausse (cf. FALSE) si table2 contient {12,6,NULL,-100} car au moins
une valeur est inférieure à 10
 La condition est non connue (cf. UNKNOW) si table2 est vide
Question : Que se passera-t-il au cas où la table2 ne contient que de null dans la

colonne1 ?
c.6 L’opérateur ANY / SOME

Dans le langage SQL, la commande ANY (ou SOME) permet de comparer une
valeur avec le résultat d’une sous-requête. Il vérifie si une valeur est « égale »,
« différente », « supérieur », « supérieur ou égale », « inférieur » ou « inférieur ou
égale » pour au moins l’une des valeurs de la sous-requête.
Syntaxe : Cette commande s’utilise dans une clause conditionnelle juste après un
opérateur conditionnel et juste avant une sous-requête. L’exemple ci-dessous démontre
une utilisation basique de ANY dans une requête SQL :
SELECT *
FROM table1
WHERE condition > ANY (SELECT *
FROM table2
WHERE condition2)
Cette requête peut se traduire de la façon suivante : sélectionner toutes les colonnes de
table1, où la condition est supérieure à n’importe quel résultat de la sous-requête.
NB: Les opérateur conditionnels peuvent être les suivants : =, <, >, <>, !=,<=, >=,…
Exemple : En se basant sur l’exemple relativement simple présenté ci-dessus, il est

possible d’effectuer une requête concrète qui utilise la commande ANY :
SELECT colonne1
FROM table1
WHERE colonne1 > ANY (SELECT colonne1
FROM table2)
Supposons que la table1 possède un seul résultat dans lequel colonne1 est égal à 10.
 La condition est vrai (cf. TRUE) si table2 contient {21,14,7} car il y a au moins une
valeur inférieure à 10
 La condition est fausse (cf. FALSE) si table2 contient {20,10} car aucune valeur est
strictement inférieure à 10
 La condition est non connue (cf. UNKNOW) si table2 est vide
NB : La commande IN est équivalent à l’opérateur = suivi de ANY.
c.7 La négation de valeurs
26
C'est l'opérateur NOT qui réalise la négation de valeurs et inverse la valeur

logique d'un prédicat. Il peut être combiné avec la plupart des opérateurs de comparaison
mais devient très intéressant lorsqu’il est combiné aux opérateurs IN, BETWEEN, LIKE et
NULL.
Exemple
SELECT CLI_NOM
FROM T_CLIENT
WHERE CLI_NOM NOT LIKE 'DU%'
c.8 Quelques fonctions SQL
c.8.1 Les fonctions d’agrégation

Les fonctions d’agrégation permettent d’effectuer des opérations statistiques
sur un ensemble d’enregistrement. Toutes ces fonctions prennent tout leur sens
lorsqu’elles sont utilisées avec la commande GROUP BY qui permet de filtrer les données
sur une ou plusieurs colonnes. L’utilisation la plus générale consiste à utiliser la syntaxe
suivante :
SELECT fonction(colonne) FROM tabl
 COUNT ()
Elle permet de compter le nombre d’enregistrement dans une table.
Syntaxe: SELECT COUNT(*)

FROM table
Il est aussi possible de connaitre le nombre d’enregistrement sur une colonne

en particulier. Les enregistrements qui possèdent la valeur nul ne seront pas comptabilisé.
Syntaxe : SELECT COUNT(nom_colonne)

FROM table
Il est également possible de compter le nombre d’enregistrement distinct pour

une colonne. La fonction ne comptabilisera pas les doublons pour une colonne choisie.
Syntaxe : SELECT COUNT(DISTINCT nom_colonne)

FROM table
Exemple
SELECT COUNT(*)
FROM utilisateur ;
SELECT COUNT(*)
FROM utilisateur
WHERE nombre_achat > 0 ;
SELECT COUNT(id_dernier_achat)
27
FROM utilisateur ;
SELECT COUNT(DISTINCT ville)

FROM utilisateur ;
 MAX ()
Elle permet de retourner la valeur maximale d’une colonne dans un set
d’enregistrement. La fonction peut s’appliquée à des données numériques
ou alphanumériques.
Syntaxe : SELECT MAX(nom_colonne)

FROM table
SELECT colonne1, MAX(colonne2)

FROM table
GROUP BY colonne1
Exemple
SELECT MAX(prix)
FROM produit
Il est aussi possible d’afficher le nom du produit le plus cher en même temps
que d’afficher son prix. La requête SQL est alors la suivante :
SELECT id, nom, MAX(prix)

FROM produit
Group by id, nom
 MIN ()
Elle permet de retourner la plus petite valeur d’une colonne sélectionnée. Cette
fonction s’applique aussi bien à des données numériques qu’à des données
alphanumériques.
Syntaxe : SELECT MIN(nom_colonne)

FROM Nom_Table
Il est possible de l’utiliser en complément de la commande GROUP BY. Cela

permet de grouper des colonnes et de connaître la plus petite valeur pour chaque groupe.
La syntaxe est alors la suivante:

SELECT colonne1, MIN(colonne2)
FROM table
GROUP BY colonne1
Exemple : Soit la Table produits (id, categorie, nom, prix, date_ajout). Pour extraire le prix
du produit le moins cher de la catégorie « maison », on effectue la requête SQL
ci-dessous:
28
SELECT MIN(prix)
FROM produits
WHERE categorie= 'maison'
Pour connaître la date du premier ajout dans chaque catégorie, on exécute la requête
suivante:
SELECT categorie, MIN(date_ajout)
FROM produits
GROUP BY categorie
 SUM ()
Elle permet de calculer la somme totale d’une colonne contenant des valeurs
numériques. Cette fonction ne fonction que sur des colonnes de types numériques (INT,
FLOAT …) et n’additionne pas les valeurs NULL.
Syntaxe
SELECT SUM(nom_colonne)
FROM table
NB : Il est possible de filtrer les enregistrements avec la commande WHERE pour ne

calculer la somme que des éléments souhaités.
Exemple : Soit la table facture (id, facture_id, produit, prix). Pour calculer le montant de la
facture n°1 il est possible d’utiliser la requête SQL suivante:
SELECT SUM(prix) AS prix_total

FROM facture
WHERE facture_id = 1
Pour calculer la somme de chaque facture, on se base sur la colonne « facture_id ». Un tel
résultat peut être obtenu en utilisant la requête suivante:
SELECT facture_id, SUM(prix) AS prix_total

FROM facture
GROUP BY facture_id
 AVG ()
Elle permet de calculer une valeur moyenne sur un ensemble d’enregistrement
de type numérique et non nul.
Syntaxe: SELECT AVG(nom_colonne)

FROM nom_table
Il est possible de filtrer les enregistrements concernés à l’aide de la commande

WHERE. Il est aussi possible d’utiliser la commande GROUP BY pour regrouper les
données appartenant à la même entité.
Exemple
SELECT client, AVG(tarif)
FROM achat
29
GROUP BY client
c.8.2 Les fonctions de chaînes de caractères

Les fonctions SQL sur les chaînes sont mono-lignes cela signifie qu’elles ne
s’appliquent qu’à une seule ligne en même temps.
 CONCAT ()
Elle permet de concaténer les valeurs de plusieurs colonnes pour ne former
qu’une seule chaîne de caractère.
Syntaxe : CONCAT (colonne1, colonne2)
Exemple : Soit la table utilisateur (id, prenom, nom, date_inscription) : un identifiant, le prénom,
le nom et la date d’ajout (sous le format DATETIME).
Pour afficher proprement le prénom suivi du nom de famille.

SELECT id, CONCAT(prenom, ' ', nom) AS affichage_nom, date_inscription
FROM utilisateur
Pour rechercher un utilisateur en cherchant son prénom suivi de son nom :

SELECT id, prenom, nom, date_inscription
FROM utilisateur
WHERE CONCAT(prenom, ' ', nom) = 'Sabine Lemaire'
 LENGTH ()
Elle permet de calculer la longueur d’une chaîne de caractères. Cette fonction
s’écrit différemment selon le SGBD :
 LENGTH() pour MySQL, PostgreSQL et Oracle
 LEN() pour SQL Server
Exemple :
SELECT LENGTH('exemple');
Résultat : 7
Exemple : Nous considérons une table utilisateur qui contient l’id, le login, la ville et le
numéro de téléphone d’un utilisateur.
Pou r connaître la longueur du login de chaque utilisateur :

SELECT id, login, LENGTH(login) AS login_length, ville, telephone
FROM utilisateur
Pou r e x trai re la liste de ces utilisateurs ayant un login de moins de 5 caractères :

SELECT id, login, ville, telephone
FROM utilisateur
WHERE LENGTH(login) < 5
 REPLACE ()
Elle permet de remplacer des caractères alphanumérique dans une chaîne de
caractère.
30
Sy nt a xe basiqu e
La fonction comporte 3 paramètres :
1. Chaîne d’entrée
2. Texte à remplacer
3. Texte qui sert de remplacement
Exemple
SELECT REPLACE('Hello tout le monde', 'Hello', 'Bonjour');
Résultat : Bonjour tout le monde
Ex e mpl e : Soit une table qui possède une liste de sites web populaires.
Table site :
id d a t e_ a jo ut Sit e url
1 2013-02-05 Wikipedia http://fr.wikipedia.org/
2 2013-02-11 Google http://www.google.fr/
3 2013-03-16 Facebook http://www.facebook.com/
4 2013-03-16 Facebook http://www.facebook.com/home.php
5 2013-03-16 Facebook http://www.facebook.com/feed/friends
Pour remplacer certains caractères du tableau, par exemple : le nom de domaine pour
toutes les URLs de Facebook :
UPDATE site
SET url = REPLACE(url, 'www.facebook.com', 'fr-fr.facebook.com')
WHERE url LIKE '%www.facebook.com%'
Résultat:
id d a t e_ a jo ut Sit e url
1 2013-02-05 Wikipedia http://fr.wikipedia.org/
2 2013-02-11 Google http://www.google.fr/
3 2013-03-16 Facebook http://fr-fr.facebook.com/
4 2013-03-16 Facebook http://fr-fr.facebook.com/home.php
http://fr-
5 2013-03-16 Facebook
fr.facebook.com/feed/friends
 SUBSTRING ()
31
La fonction SUBSTRING() ou SUBSTR(), selon le SGBD, est utilisée pour

segmenter une chaîne de caractère. Autrement dit, elle permet d’extraire une partie d’une
chaîne.
Syntaxe
La fonction SUBSTRING() peut s’utiliser de 4 façons différentes, que voici :
 SUBSTRING(chaine, debut) : retourne la chaîne de caractère de « chaine » à partir
de la position définie par « debut » (position en nombre de caractères)
 SUBSTRING(chaine FROM debut) : idem que précédent
 SUBSTRING(chaine, debut, longueur) : retourne la chaîne de caractère « chaine » en
partant de la position définie par « debut » et sur la longueur définie par
« longueur »
 SUBSTRING(chaine FROM debut FOR longueur) : idem que précédent
Exemple
SELECT SUBSTR(nom_colonne, 3, 10)
FROM tableau
Dans cet exemple, le contenu de la colonne « nom_colonne » sera tronqué à partir du

3ème caractère sur 10 caractères.
Exemple : Soit une base de données qui contient une liste de pays en français et en
anglais.
Table pays :
Id no m_ en _ fr no m_ en_ a ng
1 France FRANCE
2 Espagne SPAIN
3 Allemagne GERMANY
4 CHINE CHINA
Une requête SQL va être construite pour extraire les informations suivantes :
 L’identifiant du pays
 Le nom du pays en français
 Les 2 premiers caractères du nom en français (soit à partir du 1er caractère et sur
une longueur de 2 caractères)
 Tout le nom en français, sans les 2 premiers caractères (soit tout le nom à partir du
3ème caractère)
Pour récupérer toutes ces données, il convient d’utiliser la requête SQL suivante :
SELECT id, nom_en_fr, SUBSTR(nom_en_fr, 1, 2) as prefixe, SUBSTR(nom_en_fr, 3) reste
FROM pays
Résultat :
32
Id no m_ en _ fr prefi xe rest e
1 FRANCE FR ANCE
2 ESPAGNE ES PAGNE
3 ALLEMAGNE AL LEMAGNE
4 CHINE CH INE
 REVERSE ()
Elle permet de retourner une chaîne de caractère en inversant l’ordre des
caractères. Le premier caractère devient le dernier, le deuxième devient l’avant dernier, et
ainsi de suite.
Syntaxe : SELECT REVERSE (chaine);
Exemple
SELECT REVERSE ('123'); -- retourne : 321
SELECT REVERSE ('bonjour le monde'); -- retourne : ednom el ruojnob
SELECT REVERSE ('lierappa'); -- retourne : appareil
 TRIM()
Elle permet de supprimer des caractères au début et en fin d’une chaîne de
caractère. Le plus souvent, dans le souci d’afficher proprement des données, on l’utilise
pour supprimer les caractères invisibles, c’est-à-dire les caractères tels que l’espace, la
tabulation, le retour à la ligne ou bien même le retour chariot.
Exemple
SELECT TRIM (' Exemple '); Résultat : « Exemple » sans les espaces de début et de fin.
Pour certains SGBD :

TRIM(BOTH 'x' FROM 'xxxExemplexxx'); Résultat : « Exemple »
TRIM('x', 'xxxExemplexxx'); Résultat : Exemple
TRIM(LEADING 'x' FROM 'xxxExemplexxx'); Résultat : « Exemplexxx »
TRIM(TRAILING 'x' FROM 'xxxExemplexxx'); Résultat : « xxxExemple »
 LTRIM ()
Elle permet de supprimer des caractères au début d’une chaîne de caractères.
Exemple
L’utilisation la plus courante consiste à supprimer les caractères invisibles tels
que l’espace, la tabulation ou le retour à la ligne.
SELECT LTRIM(' Exemple '); Résultat :'Exemple '
Pour certains SGBD tels que PostgreSQL, Oracle et SQLite, il est possible de
spécifier les caractères à supprimer au début de la chaîne de caractère.
Exemple
33
SELECT LTRIM('xxxExemplexxx', 'x'); Résultat :'Exemplexxx'
 RTRIM()
Elle permet de supprimer des caractères à la fin d’une chaîne de caractères.
Certains SGBD tels que PostgreSQL, Oracle et SQLite permettent de choisir les caractères
à supprimer. L’utilisation la plus courante consiste à supprimer à la fin d’une chaîne les
caractères invisibles tels que l’espace, la tabulation ou le retour à la ligne.
SELECT RTRIM(' Exemple '); Résultat :' Exemple'
SELECT RTRIM('xxxExemplexxx', 'x'); Résultat:'xxxExemple'
 UPPER ()
Elle permet de transformer tous les caractères minuscules d’une chaîne de
caractère en majuscules. Sous MySQL et Oracle la fonction peut aussi être appelée grâce à
l’alias UCASE().
Syntaxe : UPPER (nom_colonne) ;
Exemple
SELECT UPPER('Exemple'); résultat :EXEMPLE
SELECT id, prenom, nom, ville

FROM utilisateur
WHERE UPPER(prenom) = 'PAUL'
 LOWER ()
Elle permet de transformer tous les caractères d’une chaîne de caractère en
minuscules. Sous MySQL et Oracle la fonction peut aussi être appelé grâce à l’alias
LCASE().
Syntaxe : LOWER (nom_colonne) ;
Exemple
SELECT LOWER('BONJOUR tout le monde'); Résultat :bonjour tout le monde
SELECT id, LOWER(prenom) AS prenom_lower, LOWER(nom) AS nom_lower, ville
FROM utilisateur
 LOCATE ()
Elle permet de chercher la position d’une chaîne de caractère dans un
enregistrement. La fonction retourne zéro si la chaîne de caractère n’a pas été trouvée.
Pour les utilisateurs de SQL Server la fonction s’appelle CHARINDEX() et fonctionne de la
même façon.
Syntaxe : LOCATE ( chaine_recherchée, chaine_source );
34
La fonction va chercher le contenu de « chaine_recherchée » dans « chaine_source ». Si

la chaîne existe et est présente, alors la fonction retournera la position de la
première occurrence si la chaîne n’est pas trouvé, la fonction retournera.
Il est aussi possible de chercher une chaîne de caractère en commençant la

recherche à partir d’une position.
SELECT LOCATE ( 'test', nom_colonne, 4 );

Ce 3ème paramètre est optionnel et peut être utilisé s’il faut ignorer une première partie. La
requête SQL permet alors de chercher la chaîne « test » dans la colonne « nom_colonne »
en commençant à partir de la position 4.
Exemple : Soit la table contenant les différentes unités liées aux mètres (kilomètre,
millimètre, centimètre …)
Table « metre » :
id U nit e P uissanc e dat e_ ajo ut
1 Kilomètre 1000 2013-07-16
2 Millimètre 0.001 2013-08-06
3 Mètre 1 2013-09-02
4 Centimètre 0.01 2013-11-27
5 Mm 0.001 2013-11-29
Pour de récupérer la position du mot « mètre » dans la colonne « unite » :

SELECT id, unite, LOCATE('mètre', unite) AS locate_unite, puissance
FROM metre
Résultats :
id U nit e lo c at e_ unit e puissanc e
1 Kilomètre 5 1000
2 Millimètre 6 0.001
3 Mètre 1 1
4 Centimètre 6 0.01
5 Mm 0 0.001
35
c.8.3 Fonctions mathématiques

Dans le langage SQL il existe de nombreuses fonctions mathématiques pour
effectuer des calculs ou des statistiques concernant les données contenus dans une base
de données, en voici quelques-unes
 RAND ()
Elle permet de sélectionner un nombre aléatoire à virgule, compris entre 0 et 1.
Le résultat de cette fonction sera différent à chaque fois que la fonction est exécutée dans
une requête SQL.
Exemple : Soit la table reprenant les principales villes de France.
Table ville :
id Ville D epart ement
1 Paris Paris
2 Marseille Bouches-du-Rhône
3 Lyon Rhône
4 Toulouse Haute-Garonne
5 Nice Alpes-Maritimes
6 Nantes Loire-Atlantique
7 Strasbourg Bas-Rhin
8 Montpellier Hérault
9 Bordeaux Gironde
10 Lille Nord
Pour trier les résultats aléatoirement en utilisant la syntaxe suivante :

SELECT *
FROM ville
ORDER BY RAND()
A chaque fois que la requête sera exécutée, celle-ci retournera un résultat aléatoire.
ROUND ()
Elle permet d’arrondir un résultat numérique, soit d’arrondir sans utiliser de
décimal pour retourner un nombre entier (c’est-à-dire : aucun chiffre après la virgule), ou
de choisir le nombre de chiffre après la virgule.
Syntaxe
SELECT ROUND(nom_colonne)
FROM table
36
CAST
Elle permet de transtyper un type de données contenues dans une colonne
dans un autre type compatible. Sa syntaxe est CAST(colonne AS nouveau type).
Exemple
SELECT ADR_VILLE, CAST (ADR_CP AS INTEGER) + 1
FROM T_ADRESSE
Exemple
SELECT CHB_ID, CHB_NUMERO, CHB_POSTE_TEL
FROM T_CHAMBRE
WHERE CAST(CHB_POSTE_TEL AS INTEGER)/ 10> CHB_NUMERO
 Autres fonctions mathématiques

Les opérateurs ci-dessous peuvent être implémentés dans différents moteurs.
ABS valeur absolue LOG logarithme décimal
MOD Modulo POWER Puissance
SIGN Signe COS Cosinus
SQRT racine carrée COSH cosinus hyperbolique
CEIL plus petit entier SIN Sinus
FLOOR plus grand entier SINH sinus hyperbolique
TRUNC Tronqué TAN Tangente
EXP Exponentielle TANH tangente hyperbolique
LN logarithme népérien PI constante Pi
c.8.4 Fonction de traitement des dates

L’heure courante, la date courante et le combiné date/heure courant peuvent
être obtenu à l’aide des fonctions CURRENT_DATE, CURRENT_TIME et
CURRENT_TIMESTAMP.
Exemple
SELECT distinct CHB_ID
FROM TJ_CHB_PLN_CLI
WHERE PLN_JOUR BETWEEN CURRENT_DATE and CURRENT_DATE + 14
Cette requête renvoi les chambres réservées entre la date du jour et pour les deux
semaines à venir.
Remarque : La plupart des SGBDR n'acceptent pas encore cette version normalisée des
fonctions de recherche de temps courant. Voici les fonctions spécifiques aux
différents serveurs SQL :
Oracle SYSDATE() Access NOW()

Sybase GETDATE() MySQL NOW()
SQLServer GETDATE() Paradox (QBE) TODAY
37
c.9 Traitement des valeurs nulles

Le comportement de la valeur NULL en SQL peut être dégoutant lorsque l’on
n’en connait pas la logique. Le NULL indique que la valeur est inconnue non applicable ou
devant être ajoutée ultérieurement. Une valeur NULL est différente d'une valeur vide ou
de zéro.
Voici quelques informations sur les valeurs NULL :

 Deux valeurs NULL ne sont pas égales. Les comparaisons de deux valeurs NULL, ou
d'une valeur NULL et d'une autre valeur, renvoient le message « inconnu » car la
valeur de chaque NULL est inconnue.
 Pour tester des valeurs NULL dans une requête, utilisez IS NULL ou IS NOT NULL
dans la clause WHERE.
 Les valeurs NULL peuvent être insérées dans une colonne en spécifiant
explicitement NULL dans une instruction INSERT ou UPDATE, en ne citant pas une
colonne dans une instruction INSERT, ou encore en ajoutant une nouvelle colonne
à une table existante à l'aide de l'instruction ALTER TABLE.
 Les valeurs NULL ne peuvent pas être utilisées comme critère de différenciation
entre une ligne dans une table et une autre, en tant que clés primaires ou
étrangères, par exemple.
 L'élimination de valeurs NULL lors des calculs peut s'avérer importante pour
certains calculs (tels que les moyennes) risquant d'être faussés par la présence de
colonnes NULL.
 Lorsque des valeurs NULL sont présentes dans les données, les opérateurs logiques
et les opérateurs de comparaison peuvent renvoyer la valeur UNKNOWN au lieu de
TRUE ou de FALSE.
 Une colonne contenant une valeur NULL est ignorée dans le calcul de valeurs
agrégée comme AVG, SUM, COUNT, MAX, …
 Dans un ORDER BY, la norme ne précise pas la règle de classement pour les NULL.
 DISTINCT ORDER BY et GROUP BY considèrent que les valeurs NULL ne peuvent
être distinguées entre elles et sont regroupées.
Exemple : Soit une table contenant les données suivantes :
Cette table représente des noms d’artistes suivi d’un code renseignant s’il s’agit
d’écrivains (code 1), de musiciens (code 2) ou de peintres (code 3). Nous n’avons pas
renseigné le champ code pour 2 personnes, les champs ont donc la valeur NULL. Nous
constatons que nous avons 8 enregistrements.
38
Si nous désirons avoir tous les peintres de la liste il nous suffit de définir la requête
suivante :
SELECT *
FROM test
WHERE code=3.
Un seul nom répond à ce critère dans notre table : CARAVAGE 3
Si maintenant, nous désirons récupérer tous les artistes qui ne sont pas peintres (code <>
3) nous devrions récupérer tous les autres enregistrements, c’est à dire 7 enregistrement
(8 - 1 = 7) en définissant la requête suivante :
SELECT *
FROM test WHERE code <> 3.
Nous obtenons le résultat suivant :
Cela est due au fait que NULL n’est pas une valeur normale puisque cela indique l’absence
de donnée dans le champ. Ce qu’il faut savoir, c’est que lorsqu’un test est effectué sur un
champ contenant NULL, le résultat ne correspond ni à vrai (TRUE) ni à faux (FALSE) mais
une valeur particulière : UNKNOWN (inconnu).
Si nous désirons récupérer la liste de toutes les personnes pour lesquels nous n’avons pas
spécifié qu’elles étaient peintre, nous devons modifier notre requête comme suit :
SELECT *
FROM test
WHERE (code <> 3) OR (code IS NULL)
En conclusion, comme la valeur NULL peut être source de pièges dans

l’utilisation des requêtes, il est conseillé, lors de la définition d’un champ, de n’autoriser la
valeur NULL que lorsque cela est justifié, c’est à dire lorsque la valeur à renseigner est
susceptible de ne pas être connue lors de la saisie d’un nouvel enregistrement mais qu’elle
pourra être renseignée plus tard.
39
d. La clause GROUP BY
La commande GROUP BY est utilisée en SQL pour grouper plusieurs résultats et
utiliser une fonction de totaux sur un groupe de résultat. La manière simple de
comprendre le GROUP BY c’est tout simplement d’assimiler qu’il va éviter de présenter
plusieurs fois les mêmes lignes : C’est une méthode pour éviter les doublons, définir de
groupes, de sous-ensembles.
De façon générale, la commande GROUP BY s’utilise de la façon suivante :

SELECT colonne1, fonction(colonne2)
FROM table
GROUP BY colonne1
NB : La clause Group by doit toujours s’utiliser après la commande WHERE et avant la

commande HAVING.
Exemple
SELECT client, SUM(tarif)
FROM achat
GROUP BY client
e. La clause HAVING
La condition HAVING en SQL est presque similaire à WHERE à la seule
différence que HAVING permet de filtrer en utilisant des fonctions telles que SUM(),
COUNT(), AVG(), MIN() ou MAX(). Elle permet donc de spécifier un filtre (condition de
regroupement des n-uplets) portant sur le résultat
Syntaxe
SELECT colonne1, SUM(colonne2)
FROM nom_table
GROUP BY colonne1
HAVING fonction(colonne2) operateur valeur
NB: La clause HAVING est très souvent utilisée en même temps que GROUP BY bien que
ça ne soit pas obligatoire.
Exemple
SELECT client, SUM(tarif)
FROM achat
GROUP BY client
HAVING SUM(tarif) > 40
f. La clause ORDER BY
Elle permet de définir le tri des colonnes de la réponse, soit en précisant le nom
littéral de la colonne, soit en précisant son n° d'ordre dans l'énumération qui suit le mot
clef SELECT. Elle permet de trier le résultat final de la requête, elle est donc la dernière
clause de tout ordre SQL et ne doit figurer qu'une seule fois dans le SELECT, même s'il
existe des requêtes imbriquées ou un jeu de requêtes ensemblistes
40
Syntaxe : ORDER BY colonne1|1 [ASC ou DSC], [colonne2|2 [ASC ou DSC] ...
Exemple
FROM T_CLIENT
ORDER BY CLI_NOM, CLI_PRENOM
ou

FROM T_CLIENT
ORDER BY 1, 2
REMARQUE :
- Par défaut les résultats sont classés par ordre ascendant ;
- Les valeurs nulles, lorsqu’elles existent dans le résultat, se situent en premier dans
l'ordre ainsi établit ;
- Le tri est un tri interne sur le résultat final de la requête, il ne faut donc placer dans
cette clause que les noms des colonnes mentionnés dans la clause SELECT
2.2.2 LA COMMANDE INSERT

L’insertion de données dans une table s’effectue à l’aide de la commande
INSERT INTO. Cette commande permet au choix d’inclure une seule ligne à la base
existante ou plusieurs lignes d’un coup.
a. Insertion d’une ligne à la fois

Pour insérer des lignes dans une table, il y a deux possibilités :
 Insérer une ligne en indiquant les informations pour chaque colonne existante (en
respectant l’ordre)
 Insérer une ligne en spécifiant les colonnes à compléter.
a.1 Insérer une ligne en spécifiant toutes les colonnes

La syntaxe pour remplir une ligne avec cette méthode est la suivante :
INSERT INTO table VALUES ('valeur 1', 'valeur 2', ...)
Cette syntaxe possède la contrainte principale qui est celle d’obliger de remplir
toutes les données de la table tout en respectant l’ordre des colonnes sinon certaines
valeurs prennent le risque d’être insérée dans la mauvaise colonne.
a.2 Insérer une ligne en spécifiant les colonnes souhaitées

Cette deuxième solution est très similaire, excepté qu’il faut indiquer le nom
des colonnes. La syntaxe est la suivante :
INSERT INTO Nom_table (nom_colonne_1, nom_colonne_2, ...)

VALUES ('valeur 1', 'valeur 2', ...)
NB: L’ordre des colonnes de la table n’est pas important.

41
b. Insertion de plusieurs lignes à la fois

Il est possible d’ajouter plusieurs lignes à un tableau avec une seule requête.
Exemple :
INSERT INTO client (prenom, nom, ville, age)
VALUES
('Rébecca', 'Armand', 'Saint-Didier-des-Bois', 24),
('Aimée', 'Hebert', 'Marigny-le-Châtel', 36),
('Marielle', 'Ribeiro', 'Maillères', 27),
('Hilaire', 'Savary', 'Conie-Molitard', 58);
Remarque : Lorsque le champ à remplir est de type VARCHAR ou TEXT il faut indiquer le
texte entre guillemet simple. En revanche, lorsque la colonne est un
numérique il n’y a pas besoin d’utiliser de guillemet, il suffit juste d’indiquer
le nombre.
NB :Il est aussi possible d’insérer des données dans une table lors de sa création par la
commande suivante :
CREATE TABLE nom_table [(nom_col1, nom_col2, ...)] AS SELECT ...
On peut ainsi, en un seul ordre SQL créer une table et la remplir avec des données
provenant du résultat d'un SELECT. Si les types des colonnes ne sont pas spécifiés, ils
correspondront à ceux du SELECT. Il en va de même pour les noms des colonnes.
CREATE TABLE Etudiant_majeur as

SELECT Et_id, nom, postnom, sexe, age
FROM ETUDIANT
WHERE age>=18
2.2.3 LA COMMANDE DELETE ET TRUNCATE

La commande DELETE permet de supprimer toutes les lignes dans une table.
En utilisant cette commande associée à WHERE, il est question de sélectionner les lignes
concernées qui seront supprimées.
Syntaxe :
DELETE FROM Nom_table
WHERE condition
Exemple : Soit la table Utilisateur (id, Nom, Prenom, date_inscription) qui contient des
informations sur les utilisateurs d’une application.
 S u ppre s s ion d’ u n e lign e

DELETE FROM utilisateur
WHERE id = 1
 S u ppre s s ion de plus ie u rs ligne s

WHERE date_inscription < 2012-04-10
42
 S u ppre s s ion de tou te s le s don n é es

L a comm an de TRU N CATE , qu an t à e lle , permet de supprimer toutes les

lignes d’une table. Elle diffère de la commande DROP qui a pour but de supprimer les
données ainsi que la table qui les contient. L’instruction TRUNCATE est semblable à
l’instruction DELETE sans utilisation de WHERE. La commande TRUNCATE est toutefois
plus rapide et utilise moins de ressource. Ces gains en performance se justifient
notamment parce que la requête n’indiquera pas le nombre d’enregistrement supprimés et
qu’il n’y aura pas d’enregistrement des modifications dans le journal.
Syntaxe : TRUNCATE TABLE Nom_table
2.2.4 LA COMMANDE UPDATE

La commande UPDATE permet d’effectuer des modifications sur des lignes
existantes. Très souvent cette commande est utilisée avec WHERE pour spécifier sur
quelles lignes doivent porter la ou les modifications.
Syntaxe :
UPDATE table
SET nom_colonne_1 = 'nouvelle valeur'
WHERE condition
Cette syntaxe permet d’attribuer une nouvelle valeur à la colonne nom_colonne_1 pour les
lignes qui respectent la condition stipulée avec WHERE. Il est aussi possible d’attribuer la
même valeur à la colonne nom_colonne_1 pour toutes les lignes d’une table si la condition
WHERE n’était pas utilisée.
NB : Pour spécifier en une seule fois plusieurs modifications, il faut séparer les attributions
de valeur par des virgules. Ainsi la syntaxe deviendrait la suivante :
UPDATE table
SET colonne_1 = 'valeur 1', colonne_2 = 'valeur 2', colonne_3 = 'valeur 3'
WHERE condition
Exemple : Soit la table « client » qui présente les coordonnées de clients.
Table « client » :
id No m R ue ville c o de_ po st al pay s
1 Chantal 12 Avenue du Petit Trianon Puteaux 92800 France
2 Pierre 18 Rue de l'Allier Ponthion 51300 France
3 Romain 3 Chemin du Chiron Trévérien 35190 France
43
Pour modifier l’adresse du client Pierre :

UPDATE client
SET rue = '49 Rue Ameline', ville = 'Saint-Eustache-la-Forêt', code_postal = '76210'
WHERE id = 2
Pour modifier toutes les lignes de colonnes pays:

UPDATE client
SET pays = 'FRANCE'
Résultats :
i d N om Ru e v ille code _ pos tal pay s
1 Chantal 12 Avenue du Petit Trianon Puteaux 92800 FRANCE
2 Pierre 49 Rue Ameline Saint-Eustache-la-Forêt 76210 FRANCE
3 Romain 3 Chemin du Chiron Trévérien 35190 FRANCE
U P D ATE a vec C ASE

Comme cela a été expliqué au début, il est aussi possible d’utiliser le CASE à la
suite de la commande SET d’un UPDATE pour mettre à jour une colonne avec une donnée
spécifique selon une règle. Imaginons par exemple que l’on souhaite offrir un produit pour
tous les achats qui ont une surcharge inférieur à 1 et que l’on souhaite retirer un produit
pour tous les achats avec une surcharge supérieur à 1. Il est possible d’utiliser la requête
SQL suivante:
UPDATE achat
SET quantite= (CASE
WHEN surcharge < 1 THEN quantite + 1
WHEN surcharge > 1 THEN quantite - 1
ELSE quantite
END )
2.2.5 LA COMMANDE MERGE

Dans le langage SQL, la commande MERGE permet d’insérer ou de mettre à
jour des données dans une table. Cette commande permet d’éviter d’effectuer plusieurs
requêtes pour savoir si une donnée est déjà dans la base de données et ainsi adapter
l’utilisation d’une requête pour ajouter ou une autre pour modifier la donnée existante.
Syntaxe :
MERGE INTO table1
USING table_reference ou requite
ON (conditions)
WHEN MATCHED THEN
UPDATE SET table1.colonne1 = valeur1, table1.colonne2 = valeur2,…
44
Voici les explications détaillées de cette requête :

1. MERGE INTO permet de sélectionner la table à modifier
2. USING et ON permet de lister les données sources et la condition de correspondance
3. WHEN MATCHED permet de définir la condition de mise à jour lorsque la condition
est vérifiée
2.2.6 LES REQUETES ENSEMBLISTES, LES SOUS-REQUETES ET LES JOINTURES
2.2.6.1 LES REQUETES ENSEMBLISTES

Les requêtes ensemblistes sont celles qui sont basées sur les résultats de deux
ou plusieurs requêtes. Ainsi nous pouvons distinguer les cas suivants :
a. L’UNION
L’union de 2 ensembles A et B est un concept qui consiste à obtenir tous les
éléments qui correspondent à la fois à l’ensemble A ou à l’ensemble B. Cela se résume
très simplement par un petit schéma où la zone hachurée correspond à la zone que l’on
souhaite obtenir (dans notre cas : tous les éléments).
La commande UNION de SQL permet de concaténer les résultats de 2 requêtes

ou plus. Pour ce faire, il est impératif que chacune des requêtes à concaténer retourne le
même nombre de colonnes, avec les mêmes types de données et dans le même ordre. Par
défaut, les enregistrements exactement identiques (pour toutes les colonnes) ne seront
pas répétés dans les résultats.
Syntaxe
SELECT * FROM table1
UNION
SELECT * FROM table2
Exemple : Soit une entreprise qui possède plusieurs magasins et dans chacun de ces
magasins il y a une table qui liste les clients. Les tables (magasin1_client,
magasin2_client) sont de la forme (prenom, nom, ville, date_naissance,
total_achat). Sachant que certains clients peuvent fréquenter les deux
magasins, pour éviter de doublons, il convient d’utiliser la requête UNION. La
requête SQL est alors la suivante :
SELECT *
FROM magasin1_client
UNION
SELECT *
La commande UNION ALL permet, à son tour, d’inclure tous les

enregistrements, même les doublons. Ainsi, la requête devient :
45
SELECT *
UNION ALL
SELECT *
b. L’INTERSECTION
L’intersection de 2 ensembles A et B correspond aux éléments qui sont présent
dans A et dans B. Cela peut être représenté par un schéma explicatif simple ou
l’intersection de A et B correspond à la zone hachurée.
La commande INTERSECT, permet donc d’obtenir l’intersection des résultats de

2 requêtes, c’est-à-dire de récupérer les enregistrements communs à 2 requêtes. Pour
faire appel à elle, il faut que les 2 requêtes retournent le même nombre de colonnes, avec
les mêmes types et dans le même ordre.
Syntaxe
SELECT *
FROM table1
INTERSECT
SELECT *
FROM table2
Exemple : Considérant le même exemple pour la gestion de clients de deux magasins,

pour obtenir la liste des clients qui sont présents de façon identiques dans ces 2
tables, la requête SQL s’écrit de la façon suivante:
SELECT * FROM magasin1_client

INTERSECT
SELECT * FROM magasin2_client
c. LA DIFFERENCE
Cette commande permet de récupérer les éléments de l’ensemble A sans
prendre en compte les éléments de A qui sont aussi présent dans l’ensemble B. Dans le
schéma ci-dessous seule la zone hachurée sera retournée grâce à la commande EXCEPT
(ou MINUS).
Dans le langage SQL la commande EXCEPT s’utilise entre 2 instructions pour

récupérer les enregistrements de la première instruction sans inclure les résultats de la
46
seconde requête. Si un même enregistrement devait être présent dans les résultats des 2
syntaxes, ils ne seront pas présents dans le résultat final. Cette commande s’appelle
différemment selon les Systèmes de Gestion de Base de Données (SGBD) :
 EXCEPT : PostgreSQL
 MINUS : MySQL et Oracle
Syntaxe
SELECT *
FROM table1
EXCEPT
SELECT *
FROM table2
NB : Les colonnes renvoyées doivent être similaires entre la première et la deuxième

requête (même nombre, même type et même ordre).
Exemple : Soit un système informatique d’une entreprise contenant des listes de clients:
 Une table « clients_inscrits » qui contient les prénoms, noms et date d’inscription de
clients
 Une table « clients_refus_email » qui contient les informations des clients qui ne
souhaitent pas être contacté par email
Pour sélectionner les clients pour envoyer un email d’information, il faut exclure les clients
de la deuxième table ne devront pas apparaître dans les résultats de la manière suivante :
SELECT prenom, nom

FROM clients_inscrits
EXCEPT
SELECT prenom, nom
FROM clients_refus_email
2.2.6.2 LES SOUS-REQUETTES

Dans le langage SQL une sous-requête, aussi appelée « requête imbriquée » ou
« requête en cascade », consiste à exécuter une requête à l’intérieur d’une autre requête.
En d’autres termes, Une sous-requête est une requête dont le résultat est utilisé par une
autre requête. Une requête imbriquée est souvent utilisée au sein d’une clause WHERE ou
de HAVING pour remplacer une ou plusieurs constantes.
Syntaxe
SELECT colonne1, colonne2,…
FROM Nom_de_la_table
WHERE nom_colonne opérateur (SELECT colonne
FROM Nom_de_la_table_2
Where prédicats)
47
NB :
- Il est possible d’utiliser n’importe quel opérateur d’égalité tel que =, >, <, >=, <=
ou <>, IN, NOT IN
- Il est impératif que la sous-requête ne renvoie qu’un seul résultat.
Exemple
SELECT Prod_id, categorie, fournisseur
FROM Produit
WHERE Prod_id NOT IN (SELECT Prod_id
FROM Commande
WHERE C_date between 2014-01-01’ and ‘2014-12-31’)
2.2.6.3 LES JOINTURES
Les jointures permettent d'exploiter pleinement le modèle relationnel des tables

d'une base de données. Elles sont faites pour combiner les colonnes, mettre en relation
deux ou plusieurs tables concourant à rechercher la réponse à des interrogations.
Remarque : Les jointures ne sont pas la seule manière de mettre en relation différentes
tables au sein d'une même requête SQL. On peut aussi joindre plusieurs
tables à l'aide des sous-requêtes ainsi qu'à l'aide des opérateurs
ensemblistes que nous avons vus précédemment.
a. Notion des alias

Dans le langage SQL il est possible d’utiliser des alias pour renommer
temporairement une colonne ou une table dans une requête. Cette astuce est
particulièrement utile pour faciliter la lecture des requêtes. L’Alias sur une colonne permet
de renommer le nom de la colonne dans les résultats d’une requête.
Syntaxe
SELECT colonne1 AS c1, colonne2
FROM table
Cette syntaxe peut également s’afficher de la façon suivante:

SELECT colonne1 c1, colonne2
FROM table
NB : Il est préférable d’utiliser la commande « AS » pour que ce soit plus explicite (plus
simple à lire qu’un simple espace), d’autant plus que c’est recommandé dans le
standard ISO pour concevoir une requête SQL.
L’Alias sur une table permet d’attribuer un autre nom à une table dans une
requête SQL. Cela peut aider à avoir des noms plus court, plus simple et plus facilement
compréhensible. Ceci est particulièrement vrai lorsqu’il y a des jointures.
Exemple :
SELECT *
FROM nom_table t1
48
Cette requête peut également s’écrire de la façon suivante:

SELECT *
FROM nom_table AS t1
b. TYPE DE JOINTURE
Selon les tables qui participent à la construction de résultats, selon le contenu
du résultat en soi, nous distinguons les types de jointures ci-dessous :
b.1 AUTO JOINTURE

Elle consiste à joindre une table à elle-même. La représentation d'une telle
jointure dans le modèle de données, se fait par le rajout d'une colonne contenant une
pseudo clef étrangère basée sur la clef de la table. C'est ce type de jointure qui rend
obligatoire l’utilisation des alias pour les tables, sinon il y a risque de confusion pour le
moteur SQL...
Syntaxe :
FROM laTable t1, laTable t2
WHERE t1.laClef = t2.laPseudoClefEtrangère
Exemple
Select a.prod_id, a._name, a.fournisseur
From produit a, produit b
Where a.fournisseur=b.fournisseur;
Exemple
SELECT cl1.Nom, cl1.Prenom, cl2.Nom, cl2.Prenom
FROM Client AS cl1, Client AS cl2
WHERE cl1.Num_Client = cl2.Num_Client
Ou
SELECT cl1.Nom, cl1.Prenom, cl2.Nom, cl2.Prenom

FROM Client AS cl1
SELF JOIN
ON Client AS cl2
b.2 JOINTURE NATURELLE

La plupart des jointures entre tables s'effectuent en imposant l'égalité des
valeurs d'une colonne d'une table à une colonne d'une autre table. On parle alors de
jointure naturelle ou équijointure. Cette condition d'égalité dans la jointure peut ne
pas porter nécessairement sur les clefs (primaires et étrangères). Le compilateur SQL va
rechercher dans les 2 tables, les colonnes dont le nom est identique. Bien entendu, le type
de données doit être le même !
49
Syntaxe :
FROM table1 NATURAL JOIN table2 [USING (colonne1 [, colonne2 ...])]
Exemple
SELECT CLI_NOM, TEL_NUMERO
FROM T_CLIENT NATURAL JOIN T_TELEPHONE
La partie optionnelle "USING" permet de restreindre les colonnes concernées, lorsque

plusieurs colonnes servent à définir la jointure naturelle. Ainsi la commande SQL devient :

FROM T_CLIENT NATURAL JOIN T_TELEPHONE USING (CLI_ID)
Ou

FROM T_CLIENT C, T_TELEPHONE T
WHERE C.CLI_ID = T.CLI_ID
Exemple : Recherche des clients dont le nom est celui d'une ville dans la table des
adresses :
SELECT DISTINCT C.CLI_ID, C.CLI_NOM, A.ADR_VILLE
FROM T_CLIENT C, T_ADRESSE A
WHERE C.CLI_NOM = A.ADR_VILLE
Il existe un opérateur normalisé INNER, pas obligatoire, permettant de traiter le

cas de l'équi-jointure :
Syntaxe :
FROM table1 [INNER] JOIN table2 ON condition de jointure
Exemple : Soit une table UTILISATEUR ainsi qu’une table COMMANDE qui contient toutes
les commandes effectuées par les utilisateurs.
Table utilisateur (id, prenom, nom, email, ville)

Table commande (utilisateur_id, date_achat, num_facture, prix_total) ;
Pour afficher toutes les commandes associées aux utilisateurs, on utilise la requête
suivante :
SELECT id, prenom, nom, date_achat, num_facture, prix_total

FROM utilisateur
INNER JOIN commande ON utilisateur.id = commande.utilisateur_id
Exemple :
SELECT DISTINCT C.CLI_ID, C.CLI_NOM, A.ADR_VILLE
FROM T_CLIENT C INNER JOIN T_ADRESSE A ON C.CLI_NOM = A.ADR_VILLE
50
Remarque :
La syntaxe avec la condition WHERE est une manière alternative de faire la
jointure mais qui possède l’inconvénient d’être moins facile à lire s’il y a déjà plusieurs
conditions dans la clause WHERE. En effet, les jointures faites dans la clause WHERE ne
permettent pas de faire la distinction, de prime abord, entre ce qui relève de la sélection
et ce qui relève de la jointure puisque tout est regroupé dans une seule clause. La lisibilité
des requêtes est plus grande en utilisant la syntaxe de l'opérateur JOIN qui permet d'isoler
les conditions de sélections (clause WHERE) de celles de jointures (clauses JOIN), et qui
permet également de cloisonner les conditions de jointures entre chaque couple de tables.
De plus, l'optimisation d'exécution de la requête est souvent plus pointue lorsque l'on
utilise l'opérateur JOIN.
b.3 NON EQUI-JOINTURE

Il s'agit là d'utiliser n'importe quelle condition de jointure entre deux tables,
excepté la stricte égalité. Nous aurons de ce fait : <, <=, >, >=, <>, !=, IN, LIKE,
BETWEEN, EXISTS
Exemple : Pour obtenir les détails de factures qui ont été émises avant que le prix des
petits déjeunés n'atteigne 4500 Fc, la requête s’écrira :
SELECT F.*
FROM T_FACTURE F, T_TARIF T
WHERE F.FAC_DATE < T.TRF_DATE_DEBUT
AND TRF_PETIT_DEJEUNE < 4500
ou
SELECT F.*
FROM T_FACTURE F INNER JOIN T_TARIF T
ON F.FAC_DATE < T.TRF_DATE_DEBUT
WHERE TRF_PETIT_DEJEUNE < 4500
b.4 CROSS JOIN

Dans le langage SQL, la commande CROSS JOIN est un type de jointure sur 2
tables qui permet de retourner le produit cartésien. Autrement dit, cela permet de
retourner chaque ligne d’une table avec chaque ligne d’une autre table. Ainsi effectuer le
produit cartésien d’une table A qui contient 30 résultats avec une table B de 40 résultats
va produire 1200 résultats (30 x 40 = 1200). En général la commande CROSS JOIN est
combinée avec la commande WHERE pour filtrer les résultats qui respectent certaines
conditions.
Syntaxe
SELECT *
FROM table1
CROSS JOIN table2
51
Méthode alternative pour retourner les mêmes résultats :

SELECT *
FROM table1, table2
L’une ou l’autre de ces syntaxes permettent d’associer tous les résultats de la table1 avec
chacun des résultats de la table2.
Exemple : Soit une application de gestion des cours suivis par des étudiants qui contient 2
tables : ETUDIANT et COURS.
Pour associer tous les étudiants avec tous les cours, il convient d’effectuer l’une ou l’autre
des requêtes suivantes:
SELECT ET_id, ET_nom, C_id, C_nom
FROM ETUDIANT
CROSS JOIN COURS
ou
SELECT ET_id, ET_nom, C_id, C_nom
FROM ETUDIANT, COURS
b.5 LEFT JOIN

Dans le langage SQL, la commande LEFT JOIN (aussi appelée LEFT OUTER
JOIN) est un type de jointure entre 2 tables qui permet de lister tous les résultats de la
table de gauche même s’il n’y a pas de correspondance dans la deuxième tables.
Syntaxe
SELECT *
FROM table1
LEFT JOIN (LEFT OUTER JOIN) table2 ON table1.id = table2.fk_id
Cette requête permet de récupérer les informations de table1 tout en récupérant les
données associées, même s’il n’y a pas de correspondance avec table2. A savoir, s’il n’y a
pas de correspondance les colonnes de table2 vaudront toutes NULL.
Exemple : Soit une application contenant des utilisateurs et des commandes pour chacun
de ces utilisateurs.
Table utilisateur :
Id P reno m No m E mail ville
1 Aimée Marechal aime.marechal@example.com Paris
2 Esmée Lefort esmee.lefort@example.com Lyon
3 Marine Prevost m.prevost@example.com Lille
4 Luc Rolland lucrolland@example.com Marseille
52
Table commande :
ut ilisa t eur_ id dat e_ ac hat num_ fac t ure prix_ t o t al
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
2 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58
Pour lister tous les utilisateurs avec leurs commandes et afficher également les utilisateurs
qui n’ont pas effectuées d’achats, il est possible d’utiliser la requête suivante:
SELECT *
FROM utilisateur
LEFT JOIN commande ON utilisateur.id = commande.utilisateur_id
Résultats :
Id P reno m No m dat e_ ac hat num_ fac t ure prix_ t o t al
1 Aimée Marechal 2013-01-23 A00103 203.14
1 Aimée Marechal 2013-02-14 A00104 124.00
2 Esmée Lefort 2013-02-17 A00105 149.45
2 Esmée Lefort 2013-02-21 A00106 235.35
3 Marine Prevost NULL NULL NULL
4 Luc Rolland NULL NULL NULL
Exemple
SELECT cl.Nom, cl.Prenom, cmd. Num_Client
FROM Client AS cl, Commande AS c
WHERE cl.Num_Client (+) = cmd.Num_Client
Ou :
SELECT cl.Nom, cl.Prenom, cmd. Num_Client

FROM Client AS cl
LEFT OUTER JOIN
ON Commande AS cmd on cl.Num_Client= cmd.Num_Client
53
b.6 RIGHT JOIN

La commande RIGHT JOIN (ou RIGHT OUTER JOIN) est un type de jointure
entre 2 tables qui permet de retourner tous les enregistrements de la table de droite
même s’il n’y a pas de correspondance avec la table de gauche.
Syntaxe
SELECT *
FROM table1
RIGHT JOIN (RIGHT OUTER JOIN) table2 ON table1.id = table2.fk_id
Cette syntaxe stipule qu’il faut lister toutes les lignes du tableau table2 (tableau de
droite) et afficher les données associées du tableau table1 s’il y a une correspondance
entre ID de table1 et FK_ID de table2. S’il n’y a pas de correspondance,
l’enregistrement de table2 sera affiché et les colonnes de table1 vaudront toutes NULL.
Exemple : Soit une base de données qui contient des utilisateurs et leur historique d’achat.
Table utilisateur :
Id P reno m No m Ville ac t if
1 Aimée Marechal Paris 1
2 Esmée Lefort Lyon 0
3 Marine Prevost Lille 1
4 Luc Rolland Marseille 1
Table commande :
ut ilisa t eur_ id dat e_ ac hat num_ fac t ure prix_ t o t al
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
3 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58
Pour afficher toutes les commandes avec le nom de l’utilisateur correspondant il est
normalement d’habitude d’utiliser INNER JOIN en SQL. Malheureusement, si l’utilisateur a
été supprimé de la table, alors ça ne retourne pas l’achat. L’utilisation de RIGHT JOIN
permet de retourner tous les achats et d’afficher le nom de l’utilisateur s’il existe. Ainsi la
requête s’écrira:
54
SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture

FROM utilisateur
RIGHT JOIN commande ON utilisateur.id = commande.utilisateur_id
Résultats :
Id p reno m no m ut ilisat eur_ id dat e_ ac hat num_ fac t ure
1 Aimée Marechal 1 2013-01-23 A00103
1 Aimée Marechal 1 2013-02-14 A00104
2 Esmée Lefort 2 2013-02-17 A00105
3 Marine Prevost 3 2013-02-21 A00106
NULL NULL NULL 5 2013-03-02 A00107
b.7 FULL JOIN

La commande FULL JOIN (ou FULL OUTER JOIN) permet de faire une jointure
entre 2 tables afin d’associer les résultats de ces dernières entre eux grâce à une condition
et remplir avec des valeurs NULL si la condition n’est pas respectée.
Syntaxe
SELECT *
FROM table1
FULL JOIN (FULL OUTER JOIN) table2 ON table1.id = table2.fk_id
Exemple : Soit une base de données qui contient une table utilisateur ainsi qu’une table
commande qui contient toutes les ventes.
Table commande :
id d a t e_ a c hat num_ fac t ure prix_ t o t al
1 2013-01-23 A00103 203.14
1 2013-02-14 A00104 124.00
2 2013-02-17 A00105 149.45
3 2013-02-21 A00106 235.35
5 2013-03-02 A00107 47.58
55
Table utilisateur :
id P reno m No m Ville ac t if
1 Aimée Marechal Paris 1
2 Esmée Lefort Lyon 0
3 Marine Prevost Lille 1
4 Luc Rolland Marseille 1
Pour lister tous les utilisateurs ayant effectué ou non une vente, et de lister toutes les
ventes qui sont associées ou non à un utilisateur. La requête est la suivante :
SELECT utilisateur.id id, prenom, nom, commande.id utilisateur_id, date_achat,

num_facture
FROM utilisateur
FULL JOIN commande ON utilisateur.id = commande.id
Résultat :
id P reno m no m ut ilisat eur_ id dat e_ ac hat num_ fac t ure
1 Aimée Marechal 1 2013-01-23 A00103
1 Aimée Marechal 1 2013-02-14 A00104
2 Esmée Lefort 2 2013-02-17 A00105
3 Marine Prevost 3 2013-02-21 A00106
4 Luc Rolland NULL NULL NULL
NULL NULL NULL 5 2013-03-02 A00107
56
2.3 LE LANGAGE DE CONTROLE DE DONNEES

Le Langage de Contrôle de Données ou Data Control Language est la partie du
SQL qui s'occupe de gérer les droits d'accès aux tables. Elle comporte les commandes de
base: GRANT et REVOKE qui permettent respectivement d'attribuer et de révoquer des
droits.
Les détails sur l’importance et l’utilisation de ces différentes commandes de
contrôle de données seront développés dans le prochain volume du support de cours.
2.4 LE LANGAGE DE CONTROLE DE TRANSACTION

Le Langage De Contrôle de Transaction ou Transaction Control Language est la
partie du SQL chargée de contrôler la bonne exécution des transactions. Elle comporte les
commandes de base suivantes : BEGIN TRANSACTION, END TRANSACTION, COMMIT,
ROLLBACK qui permettent de gérer les propriétés ACID des transactions.
Le terme "ACID", fait référence aux termes suivants :
A Atomicité : Une transaction s'effectue ou pas (tout ou rien), il n'y a pas de demi-
mesure. Par exemple l'augmentation des prix de 10% de tous les articles d'une table des
produits ne saurait être effectuée partiellement, même si le système connaît une panne en
cours d'exécution de la requête.
C Cohérence : le résultat ou les changements induits par une transaction doivent

impérativement préserver la cohérence de la base de données. Par exemple lors d'une
fusion de société, la concaténation des tables des clients des différentes entités ne peut
entraîner la présence de plusieurs client ayant le même identifiant. Il faudra résoudre les
conflits portant sur le numéro de client avant d'opérer l'union des deux tables.
I Isolation : les transactions sont isolées les unes des autres. Par exemple la mise à
jour des prix des articles ne sera visible pour d'autres transactions que si ces dernières ont
démarrées après la validation de la transaction de mise à jour des données. Il n'y aura
donc pas de vue partielle des données pendant toute la durée de la transaction de mise à
jour.
D Durabilité : une fois validée, une transaction doit perdurer, c'est à dire que les
données sont persistantes même s'il s'ensuit une défaillance dans le système. Par
exemple, dès lors qu'une transaction a été validée, comme la mise à jour des prix, les
données modifiées doivent être physiquement stockées pour qu'en cas de panne, ces
données soient conservées dans l'état où elles ont été spécifiées à la fin de la transaction.
Les détails sur l’emploi de ces différentes commandes de contrôle de

transactions seront développés dans le prochain volume du support de cours.
57
ANNEXE : MOTS RESERVES DU SQL
ABS ABSOLUTE ACTION ADD AFTER

ALL ALLOCATE ALTER AND ANY
ARE ARRAY AS ASC ASENSITIVE
ASSERTION ASYMMETRIC AT ATOMIC AUTHORIZATION
AVG BEFORE BEGIN BETWEEN BIGINT
BINARY BIT BIT_LENGTH BLOB BOOLEAN
BOTH BREADTH BY CALL CALLED
CARDINALITY CASCADE CASCADED CASE CAST
CATALOG CEIL CEILING CHAR CHARACTER
CHARACTER_LENGTH CHAR_LENGTH CHECK CLOB CLOSE
COALESCE COLLATE COLLATION COLLECT COLUMN
COMMIT CONDITION CONNECT CONNECTION CONSTRAINT
CONSTRAINTS CONSTRUCTOR CONTINUE CONVERT CORR
CORRESPONDING COUNT COVAR_POP COVAR_SAMP CREATE
CROSS CUBE CUME_DIST CURRENT CURRENT_DATE
CURRENT_DEFAULT_TRANSFORM_GROUP CURRENT_PATH CURRENT_ROLE CURRENT_TIME CURRENT_TIMESTAMP
CURRENT_TRANSFORM_GROUP_FOR_TYPE CURRENT_USER CURSOR CYCLE DATA
DATE DAY DEALLOCATE DEC DECIMAL

DECLARE DEFAULT DEFERRABLE DEFERRED DELETE
DENSE_RANK DEPTH DEREF DESC DESCRIBE
DESCRIPTOR DETERMINISTIC DIAGNOSTICS DISCONNECT DISTINCT
DO DOMAIN DOUBLE DROP DYNAMIC
EACH ELEMENT ELSE ELSEIF END
END-EXEC EQUALS ESCAPE EVERY EXCEPT
EXCEPTION EXEC EXECUTE EXISTS EXIT
EXP EXTERNAL EXTRACT FALSE FETCH
FILTER FIRST FIRST_VALUE FLOAT FLOOR
FOR FOREIGN FOUND FREE FROM
FULL FUNCTION FUSION GENERAL GET
GLOBAL GO GOTO GRANT GROUP
GROUPING HANDLE HAVING HOLD HOUR
IDENTITY IF IGNORE IMMEDIATE IN
INDICATOR INITIALLY INNER INOUT INPUT
INSENSITIVE INSERT INT INTEGER INTERSECT
INTERSECTION INTERVAL INTO IS ISOLATION
JOIN KEY LAG LANGUAGE LARGE
LAST LAST_VALUE LATERAL LEAD LEADING
LEAVE LEFT LEVEL LIKE LN
LOCAL LOCALTIME LOCALTIMESTAMP LOCATOR LOOP
LOWER MAP MATCH MAX MEMBER
MERGE METHOD MIN MINUTE MOD
MODIFIES MODULE MONTH MULTISET NAMES
NATIONAL NATURAL NCHAR NCLOB NESTING
58
NEW NEXT NO NONE NORMALIZE

NOT NTH_VALUE NTILE NULL NULLIF
NULLS NUMERIC OBJECT OCTET_LENGTH OF
OFFSET OLD ON ONLY OPEN
OPTION OR ORDER ORDINALITY OUT
OUTER OUTPUT OVER OVERLAPS OVERLAY
PAD PARAMETER PARTIAL PARTITION PATH
PERCENTILE_CONT PERCENTILE_DISC PERCENT_RANK POSITION POWER
PRECISION PREPARE PRESERVE PRIMARY PRIOR
PRIVILEGES PROCEDURE PUBLIC RANGE RANK
READ READS REAL RECURSIVE REDO
REF REFERENCES REFERENCING REGR_AVGX REGR_AVGY
REGR_COUNT REGR_INTERCEPT REGR_R2 REGR_SLOPE REGR_SXX
REGR_SXY REGR_SYY RELATIVE RELEASE REPEATE
RESIGNAL RESPECT RESTRICT RESULT RETURN
RETURNS REVOKE RIGHT ROLE ROLLBACK
ROLLUP ROUTINE ROW ROWS ROW_NUMBER
SAVEPOINT SCHEMA SCOPE SCROLL SEARCH
SECOND SECTION SELECT SENSITIVE SESSION
SESSION_USER SET SETS SIGNAL SIMILAR
SIZE SMALLINT SOME SPACE SPECIFIC
SPECIFICTYPE SQL SQLCODE SQLERROR SQLEXCEPTION
SQLSTATE SQLWARNING SQRT START STATE
STATIC STDDEV_POP STDDEV_SAMP SUBMULTISET SUBSTRING
SUM SYMMETRIC SYSTEM SYSTEM_USER TABLE
TABLESAMPLE TEMPORARY THEN TIME TIMESTAMP
TIMEZONE_HOUR TIMEZONE_MINUTE TO TRAILING TRANSACTION
TRANSLATE TRANSLATION TREAT TRIGGER TRIM
TRIM_ARRAY TRUE UESCAPE UNDER UNDO
UNION UNIQUE UNKNOWN UNNEST UNTIL
UPDATE UPPER USAGE USER USING
VALUE VALUES VARCHAR VARYING VAR_POP
VAR_SAMP VIEW WHEN WHENEVER WHERE
WHILE WIDTH_BUCKET WINDOW WITH WITHIN
WITHOUT WORK WRITE YEAR ZONE
59
BIBLIOGRAPHIE
1. Articles en ligne sur Developpez.com. LE SQL de A à Z : Le simple (?) SELECT et

les fonctions SQL. (http://sql.developpez.com/sqlaz/select), 2005.
2. Articles en ligne sur Developpez.com. LE SQL de A à Z : Les jointures, ou comment

interroger plusieurs tables. (http://sql.developpez.com/sqlaz/jointures), 2005.
3. Cyril Gruau. Conception d'une base de données. (http:// cyril-

gruau.developpez.com/uml/tutoriel/ConceptionBD/), 2006.
4. Didier Banos and Michel Mouyssinat. De Merise aux bases de données. Eyrolles,
1990.
5. Dominique Dionisi. L'essentiel sur Merise. Eyrolles, 1993.
6. Encyclopédie Wikipédia. Articles en ligne sur Wikipédia. (http://fr.wikipedia.org),

2005.
7. Jacky Akoka and Isabelle Comyn-Wattiau. Conception des bases de données

relationnelles. Vuibert informatique, 2001.
8. Jérôme Gabillaud. SQL et algèbre relationnelle - Notions de base. TechNote. ENI,

February 2004.
9. John Kauffman, Brian Matsik, and Kevin Spencer. Maîtrisez SQL. CampusPress, 20
August 2001.
10. Michael J. Hernandez and John L. Viescas. Introduction aux requêtes SQL. Eyrolles,
6 June 2001
11. Robert Godin. Systèmes de gestion de bases de données, volume 2. Loze-Dion,

2000.
12. Yolaine Bourda. Le langage SQL. (http://wwwlsi.supelec.fr/www/yb/poly_bd/sql/

tdm_sql.html), 2005.
13. Yolaine Bourda. Systèmes de Gestion de Bases de Données Relationnelles.

(http://wwwlsi.supelec.fr/www/yb/poly_bd/poly.html), 2005.
60
TABLE DES MATIERES

CHAP I : NOTIONS PRELIMINAIRES .............................................................................................. 1
1.1 QUELQUES DEFINITIONS .................................................................................... 1
1.2 LES REGLES DE NOMENCLATURE D’UN IDENTIFICATEUR ...................................... 3
1.3 ORDRE DE CREATION DE COLONNES ................................................................... 4
1.4 DOCUMENTATION, ERGONOMIE, ET ECRITURE .................................................... 4
1.5 COMMENTAIRES EN SQL ..................................................................................... 5
1.6 TYPE DE DONNEES.............................................................................................. 6
CHAP II : LES SUBDIVISIONS DU LANGAGE SQL ........................................................................ 8

2.1 LE LANGAGE DE DEFINITION DE DONNEES .......................................................... 8
2.1.1 LA COMMANDE CREATE ............................................................................................. 8
2.1.2 LES COMMANDES ALTER ET DROP ............................................................................. 17
2.2 LE LANGAGE DE MANIPULATION DE DONNEES ................................................... 19

2.2.1 LA COMMANDE SELECT ................................................................................................ 19
2.2.2 LA COMMANDE INSERT ................................................................................................ 41
2.2.3 LA COMMANDE DELETE ET TRUNCATE ..................................................................... 42
2.2.4 LA COMMANDE UPDATE ............................................................................................... 43
2.2.5 LA COMMANDE MERGE ................................................................................................. 44
2.2.6 LES REQUETES ENSEMBLISTES, LES SOUS-REQUETES ET LES JOINTURES.................... 45
2.3 LE LANGAGE DE CONTROLE DE DONNEES..................................................................... 57
2.4 LE LANGAGE DE CONTROLE DE TRANSACTION ............................................................. 57
ANNEXE : MOTS RESERVES DU SQL.......................................................................................................... 58
BIBLIOGRAPHIE ............................................................................................................................................ 60
61

Support de Cours Langage de Gestion SQL. G3 Info

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support de Cours Langage de Gestion SQL. G3 Info

Transféré par

Droits d'auteur :

Formats disponibles

UNIKIN/FAC DES SCIENCES/G3 INFO

CHAP I : NOTIONS PRELIMINAIRES

Il est impératif, pour quiconque se veut manipuler le langage SQL, de connaitre

1.1 QUELQUES DEFINITIONS

Exemple : Entité Etudiant

Exemple : Date de Naissance, Nom,… pour l’entité Etudiant

Exemple : Les différentes dates de naissance des étudiants

Exemple : Les différentes informations renseignées comprenant le nom, le postnom, la

e. Clef (Clé ou Clef primaire)

Exemple : Le Numéro matricule d’un étudiant

h. Contrainte et intégrité référentielle

Exemple : On ne peut commander un produit qui existe dans l’entrepôt

i. Violation (de contrainte, de clef)

n. Microsoft SQL Server

1.2 LES REGLES DE NOMENCLATURE D’UN IDENTIFICATEUR

Règles pour les identificateurs réguliers

4. Le nom d’un objet peut contenir les caractères suivants :

NOTA: Les caractères de ponctuation (, ; : ! ? ...) et autres caractères spéciaux, comme le

1.3 ORDRE DE CREATION DE COLONNES

L'ordre de création et de description des colonnes devra répondre aux règles

1.4 DOCUMENTATION, ERGONOMIE, ET ECRITURE

 Les commandes ou requêtes sont séparées par des points-virgules ;

 Toutes les colonnes renvoyées devront être nommées :

1.5 COMMENTAIRES EN SQL

a. Commentaire double tiret : –-

1.6 TYPE DE DONNEES

A chaque colonne, variable locale, expression et paramètre correspond un type

Character (ou Char) :

Character Varying (ou Varchar ou char varying) :

Numeric (ou Decimal ou dec) :

Integer (ou Int):

Exemple : 2015-07-08 correspond au 8 Juillet 2015.

CHAP II : LES SUBDIVISIONS DU LANGAGE SQL

Le langage SQL comporte quatre grandes parties qui permettent :

 La définition des éléments d'une base de données : Langage de définition de

 La manipulation des données : langage de manipulation de données ou Data

 La gestion des droits d'accès aux données : Langage de contrôle de données ou

 La gestion des transactions : Langage de contrôle de transactions ou Transaction

2.1 LE LANGAGE DE DEFINITION DE DONNEES

Grâce aux commandes de base : CREATE, ALTER, DROP ; le Langage de

2.1.1 LA COMMANDE CREATE

a. CREATION DE LA BASE DE DONNEES

Syntaxe : CREATE DATABASE nom_de_la_base ;

Exemple : CREATE DATABASE GESTION_ETUDIANT ;

b. CREATION DES TABLES

Exemple : CREATE TABLE T_ETUDIANT

B.1 LES CONTRAINTES AU SEIN D’UNE TABLE

b.1.1 NULL / NOT NULL

Exemple : --insertion et modification acceptées :

Exemple : -- insertion et modification refusées :

b.1.3 PRIMARY KEY

Dans le cas de plusieurs colonnes constituant la clef, la syntaxe est :

CONSTRAINT nom_contrainte PRIMARY KEY (liste_colonne)

INSERT INTO T_PERSONNE7 VALUES ('Konde', 'Eric', '08989891000') ;

Les contraintes définies ci-dessus indiquent:

En cas de contrôle de validation multi-colonnes au sein de la table, la syntaxe

b.1.6 FOREIGN KEY :

CREATE TABLE T_FACTURE1

CREATE DOMAIN D_ALFA_FIX_32 CHAR(32);

CREATE DOMAIN D_ALFA_VAR_32 VARCHAR(32);

CREATE TABLE T_CLIENT

b.2 MODE GESTION DE L’INTEGRITE

CREATE TABLE souscategorie (

CREATE TABLE employe (