Vous êtes sur la page 1sur 78

i

REPUBLIQUE DEMOCRATIQUE DU CONGO


ENSEIGNEMENT SUPERIEUR ET UNIVERSITAIRE

INSTITUT SUPERIEUR D’INFORMATIQUE ET DE GESTION


ISIG
DEVELOPPEMENT
ISIG

PROFES
MATION

B.P. 841 GOMA

Cours du langage SQL

Dispensé Par: l'Assistant Irenge Balolage Jean de Dieu

Promotion: L1 RTEL

V.H: 45h

Année Académique 2018 – 2019


ii

Les Objectifs

1. Comprendre des notions de base du langage SQL.

2. Maitriser les Aspects du langage SQL

3. Ecrire et lire des Requêtes SQL simples et complexes.

4. Interroger efficacement une Base des données Relationnelle


1

CHAP.I Introduction Générale


1.1 Brève Historique de SQL

En 1970, Edgar Frank Codd (E.F. COD), Directeur de recherche du centre IBM de San José,
invente le modèle relationnel qui repose sur une algèbre relationnelle. Ce modèle provoque
une révolution dans l’approche des bases des données.

En 1977, création du langage SEQUEL (Structured English Query Language) et mise en


place du Système R, prototype de base de données reposant sur la théorie de CODD.
SEQUEL continue de s’enrichir pour devenir SQL (Structured Query Language).

C’est IBM, à tout seigneur tout honneur, qui, avec System-R, a implanté le modèle
relationnel au travers du langage SEQUEL (Stuctured English as QUEry Language),
rebaptisé par la suite SQL (Structured Query Language).

La première norme (SQL1) date de 1987. Elle était le résultat de compromis entre
constructeurs, mais elle était fortement influencée par le dialecte d’IBM.

SQL2 (appelée aussi SQL92 est présentée en 600 pages) a été normalisée en1992. . Elle
Définit quatre niveaux de conformité : le niveau d’entrée (entry level), les niveaux
intermédiaires (transitional et intermediate levels) et le niveau supérieur (full level). Les
langages SQL des principaux éditeurs sont tous conformes au premier niveau et ont beaucoup
de caractéristiques relevant des niveaux supérieurs.
Le niveau d’entrée peut être perçu comme une amélioration de SQL1, alors que les niveaux
intermédiaire et complet permettent de supporter totalement le modèle relationnel avec des
domaines variés, tels date et temps.

SQL3
La norme SQL3 (intitulée initialement SQL:1999)
Comporte de nombreuses parties : concepts objets, entrepôts de données, séries temporelles,
2

Accès à des sources non SQL, réplication des données, etc. Les groupes de travail X3H2 de
l’ANSI et WG3 de l’ISO se penchent à partir de 1993 sur les
Extensions à apporter à la précédente norme. Les optimistes prévoient SQL3 pour 1996 mais
rien ne se passe comme prévu. C’est en 1999 que naît SQL:1999, appelé aussi SQL3 (présenté
dans un volume de 1 600 pages). Ce retard est probablement dû aux nombreux protagonistes
(Oracle,IBM, Microsoft, Digital, Computer Associates…) qui rechignent à remettre en cause
leur mode de pensée, au risque de ne pouvoir assurer la compatibilité des bases de leurs
clients.

Les évolutions de l’ancienne norme ne sont pas limitées qu’aux extensions objet. Bien
d’autres mécanismes sont introduits dans SQL:1999 (géographie, temps réel, séries
temporelles, multimédia, OLAP, données et routines externes).

La dernière version de SQL est référencée SQL:2003. Ses apports concernent l’auto-
incrément des clés, de nouvelles fonctions d’agrégation, de ranking(classement) et de calculs
statistiques, les colonnes calculées, et surtout une prise en charge de XML. Il est prévu de
s’occuper des aspects relatifs aux bases de données déductives dans SQL4.

Le succès que connaissent les éditeurs de SGBD relationnels a plusieurs origines et repose
notamment sur SQL :
• Le langage est une norme depuis 1986, qui s’enrichit au fil du temps.
• SQL peut s’interfacer avec des langages de troisième génération comme C ou Cobol,
mais aussi avec des langages plus évolués comme C++, Java ou C#. Certains
considèrent ainsi que le langage SQL n’est pas assez complet (le dialogue entre la base
et l’interface n’est pas direct), et la littérature parle de « défaut d’impédance »
(impedance mismatch).
• Les SGBD rendent indépendants programmes et données (la modification d’une
structure de données n’entraîne pas forcément une importante refonte des programmes
d’application).
• Ces systèmes sont bien adaptés aux grandes applications informatiques de gestion
(architectures type client-serveur et Internet) et ont acquis une maturité sur le plan de
la fiabilité et des performances.
3

• Ils intègrent des outils de développement comme les précompilateurs, les générateurs
de code, d’états, de formulaires.
• Ils offrent la possibilité de stocker des informations non structurées (
l’image, etc.)

NB. :
SQL est désormais un langage incontournable pour tout SGBD moderne.
Par contre, bien qu’une norme existe, on assiste à une prolifération de dialectes propres à
chaque produit : soit des sous-ensembles de la norme (certaines fonctionnalités n’étant pas
implantées), soit des sur-ensembles (ajout de certaines fonctionnalités, propres à chaque
produit).

1.2. Classification des ordres SQL

Ordres SQL Aspect du langage SQL comme


CREATE – ALTER – DROP - RENAME – TRUNCATE Définition des données Langage de définition
(LDD ) des Données
INSERT – UPDATE – DELETE - LOCK TABLE Manipulation des Langage de
Manipulation
données (LMD)
de Données
SELECT Interrogation des Langage
données (LID) d'Interrogation des
données
GRANT – REVOKE – COMMIT – ROLLBACK – Contrôle des données Langage de contrôle
SAVEPOINT - SET TRANSACTION
(LCD) des données

NB: SQL intégré

Le SQL intégré (Embedded SQL) permet d’utiliser SQL dans un langage de de programmation (C,
Java, Cobol, etc.) :

1.3 bases de données et l'approche SGBD


4

1.3.1 Qu’est-ce qu’une base de données ?

Définition Base de données

- Un ensemble organisé d’informations avec un objectif commun. Peu importe le support


utilisé pour rassembler et stocker les données (papier, fichiers, etc.),dès lors que des données
sont rassemblées et stockées d’une manière organisée dans un but spécifique, on parle de
base de données. Plus précisément, on appelle base de données un ensemble structuré et
organisé permettant le stockage de grandes quantités d’informations afin d’en faciliter
l’exploitation (ajout, mise à jour, recherche de données). Bien entendu, dans le cadre de ce
cours, nous nous intéressons aux bases de données informatisées.

Base de données informatisée

Une base de données informatisée est un ensemble structuré de données enregistrées sur des
supports accessibles par l’ordinateur, représentant des informations du monde réel et pouvant
être interrogées et mises à jour par une communauté d’utilisateurs. Le résultat de la
conception d’une base de données informatisée est une description des données. Par
description on entend définir les propriétés d’ensembles d’objets modélisés dans la base de
données et non pas d’objets particuliers. Les objets particuliers sont créés par des programmes
d’applications ou des langages de manipulation lors des insertions et des mises à jour des
données. Cette description des données est réalisée en utilisant un modèle de données. Ce
dernier est un outil formel utilisé pour comprendre l’organisation logique des données. La
gestion et l’accès à une base de données sont assurés par un ensemble de programmes qui
constituent le Système de gestion de base de données (SGBD).

1.3.2 Approche sur le Système de Gestion de Base des données

La gestion et l’accès à une base de données sont assurés par un ensemble de programmes
qui constituent le Système de gestion de base de données (SGBD). Un SGBD doit permettre
l’ajout, la modification et la recherche de données.
Un système de gestion de bases de données héberge généralement plusieurs bases de
données, qui sont destinées à des logiciels ou des thématiques différents.
5

Actuellement, la plupart des SGBD fonctionnent selon un mode client/serveur. Le serveur


(sous entendu la machine qui stocke les données) reçoit des requêtes de plusieurs clients et
ceci de manière concurrente. Le serveur analyse la requête, la traite et retourne le résultat au
client. Le modèle client/serveur est assez souvent implémenté au moyen de l’interface des
sockets (voir le cours de réseau) ; le réseau étant Internet.
6

CHAP II. LA SYNTAXE DU LANGAGE SQL et LANGAGE SQL


COMME LANGAGE DE DEFINITION DES DONNEES

Ce chapitre décrit les instructions SQL qui constituent l’aspect LDD (langage de définition des
données) de SQL. À cet effet, nous verrons notamment comment déclarer une table, ses éventuels
contraintes.

2.1 Le Syntaxe du Langage SQL

a) Commentaires

On peut insérer des commentaires de deux façons :


– sur une ligne, à partir de deux tirets -- ;
– dans un bloc délimité par /* et par */.

b) Noms d'objets

Tous les noms d’objets (table, colonne, variable, etc.) doivent respecter les règles suivantes :
– Les noms d'objets peuvent comporter des lettres majuscules ou minuscules (accentuées ou
pas), des chiffres et les symboles, par exemple : _, $ et #.

– commencer par une lettre ;


– ne pas contenir d’espace
Par ailleurs, on est pas obligé de respecter la casse (i.e. il n’y a aucune différence entre les
majuscules et les minuscules). Mais on prendra l’habitude de laisser en majuscule les mots-
clés du langage et seulement les mots-clés du langage.

c) Opérateurs

– Les opérateurs arithmétiques disponibles sont : +, -, *, / et % le reste par division entière ;


– les opérateurs de comparaison logique sont : <, <=, =, >=, > et <> (différent) ;
– les autres opérateurs logique sont : AND, OR et NOT ;

d) Variables

Les principaux types disponibles sont :


7

• INT entier
• DECIMAL(9,2) montant à 9 chiffres (décimaux) dont 2 après la virgule
• REAL réel flottant codé sur 24 bits
• CHAR(64) chaîne de caractère de longueur fixe 64
• VARCHAR(64) chaîne de caractère de longueur variable mais inférieure ou égale à 64
• DATETIME date et/ou heure avec une précision de 3.33 ms

2.2. LANGAGE SQL COMME LANGAGE DE DEFINITION DES DONNEES

2.2.1. DATABASE

a) CREATE DATABASE

La création d’une base de données en SQL est possible en ligne de commande. Même si les
systèmes de gestion de base de données (SGBD) sont souvent utilises pour créer une base, il
convient de connaitre la commande a utiliser, qui est très simple.

Syntaxe
Pour créer une base de données qui sera appelé ma_base , il suffit d’utiliser la requête
suivante qui est très simple :

CREATE DATABASE ma_base

Dans le standard SQL la commande CREATE DATABASE n’existe normalement pas. En


conséquent il revient de vérifier la documentation des différents SGBD pour verifier les
syntaxes possibles pour définir des options. Ces options permettent selon les cas, de définir
les jeux de caractères, le propriétaire de la base ou même les limites de connexion.

b) DROP DATABASE

En SQL, la commande DROP DATABASE permet de supprimer totalement une base de


données et tout ce qu’elle contient. Cette commande est a utiliser avec beaucoup d’attention
car elle permet de supprimer tout ce qui est inclus dans une base: les tables, les données, les
index …

Syntaxe
8

Pour supprimer la base de données ma_base , la requête est la suivante :


DROP DATABASE ma_base

2.2.2 . LES TABLES

a) CREATE TABLE
La commande CREATE TABLE permet de créer une table en SQL. Un tableau est une entité
qui est contenu dans une base de données pour stocker des données ordonnées dans des
colonnes. La création d’une table sert a définir les colonnes et le type de données qui seront
contenus dans chacun des colonne (entier, chaine de caractères, date, valeur binaire …).

Syntaxe
La syntaxe générale pour créer une table est la suivante :

CREATE TABLE nom_de_la_table


(
colonne1 type_donnees,
colonne2 type_donnees,
colonne3 type_donnees,
colonne4 type_donnees
)

Imaginons que l'ont souhaite créer une table utilisateur, dans laquelle chaque ligne correspond
a un utilisateur inscrit sur un site web. La requête pour créer cette table peut ressembler a ceci
:

CREATE TABLE utilisateur


(id INT PRIMARY KEY,nom VARCHAR(100), prenom VARCHAR(100),email
VARCHAR(255),date_naissance DATE,pays VARCHAR(255),ville
VARCHAR(255),code_postal VARCHAR(5),nombre_achat INT)

b) ALTER TABLE
9

La commande ALTER TABLE en SQL permet de modifier une table existante. Il est ainsi
possible d’ajouter une colonne, d’en supprimer une ou de modifier une colonne existante, par
exemple pour changer le type.

Syntaxe de base
D'une manière générale, la commande s’utilise de la manière suivante :

ALTER TABLE nom_table


instruction

Le mot-clé " instruction " ici sert a designer une commande supplémentaire, qui sera détaillée
ci-dessous selon l’action que l’ont souhaite effectuer : ajouter, supprimer ou modifier une
colonne.

b.1) Ajouter une colonne

Syntaxe

L’ajout d’une colonne dans une table est relativement simple et peut s’effectuer a l’aide d’une
requête ressemblant a ceci :

