chapitre 7 - Langage SQL

Chapitre 7
Langage SQL
I. Introduction
SQL (Structured Query Language, ou langage de requêtes structurées) est l'interface externe la plus
répandue pour gérer une base de données. C'est un langage déclaratif dans le sens où il suffit d'exprimer ce
que l'on veut obtenir, sans devoir expliquer la méthode pour y parvenir. Ainsi, les opérations directement
utilisables par les usagers sont en général celles des langages dits assertionnels.
Ces langages, bâtis sur l'algèbre relationnelle, permettent de manipuler des bases de données relationnelles.
Nous pouvons citer à titre d'exemple :
- QUEL (QUEry Language) par Zook en 1977
- QBE (Query By Example) par Zloof en 1977
- SQL (Structured Query Language) par IBM
Aujourd'hui, le langage SQL est normalisé et constitue le standard d'accès aux bases de données
relationnelles. Les autres interfaces par menus, fenêtres, grilles ou de programmation type langage de 3ème
ou 4ème génération (L3G et L4G) sont le plus souvent offertes au-dessus du langage SQL. Celui-ci
constitue donc le point d'entrée des SGBD relationnels. Il a été normalisé à quatre reprises (ISO et ANSI
sont des organismes chargés de la normalisation) :
- 1986 : SQL 86 - ANSI*
- 1989 : - ISO* et ANSI
- 1992 : SQL 2 - ISO et ANSI
- 1999 : SQL 3 - ISO
II. Présentation de SQL
SQL est un langage de gestion de bases de données relationnelles. Il étend l'algèbre relationnelle et permet :
- de créer des bases de données
- d'ajouter, modifier et consulter des données d'une base de données existante
- de contrôler les accès aux informations d'une BD
SQL est un langage ensembliste qui :
- respecte l’indépendance des niveaux
- garantit la sécurité
- permet une gestion multi-utilisateurs
- utilise un dictionnaire
- respecte les contraintes d’intégrité
- est portable (standardisation)
SQL étend l'algèbre relationnelle, cependant il utilise les termes table, ligne et colonne au lieu des termes
relationnels relation, tuple et attribut. Une instruction SQL peut s'écrire sur plusieurs lignes. Pour être
exécutée, l'instruction doit se terminer par un point-virgule. SQL est un langage de requête, pas un langage
de programmation. Par conséquent, il n'y pas de variables ni de structures de contrôles (if, while, for). C'est
pourquoi on peut éventuellement l'intégrer dans un langage de programmation comme PL/SQL, C ou Java.
III. Les 3 facettes de SQL
SQL se subdivise en 3 sous-langages :
- LDD (Langage de Définition de Données) : création, modification et suppression des objets que peut
manipuler une BD (tables, vues et index, etc).
- LMD (Langage de Manipulation de Données) : ajout, suppression, modification et extraction des
données.
- LCD (Langage de Contrôle de Données) : sécurisation et validation des données.

Base de données 37
Chacun de ces sous-langages propose ses mots-clés propres. Voici les principales primitives que nous
verrons au cours de ce chapitre :
LDD LMD LCD
CREATE
ALTER
DROP
SELECT
INSERT
UPDATE
DELETE
GRANT
REVOKE
COMMIT
ROLLBACK
IV. Le Langage de Définition de Données (LDD)
Définition :
Le langage de définition de données permet la définition du schéma d'une base de données ainsi que
certaines de ses contraintes d'intégrité. Il comporte également les opérations de mise à jour de schéma
telles que la suppression d'une table ou la modification de la définition d'une table.
Le LDD est donc composé de 3 primitives :
- CREATE pour la création d'un objet (table, index, vue, etc).
- ALTER pour la modification d'un objet.
- DROP pour la suppression d'un objet.
1. Création de table
La création de table se fait grâce au mot-clé CREATE TABLE.
Chaque table est définie par :
- son nom
- sa liste d'attributs
- sa liste de contraintes sur table
Chaque attribut est défini par :
- son type
- sa valeur par défaut
- sa liste des contraintes sur attribut
Le type des attributs est à choisir parmi un ensemble fini de types. Les principaux types possibles sont
selon les standards:
- VARCHAR2(n) : chaîne de caractères de longueur variable (maximum n)
- CHAR(n) : chaîne de caractères de longueur fixe (n caractères)
- NUMBER : nombre entier (40 chiffres au maximum)
- NUMBER(n,m) : nombre entier de longueur totale n avec m décimales
- INTEGER : entier
- FLOAT : réel
- DATE : date (DD-MON-YY est le format par défaut)
- ...
Syntaxe de définition d'une table en SQL
CREATE TABLE nom_table
(attribut1 type1
[DEFAULT valeur_par_défaut] [contrainte sur attribut1],
…,
attributN typeN
[DEFAULT valeur_par_défaut] [contrainte sur attributN],
CONSTRAINT contrainte1 sur relation),
…,
CONSTRAINT contrainteM sur relation);

