|
Chapitre 17 :
les tables en SQL |
|
|
1 - Introduction à SQL |
|
|||||||||||||
|
|
|
Le
sigle SQL signifie "Structured Query Language", soit en français "Langage de
recherche structuré". SQL est un langage de gestion des bases de données
relationnelles que presque tous les SGBD comprennent. Il a été développé par
IBM dans le courant des années 70, et son nom actuel (il s'appelait
initialement SEQUEL) date du début des années 80. |
|
||||||||||||
|
|
|
SQL
a été normalisé par l'ANSI (American National Standards Institute) et par
l'ISO (International Organization for Standardization). Voici les principales étapes de ce
processus : |
|
||||||||||||
|
|
|
|
|
||||||||||||
|
|
|
Malgré
la normalisation ISO, l'implémentation du SQL par les différents éditeurs de
SGBD comporte des différences plus ou moins marquées concernant : |
|
||||||||||||
|
|
|
|
|
||||||||||||
|
|
|
Bref,
il n'y a qu'un seul langage SQL, mais chaque éditeur de SGBD implémente son
propre dialecte. Le "dictionnaire" qui permet de passer d'un
dialecte à l'autre s'appelle ODBC (Open Data Base Connectivity).
Il a été imaginé par Microsoft, et mis sur le marché en 1993. |
|
||||||||||||
|
|
|
Contrairement
à ce que son nom indique, SQL ne sert pas qu'à écrire des requêtes. C'est un langage
complet, qui permet de créer des BDD, des tables, de saisir des données et de
les corriger, de créer des vues, des index et des états (parfois baptisés
"rapports", par francisation de l'anglais "reports").
Sauf erreur de notre part, il ne permet pas de créer des formulaires, parce
qu'il a été conçu à une époque ou l'interface graphique n'existait pas sur
ordinateur, et parce qu'un formulaire sans interface graphique n'a guère
d'intérêt. |
|
||||||||||||
|
|
|
Par
contre, dans les SGBD sans interface graphique, le recours à SQL est
obligatoire pour toutes les opérations, y compris la création de la BDD,
celle des tables, et la saisie des données. La tentation est donc forte, pour
un professeur qui ignore à quels SGBD ses étudiants seront confrontés
lorsqu'ils entreront dans la vie active, de faire dans son enseignement une
large part à SQL, qui représente l'outil universel de manipulation des
données. Ceci dit, l'interface graphique est tellement entrée dans les moeurs,
qu'il parait difficile qu'à terme tous les SGBD n'en soient pas dotés. En
attendant, nous avons adopté une position mixte, en commençant par
l'interface graphique, plus facile à appréhender, et en rajoutant à ce
tutoriel quatre chapitres consacrés au langage SQL. |
|
||||||||||||
|
|
|
Selon
notre habitude, nous utiliserons le SGBD Access comme support pratique de ce
tutoriel (ou tutorial, ou cours en ligne). A l'occasion, nous comparerons
l'implémentation du SQL d'Access à celle d'Oracle. Comme nous ne disposons
pas d'une base Oracle (nos moyens ne nous le permettent pas...), nous nous
inspirerons d'un manuel de formation à la version 8 (l'avant-dernière). |
|
||||||||||||
|
|
|||||||||||||||
|
|
2 - Le langage SQL dans Access |
|
|||||||
|
|
|
Dans
Access, le langage SQL est utilisé par le moteur du SGBD pour traduire en
commandes exécutables les instructions que donne l'utilisateur à travers
l'interface graphique. Mais l'utilisateur n'a pas accès à ce code, sauf
pour la conception des requêtes, où il peut passer facilement du mode
graphique au mode SQL et vice versa. Nous utiliserons largement cette
possibilité dans les trois chapitres suivants. |
|
||||||
|
|
|
Pour
les tables, la situation est nettement moins satisfaisante. L'utilisateur qui
se sert de l'interface graphique pour créer une table n'a pas accès au code
SQL correspondant. Par contre, il dispose d'un éditeur de SQL qui reconnaît
les principales commandes concernant la création et la modification des
tables, et la saisie des données. |
|
||||||
|
|
|
Cet
éditeur, cependant, ne doit pas faire illusion, car il est loin d'être
complet. Il ne permet pas de régler dans le détail les propriétés des champs,
comme on peut le faire dans l'interface graphique. Il ne permet pas non plus
de créer des listes. Il rend donc des services limités. Il présente cependant
de l'intérêt dans les deux cas suivants : |
|
||||||
|
|
|
|
|
||||||
|
|
|
Évidemment,
il est beaucoup plus facile de créer, remplir, modifier, et supprimer une table
dans l'interface graphique d'Access qu'en utilisant des commandes SQL. Mais
tous les SGBD ne sont pas dotés d'une interface graphique, et il est bon de
savoir se débrouiller sans elle le cas échéant. |
|
||||||
|
|
|||||||||
|
|
3 - La procédure |
|
|
|
|
|
Pour
gérer les tables en langage SQL dans Access, il nous faut opérer de la
manière suivante. Dans la fenêtre "Base de données", nous
sélectionnons l'objet |
|
|
|
|
Requête --> Spécifique SQL --> Définition des
données |
|
|
|
|
S'ouvre
alors une fenêtre intitulée "Requête1 : Requête Définition des
données", dans laquelle nous pouvons écrire du code SQL. |
|
|
|
|
Pour
exécuter ce code, nous cliquons sur l'icône |
|
|
|
|
Pour
modifier le code SQL, nous sélectionnons la requête enregistrée précédemment,
et nous cliquons sur l'icône |
|
|
|
|
Tous
les exemples cités dans ce chapitre ont été transportés (par copier/coller)
dans Access 2002, et nous avons vérifié leur bon fonctionnement. Vous ne
devriez donc pas rencontrer de difficulté pour les reproduire. |
|
|
|
|||
|
|
4 - La création et la suppression d'une table |
|
|||||||||||||||||||||||||
|
|
|
Dans
la fenêtre ouverte grâce à la procédure précédente, nous écrivons notre
première commande (ou instruction)
SQL, contenant la clause CREATE
TABLE, pour créer la table "Personnes" (nous notons qu'un
point-virgule marque la fin de la commande) : |
|
||||||||||||||||||||||||
|
|||||||||||||||||||||||||||
|
|
|
Nous
exécutons cette commande en cliquant sur l'icône |
|
||||||||||||||||||||||||
|
|
|
|
|
||||||||||||||||||||||||
|
|
|
Si
nous enregistrons cette commande en cliquant sur l'icône |
|
||||||||||||||||||||||||
|
|
|
Bien
entendu, si nous n'exécutons pas la requête, la table "Personnes"
ne sera pas créée. Par contre, si la table "Personnes" existe déjà,
la commande ne s'exécute pas (la table existante n'est pas écrasée), et le
SGBD affiche le message suivant : |
|
||||||||||||||||||||||||
|
|
|||||||||||||||||||||||||||
|
|
|||||||||||||||||||||||||||
|
|
|||||||||||||||||||||||||||
|
|
|
Attention
! Si l'objet "Table" est sélectionné quand vous lancez l'exécution
de la commande SQL, la table "Personnes" n'apparaîtra pas (c'est
l'éternel problème de la synchronisation dans Access). Il suffit de cliquer,
dans le menu, sur "Affichage", puis sur "Actualiser",
pour que le nom de la table apparaisse. |
|
||||||||||||||||||||||||
|
|
|
Les
commandes SQL s'expriment en format libre.
Nous pouvons écrire les clauses en minuscules, et nous ne sommes pas tenus
d'aller à la ligne pour détailler les champs. Bien que la précédente
présentation (sur trois lignes) soit considérée comme plus lisible, l'expression
suivante est parfaitement exacte et s'exécute normalement : |
|
||||||||||||||||||||||||
|
|||||||||||||||||||||||||||
|
|
|
Les conventions relatives aux noms
des tables et des champs varient quelque peu d'un SGBD à l'autre. En ce
qui concerne plus particulièrement les champs : |
|
||||||||||||||||||||||||
|
|
|
|
|
||||||||||||||||||||||||
|
|
|
Les
types de données sont définis dans le DDL (Data Definition
Language) de chaque SGBD, et ils varient beaucoup d'un
logiciel à l'autre. Dans Access, les mêmes termes ne sont pas toujours
utilisés dans l'interface graphique, en VBA et en SQL. Voici un échantillon
représentatif des différentes façons d'exprimer un type de données lors de la
création d'une table en SQL dans Access : |
|
||||||||||||||||||||||||
|
|
|
|
|
||||||||||||||||||||||||
|
|
|
On
notera qu'il n'est pas possible de créer un champ de type hypertexte via une
commande SQL dans Access. Même remarque en ce qui concerne les listes de
choix. |
|
||||||||||||||||||||||||
|
|
|
Pour
supprimer une table, on utilise la clause DROP TABLE, comme le montre
l'exemple suivant : |
|
||||||||||||||||||||||||
|
|||||||||||||||||||||||||||
|
|
|
Attention
! Si l'objet "Table" est sélectionné dans la fenêtre "Base de
données" quand vous lancez l'exécution de la commande SQL de
suppression, la table "Personnes" ne disparaîtra pas (c'est
l'éternel problème de la synchronisation dans Access). Il suffit de cliquer,
dans le menu, sur "Affichage", puis sur "Actualiser",
pour que le nom de la table disparaisse. |
|
||||||||||||||||||||||||
|
|
|
Si
nous enregistrons la commande de suppression de table, Access place devant son
nom l'icône |
|
||||||||||||||||||||||||
|
|
|||||||||||||||||||||||||||
|
|
5 - La modification d'une table |
|
||
|
|
|
Il
est possible de modifier une table existante. Les exemples les plus
classiques concernent l'addition d'une nouvelle colonne et la suppression
d'une colonne existante. La commande : |
|
|
|
||||
|
|
|
permet,
lorsqu'on l'exécute, d'ajouter le champ intitulé "Naissance", de
type Date/Heure, à la table "Personnes". La variante suivante
fonctionne également : |
|
|
|
||||
|
|
|
La
clause INIT, qui permet de donner une valeur initiale aux champs ainsi créés,
ne fonctionne pas dans Access. Par défaut, cette valeur initiale est Null. Pour la modifier, il faut utiliser une commande
UPDATE (dont nous parlerons au paragraphe 9 ci-dessous). |
|
|
|
|
|
Pour
supprimer la colonne que nous venons de créer, nous utilisons la commande
suivante : |
|
|
|
||||
|
|
|
ou
sa variante : |
|
|
|
||||
|
|
|
En
SQL standard, la commande ALTER TABLE peut aussi être utilisée pour modifier
les propriétés d'une colonne existante. Exemple : |
|
|
|
||||
|
|
|
mais
la clause MODIFY n'est pas reconnue par Access, et l'exécution de la commande
ci-dessus entraîne un message d'erreur. L'ignorance de la clause MODIFY enlève
à la commande ALTER TABLE une bonne partie de son intérêt dans Access, et
l'on se demande pourquoi l'éditeur a fait les choses à moitié. |
|
|
|
|
|
Nous
verrons cependant au paragraphe 8 que la commande ALTER TABLE admet la clause
ADD CONSTRAINT, ce qui permet de rajouter une clé ou de créer une relation. |
|
|
|
|
||||
|
|
6 - Les propriétés des champs |
|
|||||||
|
|
|
Le
langage SQL est doté de clauses permettant de définir les propriétés des champs
lors de la création d'une table. Mais le moteur d'Access ne les reconnaît pas
toutes, loin de là. |
|
||||||
|
|
|
Pour
empêcher un champ de rester vide, nous utilisons la clause NOT NULL, comme le
montre l'exemple suivant : |
|
||||||
|
|||||||||
|
|
|
Après
avoir exécuté la commande nous vérifions, dans le propriétés de la table
"Personnes" ainsi créée, que le Null est
interdit dans le champ "Nom". |
|
||||||
|
|
|
Pour
qu'un champ soit indexé sans doublons, nous utilisons la clause UNIQUE, comme
le montre l'exemple suivant : |
|
||||||
|
|||||||||
|
|
|
Après
avoir exécuté la commande, nous ouvrons la table "Personnes" en
mode modification, nous cliquons sur le champ "Nom", et nous
vérifions que la propriété "Indexé :" vaut "Oui - Sans
doublons". En fait, cette clause possède un intérêt limité pour deux
raisons : |
|
||||||
|
|
|
|
|
||||||
|
|
|
Il
est donc souvent préférable d'utiliser la commande de création d'index que
nous présenterons au paragraphe suivant. |
|
||||||
|
|
|
Pour
poser une clé primaire sur un champ, nous utilisons la clause PRIMARY KEY,
comme le montre l'exemple suivant : |
|
||||||
|
|||||||||
|
|
|
Après
avoir exécuté la commande, nous ouvrons la table "Personnes" en
mode modification, nous cliquons sur le champ "Nom", et nous
vérifions qu'il est effectivement doté de la clé. Cette commande possède les
deux mêmes défauts que la précédente : nous ne sommes pas maîtres du nom
de la clé (le système l'appellera Index_976A9AC0_494C_41C1, par exemple...),
et nous ne pouvons pas appliquer la clé à plusieurs champs simultanément. Le
premier défaut peut être corrigé grâce à la commande suivante : |
|
||||||
|
|||||||||
|
|
|
qui
permet d'attribuer le nom "clé_primaire"
à la clé ainsi créée. Nous verrons au paragraphe suivant comment placer une
clé sur plusieurs champs. |
|
||||||
|
|
|
Les
autres clauses permettant de définir les propriétés des champs ne
fonctionnent pas dans Access. Il en est ainsi de DEFAULT, qui permet de fixer
la valeur par défaut d'un champ, ainsi que de CHECK, qui permet de fixer des contraintes
sur le contenu d'un champ (propriété "Valide si"). |
|
||||||
|
|
|||||||||
|
|
7 - La clé primaire et l'index |
|
||
|
|
|
Pour
placer une clé primaire sur un champ, nous pouvons utiliser la clause
CONSTRAINT, qui est obligatoirement suivie d'un nom d'index, et que nous
avons déjà rencontrée au paragraphe précédent. Créons, par exemple, la table
"Personnes" avec une clé primaire (intitulée clé_primaire)
sur le champ "Nom". La commande s'écrit : |
|
|
|
||||
|
|
|
L'objet
"Table" étant sélectionné, nous cliquons sur l'icône |
|
|
|
|
||||
|
|
||||
|
|
||||
|
|
|
Pour
appliquer la clé à deux champs, nous utilisons la syntaxe suivante : |
|
|
|
||||
|
|
|
La
création d'un index peut s'effectuer alors que la table existe déjà, mais
cela requiert l'usage d'une syntaxe différente. Créons par exemple un index
sur le champ "Nom" de la table "Personnes" : |
|
|
|
||||
|
|
|
Dans
le cas d'un index sur deux champs, cette syntaxe devient : |
|
|
|
||||
|
|
|
Pour
supprimer un index, la syntaxe SQL standard s'écrit : |
|
|
|
||||
|
|
|
Mais
cette syntaxe standard ne fonctionne pas dans Access. Il faut utiliser
la variante suivante : |
|
|
|
||||
|
|
||||
|
|
8 - La création et la suppression d'une relation |
|
||
|
|
|
Pour
montrer comment on crée une relation 1-n entre deux tables, nous avons décomposé
les opérations en quatre étapes. Dans un premier temps, nous créons la table
"Personnes", avec un champ "Nom", un champ
"Prénom", et un champ "Code_Ville"
(entier long), en exécutant la commande suivante : |
|
|
|
||||
|
|
|
Dans
un deuxième temps, nous créons la table "Villes", avec un champ
"Code_Ville" (NuméroAuto)
et un champ "Ville". Cette table servira de liste externe
pour la table "Personnes". Nous exécutons la commande
suivante : |
|
|
|
||||
|
|
|
Dans
un troisième temps, nous modifions la table "Villes" en plaçant une
clé primaire sur le champ "Code_Ville", qui
servira de côté 1 à la future relation. Pour ce faire, nous exécutons la
commande suivante : |
|
|
|
|
||||
|
||||
|
|
|
Dans
un quatrième temps, nous modifions la table "Personnes" en plaçant
une clé étrangère, nommée "relation_ville",
sur le champ "Code_Ville" de la table
"Personnes" (on parle de clé
étrangère pour le côté n de la relation), en précisant que le côté
1 de la relation est le champ "Code_Ville"
de la table "Villes". Nous exécutons donc la commande suivante : |
|
|
|
||||
|
|
||||
|
|
|
Nous
vérifions dans la fenêtre |
|
|
|
|
||||
|
|
9 - La saisie et la correction des données |
|
||
|
|
|
Pour
saisir des données dans la table "Personnes", la commande SQL utilise
la clause INSERT INTO. Les données en mode texte doivent être placées entre
guillemets. Exemple : |
|
|
|
||||
|
|
|
Nous
vérifions, après exécution de la commande, que Pierre Machin a bien été
introduit dans la table "Personnes". Si nous enregistrons la
commande, le SGBD la fait précéder de l'icône |
|
|
|
|
||||
|
|
|
En
bon français, notre commande ressemble à une requête ajout, elle possède
l'icône d'une requête ajout, elle utilise la clause INSERT comme une requête
ajout, mais ce n'est pas une requête ajout. Qu'on se le dise ! |
|
|
|
|
|
Si
le Null n'est pas interdit dans les champs de la
table "Personnes", nous pouvons introduire un nom sans le prénom correspondant,
en opérant de la manière suivante : |
|
|
|
||||
|
|
|
Pour
modifier un enregistrement existant, nous faisons appel à la clause UPDATE
(qui signifie "mise à jour" en anglais). Si, par exemple, nous
voulons doter M. Truc de son prénom, nous écrirons : |
|
|
|
||||
|
|
|
Si
nous enregistrons cette commande, le SGBD Access lui attribue l'icône |
|
|
|
|
|
Pour
supprimer une ligne, nous utilisons la commande basée sur la clause
DELETE : |
|
|
|
||||
|
|
|
Lorsque
la clause WHERE est absente, le SGBD supprime tous les enregistrements,
laissant la table vide (mais ne la supprimant pas) : |
|
|
|
||||
|
|
|
Si
nous enregistrons ces deux commandes, le SGBD Access fait précéder leur nom de
l'icône |
|
|
|
|
|
Dans
certaines implémentations du langage SQL (mais pas dans Access), on peut
omettre la clause FROM qui suit la clause DELETE. |
|
|
|
|
||||
|
|
10 - Conclusion |
|
|
|
|
|
La
création d'une table en SQL n'est pas une travail bien
ardu, même s'il est certain qu'une bonne interface graphique simplifie
fortement l'opération. La saisie des informations en SQL, par contre, est une
tâche quasi désespérante. A moins que les données ne soient importées,
l'usage d'une interface graphique s'impose. |
|
|
|
|
En
ce qui concerne les tables, l'interface graphique du SGBD Access est beaucoup
plus développée que son interface SQL. Nous verrons dans les chapitres
suivants que la situation est très différente, et nettement plus équilibrée,
pour les requêtes. |
|
|
|
|||