ALTER TABLE nom_table


ADD nom_colonne type_donnees

Exemple

Pour ajouter une colonne qui correspond a une rue sur une table utilisateur, il est possible
d’utiliser la requête suivante :

ALTER TABLE utilisateur


ADD adresse_rue VARCHAR(255)

b.2 )Supprimer une colonne

Une syntaxe permet également de supprimer une colonne pour une table. Il y a 2 manières
totalement équivalente pour supprimer une colonne :

ALTER TABLE nom_table


DROP nom_colonne

Ou (le résultat sera le même)

ALTER TABLE nom_table


DROP COLUMN nom_colonne
10

b.3 )Modifier une colonne

Pour modifier une colonne, comme par exemple changer le type d’une colonne, il y a
différentes syntaxes selon le SGBD.

MySQL
ALTER TABLE nom_table
MODIFY nom_colonne type_donnees

PostgreSQL

ALTER TABLE nom_table


ALTER COLUMN nom_colonne TYPE type_donnees

SQL server

ALTER TABLE nom_table


ALTER COLUMN nom_colonne Type_donne
Ici, le mot-clé " type données " est a remplacer par un type de données tel que INT,
VARCHAR, TEXT, DATE …

E) Renommer une colonne

Pour renommer une colonne, il convient d’indiquer l’ancien nom de la colonne et le nouveau
nom de
celle-ci.

MySQL
Pour MySQL, il faut également indiquer le type de la colonne.

ALTER TABLE nom_table


CHANGE colonne_ancien_nom colonne_nouveau_nom type_donnees

Ici " type données " peut correspondre par exemple a INT, VARCHAR, TEXT, DATE …

PostgreSQL

Pour PostgreSQL la syntaxe est plus simple et ressemble a ceci (le type n’est pas demande) :

ALTER TABLE nom_table


11

RENAME COLUMN colonne_ancien_nom TO colonne_nouveau_nom

SQL Server

Pour SQL server , il existe une procédure Stockée qui permet de renommer le nom
d'une colonne.

Exec Sp_Rename 'Table.AncienNom','NouveauNom','COLUMN'

EXemple
exec sp_rename'dbo.TBRANCHE1.createdate','createdate','COLUMN'

C) SQL DROP TABLE


La commande DROP TABLE en SQL permet de supprimer définitivement une table d’une
base de données. Cela supprime en même temps les éventuels index, trigger, contraintes et
permissions associées a cette table.

Attention : il faut utiliser cette commande avec attention car une fois supprimée, les données
sont perdues. Avant de l’utiliser sur une base importante il peut être judicieux d’effectuer un
backup (une sauvegarde) pour éviter les mauvaises surprises.
Syntaxe

Pour supprimer une table " nom_table "il suffit simplement d’utiliser la syntaxe suivante :

DROP TABLE nom_table

A savoir : s’il y a une dépendance avec une autre table, il est recommande de les supprimer
avant de supprimer la table. C’est le cas par exemple s’il y a des clés étrangères.
Intérêts
Il arrive qu’une table soit crée temporairement pour stocker des données qui n’ont pas
vocation a être réutiliser. La suppression d’une table non utilisée est avantageux sur plusieurs
aspects :
• Libérer de la mémoire et alléger le poids des backups
• Eviter des erreurs dans le futur si une table porte un nom similaire ou qui porte a confusion
• Lorsqu’un développeur ou administrateur de base de données découvre une application, il
est plus rapide de comprendre le système s’il n’y a que les tables utilisées qui sont présente
Exemple de requête
Imaginons qu’une base de données possède une table " client_2009 " qui ne sera plus jamais
utilise et qui existe déjà dans un ancien backup. Pour supprimer cette table, il suffit
d’effectuer la requête
suivante :

DROP TABLE client_2009

L’exécution de cette requête va permettre de supprimer la table.


12

d) TRUNCATE TABLE

En SQL, la commande TRUNCATE permet de supprimer toutes les données d’une table sans
supprimer la table en elle-même. En d’autres mots, cela permet de purger la table. Cette
instruction diffère de la commande DROP qui a pour but de supprimer les données ainsi que
la table qui les contient.
A noter : l’instruction TRUNCATE est semblable a l’instruction DELETE sans utilisation de
WHERE.

Parmi les petite différences TRUNCATE est toutefois plus rapide et utilise moins de
ressource. Ces
gains en performance se justifie notamment parce que la requete n’indiquera pas le nombre
d’enregistrement supprimes et qu’il n’y aura pas d’enregistrement des modifications dans le
journal.
Syntaxe
Cette instruction s’utilise dans une requete SQL semblable a celle-ci :
TRUNCATE TABLE `table`
Dans cet exemple, les données de la table " table " seront perdues une fois cette requête
exécutée.

2.2.3 Contraintes

Les contraintes ont pour but de programmer des règles de gestion au niveau des colonnes des
tables. Elles peuvent alléger un développement côté client (si on déclare qu’une note doit être
comprise entre 0 et 20, les programmes de saisie n’ont plus à tester les valeurs en entrée mais
seulement le code retour après connexion à la base ; on déporte les contraintes côté serveur).
Quatre types de contraintes sont possibles :

CONSTRAINT nomContrainte
• UNIQUE (colonne1 [,colonne2]…)
• PRIMARY KEY (colonne1 [,colonne2]…)
• FOREIGN KEY (colonne1 [,colonne2]…)
REFERENCES [schéma.]nomTablePere (colonne1 [,colonne2]…)
[ON DELETE { CASCADE | SET NULL }]
• CHECK (condition)
13

● La contrainte UNIQUE impose une valeur distincte au niveau de la table (les valeurs nulles
font exception à moins que NOT NULL soit aussi appliquée sur les colonnes).
exemple
CREATE TABLE personne
(
id int not null identity primary key,
nom varchar(20) not null ,
prenom varchar(20) null,
date_naissance smalldatetime null,
lieu_naissance varchar(255),
nombre_enfant int not null default 0,Constraint UniqueNomPrenocombine
unique (nom, prenom)
)
● La contrainte PRIMARY KEY déclare la clé primaire de la table. Un index est généré
automatiquement sur la ou les colonnes concernées. Les colonnes clés primaires ne peuvent
être ni nulles ni identiques (en totalité si elles sont composées de plusieurs colonnes).
Exemple 1;
CREATE TABLE personne
(
id int not null primary key,
nom varchar(20) not null ,
prenom varchar(20) null,
date_naissance datetime null,
lieu_naissance varchar(255),
nombre_enfant int not null default 0
)
Exemple 2

CREATE TABLE telephone


(
id int not null,
id_personne int not null,
numero varchar(20) not null,constraint Pk_Personne
primary key (id, id_personne)
)

● La contrainte FOREIGN KEY déclare une clé étrangère entre une table enfant (child) et
une table père (parent). Ces contraintes définissent l’intégrité référentielle que nous
aborderons plus tard. La directive ON DELETE dispose de deux options : CASCADE
propagera la suppression de tous les enregistrements fils rattachés à l’enregistrement père
supprimé, SET NULL positionnera seulement leur clé étrangère à NULL .

CREATE TABLE telephone


(
id int not null,
id_personne int not null,
numero varchar(20) not null,
primary key (id),Constraint Fktelephone personne
foreign key (id_personne) references personne (id)
14

)
La commande foreign key (id_personne) references personne (id)
indique que id_personne de la table telephone référence la clé primaire id de la table
personne.Le SGBD vérifiera alors, pour toute modification pouvant affecter le lien entre les
deux tables, que la valeur de id_personne correspond bien à une ligne de personne.

● La contrainte CHECK impose un domaine de valeurs ou une condition simple ou


complexe entre colonnes (exemple : CHECK (note BETWEEN 0 AND 20), CHECK
(grade='Copilote' OR grade='Commandant')).
NB. : Les contraintes peuvent être déclarées de deux manières :
● En même temps que la colonne (valable pour les contraintes monocolonnes), ces contraintes
sont dites « en ligne » (inline constraints). L’exemple précédent en déclare deux.
● Une fois la colonne déclarées, ces contraintes ne sont pas limitées à une colonne et peuvent
être personnalisées par un nom (out-of-line constraints).
• Autres Contraintes
NOT NULL ou NULL : Interdit (NOT NULL) ou autorise (NULL) l’insertion
de valeur NULL pour cet attribut.
DEFAULT valeur : Permet de spécifier la valeur par défaut de l’attribut.

2.2.4 Vues
a) Notion
Outre le contrôle de l’accès aux données (privilèges), la confidentialité des informations est
un aspect important qu’un SGBD relationnel doit prendre en compte. La confidentialité est
renforcée par l’utilisation de vues (views) qui agissent comme des fenêtres sur la base de
données. Cette section décrit les différents types de vues qu’on peut rencontrer. Les vues
correspondent à ce qu’on appelle « le niveau externe » qui reflète la partie visible de la base
de données pour chaque utilisateur. Seules les tables contiennent des données et, pourtant,
pour l’utilisateur, une vue apparaît comme une table. En théorie, les utilisateurs ne devraient
accéder aux informations qu’en questionnant des vues. Ces dernières masquant la structure
des tables interrogées. En pratique, la plupart des applications se passent de ce concept en
manipulant directement les tables. La définition d'une vue est donnée par un SELECT qui
indique les données de la base qui seront vues. Les utilisateurs pourront consulter la base, ou
modifier la base (avec certaines restrictions) à travers la vue, c'est-à-dire manipuler les
données renvoyés par la vue comme si c'était des données d'une table réelle.

Une vue est considérée comme une table virtuelle car elle n’a pas d’existence propre. Seule sa
Structure est stockée dans le dictionnaire. Ses données seront extraites de la mémoire à partir
Des tables source, à la demande. Une vue est créée à l’aide d’une instruction SELECT
appelée « requête de définition ». Cette requête interroge une (ou plusieurs) table(s) ou vue(s).
Une vue se recharge chaque fois qu’elle est interrogée.
b) Classification
15

On distingue les vues simples des vues complexes en fonction de la nature de la requête de
Définition

NB.
• Lorsqu’il est possible d’exécuter des instructions INSERT, UPDATE ou DELETE sur une vue,
cette dernière est dite « modifiable » (updatable view).
• Pour qu’une vue simple soit modifiable, sa requête de définition doit respecter les critères
suivants :
o pas de directive DISTINCT, de fonction (AVG, COUNT, MAX, MIN, SUM, ou
VARIANCE),
d’expression dans le SELECT ;

o pas de GROUP BY, ORDER BY ou HAVING.

• Pour pouvoir modifier une vue complexe, les restrictions sont les suivantes :

o La requête de définition ne doit pas contenir de sous-interrogation (jointure


procédurale).

o Il n’est pas possible d’utiliser d’opérateur ensembliste (sauf UNION [ALL]).

a) CREATE VIEW

La commande CREATE VIEW permet de créer une vue en spécifiant le


SELECT constituant la définition de la vue :

CREATE VIEW nom_vue (col1, col2...) AS SELECT ...


ou
CREATE VIEW nom_vue AS SELECT ...

exemple
Vue ne comportant que le matricule, le nom et le département des
employés :
CREATE VIEW EMP2 (MATR, NOM, DEPT)
AS SELECT MATR, NOM, DEPT FROM EMP

b) DROP VIEW
16

DROP VIEW vue_Name

supprime la vue.

c) Utilisation des vues

Une vue peut être référencée dans un SELECT de la même façon qu'une
table. Ainsi, il est possible de consulter la vue EMP10. Tout se passe comme
s'il existait une table EMP10 des employés du département 10 :

SELECT * FROM EMP10

d) Utilité des vues


De façon générale, les vues permettent de dissocier la façon dont les utilisateurs voient les
données, du découpage en tables. On sépare l'aspect externe (ce que voit un utilisateur
particulier de la base) de l'aspect conceptuel (comment a été conçu l'ensemble de la base).
Ceci favorise l'indépendance entre les programmes et les données. Si la structure des données
est modifiée, les programmes ne seront pas à modifier si l'on a pris la précaution d'utiliser des
vues (ou si on peut se ramener à travailler sur des vues).
17

CHAP III. LANGAGE SQL COMME LANGAGE DE


MANIPULATION DES DONNEES

Ce chapitre décrit l’aspect LMD (langage de manipulation des données) de SQL. Il existe une
autre possibilité, que nous ne détaillerons pas, pour insérer des données dans les tables en
utilisant des outils d’importation propre à chaque SGBD. Nous verrons que SQL propose trois
instructions pour manipuler des données :

● L’insertion d’enregistrements : INSERT ;


● La modification de données : UPDATE ;
● La suppression d’enregistrements : DELETE

3.1 SQL INSERT INTO

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

Insertion d’une ligne à la fois

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


• 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 que vous souhaitez compléter. Il est possible
d’insérer une ligne en renseigner seulement une partie des colonnes
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 les avantages et inconvénients suivants :