Base de données 38
Notation (les éléments entre [ ] sont optionnels) :
- Valeur_par_défaut doit être compatible avec le type de l'attribut. Elle peut prendre une des valeurs
parmi :
o constante
o NULL
- Contrainte sur attribut décrit les contraintes mono-attributs. Elle peut prendre une valeur parmi :
o NOT NULL
o UNIQUE
o REFERENCES nom_de_relation2 (pour les clés étrangères)
o CHECK (expression logique)
o PRIMARY KEY
Les contraintes sur attribut restreignent les valeurs d'un attribut (ex : l'âge d'une personne – attribut
Age – ne peut pas être négatif et ne dépasse pas 130 ans).
Remarque : S'il y a plusieurs contraintes sur un attribut, elles sont séparées par des virgules.
- Contrainte sur relation décrit les contraintes multi-attributs. Elle peut prendre une valeur parmi :
o UNIQUE (liste d'attributs)
o PRIMARY KEY (liste d'attributs)
o FOREIGN KEY (liste d'attributs) REFERENCES nom_de_relation2 (liste d'attributs)
S'il y a plusieurs contraintes multi-attribut, elles sont séparées par des virgules.
Les contraintes sur relation définissent des règles sémantiques entre plusieurs attributs. Il n'y a pas
d'ordre dans la définition des attributs ou des contraintes sur relation.
Les définitions d'attributs et de contraintes sont séparées par des virgules. Chaque définition de
relation se termine par un point-virgule.
Il est recommandé de donner des noms de contraintes explicites (après le mot clé CONSTRAINT)
afin de retrouver plus facilement l'origine des erreurs qui pourront être signalées par le SGBD, suite à
des violations de ces contraintes.
La signification des différents mots-clés (NULL, NOT NULL, UNIQUE,…) est donnée dans la suite
du chapitre.
a. Règles d'écriture des contraintes
Les contraintes sur attribut (C/A) ou sur relation (C/R) doivent satisfaire les règles d'écriture
suivantes :
1. La clause NOT NULL dans les C/A et la valeur par défaut NULL sont incompatibles.
Un attribut ne peut pas être NULL et NOT NULL en même temps.
2. La clause UNIQUE (aussi bien dans les C/A que dans les C/R) ne peut être spécifiée que sur
des attributs déclarés NOT NULL.
3. L'expression logique de la condition CHECK ne peut contenir que des prédicats de
comparaison d'attributs avec des constantes. La comparaison avec d'autres attributs ou l'usage
de fonctions ou de sous-requêtes ne sont pas autorisés.
4. Les attributs de la clause PRIMARY KEY doivent être préalablement déclarés avec la
clause NOT NULL.
5. Dans les contraintes de relation, les clauses FOREIGN KEY et REFERENCES doivent
apparaître simultanément
6. Les attributs de la clause FOREIGN KEY doivent correspondre soit à des attributs déclarés
comme PRIMARY KEY dans une autre relation, soit à des attributs déclarés UNIQUE dans
une autre table. La première option correspond à une contrainte référentielle avec la clé
primaire, la seconde correspond à une contrainte référentielle avec une clé candidate.
7. Si les attributs de FOREIGN KEY correspondent à une clé primaire dans une autre relation,
la clause REFERENCES ne spécifie que le nom de cette dernière.

Base de données 39
8. Si les attributs de FOREIGN KEY correspondent à une clé candidate dans une autre
relation, la clause REFERENCES doit mentionner le nom de cette relation ainsi que la liste
des attributs composant la clé candidate.
9. Les clauses PRIMARY KEY, UNIQUE et NOT NULL sont redondantes lorsqu'il n'y a
qu'une clé par relation. L'une ou l'autre des clauses suffit à la spécifier. Selon la clause
utilisée, il faut assurer la cohérence de la définition des contraintes référentielles en utilisant
respectivement la règle 7 ou la règle 8.
10. Il faut enfin noter que l'ordre des CREATE TABLE peut être très important par rapport aux
contraintes : les tables référencées doivent apparaître avant les tables référençantes.
b. Exemple
CREATE TABLE VOITURE
(
Immatriculation VARCHAR(8),
Marque VARCHAR(20),
Couleur VARCHAR(15),
Prix INTEGER CONSTRAINT C1 CHECK (Prix>=0),
CONSTRAINT C2 PRIMARY KEY (Immatriculation)
);
Cette instruction SQL crée la table VOITURE suivante :
Immatriculation Marque Couleur Prix
Texte Texte Texte Nombre
On aperçoit qu'on a inclut une contrainte sur l'attribut Prix, à savoir qu'un prix ne peut pas être
négatif. On a également indiqué que le numéro d'immatriculation est la clé primaire de la relation
VOITURE.
CREATE TABLE PERSONNE
(
NuméroSS INTEGER NOT NULL UNIQUE,
Nom VARCHAR ), (30
Prénom VARCHAR 20), (
Adresse VARCHAR(80)
);
Cette instruction SQL crée la table PERSONNE suivante :
NuméroSS Nom Prénom Adresse
Nombre Texte Texte Texte
Ici, on a déclaré la clé primaire NuméroSS, d'une autre manière que précédemment : dans la
relation VOITURE, la clé primaire avait été déclarée grâce à la contrainte de relation PRIMARY
KEY alors qu'ici, nous l'avons déclarée grâce aux contraintes sur attribut NOT NULL et
UNIQUE.

Base de données 40
CREATE TABLE ACHAT
(
numImmatriculation VARCHAR(8),
numPersonn INTEGER, e
dateAchat DATE,
CONSTRAINT C3
PRIMARY KEY (numImmatriculation, numPersonne),
CONSTRAINT C4
FOREIGN KEY (numImmatriculation)
REFERENCES VOITURE(Immatriculation),
CONSTRAINT C5
FOREIGN KEY (numPersonne)
REFERENCES Personne(NuméroSS)
);
Cette instruction SQL crée la table ACHAT suivante :
numImmatriculation numPersonne dateAchat
Texte Nombre Date
Dans cette instruction, nous avons déclaré dans la contrainte C3, la clé primaire (clé composée de
numImmatriculation et numPersonne) et, dans les contraintes C4 et C5, les dépendances avec les
tables VOITURE et PERSONNE via les clés étrangères.
c. Définition d'une table par requête
Il est possible de créer une table par récupération des tuples d'une autre table. On peut, par
exemple, créer une table appelée ma_table par récupération de la structure et du contenu de
autre_table :
CREATE TABLE ma_table
as SELECT * FROM autre_table;
On peut également créer une table appelée ma_table par récupération d'une partie seulement de la
structure et du contenu de ACHAT. On renomme dans l'exemple ci-dessous les colonnes
numImmatriculation et nomPersonne en num et nom :
CREATE TABLE ma_table
(
num integer,
nom varchar(20)
)
as SELECT numImmatriculation, nomPersonne FROM ACHAT;
2. Modification d'une table
La modification d'une table se fait grâce au mot-clé ALTER TABLE.
Les principales modifications sur la structure d'une table sont :
- l'ajout d’un attribut
- la modification d'un attribut
- la suppression d'un attribut
Cependant, la modification de schéma est une opération délicate qui peut mettre en péril l'intégrité de
la base de données. Aussi toutes les opérations de suppression ou de modification de relation, d'attribut
ou de contrainte doivent être faites avec précaution. Pour éviter les erreurs, la plupart des systèmes