|
Chapitre 18 :
la sélection simple en SQL |
|
|
1 - Introduction |
|
||||||||||
|
|
|
Nous
avons vu au chapitre précédent qu'il était possible, dans le SGBD Access, de
manipuler les tables en langage SQL. Cependant, les commandes correspondantes
sont considérées comme des requêtes, et il n'est pas possible de
basculer entre le mode graphique et le mode SQL. En effet, le mode graphique
s'obtient lorsque l'objet "Tables" est sélectionné, alors que le
mode SQL requiert que l'objet "Requêtes" soit actif. |
|
|||||||||
|
|
|
En
ce qui concerne les requêtes, la situation est nettement plus satisfaisante.
La plupart des commandes SQL relatives aux requêtes sont connues du moteur d'Access,
et on bascule sans problème du mode graphique au mode SQL (l'objet
"Requêtes" étant sélectionné). |
|
|||||||||
|
|
|
Il
existe cependant quelques exceptions, que nous étudierons au
chapitre 21. Il s'agit des opérations ensemblistes, pour lesquelles il
n'existe pas d'interface graphique. Ces trois opérations sont : |
|
|||||||||
|
|
|
|
|
|||||||||
|
|
|
Selon
notre habitude, nous utiliserons le SGBD Access comme support pratique de ce
tutoriel (ou tutorial, ou cours en ligne). |
|
|||||||||
|
|
||||||||||||
|
|
2 - La sélection simple |
|
||
|
|
|
Créons,
dans l'interface graphique, la requête qui extrait de la table
"Personnes" (contenant une liste de personnes) les deux champs
"Nom" et "Prénom". Cliquons sur la petite flèche située à
droite de l'outil |
|
|
|
||||
|
|
|
La
requête simple commence par la clause
"SELECT", suivie du nom des champs, puis continue avec la clause
"FROM", suivie du nom de la table à laquelle appartiennent les
champs. Le point-virgule marque la fin de la commande. |
|
|
|
|
|
La
syntaxe relative aux noms des champs consiste à écrire le nom de la table,
suivi d'un point et du nom du champ. Cette façon de procéder s'appelle la qualification. Dans le cas présent,
cette qualification est redondante, et nous pouvons très bien écrire : |
|
|
|
||||
|
|
|
La
politique la plus raisonnable consiste à qualifier les champs chaque fois
qu'une ambiguïté existe (même nom de champ dans deux tables différentes, lors
d'une requête multi-table), et de ne pas les qualifier dans le cas contraire. |
|
|
|
|
||||
|
|
|
sont
parfaitement valables. Par prudence, certains professionnels utilisant les
SGBD préfèrent s'abstenir de tout caractère accentué, remplacent
systématiquement l'espace par le caractère de soulignement, et évitent
d'utiliser les termes réservés. Rappelons que l'implémentation de SQL par
Access accepte les caractères accentués pour les noms des champs et des
tables. |
|
|
|
|
|
Attention
aux détails de syntaxe ! Comme tous les langages informatiques, SQL a
ses petites manies qui empoisonnent les utilisateurs. L'interface graphique a
ceci de bon qu'elle nous débarrasse de ces problèmes stupides -- en plus du
fait qu'elle nous permet de créer des requêtes plus simplement et plus
rapidement. On notera que, dans Access, le point-virgule qui marque la fin
d'une commande n'est pas indispensable. |
|
|
|
|
||||
|
|
3 - La requête avec création de table |
|
||
|
|
|
Récupérons
la requête précédente dans l'interface graphique, faisons en sorte qu'elle
crée une table appelée "Essai", puis basculons en mode SQL. Nous
obtenons : |
|
|
|
||||
|
|
||||
|
|
|
Dans
Access, cette syntaxe fonctionne à condition que la table "Essai"
préexiste, et contienne au moins les champs "Nom" et
"Prénom" avec les mêmes propriétés que dans la table
"Personnes". Access effectue alors une requête ajout des
deux premières colonnes de la table "Personnes" à la table
"Essai". |
|
|
|
|
||||
|
|
4 - Le tri simple ou multiple |
|
||
|
|
|
Nous
pouvons demander que le résultat de la requête soit trié sur un ou plusieurs
champs. Récupérons la requête précédente dans l'interface graphique, faisons
en sorte que le résultat soit trié sur les noms d'abord, sur les prénoms
ensuite, et basculons en mode SQL. Nous obtenons : |
|
|
|
||||
|
|
|
Nous
voyons que le tri (dans l'ordre croissant) s'obtient grâce à la clause ORDER
BY, suivi des noms des champs. Le tri multiple est effectué dans l'ordre
d'énumération des champs. |
|
|
|
|
|
Le
tri d'un champ dans l'ordre décroissant s'obtient en faisant suivre le nom de
ce champ par l'opérateur DESC.
L'exemple suivant effectue un tri croissant sur les noms, suivi d'un tri
décroissant sur les prénoms : |
|
|
|
||||
|
|
||||
|
|
5 - L'élimination des doublons |
|
||
|
|
|
Comme nous
l'avons vu au chapitre 8, la requête simple peut créer des doublons, et il
est possible de remédier de façon simple à cette situation en jouant sur les
propriétés de la requête. Créons dans l'interface graphique une requête de
sélection simple qui concerne le seul champ "Nom" de la table
"Personnes". Modifions la propriété "Valeurs distinctes"
de "Non" à "Oui", puis basculons en mode SQL. Nous
obtenons : |
|
|
|
||||
|
|
||||
|
|
6 - La requête avec création de champ |
|
||
|
|
|
Reprenons
l'exemple déjà traité au chapitre 8, lequel consiste à concaténer le nom
avec le prénom, en les séparant par un espace. Appelons "Nom_complet" le nouveau champ. En mode SQL, nous
obtenons : |
|
|
|
||||
|
|
|
La
façon d'extraire le contenu des champs et d'exprimer la concaténation varient d'un SGBD à l'autre. Cependant, la possibilité de
créer un nouveau champ (et d'en définir le contenu à partir de champs
existants) se retrouve dans tous les SGBD dignes de ce nom. |
|
|
|
|
||||
|
|
7 - La requête multi-fonctionnelle |
|
||
|
|
|
En définitive,
nous pouvons regrouper toutes les opérations précédentes (requête simple,
création de table, création de champ, tri et élimination des doublons) en une
seule requête, dont voici le code SQL (en version Access) : |
|
|
|
||||
|
|
||||
|
|
8 - Les requêtes emboîtées |
|
||||||||||
|
|
|
Nous
avons vu au chapitre 8 qu'il est possible de créer dans Access une
requête à partir du résultat d'une autre requête, à condition que cette
dernière ne crée pas de table. En mode SQL, la commande s'écrit : |
|
|||||||||
|
||||||||||||
|
|
|
On
ne peut pas rêver plus simple pour emboîter deux requêtes ! Cette belle
simplicité ne se retrouve pas en SQL pur et dur, où l'emboîtement de deux
requêtes est d'une écriture plutôt complexe. Que l'on en juge : |
|
|||||||||
|
|
|
|
|
|||||||||
|
|
|
Bonjour
les erreurs ! |
|
|||||||||
|
|
||||||||||||
|
|
9 - Conclusion |
|
|||||||
|
|
|
Le
chapitre 11 est consacré à la sélection simple, mise en oeuvre à l'aide de
l'interface graphique d'Access. Le présent chapitre 19 suit pratiquement
le même plan, mais utilise le langage SQL. La comparaison entre ces deux
chapitres nous amène à faire une double constatation : |
|
||||||
|
|
|
|
|
||||||
|
|
|||||||||