• Obliger de remplir toutes les données, tout en respectant l’ordre des colonnes
• Il n’y a pas le nom de colonne, donc les fautes de frappe sont limitées. Par ailleurs, les
colonnes peuvent être renommées sans avoir a changer la requête
• L’ordre des colonnes doit reste identique sinon certaines valeurs prennent le risque d’être
complétée dans la mauvaise colonne
Insérer une ligne en spécifiant seulement les colonnes souhaitées
Cette deuxième solution est très similaire, excepte qu’il faut indiquer le nom des colonnes
avant " VALUES ". La syntaxe est la suivante :
18

INSERT INTO table(nom_colonne_1, nom_colonne_2, ...) VALUES ('valeur 1', 'valeur 2', ...)

NB : il est possible de ne pas renseigner toutes les colonnes. De plus, l’ordre des colonnes
n’est pas important.

Insertion de plusieurs lignes à la fois

Il est possible d’ajouter plusieurs lignes à un tableau avec une seule requête. Pour ce faire, il
convient d’utiliser la syntaxe suivante :

INSERT INTO NomTable (colonne1, colonne2,...)


SELECT colonne1, colonne2... FROM NomTable2
WHERE CONDITION

OU

INSERT INTO client (prenom, nom, ville, age)


VALUES
('Rebecca', 'Armand', 'Saint-Didier-des-Bois', 24),
('Aimee', 'Hebert', 'Marigny-le-Chatel', 36),
('Marielle', 'Ribeiro', 'Mailleres', 27),
('Hilaire', 'Savary', 'Conie-Molitard', 58)

A noter : lorsque le champ a remplir est de type VARCHAR ou TEXT il faut indiquer le
texte entre guillemet simple. En revanche, lorsque la colonne est un numérique tel que INT ou
BIGINT il n’y a pas besoin d’utiliser de guillemet, il suffit juste d’indiquer le nombre.

3.2 SQL 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
La syntaxe basique d’une requête utilisant UPDATE est la suivante :

UPDATE table SET nom_colonne_1 = 'nouvelle valeur' WHERE condition

Cette syntaxe permet d’attribuer une nouvelle valeur a la colonne nom_colonne_1 pour les
lignes qui respectent la condition stipule avec WHERE. Il est aussi possible d’attribuer la
même valeur a la colonne nom_colonne_1 pour toutes les lignes d’une table si la condition
WHERE n’était pas utilisée. A noter, pour spécifier en une seule fois plusieurs modification,
19

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

Cette syntaxe permet d’attribuer une nouvelle valeur a la colonne nom_colonne_1 pour les
lignes qui respectent la condition stipule avec WHERE. Il est aussi possible d’attribuer la
même valeur a la colonne nom_colonne_1 pour toutes les lignes d’une table si la condition
WHERE n’était pas utilisée. A noter, pour spécifier en une seule fois plusieurs modification,
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

3.3 DELETE
La commande DELETE en SQL permet de supprimer des lignes dans une table. En utilisant
cette commande associe a WHERE il est possible de sélectionner les lignes concernées qui
seront supprimées.

Attention : Avant d’essayer de supprimer des lignes, il est recommande d’effectuer une
sauvegarde de la base de données, ou tout du moins de la table concernée par la suppression.
Ainsi, s’il y a une mauvaise manipulation il est toujours possible de restaurer les données.
Syntaxe
La syntaxe pour supprimer des lignes est la suivante :

DELETE FROM table WHERE condition

Attention : s’il n’y a pas de condition WHERE alors toutes les lignes seront supprimées et la
table sera alors vide.

exemple.
Si l’ont souhaite supprimer les utilisateurs qui se sont inscrit avant le " 10/04/2012″, il va
falloir effectuer la requête suivante :

DELETE FROM utilisateur WHERE date_inscription < '2012-04-10'


20

CHAP.IV. SQL COMME LANGAGE D'INTERROGATION ET


CONTROLE DES DONNEES

4.1 SQL COMME LANGAGE D'INTERROGATION DES DONNEES

4.1.0 SQL SELECT

L’utilisation la plus courante de SQL consiste à lire des données issues de la base de données.
Cela s’effectue grâce à la commande SELECT, qui retourne des enregistrements dans un
tableau de résultat. Cette commande peut sélectionner une ou plusieurs colonnes d’une table.

Commande basique

L’utilisation basique de cette commande s’effectue de la manière suivante :

SELECT nom_du_champ
FROM nom_du_tableau

Cette requête va sélectionner (SELECT) le champ " nom_du_champ " provenant (FROM) du
tableau appelé " nom_du_tableau ".

Exemple
Imaginons une base de données appelée " client" qui contient des informations sur les clients
d’une entreprise.
Table « client » :

Si l’ont veut avoir la liste de toutes les villes des clients, il suffit d’effectuer la requête
suivante :

SELECT ville FROM client


21

Avec la même table client il est possible de lire plusieurs colonnes a la fois. Il suffit tout
simplement de séparer les noms des champs souhaites par une virgule. Pour obtenir les
prénoms et les noms des clients il faut alors faire la requête suivante:

SELECT prenom, nom FROM client

Il est possible de retourner automatiquement toutes les colonnes d’un tableau sans avoir a
connaitre le nom de toutes les colonnes. Au lieu de lister toutes les colonnes, il faut
simplement utiliser le caractere " * " (etoile). C’est un joker qui permet de sélectionner toutes
les colonnes. Il s’utilise de la maniere suivante :

SELECT * FROM client

4.1.1 ordre des commandes du SELECT


Une requête SELECT peut devenir assez longue. Juste à titre informatif, voici une requête
SELECT qui possède presque toutes les commandes possibles :

SELECT *
FROM table
WHERE condition
GROUP BY expression
HAVING condition
{ UNION | INTERSECT | EXCEPT }
ORDER BY expression
LIMIT count
OFFSET start

4.1.2 .DISTINCT
L’utilisation de la commande SELECT en SQL permet de lire toutes les données d’une ou
plusieurs colonnes. Cette commande peut potentiellement afficher des lignes en doubles. Pour
éviter des redondances dans les résultats il faut simplement ajouter DISTINCT après le mot
SELECT.
L’utilisation basique de cette commande consiste alors a effectuer la requete suivante :

SELECT DISTINCT ma_colonne FROM nom_du_tableau

Cette requete selectionne le champ " ma_colonne " de la table " nom_du_tableau " en évitant
de retourner des doublons.

NB. Pour le Systeme de Gestion de Bases de Donnees (SGBD) Oracle, cette requete est
remplacee par
la commande " UNIQUE " :
SELECT UNIQUE ma_colonne
22

FROM nom_du_tableau

4.1.3 AS (alias) dans SQL

Alias sur une colonne

Permet de renommer le nom d’une colonne dans les résultats d’une requête SQL. C’est
pratique pour avoir un nom facilement identifiable dans une application qui doit ensuite
exploiter les résultats d’une recherche.

La syntaxe pour renommer une colonne de colonne1 à c1 est la suivante :

SELECT colonne1 AS c1, colonne2 FROM `table`

Cette syntaxe peut également s’afficher de la façon suivante :

SELECT colonne1 c1, colonne2 FROM `table`

Alias sur une table


La syntaxe pour renommer une table dans une requete est la suivante :

SELECT * FROM `nom_table` AS t1

Cette requête peut également s’écrire de la façon suivante :

SELECT * FROM `table`t1

4.1.4. 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
La commande WHERE s’utilise en complément à une requete utilisant SELECT. La façon la
plus simple de l’utiliser est la suivante :

SELECT nom_colonnes FROM nom_table WHERE condition


23

Exemple: Pour obtenir seulement la liste des clients qui habitent à Paris, il faut effectuer la
requête suivante :

SELECT * FROM client WHERE ville = 'paris'

Exemple
Imaginons une base de données appelée " client " qui contient le nom des clients, le nombre
de commandes qu’ils ont effectués et leur ville :

Pour obtenir seulement la liste des clients qui habitent a Paris, il faut effectuer la requete
suivante :

SELECT * FROM client WHERE ville = 'paris'

• Opérateurs de comparaisons

Il existe plusieurs opérateurs de comparaisons. La liste ci-jointe présente quelques-uns des


opérateurs les plus couramment utilises.

• SQL AND & OR

Une requête SQL peut être restreinte a l’aide de la condition WHERE. Les operateurs
logiques AND et OR peuvent être utilisées au sein de la commande WHERE pour combiner
des conditions.

Syntaxe d’utilisation des opérateurs AND et OR


24

Les operateurs sont a ajoutes dans la condition WHERE. Ils peuvent être combines a l’infini
pour filtrer les données comme souhaites.
L’operateur AND permet de s’assurer que la condition1 ET la condition2 sont vrai :

SELECT nom_colonnes FROM nom_table WHERE condition1 AND condition2

L’operateur OR verifie quant a lui que la condition1 OU la condition2 est vrai :

SELECT nom_colonnes FROM nom_table WHERE condition1 OR condition2

Ces operateurs peuvent être combines a l’infini et mélanges. L’exemple ci-dessous filtre les
résultats
de la table " nom_table " si condition1 ET condition2 OU condition3 est vrai :

SELECT nom_colonnes FROM nom_table WHERE condition1 AND (condition2 OR


condition3)

Attention : il faut penser à utiliser des parenthèses lorsque c’est nécessaire. Cela permet
d’éviter les erreurs car et ca améliore la lecture d’une requête par un humain.

4.1.5 IN

L’operateur logique IN dans SQL s’utilise avec la commande WHERE pour verifier si une
colonne est égale a une des valeurs comprise dans une liste des valeurs déterminées. C’est une
méthode simple pour verifier si une colonne est égale a une valeur OU une autre valeur
OU une autre valeur et ainsi de suite, sans avoir a utiliser de multiple fois l’operateur
OR.
Syntaxe
Pour chercher toutes les lignes ou la colonne "nom_colonne " est égale a ‘valeur 1′ OU
‘valeur 2′ ou ‘valeur 3′, il est possible d’utiliser la syntaxe suivante :

SELECT nom_colonne FROM table WHERE nom_colonne IN ( valeur1, valeur2, valeur3,


...)

NB.
La syntaxe utilisée avec l’operateur est plus simple que d’utiliser une succession d’operateur
OR. Pour le montrer concrètement avec un exemple, voici 2 requêtes qui retournerons les
mêmes résultats, l’une utilise l’operateur IN, tandis que l’autre utilise plusieurs OR.

Requête avec plusieurs OR


25

SELECT prenom FROM utilisateur WHERE prenom = 'Maurice' OR prenom = 'Marie' OR


prenom = 'Thimote'

Requête équivalent avec l’opérateur IN

SELECT prenom FROM utilisateur WHERE prenom IN ( 'Maurice', 'Marie', 'Thimote' )

4.1.6 BETWEEN

L’operateur BETWEEN est utilise dans une requête SQL pour sélectionner un intervalle de
données dans une requête utilisant WHERE. L’intervalle peut être constitue de chaines de
caractères, de nombres ou de dates. L’exemple le plus concret consiste par exemple a
récupérer uniquement les
enregistrements entre 2 dates définies.
Syntaxe
L’utilisation de la commande BETWEEN s’effectue de la manière suivante :

SELECT * FROM table WHERE nom_colonne BETWEEN 'valeur1' AND 'valeur2'

La requête suivante retournera toutes les lignes dont la valeur de la colonne " nom_colonne "
sera comprise entre valeur1 et valeur2.
Exemple1:
Si l’ont souhaite obtenir les membres qui se sont inscrit entre le 1 avril 2012 et le 20 avril
2012 il est possible d’effectuer la requête suivante :

SELECT * FROM utilisateur WHERE date_inscription BETWEEN ’2012-04-01′ AND


’2012-04-20′

Exemple2:
Si l’ont souhaite obtenir tous les résultats dont l’identifiant n’est pas situe entre 4 et 10, il
faudra alors utiliser la requête suivante :

SELECT * FROM utilisateur WHERE id NOT BETWEEN 4 AND 10

4.1.7 LIKE
26

L’operateur LIKE est utilise dans la clause WHERE des requêtes SQL. Ce mot-clé permet
d’effectuer une recherche sur un modèle particulier. Il est par exemple possible de rechercher
les enregistrements dont la valeur d’une colonne commence par telle ou telle lettre. Les
modèles de
recherches sont multiple.
Syntaxe

La syntaxe a utiliser pour utiliser l’operateur LIKE est la suivante :

SELECT * FROM table WHERE colonne LIKE modele


Exemples:

• LIKE ‘%a’ : le caractère " % " est un caractère joker qui remplace tous les autres
caractères.
Ainsi, ce modèle permet de rechercher toutes les chaines de caractère qui se termine par un "
a ".
• LIKE ‘a%’ : ce modèle permet de rechercher toutes les lignes de " colonne " qui commence
par un " a ".
• LIKE ‘%a%’ : ce modèle est utilise pour rechercher tous les enregistrement qui utilisent le
caractère " a ".
• LIKE ‘pa%on’ : ce modèle permet de rechercher les chaines qui commence par " pa " et
qui se terminent par " on ", comme " pantalon " ou " pardon ".

4.1.8 SQL IS NULL / IS NOT NULL

Dans le langage SQL, l’operateur IS permet de filtrer les colonnes qui contiennent la valeur
NULL. Cet operateur est indispensable car la valeur NULL est une valeur inconnue et ne peut
par conséquent pas être filtrée par les operateurs de comparaison (cf. égal, inferieur, supérieur
ou différent).

