|
1 - Introduction |
|
| |
|
Dans ce chapitre (le second d'une série de quatre consacrés aux requêtes), nous apprendrons à réaliser des opérations de
sélection simple (encore appelée projection). La sélection simple
opère sur les colonnes. Il n'y a pas de critère de sélection relatif au contenu des enregistrements, et de ce fait le nombre de
lignes reste inchangé. |
|
|
|
La figure ci-dessous représente schématiquement une table contenant 7 colonnes. Grâce à une sélection simple (ou
projection), nous pouvons reconstituer une table ne contenant que les colonnes V, Y et Z (colorées en jaune). |
|
|
|
|
|
En fait, le nombre de lignes peut diminuer quelque peu. C'est le cas lorsqu'on élimine les doublons, ou lorsqu'on
effectue une requête basée sur plusieurs tables et qu'il manque des informations dans certaines d'entre elles. |
|
|
|
Nous déborderons quelque peu du cadre de la sélection simple, pour apprendre à mettre en forme l'information obtenue, par
élimination des doublons, concaténation de chaînes, etc. |
|
|
|
Comme pour les autres chapitres de ce tutoriel (encore appelé "cours en ligne" ou tutorial), nous utiliserons le
SGBD Access comme support pratique. |
|
|
|
2 - La création d'une requête |
|
| |
|
A titre de premier exemple de sélection simple, nous allons créer une requête qui extrait d'une table une liste de
personnes désignées par leur nom et leur prénom. Notre point de départ sera la table "Personnes" représentée ci-dessous. |
|
|
| nom_personne |
prénom |
nom_organisme |
fonction |
| Turlutu |
Jean |
Chose et Cie |
technicien |
| Surpont |
Yvette |
EFPG |
secrétaire |
| Lechant |
Paul |
Société Machin |
directeur |
| Durand |
Nathalie |
Entreprise Truc |
ingénieur |
| Lechant |
Paul |
Association Z |
président |
| Verseau |
Pierre |
Bidule SA |
commercial |
|
|
|
|
Notons d'abord qu'une requête opère sur une ou sur plusieurs tables. On ne peut donc pas créer de requête
dans une base de données vide. Certes, le SGBD Access ne refusera pas d'ouvrir la fenêtre de création d'une requête dans une base
vide, mais si aucune table n'est présente, nous ne pourrons rien faire d'autre que créer une requête vide. |
|
|
|
Ouvrons donc la BDD contenant la table "Personnes" représentée ci-dessus. Dans la fenêtre "Base de
données", sélectionnons l'objet "Requêtes". Double cliquons sur "Créer une requête en mode création". Une fenêtre
intitulée "Requête1 : Requête Sélection" s'ouvre, ainsi qu'une boite de dialogue intitulée "Afficher la table".
Cette boite affiche la liste des tables que contient la BDD. Nous sélectionnons la table "Personnes" sur laquelle doit porter la
requête, puis nous cliquons successivement sur les boutons "Ajouter" et "Fermer". La table
"Personnes" est maintenant présente dans la moitié haute de la fenêtre de création de la requête. |
|
|
|
La moitié basse contient la grille de définition de la requête. Pour y introduire un champ (on notera au
passage que l'astérisque représente la totalité des champs), nous disposons de trois méthodes : |
|
|
|
| |
 |
cliquer sur la ligne "Champ :" et choisir dans la liste déroulante qui s'affiche ; |
|
|
double cliquer sur le nom du champ ; |
|
|
tirer le nom du champ avec la souris de la table vers la grille. |
|
|
|
|
Pour extraire de la table "Personnes" les deux premières colonnes, nous introduisons dans la grille les
champs correspondants. Sur la ligne "Afficher :", les cases doivent être cochées (elles le sont par défaut). La figure
suivante est extraite de la grille de définition de la requête : |
|
|
 |
|
|
|
La requête étant définie, nous l'exécutons en cliquant sur le bouton
 de la barre d'outils. Nous obtenons le résultat suivant : |
|
|
| nom_personne |
prénom |
| Turlutu |
Jean |
| Surpont |
Yvette |
| Lechant |
Paul |
| Durand |
Nathalie |
| Lechant |
Paul |
| Verseau |
Pierre |
|
|
|
|
Nous voyons que, comme une table, une requête présente un double aspect : |
|
|
|
| |
|
l'aspect structure, lequel est défini en mode création ; |
|
|
l'aspect résultat, qui est représentée par une table à l'existence volatile, laquelle
s'appelle "feuille de données" dans la terminologie de Microsoft. |
|
|
|
|
Comme pour une table également, on peut passer rapidement d'un aspect à l'autre en cliquant dans la barre d'outils sur le
bouton  (en mode feuille de données), ou le bouton
 (en mode création). |
|
|
|
Pour conserver la structure de la requête, il suffit de cliquer sur l'icône
 "Enregistrer", de donner un nom (par exemple,
"Sélection des personnes") à la requête dans la boite de dialogue qui s'ouvre, et de confirmer. Ce nom figurera désormais
dans la fenêtre "Base de données" (l'objet "Requêtes" étant sélectionné), précédé de l'icône
 , pour rappeler qu'il s'agit d'une requête de sélection. Si nous fermons
la fenêtre de définition de la requête sans avoir préalablement enregistré la structure, le SGBD nous demande si
nous voulons conserver la requête. Dans l'affirmative, la boite de dialogue s'ouvre, et nous procédons comme précédemment. |
|
|
|
Mais le résultat de la requête a disparu ! Pour retrouver cette "feuille de données" volatile, il faut relancer
la requête, soit en double-cliquant sur son nom, soit en la sélectionnant et en cliquant sur le bouton
 "Ouvrir" (lequel devrait plutôt s'appeler
"Exécuter"). |
|
|
|
3 - La requête avec création de table |
|
| |
|
Le résultat d'une requête est une table, et il peut être enregistré comme tel. Pour ce faire, nous sélectionnons
la requête précédente, et nous cliquons sur le bouton "Modifier". La requête s'ouvre en mode création. Nous
cliquons sur le bouton  de la barre d'outils et, dans la liste déroulante
qui s'affiche, nous sélectionnons "Requête Création de table...". Une boite de dialogue s'ouvre, dans laquelle nous renseignons
le nom de la table ("Liste de personnes", par exemple). Dans la liste des requêtes, "Sélection des personnes"
apparaît maintenant avec l'icône  , qui rappelle que le résultat de la
requête est enregistré dans la base sous forme d'une table. |
|
|
|
Exécutons la requête : deux boites d'alerte s'ouvrent successivement. Pas de panique, répondons "oui" dans les
deux cas. Si la table existe déjà, une troisième boite d'alerte prévient de son écrasement. Que de précautions ! (Si ces alertes
vous agacent, vous pouvez les supprimer en utilisant la rubrique "Outils" du menu. Cliquez sur "Options...", puis sur
l'onglet "Modifier/Rechercher, et décochez les cases de la zone "Confirmer"). |
|
|
|
Nous pouvons maintenant vérifier, dans la fenêtre "Base de donnée" (l'objet "Tables" étant sélectionné),
que la table "Liste de personnes" a bien été créée. Si nous l'ouvrons, nous constatons que son contenu correspond bien à la
structure de la requête "Sélection des personnes". |
|
|
|
Comment faire pour qu'une requête ne crée plus de table ? Il semble que l'éditeur Microsoft n'ait pas prévu la chose en
mode graphique, si bien qu'il faut passer en mode SQL. La fenêtre de création (ou modification) de la requête étant ouverte, nous
cliquons sur la petite flèche adjacente à l'icône "Affichage".
Dans la liste déroulante, nous choisissons "Mode SQL", et la traduction de notre requête en langage SQL s'affiche. Dans la
première ligne du code, nous repérons le terme "INTO" suivi du nom de la table (éventuellement écrit entre crochets). Nous
les supprimons tous les deux, nous refermons la fenêtre, et nous confirmons la modification de la requête. |
|
|
|
4 - Le tri simple et le tri multiple |
|
| |
|
On ne peut retrouver rapidement des informations dans une liste que si elle est triée (par ordre alphabétique). Or la liste
des personnes que crée notre requête présente le défaut d'être présentée dans l'ordre où les informations ont été saisies. Une table, en
effet, se remplit toujours par la ligne la plus basse. Pour trier la table, nous pouvons utiliser le bouton
 , mais il est plus pratique de rendre l'opération automatique. Sélectionnons
la requête, et cliquons sur . Dans la grille, cliquons à l'intersection
de la colonne "nom_personne" et de la ligne "Tri :". Une liste s'affiche, qui nous propose les trois options
possibles : croissant, décroissant et non trié. Choisissons "croissant", refermons la fenêtre, confirmons la modification,
et relançons la requête : la table "Liste de personnes" s'affiche désormais par ordre alphabétique des noms, comme le
montre la feuille de données ci-dessous. |
|
|
| nom_personne |
prénom |
| Durand |
Nathalie |
| Lechant |
Paul |
| Lechant |
Paul |
| Surpont |
Yvette |
| Turlutu |
Jean |
| Verseau |
Pierre |
|
|
|
|
Nous pouvons également demander le tri croissant dans le champ "prénom". Si deux personnes portent le même nom,
elles apparaîtront dans l'ordre croissant de leurs prénoms respectifs. Attention ! ce tri multiple s'exécute de gauche à
droite : par les noms d'abord, par les prénoms ensuite. Si nous voulons obtenir le résultat inverse, il faut que nous placions
la colonne nom à droite de la colonne prénom dans la grille de création de la requête. Pour ce faire, il faut sélectionner (par le haut)
la colonne à déplacer, puis la tirer (toujours par le haut) jusqu'à sa nouvelle position. |
|
|
|
5 - L'élimination des doublons |
|
| |
|
Dans la table "Liste de personnes", Paul Lechant apparaît à deux reprises : nous avons affaire à un
doublon, une information répétée deux fois ou plus. Dans la table "Personnes" de départ, cette
double apparition de Paul Lechant était justifiée par deux affiliations distinctes. La sélection a fait disparaître les informations
correspondant à l'affiliation et créé le doublon. Nous pouvons faire en sorte que les doublons soient éliminés du résultat : |
|
|
|
| |
|
grâce à une modification des propriétés de la requête ; |
|
|
grâce à une opération de regroupement. |
|
|
|
|
Première méthode. Ouvrons la requête "Requête1" en mode création. Effectuons un
clic droit dans la fenêtre de définition de la requête et sélectionnons "Propriétés" dans la
liste déroulante, ou cliquons sur l'icône  "Propriétés". La
boite de dialogue "Propriétés de la requête" s'ouvre. Modifions la propriété "Valeurs distinctes" de "Non" à
"Oui". Fermons la boite de dialogue, et basculons en mode feuille de données : les doublons ont disparu, comme le montre la
feuille de données ci-dessous. |
|
|
| nom_personne |
prénom |
| Durand |
Nathalie |
| Lechant |
Paul |
| Surpont |
Yvette |
| Turlutu |
Jean |
| Verseau |
Pierre |
|
|
|
|
L'opération est réversible : si nous basculons en mode création, ramenons la propriété "Valeurs distinctes" de
"Oui" à "Non", et rebasculons en mode feuilles de données, les doublons sont de retour. |
|
|
|
Deuxième méthode. Comme son nom l'indique, l'opération de
regroupement consiste à rassembler les lignes d'une table qui ont quelque chose en commun -- la même
valeur dans un champ donné, par exemple. Au cours de l'opération de regroupement, les doublons sont automatiquement éliminés. On se sert
habituellement du regroupement pour effectuer des calculs sur des groupes de lignes, au lieu de les effectuer sur la table entière. Mais
on peut aussi utiliser le regroupement pour éliminer les doublons. |
|
|
|
Créons une requête simple basée sur la table "Personnes", et sélectionnons les deux champs "nom_personne"
et "prénom". Cliquons sur l'icône  "Totaux" :
une nouvelle ligne (intitulée "Opération :") apparaît dans la grille de définition de la requête, avec la mention
"Regroupement" déjà inscrite par défaut pour chacun des deux champs (si cette mention n'apparaît pas, il faut cliquer à l'endroit
correspondant, et choisir "Regroupement" dans la liste déroulante qui s'affiche). La requête se présente comme le montre la
figure ci-dessous. |
|
|
 |
|
|
|
Basculons ensuite en mode "feuille de données" : les doublons ont disparu et la feuille de données est triée
par ordre alphabétique croissant. |
|
|
|
Notons que ces deux technique éliminent également les doublons éventuellement présents dans la table de départ. |
|
|
6 - La requête avec création de champ |
|
| |
|
Dans la liste des personnes, nous voulons maintenant rassembler chaque nom, suivi de son prénom, dans une même colonne.
Pour ce faire, nous créons la requête suivante : |
|
|
 |
|
|
|
La signification du contenu de la ligne "Champ :" de la grille ci-dessus est la suivante : |
|
|
|
| |
|
la requête crée une feuille de données contenant une colonne intitulée "personne" ; |
|
|
chaque ligne contiendra le nom, puis un espace, puis le prénom. Ces données proviendront de la table située au-dessus de la
grille. |
|
|
|
|
Le signe & désigne, comme en Visual Basic, l'opérateur de concaténation de chaînes. Les crochets [........] signifient
que l'on évoque le contenu des champs correspondants. L'espace qui sépare le nom du prénom est mis entre guillemets pour rappeler qu'il
s'agit d'une chaîne de caractères. Le résultat de la requête est le suivant : |
|
|
| nom_personne |
| Durand Nathalie |
| Lechant Paul |
| Surpont Yvette |
| Turlutu Jean |
| Verseau Pierre |
|
|
|
|
De la même manière, on peut concaténer le code postal avec un tiret suivi du nom de la commune, reconstituer une
adresse complète, etc. Cette technique de reconstitution de chaînes est intéressante parce que, au nom du principe d'atomisation, les
informations situées dans une BDD sont divisées le plus possible en petits morceaux. |
|
|
|
De manière plus générale, une requête avec création de champ permet d'effectuer des opérations (numériques ou sur
chaînes de caractères) sur le contenu des champs d'un même enregistrement, c'est à dire horizontalement. On peut effectuer des
opérations verticalement dans une table (en utilisant ou non la notion de regroupement), mais on obtient une meilleure présentation en se
servant des états, que nous étudierons dans un chapitre ultérieur. |
|
|
|
7 - Les requêtes emboîtées |
|
| |
|
Une requête peut prendre comme point de départ la feuille de données résultant de l'exécution d'une autre requête. Il
suffit de lancer la seconde requête pour que la première s'exécute en premier lieu. On peut généraliser, et créer une chaîne de requêtes qui
s'exécutent dans l'ordre par simple lancement de la dernière. Il faut simplement veiller à ce que chaque requête (à l'exclusion de la
dernière) ne crée pas de table. Sinon, le logiciel proposera de partir de cette table, et la chaîne sera rompue. |
|
|
|
A titre d'exemple, créons les requêtes suivantes : |
|
|
|
| |
|
la requête n° 1 extrait les colonnes nom et prénom de la table "Personnes", et trie par ordre croissant des noms ; |
|
|
la requête n° 2 part du résultat de la requête n° 1 et élimine les doublons (par modification de propriété, ou par
regroupement) ; |
|
|
la requête n° 3 part du résultat de la requête n° 2 et concatène nom et prénom. |
|
|
|
|
Il suffit de lancer la troisième requête pour que l'ensemble s'exécute et fournisse le résultat obtenu au paragraphe
précédent. Nous avons ainsi créé un automatisme élémentaire. Nous verrons dans un chapitre ultérieur que l'on peut obtenir le
même résultat avec une macro. |
|
|
|
Il ne faut pas abuser de l'emboîtement, et les professionnels conseillent généralement de ne pas emboîter plus de 3
requêtes à la file. Il y a plusieurs raisons à cela : |
|
|
|
| |
|
si une requête est utilisée plusieurs fois dans une application, toutes les requêtes emboîtées qui la précédent seront
re-exécutées. On allonge ainsi le temps machine requis pour l'application ; |
|
|
si une requête faisant partie d'un emboîtement contient une erreur, cette erreur sera signalée par le système (du moins par le SGBD
Access) comme faisant partie de la dernière requête de l'emboîtement. L'emboîtement rend donc la correction des erreurs
plus difficile ; |
|
|
l'emboîtement se programme malaisément lorsqu'on utilise le langage SQL, et le risque d'erreur croit avec le nombre de
requêtes emboîtées. |
|
|
|
|
8 - La requête multifonctionnelle |
|
| |
|
Pour des raisons didactiques, nous avons créé une nouvelle requête pour chaque opération que nous voulions réaliser. Dans la
pratique, nous éviterons de multiplier les requêtes, en regroupant le plus possible les opérations à effectuer dans une même requête. |
|
|
|
Ainsi, la requête représentée par la figure ci-dessous permet d'obtenir le résultat final (la liste des noms concaténés
avec les prénoms, dans l'ordre alphabétique, et sans doublons) en une seule étape : |
|
|
 |
|
|
|
et on peut lui demander en plus de créer une table si on le désire. On notera qu'il n'est pas nécessaire que le nom de
la table figure dans la grille (mais la table doit être présente au-dessus de la grille), et qu'il est inutile de spécifier un tri car ce
dernier est implicite en cas de regroupement. |
|
|
|
9- La requête multi-table |
|
| |
|
Dans une BDD relationnelle, les informations sont généralement dispersées dans plusieurs tables (une dizaine couramment,
voire plus) liées par un nombre similaire de relations, ce qui fait qu'il est impossible d'avoir une vue globale du contenu de la
base. Une requête multi-table permet de rassembler dans une même table les informations désirées, et d'obtenir au premier coup d'oeil
une idée de ce contenu. |
|
|
|
Revenons à la table "Personnes" que nous avons utilisée au début de ce chapitre. Une personne pouvant travailler pour
plusieurs organismes, et un organisme pouvant employer les services de plusieurs personnes, la table "Personnes" doit être
séparée en trois tables (dont une table de jonction), liées par des relations. Le schéma relationnel correspondant apparaît sur la figure
ci-dessous. |
|
|
|
Mais cette séparation en trois tables fragmente les données, et nous empêche de voir simplement qui travaille pour qui. Si
nous nous plaçons dans la table "Personnes", nous voyons aussi (grâce à la sous-table) les données de la table
"Affiliation", mais pas celles de la table "Organismes". Si nous nous plaçons dans la table "Organismes",
nous voyons aussi (grâce à la sous-table) les données de la table "Affiliation", mais pas celles de la table
"Personnes". La solution consiste à rassembler pour examen, dans une même table, les données que nous voulons examiner
simultanément. Bref, il faut que nous exécutions une requête de sélection simple multi-table. |
|
|
|
Dans la fenêtre "Base de données", l'objet "Requêtes" étant sélectionné, nous cliquons sur "Créer
une requête en mode Création". Dans la boite de dialogue "Afficher la table", nous sélectionnons les trois tables
nécessaires (l'une après l'autre, ou simultanément grâce à la touche CTRL), et nousconstruisons la requête représentée ci-dessous. |
|
|
 |
|
|
|
Nous obtenons ainsi une vue claire du contenu de la base, vue que nous n'avons
absolument pas lorsque nous examinons les trois tables de départ. |
|
|
|
Attention ! Si nous effectuons une sélection sur les colonnes de deux tables qui ne sont pas liées par une
relation, le logiciel associe chaque ligne de la première table à toutes les lignes de la seconde (cela s'appelle faire leur produit
vectoriel). Le résultat est généralement sans intérêt et, si les deux tables sont conséquentes, l'opération risque d'être fort longue. |
|
|
|
Dans le même ordre d'idée, il ne faut jamais introduire dans la fenêtre de création de requête une table dont la
présence n'est pas nécessaire. Le résultat de la requête risque d'être tout à fait aberrant. |
|
|