Syntaxe
Pour filtrer les résultats ou les champs d’une colonne sont a NULL il convient d’utiliser la
syntaxe suivante :

SELECT * FROM `table` WHERE nom_colonne IS NULL

A l’inverse, pour filtrer les résultats et obtenir uniquement les enregistrements qui ne sont pas
null, il convient d’utiliser la syntaxe suivante :

SELECT * FROM `table` WHERE nom_colonne IS NOT NULL

NB:
l’operateur IS retourne en réalité un booléen, c’est a dire une valeur TRUE si la condition
est vrai ou FALSE si la condition n’est pas respectée. Cet operateur est souvent utilise avec la
condition WHERE mais peut aussi trouve son utilité lorsqu’une sous-requête est utilisée.
27

4.1.9. Utilisation d’autres fonctions de statistiques

Il existe plusieurs fonctions qui peuvent être utilisées pour manipuler plusieurs
enregistrements, il s’agit des fonctions d’agrégations statistiques, les principales sont les
suivantes :
• AVG() pour calculer la moyenne d’un set de valeur. Permet de connaitre le prix du panier
moyen pour de chaque client
• COUNT() pour compter le nombre de lignes concernées. Permet de savoir combien d’achats
a été effectue par chaque client
• MAX() pour récupérer la plus haute valeur. Pratique pour savoir l’achat le plus cher
• MIN() pour récupérer la plus petite valeur. Utile par exemple pour connaitre la date du
premier achat d’un client
• SUM() pour calculer la somme de plusieurs lignes. Permet par exemple de connaitre le total
de tous les achats d’un client Ces petites fonctions se révèlent rapidement indispensable pour
travailler sur des données.

4.1.10 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. Sur une table qui contient toutes les ventes d’un
magasin, il est par exemple possible de liste regrouper les ventes par clients identiques et
d’obtenir le cout total des achats pour chaque client.

Syntaxe d’utilisation de GROUP BY

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

exemple:
Pour obtenir le cout total de chaque client en regroupant les commandes des mêmes clients, il
faut utiliser la requête suivante :

SELECT client, SUM(tarif) FROM achat GROUP BY client

4.1.11 SQL HAVING


28

La condition HAVING en SQL est presque similaire a WHERE a la seule différence que
HAVING permet de filtrer en utilisant des fonctions telles que SUM(), COUNT(), AVG(),
MIN() ou MAX().

Syntaxe
L’utilisation de HAVING s’utilise de la maniere suivante :

SELECT colonne1, SUM(colonne2) FROM nom_table GROUP BY colonne1 HAVING


fonction(colonne2) operateur valeur

Exemple

Pour utiliser un exemple concret, imaginons une table " achat " qui contient les achats de
différents clients avec le cout du panier pour chaque achat.

Si dans cette table on souhaite récupérer la liste des clients qui ont commande plus de 40€,
toute commandes confondu alors il est possible d’utiliser la requête suivante :

SELECT client, SUM(tarif) FROM achat GROUP BY client HAVING SUM(tarif) > 40

Résultat :

4.1.12 SQL ORDER BY

La commande ORDER BY permet de trier les lignes dans un résultat d’une requête SQL. Il
est possible de trier les données sur une ou plusieurs colonnes, par ordre ascendant ou
descendant.
Syntaxe
Une requête ou l’ont souhaite filtrer l’ordre des résultats utilise la commande ORDER BY de
la sorte :

SELECT colonne1, colonne2 FROM table ORDER BY colonne1


29

Par défaut les résultats sont classes par ordre ascendant, toutefois il est possible d’inverser
l’ordre en utilisant le suffixe DESC après le nom de la colonne. Par ailleurs, il est possible de
trier sur plusieurs colonnes en les séparant par une virgule. Une requête plus élabore
ressemblerais alors cela :

SELECT colonne1, colonne2, colonne3 FROM table ORDER BY colonne1 DESC, colonne2
ASC

A noter : il n’est pas oblige d’utiliser le suffixe " ASC " sachant que les résultats sont
toujours classe par ordre ascendant par défaut. Toutefois, c’est plus pratique pour mieux s’y
retrouver, surtout si on a oublie l’ordre par défaut.

EXEMPLE

En utilisant deux méthodes de tri, il est possible de retourner les utilisateurs par ordre
alphabétique ET pour ceux qui ont le même nom de famille, les trier par ordre décroissant
d’inscription. La requête serait alors la suivante :

SELECT * FROM utilisateur ORDER BY nom, date_inscription DESC

4.1.13.SQL LIMIT

La clause LIMIT est à utiliser dans une requête SQL pour spécifier le nombre
maximum de résultats que l’ont souhaite obtenir. Cette clause est souvent associe a un
30

OFFSET, c’est-a-dire effectuer un décalage sur le jeu de résultat. pagination (exemple


: récupérer les 3 clients de la page 27 ).

ATTENTION : selon le système de gestion de base de données, la syntaxe ne sera pas pareil.
Ce tutoriel va donc présenter la syntaxe pour MySQL et pour PostgreSQL.

Syntaxe simple
La syntaxe commune aux principales système de gestion de bases de données est la suivante :

SELECT * FROM table LIMIT 10

Cette requête permet de récupérer seulement les 10 premiers résultats d’une table. Bien
entendu, si la table contient moins de 10 résultats, alors la requête retournera toutes les lignes.
Bon à savoir : la bonne pratique lorsque l’ont utilise LIMIT consiste a utiliser également la
clause ORDER BY pour s’assurer que quoi qu’il en soit ce sont toujours les bonnes données
qui sont présentées. En effet, si le système de tri est non spécifié, alors il est en principe
inconnu et les résultats peuvent être imprévisible

4.1.14 SQL UNION

La commande UNION de SQL permet de mettre bout-a-bout les résultats de plusieurs


requêtes utilisant elles-mêmes la commande SELECT. C’est donc une commande qui permet
de concaténer les résultats de 2 requêtes ou plus. Pour l’utiliser il est nécessaire que chacune
des requêtes a concaténer retournes le même nombre de colonnes, avec les mêmes types de
données et dans le même ordre.

A savoir : par défaut, les enregistrements exactement identiques ne seront pas répètes dans les
résultats. Pour effectuer une union dans laquelle même les lignes dupliquées sont affichées il
faut plutôt utiliser la commande UNION ALL.
Syntaxe La syntaxe pour unir les résultats de 2 tableaux sans afficher les doublons est la
suivante :

SELECT * FROM table1


UNION
SELECT * FROM table2

Syntaxe La syntaxe pour unir les résultats de 2 tableaux en affichant les doublons est la
suivante :

SELECT * FROM table1


UNION ALL
SELECT * FROM table2
31
32

4.1.15. Jointure SQL

Les jointures en SQL permettent d’associer plusieurs tables dans une même requête. Cela
permet d’exploiter la puissance des bases de données relationnelles pour obtenir des résultats
qui combinent les données de plusieurs tables de manière efficace.

Le processus de normalisation du modèle relationnel est basé sur la décomposition et a pour


conséquence d’augmenter le nombre de tables d’un schéma. Ainsi, la majorité des requêtes
utilisent des jointures nécessaires pour pouvoir extraire des données de tables distinctes.
Une jointure met en relation deux tables sur la base d’une clause de jointure (comparaison de
Colonnes). Généralement, cette comparaison fait intervenir une clé étrangère d’une table avec
une clé primaire d’une autre table (car le modèle relationnel est fondamentalement basé sur
les valeurs).
a) Classifications des jointures Classification

Bien que, dans le vocabulaire courant, on ne parle que de « jointures » en fonction de la


nature de l’opérateur utilisé dans la requête, de la clause de jointure et des tables concernées,
on distingue :
a.1 Les jointures internes (inner joins) :

L’équijointure (equi join) est la plus connue, elle utilise l’opérateur d’égalité(=) dans
la
Clause de jointure. La non équijointure utilise l’opérateur d’inégalité dans la clause de
jointure (<>, >, <, >=, <=, BETWEEN, LIKE, IN).À l’inverse des équijointures, la clause
d’une inéquijointure n’est pas basée sur l’égalité de clés primaires (ou candidates) et de clés
étrangères.
L’autojointure (self join) est un cas particulier de l’équijointure, qui met en œuvre
deux
fois la même table (des alias de tables permettront de distinguer les enregistrements
Entre eux).

a.2 La jointure externe (outer join) :

La plus compliquée, qui favorise une table (dite « dominante ») par rapport à l’autre (dite «
subordonnée »). Les lignes de la table dominante sont retournées même si elles ne satisfont
pas aux conditions de jointure. Les jointures externes sont généralement basées sur les clés
Primaires et étrangères. On distingue les jointures unilatérales qui considèrent une table domi-
nante et une table subordonnée, et les jointures bilatérales pour lesquelles les tables jouent un
Rôle symétrique (pas de dominant).

a.3 Jointures procédurales

Les jointures procédurales sont écrites par des requêtes qui contiennent des sous-interroga-
tions (SELECT imbriqué). Chaque clause FROM ne contient qu’une seule table.
SELECT colonnesTable1 FROM [nomBase.]nomTable1
WHERE colonne(s) | expression(s) { IN | = | opérateur }
(SELECT colonne(s)delaTable2 FROM [nomBase.]nomTable2
33

WHERE colonne(s) | expression(s) { IN | = | opérateur }


(SELECT …)
[AND (conditionsTable2)]
)
[AND (conditionsTable1)];

b) Les techniques pour associer les tables entre elles


Il y a plusieurs techniques pour associer 2 tables ensemble. Voici la liste des différentes
techniques qui sont utilisées :

• INNER JOIN : jointure interne pour retourner les enregistrements quand la condition est
vrai dans les 2 tables. C’est l’une des jointures les plus communes.

• LEFT JOIN (ou LEFT OUTER JOIN) : jointure externe pour retourner tous les
enregistrements de la table de gauche (LEFT = gauche) même si la condition n’est pas verifie
dans l’autre table.
• RIGHT JOIN (ou RIGHT OUTER JOIN) : jointure externe pour retourner tous les
enregistrements de la table de droite (RIGHT = droite) même si la condition n’est pas vérifie
dans l’autre table.
• FULL JOIN (ou FULL OUTER JOIN) : jointure externe pour retourner les résultats
quand la condition est vrai dans au moins une des 2 tables.

• CROSS JOIN : jointure croisée permettant de faire le produit cartésien de 2 tables. En


d’autres mots, permet de joindre chaque lignes d’une table avec chaque lignes d’une seconde
table. Attention, le nombre de résultats est en général très élevé.

b.1) SQL INNER JOIN

Dans le langage SQL la commande INNER JOIN, aussi appelée EQUIJOIN, est un type de
jointures très communes pour lier plusieurs tables entre-elles. Cette commande retourne les
enregistrements lorsqu’il y a au moins une ligne dans chaque colonne qui correspond a la
condition.

Syntaxe
Pour utiliser ce type de jointure il convient d’utiliser une requête SQL avec cette syntaxe :

SELECT *
FROM table1
INNER JOIN table2 ON table1.id = table2.fk_id

Exemple
Imaginons une application qui possède une table utilisateur ainsi qu’une table commande qui
contient toutes les commandes effectuées par les utilisateurs.
Table utilisateur :
34

Table commande :

Pour afficher toutes les commandes associées aux utilisateurs, il est possible d’utiliser 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
Résultats :

b.2) CROSS JOIN

Dans le langage SQL, la commande CROSS JOIN est un type de jointure sur 2 tables SQL
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.
Attention, le nombre de résultat peut facilement être très élevé. S’il est effectue sur des tables
avec beaucoup d’enregistrements, cela peut ralentir sensiblement le serveur.

Syntaxe
Pour effectuer un jointure avec CROSS JOIN, il convient d’effectuer une requête SQL
respectant la syntaxe suivante :

SELECT *
35

FROM table1
CROSS JOIN table2

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 table1 avec chacun
des résultats de table2.

Exemple
Imaginons une application de recettes de cuisines qui contient 2 tables d’ingrédients, la table
légume et la table fruit.

Pour une raison quelconque l’application doit associer tous les légumes avec tous les fruits.
Toutes les combinaisons doivent être affichées. Pour cela il convient d’effectuer l’une ou
l’autre des requêtes
suivantes :

SELECT l_id, l_nom_fr_fr, f_id, f_nom_fr_fr FROM legume CROSS JOIN fruit

ou :

SELECT l_id, l_nom_fr_fr, f_id, f_nom_fr_fr FROM legume, fruit


36

b.3) SQL LEFT JOIN

Dans le langage SQL, la commande LEFT JOIN (aussi appelée LEFT OUTER JOIN) est un
type de jointure entre 2 tables. Cela permet de lister tous les résultats de la table de gauche
(left = gauche) même s’il n’y a pas de correspondance dans la deuxième tables.

Syntaxe

Pour lister les enregistrement de table1, même s’il n’y a pas de correspondance avec table2, il
convient d’effectuer une requête SQL utilisant la syntaxe suivante.
SELECT *
FROM table1
LEFT JOIN table2 ON table1.id = table2.fk_id
La requête peux aussi s’écrire de la façon suivante :
SELECT * FROM table1 LEFT OUTER JOIN table2 ON table1.id = table2.fk_id
Cette requête est particulièrement intéressante pour 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
Imaginons une application contenant des utilisateurs et des commandes pour chacun de ces
utilisateurs. La base de données de cette application contient une table pour les utilisateurs et
sauvegarde leurs achats dans une seconde table. Les 2 tables sont reliées grâce a la colonne
utilisateur_id de la table des commandes. Cela permet d’associer une commande a un
utilisateur.

Table utilisateur :
37

Table commande :

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

b.4) SQL RIGHT JOIN


En SQL, 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 (right = droite)
même s’il n’y a pas de correspondance avec la table de gauche. S’il y a un enregistrement de
la table de droite qui ne trouve pas de correspondance dans la table de gauche, alors les
colonnes de la table de gauche auront NULL pour valeur.
Syntaxe
L’utilisation de cette commande SQL s’effectue de la facon suivante :
38

SELECT * FROM table1 RIGHT JOIN table2 ON table1.id = table2.fk_id


La syntaxe de cette requete SQL peux aussi s’ecrire de la facon suivante :
SELECT * FROM table1 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 affiche
et les colonnes de table1 vaudront toutes NULL.
Exemple
Prenons l’exemple d’une base de données qui contient des utilisateurs et un historique d’achat
de ces utilisateurs. Cette 2 tables sont reliées entre grâce a la colonne utilisateur_id de la table
des commandes. Cela permet de savoir a quel utilisateur est associe un achat.

Table utilisateur :

Table commande :

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é supprime de la table, alors ca 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. Pour cela il
convient d’utiliser cette requête :

SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture FROM utilisateur


RIGHT JOIN commande ON utilisateur.id = commande.utilisateur_id

Résultats :
39

b.5) SQL FULL JOIN

Dans le langage SQL, la commande FULL JOIN (ou FULL OUTER JOIN) permet de faire
une jointure entre 2 tables. L’utilisation de cette commande permet de combiner les resultats
des 2 tables, les associer entre eux grâce a une condition et remplir avec des valeurs NULL si
la condition n’est pas respectée.
Syntaxe
Pour retourner les enregistrements de table1 et table2, il convient d’utiliser une requete SQL
avec une syntaxe telle que celle-ci :
SELECT *
FROM table1
FULL JOIN table2 ON table1.id = table2.fk_id

Cette requête peut aussi être conçu de cette façon :

SELECT *
FROM table1
FULL OUTER JOIN table2 ON table1.id = table2.fk_id

La condition présentée ici consiste a lier les tables sur un identifiant, mais la condition peut
être définie sur d’autres champs.
Exemple
Prenons l’exemple d’une base de données qui contient une table utilisateur ainsi qu’une table
commande qui contient toutes les ventes.
Table utilisateur :
40

Il est possible d’utiliser FULL JOIN pour lister tous les utilisateurs ayant effectue ou non une
vente, et
de lister toutes les ventes qui sont associees ou non a un utilisateur. La requête SQL est la
suivante :

SELECT id, prenom, nom, utilisateur_id, date_achat, num_facture


FROM utilisateur
FULL JOIN commande ON utilisateur.id = commande.utilisateur_id

4.1.14 SQL Sous-requête

Dans le langage SQL une sous-requête (aussi appelé " requête imbriquée " ou " requête en
cascade ") consiste a exécuter une requête a l’intérieur d’une autre requête. Une requête
imbriquée est souvent utilisée au sein d’une clause WHERE ou de HAVING pou remplacer
une ou plusieurs constante.

Syntaxe

Il y a plusieurs façons d’utiliser les sous-requêtes. De cette façon il y a plusieurs syntaxes


envisageables pour utiliser des requêtes dans des requêtes.

Requête imbriquée qui retourne un seul résultat


41

L’exemple ci-dessous est une exemple typique d’une sous-requete qui retourne un seul
résultat à la requête principale.

SELECT *
FROM `table`
WHERE `nom_colonne` = (
SELECT `valeur`
FROM `table2`
LIMIT 1
)
Cet exemple montre une requête interne (celle sur " table2″) qui renvoi une seule valeur. La
requête externe quant a elle, va chercher les résultat de " table " et filtre les résultats à partir de
la valeur retournée par la requête interne.

A noter :
Il est possible d’utiliser n’importe quel operateur d’égalité tel que =, >, <, >=, <= ou <>.
• Il est possible d’imbriquer plusieurs requêtes et il n’y a pas de limite dans le nombre de
niveaux d’imbrication .Le résultat de chaque requête imbriquée sert de valeur de référence
dans la condition de sélection de la requête de niveau supérieur, appelée requête
principale.
• La sous-requête peut renvoyer soit une ligne, soit plusieurs.
Si la sous-requête renvoie plusieurs lignes, nous avons deux cas, selon que la
sous-requête est indépendante de la requête principale ou synchronisée avec
elle.
Si la sous-requête est synchronisée avec la requête principale, on parle de
requête corrélée.
Remarques

ANY : la condition est vraie si elle est vérifiée Pour au moins une des valeurs renvoyées par
la sous-requête
ALL : la condition est vraie si elle est vérifiée
Pour chacune des valeurs renvoyées par la
Sous-requête
IN : la condition est vraie si elle est vérifiée
Pour une des valeurs renvoyées par la sous-requête
La condition de sélection emploie alors :

• L’opérateur IN (équivalent à = ANY)


• L’opérateur NOT IN (équivalent à != ALL)
• Un opérateur simple ( =, !=, <>, <, >, <=,
>=) suivi de ALL ou ANY
• L’opérateur EXISTS

Exemple de requête imbriquée renvoyant plusieurs lignes


42

Ex1 : Donner les numéros des voyages Passant pour une ville où passe aussi le Voyage
numéro 4

SELECT DISTINCT numVoyage FROM Etape WHERE numVille IN (SELECT


numVille FROM Etape WHERE numVoyage = 4)

Ex2 : Numéros des voyages dont il n’y a pas eu de départs après le mois de septembre 2014

SELECT numVoyage FROM Voyage WHERE numVoyage NOT IN (SELECT


numVoyage FROM Tarif
WHERE dateDeb > '30-09-14')

Exemple de requête imbriquée renvoyant une seule ligne


Question:
Donner les numéros des voyages ayant le même type de pension que le voyage
numéro 4

SELECT numVoyage FROM Voyage WHERE typePension = (SELECT typePension


FROM Voyage WHERE numVoyage = 4)

• Opérateur EXISTS

... WHERE EXISTS (sous-select)


Cet opérateur permet de construire un prédicat évalué à vrai si la sous-requête
Renvoie au moins une ligne

Exemple

Numéros des voyages qui font au moins 6 étapes


SELECT numVoyage FROM Voyage V
WHERE EXISTS (SELECT * FROM Etape E
WHERE numOrdre = 6
AND E.numVoyage = V.numVoyage)

Remarque :
• L’instruction Sql suivant permet de créer une table à partir d’une autre table existante

Create table Tcours1 as select codec , Intitule from Tcours


43

Nb :Possible dans Mysql

4.2 SQL COMME LANGAGE DE CONTROLE DES DONNES

4.2.1 APPROCHE

Les types d’utilisateurs, leurs fonctions et leur nombre peuvent varier d’une base à une autre.
Néanmoins, pour chaque base de données en activité, on peut classifier les utilisateurs de la
manière suivante :
● Le DBA (DataBase Administrator). Il en existe au moins un. Une petite base peut n’avoir
qu’un seul administrateur. Une base importante peut en regrouper plusieurs qui se partagent
les tâches suivantes :
– installation et mises à jour de la base et des outils éventuels ;
– gestion de l’espace disque et des espaces pour les données (tablespaces) ;
– gestion des utilisateurs et de leurs objets;
– optimisation des performances ;
– sauvegardes, restaurations et archivages ;
– contact avec le support technique.
● L’administrateur réseaux (qui peut être le DBA) se charge de la configuration de
l’intergiciel(middleware) au niveau des postes clients.
● Les développeurs qui conçoivent et mettent à jour la base. Ils peuvent aussi agir sur leurs
objets (création et modification des tables, index, séquences, etc.). Ils transmettent au DBA
leurs demandes spécifiques (stockage, optimisation, sécurité).
44

● Les administrateurs d’applications qui gèrent les données manipulées par l’application ou
les applications. Pour les petites et les moyennes bases, le DBA joue ce rôle.
● Les utilisateurs qui se connectent et interagissent avec la base à travers les applications
ou à l’aide d’outils (interrogations pour la génération de rapports, ajouts, modifications ou
suppressions d’enregistrements).

Il arrive que plusieurs personnes travaillent simultanément sur une base de


données. Cependant, en fonction de leurs besoins, elles n'auront pas toutes la même
utilisation de la base au même moment et les mêmes privilèges sur les objets de la base des
données (tables,vues ,etc) . Certaines peuvent par exemple avoir besoin de modifier ou
supprimer des données dans la table, pendant que d'autres ont seulement un besoin de
consultation de données, etc.
Ainsi, il est possible de définir des permissions pour chaque personne sur les objets bien
identifiés de la base des données. Cette tâche incombe à l'administrateur de la base de
données (en anglais DBA, DataBase Administrator). Il doit dans un premier temps définir les
besoins de chacun, puis les appliquer à la base de données sous forme de permissions.

Le langage SQL permet d'effectuer ces opérations grâce à deux clauses :

GRANT permet d'accorder des droits à un utilisateur (parfois plusieurs sur certains SGBD) .
REVOKE permet de retirer des droits à un utilisateur (ou plusieurs sur certains SGBD). Les
permissions (appelées aussi droits ou privilèges) peuvent être définies pour chaque clause.
D'autre part, il est aussi possible de définir des rôles, c'est-à-dire de permettre à d'autres
utilisateurs d'accorder des permissions.

Les privilèges sont les clauses qui peuvent être autorisées ou retirées à un utilisateur.
Les principales sont :

- DELETE : pour supprimer les données d'une table ;


- INSERT : pour ajouter des données à une table ;
- SELECT : pour accéder aux données d'une table ;
- UPDATE : pour mettre à jour les données d'une table.

Seule la personne qui a créé un élément (table, vue ou index) a le pouvoir d'accorder
ou de retirer des droits.
45

4.2.2. Création, Modification et Suppression des Utilisateurs

a) Création Utilisateur

C’est par l’intermédiaire de l’instruction CREATE USER qu’il est possible de définir des
comptes utilisateurs au niveau de la base de données.

Syntaxe

CREATE USER nomUtilisateur

Attention: Il y a d'autres options à ajouter à cette requête SQL selon qu'on utilise un ou un
autre SGBD.

• Pour SQL SERVER


Syntaxe1

CREATE USER nom_User


FOR LOGIN nom_login
WITH DEFAULT_SCHEMA=schemaParDefaut

• Pour Oracle

La syntaxe SQL de création d’un utilisateur est la suivante :

CREATE USER utilisateur IDENTIFIED


{ BY motdePasse | EXTERNALLY | GLOBALLY AS 'nomExterne' }
[ DEFAULT TABLESPACE nomTablespace
[QUOTA { entier [ K | M ] | UNLIMITED } ON nomTablespace ] ]
[TEMPORARY TABLESPACE nomTablespace
[QUOTA { entier [ K | M ] | UNLIMITED } ON nomTablespace ].]
[PROFILE nomProfil ] [PASSWORD EXPIRE ] [ ACCOUNT { LOCK |
UNLOCK } ] ;

Exemple

CREATE USER Paul


IDENTIFIED BY Pokémon
DEFAULT TABLESPACE USERS
QUOTA 10M ON USERS
TEMPORARY TABLESPACE TEMP
QUOTA 5M ON TEMP
PASSWORD EXPIRE;

Paul est déclaré « utilisateur », ses objets (pas plus


de 10 mégaoctets) seront stockés dans USERS,
certaines de ses opérations nécessiteront de ranger
des données dans TEMP (pas plus de
46

5 mégaoctets). Il devra changer son mot de passe


à la première connexion.
Exemple 2

CREATE USER Paul2


IDENTIFIED BY Pokémon
DEFAULT TABLESPACE USERS
ACCOUNT LOCK;

Paul2 est déclaré « utilisateur », ses objets seront


stockés dans USERS, son espace temporaire est SYSTEM. Le compte est pour l’instant
bloqué.

• Pour Mysql

La syntaxe de création d’un utilisateur est la suivante pour Mysql :

CREATE USER utilisateur


[IDENTIFIED BY [PASSWORD] 'motdePasse']
[,utilisateur2 [IDENTIFIED BY [PASSWORD] 'motdePasse2'] ...];

exemple:

CREATE USER soutou@localhost IDENTIFIED BY 'iut';

b)Modification d'un Utilisateur

• SQL server

Syntaxe pour changer le nom d'un utilisateur en SQL Server :

ALTER USER nomUtilisateur


WITH NAME=nouveauNomUtilisateur,
DEFAULT_SCHEMA = nomNouveauSchema

• Oracle

La syntaxe simplifiée SQL pour modifier un utilisateur est la suivante/

ALTER USER utilisateur


[ IDENTIFIED { BY password [ REPLACE old_password ] |
EXTERNALLY | GLOBALLY AS 'external_name' } ]
[ DEFAULT TABLESPACE nomTablespace
[QUOTA { entier [ K | M ] | UNLIMITED } ON nomTablespace ] ]
[ TEMPORARY TABLESPACE nomTablespace
[QUOTA { entier [ K | M ] | UNLIMITED } ON nomTablespace ].]
[ PROFILE nomProfil ]
[ DEFAULT ROLE { rôle1 [,rôle2]… | ALL [EXCEPT rôle1 [,rôle2]…]
| NONE }
[ PASSWORD EXPIRE ] [ ACCOUNT { LOCK | UNLOCK } ] ;
47

Exemples:

ALTER USER Paul


IDENTIFIED BY X_Men
TEMPORARY TABLESPACE TEMP
QUOTA UNLIMITED ON TEMP;

Paul a changé de mot de passe, son espace


temporaire est illimité dans TEMP. Il ne devra
plus changer son mot de passe à la première
connexion.

ALTER USER Paul2


DEFAULT TABLESPACE USERS
QUOTA 10M ON USERS
ACCOUNT UNLOCK;

L’espace de travail de Paul2 est limité à


10 mégaoctets dans USERS. Le compte est
débloqué.

• Mysql

UPDATE mysql.user
SET Password = PASSWORD('eyrolles')
WHERE User = 'soutou'
AND Host = 'localhost';

c)Suppression

La syntaxe SQL est la suivante pour supprimer un utilisateur est:

DROP USER utilisateur

NB:

1. Pour pouvoir supprimer un utilisateur, vous devez posséder le privilège CREATE


USER (ou le privilège DELETE sur la base de données mysql en Mysql).

2. Un utilisateur bien connu pour chacun des SGBD:

• Lors de l’installation, vous avez dû noter la présence de l’utilisateur root (mot de passe
saisi à l’installation). Cet utilisateur est le DBA que MySQL vous offre. Il vous permettra
d’effectuer vos tâches administratives en ligne de commande ou par une console
graphique (créer des utilisateurs par exemple).
48

• Mais pour SQL Server l'utilisateur se nomme SA.


• Pour Oracle SYSTEM (mot de passe par défaut : MANAGER). Le premier est le
propriétaire des tables du dictionnaire de données. Il est préférable de ne jamais se
connecter sous SYS en ligne. L’utilisateur SYSTEM est le DBA qu’Oracle vous offre.

4.2.3 GRANT

Les droits sont accordés par la commande GRANT dont voici la syntaxe :

GRANT <privilege>
ON <element du schema>
TO <utilisateur>

• Syntaxe avec SQL server

GRANT {ALL [PRIVILEGES]|permission[(colonne,[,...])] [,...]}


ON objet[,...]
TO utilisateur [,...]
[WITH GRANT OPTION ]

• Syntaxe avec Oracle

GRANT { privilègeObjet | nomRôle | ALL PRIVILEGES } [(colonne1


[,colonne2]…)]
[, { privilègeObjet | nomRôle | ALL PRIVILEGES }] [(colonne1
[,colonne2]…)]…
ON { [schéma.]nomObjet | { DIRECTORY nomRépertoire
| JAVA { SOURCE | RESOURCE } [schéma.]nomObjet } }
TO { utilisateur | nomRôle | PUBLIC } [,{ utilisateur | nomRôle |
PUBLIC } ]…
[WITH GRANT OPTION] ;

• syntaxe avec Mysql

GRANT privilège [ (col1 [, col2...])] [,privilège2 ... ]


ON [ {TABLE | FUNCTION | PROCEDURE} ]
{nomTable | * | *.* | nomBase.*}
TO utilisateur [IDENTIFIED BY [PASSWORD] 'password']
[,utilisateur2 ...]
[ WITH [ GRANT OPTION ]
[ MAX_QUERIES_PER_HOUR nb ]
[ MAX_UPDATES_PER_HOUR nb2 ]
[ MAX_CONNECTIONS_PER_HOUR nb3 ]
[ MAX_USER_CONNECTIONS nb4 ] ];

Quelques Exemples Avec Mysql


49

Instruction faite par root Explication

GRANT CREATE, DROP ON bdpaul TO Paul;

Privilège système database level : Paul (en accès local) peut créer ou supprimer des tables
dans la base bdpaul.

GRANT INSERT, SELECT, DELETE, UPDATE(ISBN) ON bdpaul .LivreTO Paul ;

Privilège objet table level :


Paul peut insérer, extraire, supprimer et
modifier la colonne ISBN de la table Livre
contenue dans la base bdpaul.

GRANT ALTER ON bdpaul.Livre TO 'Paul'@'localhost';


Privilège système table level :
Paul peut modifier la structure ou les
contraintes de la table Livre contenue
dans la base bdpaul.

GRANT SELECT(titre) ON bdpaul. Livre TO 'Jules'@'localhost' WITH GRANT


OPTION;

Privilège objet column level :


Jules peut extraire seulement la colonne
titre de la table Livre contenue dans la
base bdpaul. Il pourra par la suite
retransmettre éventuellement ce droit.

4.2.4 Revoke

permet de retirer des droits à un utilisateur (ou plusieurs sur certains SGBD)

• Syntaxe Avec MYSQL

Dans la syntaxe suivante, les options sont les mêmes que pour la commande GRANT.

REVOKE privilège [ (col1 [, col2...])] [,privilège2 ... ]


ON [ {TABLE | FUNCTION | PROCEDURE} ]
{nomTable | * | *.* | nomBase.*}
FROM utilisateur [,utilisateur2 ... ];

Exemples
REVOKE CREATE ON bdpaul.* FROM paul ;

Privilège système database level : Paul(en accès local) ne peut plus créer de tables dans la base bdpaul.

REVOKE ALTER,INSERT,UPDATE(ISBN) ON bdpaul.Livre FROM 'Paul'@'localhost';


50

Privilège objet table level :

Paul ne peut plus modifier la structure (ou les contraintes), insérer et modifier la colonne ISBN de la table Livre contenue
dans la base bdpaul.

• Avec SQL SERVER

Syntaxe avec SQL SERVER


REVOKE [GRANT OPTION FOR ]
{ALL [PRIVILEGES]|permission[(colonne,[,...])] [,...]}
ON object [(colonne [,...])]
{FROM | TO} utilisateur [,...]
[ CASCADE ]
GRANT OPTION FOR

Exemples avec SQL server :

1. Retirer le droit de sélection à l’utilisateur ‘Jean' à la table personne

revoke select on personne to Jean

2. Retirer le droit d'insertion, de sélection,de suppression et de Mis à jour de la colonne code


à l’utilisateur ‘Jean' à la table personne

revoke INSERT, SELECT, DELETE, UPDATE(CODE) ON personne from jean

ou

revoke INSERT, SELECT, DELETE, UPDATE(CODE) ON personne To jean

• Avec Oracle

syntaxes avec Oracle


REVOKE
{ privilègeSystème | nomRôle | ALL PRIVILEGES }
[,{ privilègeSystème | nomRôle }].....
FROM { utilisateur | nomRôle | PUBLIC } [,{ utilisateur |
nomRôle } ] ;

examples Oracles
REVOKE CREATE SESSION FROM Paul, Paul2 ;

Paul et Paul2 ne peuvent plus se connecter à la


base. Ils conservent néanmoins leurs autres
privilèges. Un tiers peut ainsi créer par exemple
51

des tables dans leur schéma (ils ont tous deux le


privilège CREATE TABLE).

REVOKE ALL PRIVILEGES FROM Paul2;

Commande incorrecte car Paul2 n’a pas reçu tous


les privilèges système. Paul, Paul2

CHAP.V. LA PROGRAMMATION EN SQL

5.1 Les sous-programmes (Les Procédures et Fonctions)


Les sous-programmes sont des blocs nommés qui sont compilés et qui résident dans la base
de données. Dans le vocabulaire des bases de données, on appelle les sous-programmes
stored procedures ou stored routines. Ce sont des fonctions ou procédures « cataloguées » (ou
« stockées ») capables d’inclure des paramètres en entrée. Comme dans tous les langages
programmation, les fonctions retournent un unique résultat, alors que les procédures réalisent
des actions sans en donner (sauf éventuellement en paramètre de sortie).
Les procédures stockées sont des morceaux de code SQL présent dans une base de données et
qui peut être appelé via une requête SQL.
52

5.1.1 Les Procédures

Les Syntaxes

a) Syntaxe SQL Server

CREATE| ALTER PROC ... le nom de la procédure


(...) les paramètres d’entrée et de sortie séparés par des virgules
AS
DECLARE ... les variables locales
BEGIN
... les instructions, les transactions
END

Exemples

CREATE PROC InfoDuClient (@numero INT) -- ne pas oublier de préciser le type


AS
SELECT *
FROM clients
WHERE clt_num = @numero

Nb : Pour exécuté la procédure on tape la requête :

Exec InfoDuClient 12

b) Syntaxe MySql

Par défaut, la procédure est créée dans la base de données courante (sélectionnée). Si un
53

nom est spécifié ( nomBase ), la procédure appartiendra à cette base de données.

IN désigne un paramètre d’entrée (par défaut),


OUT un paramètre de sortie et
INOUT un paramètre d’entrée et de sortie.

5.1.2 Les fonctions

5.1.2.1 Les Syntaxes

a) Syntaxe Mysql

b) Syntaxe sql Serveur


54

Exemples Fonction pour SQL serveur

CREATE FUNCTION EcartEnHeure


(
@date1 DATETIME,
@date2 DATETIME
)
RETURNS INT
AS
BEGIN
RETURN ABS(DATEDIFF(hour, @date1, @date2))
END

5.1.2.2 Exemple de l’ utilisation de la function en sql server

declare @i int
set @i=dbo.EcartEnHeure('01 jan 2016 13:15:25','01 jan 2016 12:19:25')
print @i

5. suppression de la fonction

Drop FUNCTION EcartEnHeure

5.1.3 Quelques avantages de Procédures stockées


• Dès lors qu’on appelle une procédure stockée, on a simplement besoin de spécifier son
nom et de lui adjoindre la valeur de ses paramètres.
C’est donc moins coûteux en termes de quantité de données qu’une autre commande
SQL, si courte soit elle. Dès lors cela réduit le trafic réseau entre les applications et le
serveur.

• Lorsqu’on crée une procédure stockée, celle-ci est compilée en un plan qui demeure
dans le cache de procédures, ce qui réduit considérablement le coût de calcul du plan
d’une requête, gourmand en ressources processeur.
• L’utilisation de procédure stockée permet la réutilisation de code. S’il est clair que
cela n’augmente pas les performances, cela augmente la productivité des développeurs
qui ont moins de code à produire, et qui passent donc moins de temps à le débugger.
• Le second plus gros avantage à mon sens après le cache de procédures est que le code
qu’elles encapsulent, la logique de celles-ci, peut être maintenu sans modifier une
seule ligne de code de l’application cliente, s’il n’est pas besoin de modifier les
paramètres et la structure de l’ensemble de données produit.

NB :
55

• Les procédures stockées évitent aussi aux utilisateurs d'avoir à connaître les
détails des tables de la base de données. Si un ensemble de procédures stockées
prend en charge toutes les fonctions de gestion nécessaires aux utilisateurs,
ceux-ci n'ont pas besoin d'accéder directement aux tables ; il leur suffit
d'exécuter les procédures stockées qui modélisent les processus avec lesquels ils
ont l'habitude de travailler.
• Il faut garder à l’esprit que ce n’est pas parce que l’on utilise exclusivement des
procédures stockées que l’application sera performante.
Il reste encore parfois à réécrire et souvent à optimiser le code qui est encapsulé
par une procédure stockée, pour que celui-ci soit performant et qu’il reste le
plus longtemps possible dans le cache de procédures.

5.2 LES TRIGGERS

5.2.1 Introduction

D’un point de vue général la plupart des déclencheurs (triggers) peuvent être vus comme des
sous-programmes résidents associés à un événement particulier (insertion, modification d’une
ou de plusieurs colonnes, suppression) sur une table (ou une vue). Une table (ou vue) peut «
héberger » plusieurs déclencheurs ou aucun. Pour certains SGBD, il existe d’autres types de
déclencheurs que ceux associés à une table (ou vue) afin de répondre à des événements qui ne
concernent pas les données (exemple : connexion d’un utilisateur particulier, suppression
d’une table, démarrage ou arrêt du serveur, déconnexion d’un utilisateur, etc.).

À la différence des sous-programmes, l’exécution d’un déclencheur n’est pas explicite (par
CALL par exemple), c’est l’événement de mise à jour de la table qui lance automatiquement
le code programmé dans le déclencheur. On dit que le déclencheur « se déclenche » (l’anglais
le traduit mieux : fired trigger)
Les délimiteurs des actions dans un déclencheur sont les clauses AS BEGIN et END. Tout le code
présent entre ces deux délimiteurs sera exécuté, à la seule condition que l’action déclenchant le
déclencheur soit faite auparavant.

• Create trigger …. : Permet de créer un trigger


• Alter trigger …: Permet de modifier un trigger
• Drop trigger… : Permet de supprimer un trigger
56

5.2.2 Syntaxes
a) Syntaxe SQL sever

CREATE TRIGGER nom_trigger ON { table | vue }


[ WITH ENCRYPTION ]
{FOR | AFTER | INSTEAD OF } { INSERT , UPDATE ,DELETE }
[ WITH APPEND ] [ NOT FOR REPLICATION ]
AS
[ IF UPDATE ( colonne )
| IF ( COLUMNS_UPDATED ( )opérateur_comparaison_bits)]
Instructions_SQL

WITH ENCRYPTION

La définition du déclencheur est enregistrée de façon cryptée. Il n’est donc pas possible de connaître le
code du
déclencheur a posteriori. Cette option évite également que le déclencheur soit publié dans le cadre d’une
réplication.

FOR
Permet de préciser à quel ordre SQL DML le déclencheur est associé. Par défaut, le déclencheur est de
type AFTER.

AFTER
C’est le mode par défaut des déclencheurs. Le code est exécuté après vérification des contraintes
d’intégrité et après
modification des données.

INSTEAD OF
Le corps du déclencheur est exécuté à la place de l’ordre SQL envoyé sur la table ou la vue. Ce type de
déclencheur
est particulièrement bien adapté pour les vues.

b) Syntaxe Mysql

CREATE TRIGGER nomDéclencheur


{ BEFORE | AFTER } { DELETE | INSERT | UPDATE }
ON nomTable FOR EACH ROW
{ instruction; |
[etiquette:] BEGIN
instructions;
END [etiquette]; }

Nb :
BEFORE | AFTER précise la chronologie entre l’action à réaliser par le déclencheur LMD et
La réalisation de l’événement (BEFORE INSERT exécutera le déclencheur avant de réaliser
L’insertion).
_ DELETE | INSERT | UPDATE précise la nature de l’événement pour les déclencheurs
LMD.
– Pour DELETE, le déclencheur examine les événements DELETE et REPLACE.
– Pour INSERT, le déclencheur prend en compte les événements suivants : INSERT,
CREATE... SELECT, LOAD DATA, et REPLACE.
– Pour UPDATE, le déclencheur considère seulement l’événement UPDATE.
57

5.2.3 Exemples des trigger en sql serveur


Ex1.

CREATE TRIGGER commandes_insert -- le nom du déclencheur


ON commandes AFTER INSERT -- la table et l’événement concernes
AS -- la programmation du declencheur
UPDATE articles SET nb_commande = nb_commande + cmd_qte
FROM articles AS a
JOIN inserted AS b ON (a.art_num = b.cmd_art)

(si plusieurs instructions : utiliser un bloc BEGIN ... END)

Ex2.
CREATE TRIGGER commandes_delete
ON commandes AFTER DELETE
AS
UPDATE articles SET nb_commande = nb_commande - cmd_qte
FROM articles AS a
JOIN deleted AS b ON (a.art_num = b.cmd_art)

EX3.

CREATE TRIGGER commandes_update


ON commandes AFTER UPDATE
AS
IF UPDATE(cmd_qte) -- si la colonne cmd_qte est touchée par la modification
BEGIN
UPDATE articles SET nb_commande = nb_commande - b.cmd_qte + c.cmd_qte
FROM articles AS a
JOIN deleted AS b ON (a.art_num = b.cmd_art)
JOIN inserted AS c ON (a.art_num = c.cmd_art)
END

5.2.4 À quoi sert un déclencheur ?

En théorie, un déclencheur permet de :


• Programmer toutes les règles de gestion qui n’ont pas pu être mises en place par des
contraintes au niveau des tables. Par exemple, la condition : une compagnie ne fait
voler un pilote que s’il a totalisé plus de 60 heures de vol dans les 2 derniers mois, sur
le type d’appareil du vol en question, ne pourra pas être programmée par une
contrainte et nécessitera l’utilisation d’un déclencheur.
• Déporter des contraintes au niveau du serveur et alléger ainsi la programmation client.
• Renforcer des aspects de sécurité et d’audit.
58

• Programmer l’intégrité référentielle et la réplication dans des architectures distribuées,


avec l’utilisation de liens de bases de données.

5.3 Les Curseurs

Les opérations réalisées dans une base de données relationnelle s'exécutent sur un ensemble
complet de lignes. L'ensemble de lignes renvoyé par une instruction SELECT contient toutes
les lignes satisfaisant aux conditions de la clause WHERE de l'instruction. Cet ensemble
complet de lignes renvoyées par l'instruction est appelé jeu de résultats. Les applications, en
particulier les applications interactives en ligne, peuvent ne pas toujours fonctionner
efficacement si le jeu de résultats est traité comme une unité. Ces applications ont besoin d'un
mécanisme leur permettant de travailler avec une seule ligne ou un petit bloc de lignes à la
fois. Les curseurs sont une extension des jeux de résultats et contiennent ce mécanisme.

Un curseur est une zone mémoire qui est générée côté serveur (mise en cache) et qui permet
de traiter individuellement chaque ligne renvoyée par un SELECT.
Les instructions disponibles pour travailler avec des curseurs sont définies dans le tableau
Suivant :

Exemple en sql serveur d'un curseur permettant d'afficher ligne par


ligne les codes du cours et leurs designations

--Declaration des variables


59

declare @codecours as varchar(5)


declare @Intitule as varchar(50)
--declaration du curseur
declare c_Parcour_ligne_cours cursor
for select codec,intitule from tcours
--Ouverture du curseur
open c_Parcour_ligne_cours
--Charge la ligne courante des données du curseur
-- dans les variables du curseur
fetch c_Parcour_ligne_cours into @codecours,@Intitule

while (@@FETCH_STATUS=0)
begin
print 'le code du cours est'+@codecours
print 'le code du cours est'+@Intitule
print '------------------'
fetch c_Parcour_ligne_cours into @codecours,@Intitule

end

close c_Parcour_ligne_cours
deallocate c_Parcour_ligne_cours

NB :

• En sql Serveur« Deallocate nom_curseur » permet de Supprimer le curseur et les


structures associées.
• la variable @@FETCH_STATUS est à 0 si le fetch s’est bien passé
• On utilisera les curseurs ANSI lorsqu’il faudra traiter les lignes individuellement dans
un ensemble ou lorsque le SQL ne pourra pas agir uniquement sur les lignes
concernées. Les curseurs des API seront utilisés par les applications clientes pour
traiter des volumes importants ou pour gérer plusieurs ensembles de résultats.

• NB: N’utilisez les curseurs que si le SQL "ensembliste" n’est pas possible. Ils sont
généralement coûteux en mémoire et en temps de traitement.

EXERCICES D'APPLICATION
On considère la base de données

BD AIRBASE suivante :
-PILOT (NumP, NameP, Address, Salary)
-AIRPLANE (NumAP, NameAP, Capacity, Localisation)
60

-FLIGHT(NumF,#NumP,#NumAP, Dep_T, Arr_T, Dep_H,Arr_H)

Convention :
Les clés primaires sont soulignées et les clés étrangères sont précédés du caractères "#"
Q0. Créer les 3 tables en respectant les différentes contraintes
Q1 : Donnez la liste des avions dont la capacité est supérieure à 350 passagers.
Q2 : Quels sont les numéros et noms des avions localisés à Nice ?
Q3 : Quels sont les numéros des pilotes en service et les villes de départ de leurs vols ?
Q4 : Donnez toutes les informations sur les pilotes de la compagnie.
Q5 : Quel est le nom des pilotes domiciliés à Paris dont le salaire est supérieur à 15000 ?
Q6 : Quels sont les avions (numéro et nom) localisés à Nice ou dont la capacité est inférieure
à 350 passagers ?
Q7 : Liste des vols au départ de Nice allant à Paris après 18 heures ?
Q8 : Quels sont les numéros des pilotes qui ne sont pas en service ?
Q9 : Quels sont les vols (numéro, ville de départ) effectués par les pilotes de numéro 100 et
204 ?

EXERCICE 2
Soit le modèle Logique des données suivant.
• Clients(NumCli, Nom, Prénom, Adresse, Cp, Ville, Téléphone)
• Achats(numAchat,#NumCli, #NumArt, Date, Qté)
• Articles(NumArt, Désignation, Catégorie, Prix)

En utilisant le langage SQL

1. Créer les 3 tables Clients, Articles et Achats


Sachant que les champs soulignés dans le modèle Logique des données sont des clés
Primaires et les champs précédés par ”#” sont des clés étrangères.
NB: La désignation des articles ne doit pas accepter des valeurs nulles
2. Créer la requête SQL qui permet de supprimer la table “client”
3.Ajouter la colonne “dateNaiss” dans la table client
4.Modifié la taille du champs “nom” de 50 à 100 de la table client
5.Supprimer la clé primaire de la table Client
61

6.Récréer la clé primaire de la table Client en l’attribuant le nom la clé “ PK_client”.


7. Le prix et la Quantité ne doivent que recevoir des valeurs supérieur ou égal à
ZERO.
8. La désignation des articles doit être unique
9.Insérer les enregistrements dans les 3 tables selon les tables ci-dessus.
10.Ajouter le numéro de téléphone pour les clients qui n’en possèdent pas.
11. Supprimer tous les articles dont le prix est entre 12 et 20.

EXERCICE 3

Soit les tables avec données ci-dessous:

1.Créer les deux tables


2. Sélectionnez dans la table FILM les films qui sont du genre Drame et Policier
3. Supprimez les enregistrements de la table FILM datant d’avant 1995
4. Supprimez la table FILM
5.Affichez le contenu de la table PERSONNE
7.Ajouter ce nouvel enregistrement dans la table FILM
: «12 22 ‘ L’âge de glace 4’ ‘Animation’ 2011» En utilisant un INSERT
62

EXERCICE 4
–Syntaxe des types de données
Quelles sont les spécifications de valeurs syntaxiquement incorrectes ?
a) DATE '18/11/2004'
b) DATE '2002-11-18'
c)TIME '11:16'
d) DATE '2004-11-18 20:20:30 000'
e)123,55
f)1E-10
g)3.145 E-1
h)'456,78'

EXERCICE 5
Cadre de livraison des Produits
Soit la base relationnelle de données PUF de schéma :
U(NumU, NomU, VilleU)
P(NumP, NomP, Couleur, Poids)
F(NumF, NomF, Statut, VilleF)
PUF(#NumP, #NumU,# NumF, Quantité)

décrivant le fait que (avec des DF évidentes) :


U : une usine est d’écrite par son numéro NumU, son nom NomU et la ville
VilleU où elle est située
P : un produit est décrit par son numéro NumP, son nom NomP, sa couleur et
son poids
F : un fournisseur est décrit par son numéro NumP, son nom NomF, son statut
(sous-traitant, client…) et la ville VilleF où il est domicilié
PUF : le produit de numéro NumP a été délivré à l’usine de numéro NumU par
le fournisseur de numéro NumF dans une quantité donnée
63

Questions:

1) Ajouter un nouveau fournisseur avec les attributs de votre choix


2) Supprimer tous les produits de couleur noire et de numéros compris
entre 100 et 1999
3) Changer la ville du fournisseur 3 par Toulouse
4) Donnez le numéro, le nom, la ville de toutes les usines
5) Donnez le numéro, le nom, la ville de toutes les usines de Paris
6) Donnez les numéros des fournisseurs qui approvisionnent l’usine de numéro 2 en produit
de numéro 100
7) Donnez les noms et les couleurs des produits livrés par le fournisseur de numéro 2
8) Donnez les numéros des fournisseurs qui approvisionnent l’usine de numéro 2 en un
produit rouge
9) Donnez les noms des fournisseurs qui approvisionnent une usine de Paris ou de Créteil en
produit rouge
10) Donnez les numéros des produits livrés à une usine par une fournisseur de la même ville
Donnez les numéros des produits livrés à une usine de Paris par un
fournisseur de Paris.
12) Donnez les numéros des usines qui ont au moins un fournisseur qui
n’est pas de la même ville
13) Donnez les numéros des fournisseurs qui approvisionnent à la fois
des usines de numéros 2 et 3
14) Donnez les numéros des usines qui utilisent au moins un produit
disponible chez le fournisseur de numéro 3 (c’est-à-dire un produit
que le fournisseur livre mais pas nécessairement à cette usine)
15) Donnez le numéro du produit le plus léger (les numéros si plusieurs
produits ont ce même poids)
16) Donnez le numéro des usines qui ne reçoivent aucun produit rouge
d’un fournisseur parisien
17) Donnez les numéros des fournisseurs qui fournissent au moins un
produit fourni par au moins un fournisseur qui fournit au moins un
produit rouge.
64

18) Donnez tous les triplets (VilleF, NumP, VilleU) tels qu’un
fournisseur de la première ville VilleF approvisionne une
usine de la deuxième ville VilleU avec un produit NumP
19) Même question que précédemment mais sans les triplets
où les deux villes sont identiques
20) Donnez les numéros des produits qui sont livrés à toutes
les usines de Paris
21) Donnez les numéros des fournisseurs qui approvisionnent
toutes les usines avec un même produit
22) Donnez les numéros des usines qui achètent au
fournisseur de numéro 3 tous les produits qu’il fournit
23) Donnez les numéros des usines qui s’approvisionnent
uniquement chez le fournisseur de numéro 3

EXERCICE 6

Soit les relations suivantes de la société Gavasoft


Emp(NumE, NomE, Fonction, NumS, Embauche, Salaire, Comm,
#NumD)
Dept(NumD, NomD, Lieu)

Exemple des données dans les tables


65

1)Donnez la liste des employés ayant une commission (non NULL) classé par commission
décroissante
2) Donnez les noms des personnes embauchées depuis le 01-09-2006
3) Donnez la liste des employés travaillant à Créteil
4) Donnez la liste des subordonnés de "Guimezanes"
5) Donnez la moyenne des salaires
6) Donnez le nombre de commissions non NULL
7) Donnez la liste des employés gagnant plus que la
moyenne des salaires de l’entreprise.

EXERCICE 7

7.1. Création des tables

Écrivez puis exécutez le script SQL de création des tables avec leur clé primaire (en gras dans
le schéma suivant) et les contraintes suivantes :
• Les noms des segments, des salles et des postes sont non nuls.
• Le domaine de valeurs de la colonne ad s’étend de 0 à 255.
• La colonne prix est supérieure ou égale à 0.
• La colonne dateIns est égale à la date du jour par défaut.
66
67

7. 2.Insérer les données Suivantes dans les tables ci-


dessus:
68

7.3 Écrivez le script modification.sql, qui permet de modifier (avec UPDATE) la colonne
étage (pour l’instant nulle) de la table Segment afin d’affecter un numéro d’étage correct (0
pour le segment 130.120.80, 1 pour le segment 130.120.81, 2 pour le segment 130.120.82).
Diminuez de 10 % le prix des logiciels de type 'PCNT'.

EXERCICE 8
69

Schéma de la base Chantiers

Une société désire informatiser les visites des chantiers de ses employés. Pour définir cette
base de données, une première étude fait apparaître les informations suivantes :

• Chaque employé est modélisé par un numéro, un nom et une qualification.


• Un chantier est caractérisé par un numéro, un nom et une adresse.
• L’entreprise dispose de véhicules pour lesquels est important de stocker pour le numéro
d’immatriculation,
le type (un code valant par exemple 0 pour une camionnette, 1 pour une moto et 2 pour
une voiture) ainsi que le kilométrage en fin d’année.
• Le gestionnaire a besoin de connaître les distances parcourues par un véhicule pour chaque
visite
d’un chantier.
• Chaque jour, un seul employé sera désigné conducteur des visites d’un véhicule.
• Pour chaque visite, il est important de pouvoir connaître les employés transportés.

Exercice 9:

Soit le modèle relationnel suivant relatif à la gestion simplifiée des étapes du Tour de France
97, dont une des étapes de type "contre la montre individuel" se déroula à Saint-Etienne :

EQUIPE(CodeEquipe, NomEquipe, DirecteurSportif)


COUREUR(NuméroCoureur, NomCoureur, CodeEquipe*, CodePays*)
PAYS(CodePays, NomPays)
TYPE_ETAPE(CodeType, LibelléType)
ETAPE(NuméroEtape, DateEtape, VilleDép, VilleArr, NbKm, CodeType*)
PARTICIPER(NuméroCoureur*, NuméroEtape*, TempsRéalisé)
ATTRIBUER_BONIFICATION(NuméroEtape*, km, Rang, NbSecondes,
NuméroCoureur*)

Remarque : les clés primaires sont soulignées et les clés étrangères sont marquées par *

Questions :

1 - Quelle est la composition de l'équipe Festina (Numéro, nom et pays des coureurs) ?
2 - Quel est le nombre de kilomètres total du Tour de France 97 ?
3 - Quel est le nombre de kilomètres total des étapes de type "Haute Montagne"?
70

4 - Quels sont les noms des coureurs qui n'ont pas obtenu de bonifications ?
5 - Quels sont les noms des coureurs qui ont participé à toutes les étapes ?
6 - Quel est le classement général des coureurs (nom, code équipe, code pays et temps des
coureurs) à l'issue des 13 premières étapes sachant que les
bonifications ont été intégrées dans les temps réalisés à chaque étape ?
7 - Quel est le classement par équipe à l'issue des 13 premières étapes (nom et temps des
équipes) ?

EXERCICE 10

Soit le modèle relationnel suivant relatif à la gestion des notes annuelles d'une promotion
d'étudiants :

ETUDIANT(N°Etudiant, Nom, Prénom)

MATIERE(CodeMat, LibelléMat, CoeffMat)

EVALUER(N°Etudiant*, CodeMat*, Date, Note)

Remarque : les clés primaires sont soulignées et les clés étrangères sont marquées par *

Questions :

Requête 1 - Quel est le nombre total d'étudiants ?

Requête 2 - Quelles sont, parmi l'ensemble des notes, la note la plus haute et la note la plus
basse ?

Requête 3 - Quelles sont les moyennes de chaque étudiant dans chacune des matières ?

Requête 4 - Quelles sont les moyennes par matière ? On utilisera la requête de la question 3
comme table source

Requête 5 - Quelle est la moyenne générale de chaque étudiant ?

On utilisera la requête de la question 3 comme table source

Requête 6 - Quelle est la moyenne générale de la promotion ?

On utilisera la requête de la question 5 comme table source

Requête 7 - Quels sont les étudiants qui ont une moyenne générale supérieure ou égale à la
moyenne générale de la promotion ?
71

On utilisera la requête de la question 5 comme table source

EXERCICE 11

Soit le modèle relationnel suivant relatif à la gestion simplifiée des étapes du Tour de France
97, dont une des étapes de type "contre la montre individuel" se déroula à Saint-Etienne :

EQUIPE(CodeEquipe, NomEquipe, DirecteurSportif)

COUREUR(NuméroCoureur, NomCoureur, CodeEquipe*, CodePays*)

PAYS(CodePays, NomPays)

TYPE_ETAPE(CodeType, LibelléType)

ETAPE(NuméroEtape, DateEtape, VilleDép, VilleArr, NbKm, CodeType*)

PARTICIPER(NuméroCoureur*, NuméroEtape*, TempsRéalisé)

ATTRIBUER_BONIFICATION(NuméroEtape*,km, Rang, NbSecondes, NuméroCoureur*)

Remarque : les clés primaires sont soulignées et les clés étrangères sont marquées par *

Questions :

Requête 1 - Quelle est la composition de l'équipe Festina (Numéro, nom et pays des coureurs)
?

Requête 2 - Quel est le nombre de kilomètres total du Tour de France 97 ?

Requête 3 - Quel est le nombre de kilomètres total des étapes de type "Haute Montagne"?

Requête 4 - Quels sont les noms des coureurs qui n'ont pas obtenu de bonifications ?

Requête 5 - Quels sont les noms des coureurs qui ont participé à toutes les étapes ?

Requête 6 - Quel est le classement général des coureurs (nom, code équipe, code pays et
temps des coureurs) à l'issue des 13 premières étapes sachant que les bonifications ont été
intégrées dans les temps réalisés à chaque étape ?

Requête 7 - Quel est le classement par équipe à l'issue des 13 premières étapes (nom et temps
des équipes) ?
72

EXERCICE 12

Soit la base de donnée suivante :

1. Soulignez les clés primaires, rajoutez un # derrière les clés étrangères.


2. Donnez la liste (Nom) des restaurants de plus de 2 étoiles par ordre alphabétique.
3. Nom et adresse des restaurants qui ne proposent pas le menu 10.
4. Donnez la liste (Nom, Adresse) des restaurants qui ne vendent pas de boissons
alcoolisées.
5. Nombre de menus par restaurant par ordre croissant du nombre de menu.
6. Nom du restaurant, nom du chef, nombre d‘étoiles, prix mini, moyen et maxi d‘un
menu dans chaque restaurant.
7. Nom du restaurant qui propose le menu le plus cher.
8. Liste des boissons en 'demi-bouteille proposées par le restaurant 1.
9. Nom des restaurants qui proposent ”foie gras poêlé‘ en entrée.
10. Donnez la liste des restaurants (nom, adresse, téléphone) qui proposent un plat à base
de ”canard‘.
12. Donnez la liste (idem) des restaurants ayant le même nombre d'étoiles que le
restaurant dont le chef s'appelle 'Dugros'
73

BIBLIOGRAPHIE

1.Livres
• Cristian Soutou, SQL pour Oracle: Application avec Java,Php et XML, Eyrolles,
2006.
• Cristian Soutou ,Apprendre SQL avec MySQL Eyrolles,3ieme Edition, 2008.
• Jérôme GABILLAUD, SQL Server 2008 Express:Administrez et développez vos
bases de données, Eyrolles, octobre 2009

2. Cours
• Cyril Gruau, Notes de Cour:SQL Server 2000: Analysis Services et DTS,2014
• Tony Archambeau,Cours SQL :Base du langage SQL et des bases de données,2014

3.Autres Sources
• Articles en ligne sur Developpez.com. (2005a). LE SQL de A à Z : Le simple ( ?)
SELECT et les fonctions SQL. (http :// sql.developpez.com/ sqlaz/ select).
• Articles en ligne sur Developpez.com. (2005b). LE SQL de A à Z : Les jointures, ou
comment interroger plusieurs tables. (http :// sql.developpez.com/ sqlaz/ jointures).
• Articles en ligne sur Developpez.com. Les fonctions dans
SQL(http://sqlpro.developpez.com/cours/sqlaz/fonctions/).
74

TABLE DES MATIERES


CHAP.I Introduction Générale ................................................................................................................. 1

1.1 Brève Historique de SQL ............................................................................................................ 1

1.2. Classification des ordres SQL .................................................................................................... 3

1.3 bases de données et l'approche SGBD ...................................................................................... 3

1.3.1 Qu’est-ce qu’une base de données ? ................................................................................. 4

1.3.2 Approche sur le Système de Gestion de Base des données............................................... 4

CHAP II. LA SYNTAXE DU LANGAGE SQL et LANGAGE SQL COMME LANGAGE DE DEFINITION DES
DONNEES ................................................................................................................................................. 6

2.1 Le Syntaxe du Langage SQL ...................................................................................................... 6

a) Commentaires ......................................................................................................................... 6

b) Noms d'objets ......................................................................................................................... 6

d) Variables ................................................................................................................................. 6

2.2. LANGAGE SQL COMME LANGAGE DE DEFINITION DES DONNEES ......................................... 7

2.2.1. DATABASE .......................................................................................................................... 7

2.2.2 . LES TABLES ........................................................................................................................ 8

d) TRUNCATE TABLE ...................................................................................................................... 12

2.2.3 Contraintes ....................................................................................................................... 12

2.2.4 Vues .................................................................................................................................. 14

CHAP III. LANGAGE SQL COMME LANGAGE DE MANIPULATION DES DONNEES ............................... 17

3.1 SQL INSERT INTO ..................................................................................................................... 17

3.2 SQL UPDATE............................................................................................................................. 18

3.3 DELETE .................................................................................................................................... 19

CHAP.IV. SQL COMME LANGAGE D'INTERROGATION ET CONTROLE DES DONNEES ........................... 20

4.1 SQL COMME LANGAGE D'INTERROGATION DES DONNEES .................................................... 20

4.1.0 SQL SELECT ...................................................................................................................... 20

4.1.1 ordre des commandes du SELECT .................................................................................... 21


75

4.1.2 .DISTINCT .......................................................................................................................... 21

4.1.3 AS (alias) dans SQL............................................................................................................ 22

4.1.4. WHERE ............................................................................................................................. 22

4.1.5 IN ..................................................................................................................................... 24

4.1.6 BETWEEN .......................................................................................................................... 25

4.1.7 LIKE ................................................................................................................................... 25

4.1.8 SQL IS NULL / IS NOT NULL ............................................................................................... 26

4.1.9. Utilisation d’autres fonctions de statistiques.................................................................. 27

4.1.10 GROUP BY ....................................................................................................................... 27

4.1.12 SQL ORDER BY ................................................................................................................ 28

4.1.13.SQL LIMIT ........................................................................................................................ 29

4.1.14 SQL UNION ..................................................................................................................... 30

4.1.15. Jointure SQL................................................................................................................... 32

4.2 SQL COMME LANGAGE DE CONTROLE DES DONNES .............................................................. 43

CHAP.V. LA PROGRAMMATION EN SQL ................................................................................................ 51

5.1 Les sous-programmes (Les Procédures et Fonctions) ............................................................ 51

5.1.1 Les Procédures ................................................................................................................. 52

5.1.2 Les fonctions ..................................................................................................................... 53

5.1.3 Quelques avantages de Procédures stockées ................................................................. 54

5.2 LES TRIGGERS ......................................................................................................................... 55

5.2.1 Introduction...................................................................................................................... 55

5.2.2 Syntaxes ............................................................................................................................ 56

5.2.3 Exemples des trigger en sql serveur ................................................................................. 57

5.2.4 À quoi sert un déclencheur ?............................................................................................ 57

5.3 Les Curseurs............................................................................................................................. 58

EXERCICES D'APPLICATION .................................................................................................................... 59


76

BIBLIOGRAPHIE ................................................................................................................................ 73