Programmation d’une base de données

relationnelle sous Visual BASIC 6.0

(Notion de base et tutoriel)

-1-
 SOMMAIRE

Chapitre I : LES BASES DE DONNEES ............................................................................................... 3

1. Définition ............................................................................................................................................... 4
2. Pourquoi apprendre une base de données relationnelle ......................................................................... 4
3. Terminologies ........................................................................................................................................ 5
4. Création d’une base de données ............................................................................................................. 5
5. Normalisation et formes normales ......................................................................................................... 7
Chapitre II : PROGRAMMATION........................................................................................................ 10
1. Préliminaires .......................................................................................................................................... 11
2. Ouverture ............................................................................................................................................... 12
3. Enregistrement ....................................................................................................................................... 13
4. Modification ........................................................................................................................................... 14
5. Suppression ............................................................................................................................................ 14
6. Navigation .............................................................................................................................................. 15
Chapitre III : NOTION SQL ................................................................................................................... 16
Partie I : Les commandes SQL ................................................................................................................ 18
Select........................................................................................................................................................... 19
Distinct ........................................................................................................................................................ 19
Where .......................................................................................................................................................... 20
And-Or ........................................................................................................................................................ 20
In ................................................................................................................................................................. 21
Between ...................................................................................................................................................... 21
Like ............................................................................................................................................................. 22
Order by ...................................................................................................................................................... 22
Les fonctions usuelles (Avg, count, max, min, sum).................................................................................. 23
Groupe by ................................................................................................................................................... 24
Having......................................................................................................................................................... 25
Alias ............................................................................................................................................................ 25
Les jointures internes .................................................................................................................................. 26
Les Jointures externes ................................................................................................................................. 27
Fonction de concaténation .......................................................................................................................... 27
Sous-chaîne ................................................................................................................................................. 28
Trim ............................................................................................................................................................ 28
Partie II : Manipulation d'enregistrements
Insert into .................................................................................................................................................... 31
Update ......................................................................................................................................................... 31
Delete from ................................................................................................................................................. 32
Partie III : Les commandes SQL avancées
UNION ....................................................................................................................................................... 34
UNION ALL ............................................................................................................................................... 34
INTERSECT ............................................................................................................................................... 35
MINUS ....................................................................................................................................................... 35
SOUS-REQUETE....................................................................................................................................... 36
EXISTS ....................................................................................................................................................... 36
CASE .......................................................................................................................................................... 37
RANG ......................................................................................................................................................... 38
MEDIANE .................................................................................................................................................. 38
EXECUTION TOTALE ............................................................................................................................. 39
POURCENTAGE DU TOTAL ................................................................................................................. 39
POURCENTAGE DU TOTAL CUMULATIF ......................................................................................... 40

-2-
 Chapitre premier
Les bases de données

Dans ce chapitre :

1. Définition ............................................................................................................................................... 4
2. Pourquoi apprendre une base de données relationnelle ......................................................................... 4
3. Terminologies ........................................................................................................................................ 5
4. Création d’une base de données ............................................................................................................. 5
5. Normalisation et formes normales ......................................................................................................... 7

-3-
1. Définition :
Une base de données est un ensemble structuré de données enregistrées dans un ordinateur et
accessibles de façon sélective par plusieurs utilisateurs.

L’utilisation d’une base de données offre plusieurs avantages. Parmi lesquels, on peut citer :

- L’accès rapide et facile à l'information :

Etant donné que toutes les informations se trouvent dans un même endroit (dans la base de données),
on n’est plus amené à les regrouper depuis plusieurs sources. La recherche d’une information spécifique
ou d’un ensemble d’informations devient, de ce fait, très facile.

Exemple: Combien me reste-t-il en stock du produit X? Qui sont mes dix plus importants clients en ce
moment? Etc.

- Un meilleur suivi de l'information :

En effet, le système de gestion d’une base de données relationnelle (SGBDR) donne la possibilité de
voir toutes les informations en un clin d’œil. Ceci permet, outre la gestion facile, une meilleure analyse
des données et de prise de décision donc on sera plus apte à répondre aux besoins de la clientèle.

- Automatisation de certaines tâches répétitives :

Beaucoup d’opérations se rapportent souvent à la manipulation des informations. Plusieurs d’entre
elles peuvent être programmées à l’avance.

2. Pourquoi apprendre une base de données relationnelle ?

Ce type de base de données a plusieurs avantages comparé à une base de données simple. Elle utilise
beaucoup moins d'espace parce qu'elle réduit au minimum les redondances ou les répétitions des données.

Pour mieux comprendre l'avantage ainsi que pour montrer certains concepts de base d'un système de
gestion de base de données relationnelle, utilisons l’exemple d’une facture. Sur une facture, nous trouvons
généralement: la date, le numéro de la facture, le numéro du vendeur, le numéro du produit, la quantité
vendue, le prix unitaire, la description du produit, le sous total, les taxes, le total, etc. Voici quelques-unes
de ces données, organisées dans une base de données simple.

N° Facture Client Produit Description Prix Unitaire Quantité

1001 ABC 415 TRIANGLE 12.75 50
1002 ABC 416 CARRÉ 10.00 20
1003 XYZ 415 TRIANGLE 12.75 75

 Tableau 1 : Organisation des informations dans une base de données simple

L'idée d'une base de données relationnelle est de répartir les données dans plusieurs tables et de créer
des connexions, des points communs, des liens, c'est-à-dire des relations entre chacune d'elles. Voici
comment les variables pourraient être divisées dans une base de données relationnelle.

Facture Client Vendeur Inventaire

N° Facture N° Client N° Vendeur N° Produit
N° Produit Adresse Nom Description
Qté vendue Code Postal Prénom Prix unitaire
N° Vendeur N° téléphone N° Ass. Soc. Qté disponible
N° Client Personne autorisée Date d'embauche Qté commandée

 Tableau 2 : Organisation des informations dans une base de données relationnelle

-4-
 Dans le tableau 2, la table FACTURE va chercher les informations sur le client de la table CLIENT
par le champ commun N° Client. Il est inutile de réécrire les données sur un client plusieurs fois.

On peut aller chercher l'information grâce à une relation entre ces deux tables, soit par le champ
N°Client. La même chose se produit pour les informations nécessaires pour les tables VENDEUR et
INVENTAIRE par leurs variables communes, respectivement, N° Vendeur et N° Produit.

De cette manière, il est inutile de réécrire les données redondantes ou répétitives. Ceci conserve de
l'espace pour d'autres données.

Pour les trois factures de l'exemple, on économise de l'espace et du temps à ne pas avoir à réécrire les
informations sur le client ABC ni la description et le prix unitaire du produit 415.

3. Terminologies
L’utilisation d'une base de données apporte de nouveaux termes à comprendre. En effet, la définition
d'une base de données n'est plus juste un fichier qui contient de l'information utile pour l'utilisateur. Il
contient aussi les requêtes, les formulaires, les états, les macros et les modules pour développer une
« application » ou un « système » qui répond aux besoins spécifiques de l'utilisateur.

TERME DEFINITION
Une information nécessaire sur une personne, une chose ou un événement.
Champ Ex.: couleur, taille, modèle, date, nom, prénom, téléphone, adresses, description,
commentaires, etc.
Un regroupement de champs qui décrivent une personne, une chose ou un événement.
Ex.: nom, prénom, date de naissance, téléphone, numéro d'assurance sociale ou
Enregistrement
compagnie, adresse, téléphone, télécopieur, personne responsable ou département,
personne responsable, téléphone.
Un regroupement d'enregistrements sur un thème un commun. Ex.: employés, inventaire,
Table
client, fournisseurs, véhicules, contacts etc.

 Tableau 3 : Terminologie courante

4. Création d'une base de données

Voici les étapes à suivre lors de la création d'une base de données. L'exercice va consister à créer une
base de données pour la facturation d'une entreprise.

 Première étape : l'analyse.

C'est l'étape la plus importante. Si cette étape n'a pas été faite correctement, une perte de temps et
d'efforts sera à refaire ce qui aurait dû être accompli auparavant.

Avant de créer la base de données, il faut avoir une idée claire de ce que seront les besoins pour celle-
ci. Il faut préparer une analyse approfondie des besoins en se posant la question : « Quelles sont les
informations dont on a besoin ? »

Exemple : Quelles informations ai-je besoin sur mes clients, sur mes fournisseurs, sur mon inventaire,
sur mon personnel, etc.

Une technique parmi d'autres que l'on peut utiliser consiste à fonctionner « à l'envers » (top-down),
c'est-à-dire, songer aux formulaires et aux états dont on aura besoin. Connaissant ces informations,
découvrir quels sont les champs nécessaires pour atteindre ceux-ci. Par exemple, il faut connaître les
quantités vendues et à quel prix unitaire avant de connaître le total des ventes.

-5-
 La technique « bottom-up » peut aussi être utilisée : à partir de la base, on détermine toutes les
informations qui sont nécessaires pour les requêtes, les formulaires et les états de la base de données.

N.B. On peut combiner les deux techniques pour s'assurer d'avoir toutes les informations nécessaires.

Voici, par exemple, la liste de champs que l'on peut retrouver une facture : Date, Numéro de facture,
Numéro de client, Adresse de facturation du client, Ville, Numéro de téléphone, Numéro de télécopieur,
courrier électronique, Adresse de livraison, Personne contact, Conditions de paiement, Numéro de
produit, Description du produit, Prix unitaire du produit, Quantité achetée, Total pour l'item, sous total,
Grand total, Escompte, Bon de commande, Numéro du vendeur, Nom du vendeur, etc...

 Deuxième étape: regrouper les informations dans des tables.

Il faut ensuite regrouper en entités toutes ces informations (champs) dans une table ou un « thème » en
commun.

Une des techniques pour regrouper les champs dans des tables et pour déterminer les relations entre
ces tables est le concept de distribuer les champs dans le plus grand nombre de tables possibles tout en
suivant certaines règles telles que :

- Regroupement des champs dans des tables qui peuvent être reliées.
- Pas de dédoublement de champs, sauf pour les champs en commun.
- Pas de dédoublement d'entrée d'information.
- Pas de champs calculables dont on peut avoir le résultat avec les informations des autres champs
des tables.

Exemple:

Si l'on se basait sur des éléments de la vie de tous les jours, du concret, on pourrait se référer sur les
questions suivantes :
- Quelles sont les opérations accomplies ?
- Qui utilise quelle information ?

Pour la facture, on retrouve des éléments qui distinguent la facture, le client, les produits et le vendeur.
Ce sont donc les quatre tables qui seront utilisées.

Il faut aussi s'assurer que les champs sont dans la bonne table, qu'il n'y a pas de tables cachées à
l'intérieur des autres.
A l'exception des « champs en commun » qui servent à « relier » les tables, un champ ne devrait pas se
retrouver dans plusieurs tables.

 Troisième étape : Déterminer les clés primaires

Une clé primaire est un champ, ou une série de champs, qui permet de différencier un enregistrement
des autres.

Par exemple, bien qu'il puisse avoir plusieurs factures avec la même date, la même quantité achetée, au
même client ou avec le même vendeur, il n'y aura pas deux factures avec le même numéro de facture.

Une clé primaire n'est pas obligatoire pour une table. Elle le devient lorsque l'on veut relier deux
tables : l'une des tables doit avoir une clé primaire.

Rendu à un certain point, il est préférable d'avoir un champ nommé Numéro d'employé ou Numéro
d'assurance social pour distinguer chacun des enregistrements de la table. Mais il y a des occasions où il
est nécessaire d'avoir une clé primaire qui est composée de plusieurs champs.

-6-
  Quatrième étape : Déterminer les relations entre les tables
Pour qu'une relation soit possible entre deux tables, il faut:
- deux tables (ou requêtes ou une combinaison des deux)
- un champ en commun dans chacune des tables.

Remarque :
Le champ en commun doit être :
- de même type (Texte avec texte, numérique avec numérique)
- de même longueur (Pas un champ long de 15 caractères avec un autre long de 50 caractères)
- de même genre d'information (Code d'inventaire avec des codes d'inventaires, NAS avec NAS ...)

En outre, il n'est pas obligatoire de relier toutes les tables l'une à l'autre. Il est possible d'accéder à
l'information tant que les tables soient reliées directement ou indirectement en elles.

 Cinquième étape : Déterminer les types de relations (cardinalité)

Il existe trois types de relations :
- 1à1
- 1 à plusieurs
- plusieurs à plusieurs.

Pour l'exemple qui est utilisé, voici comment relier les tables dont les informations se retrouvent sur
une facture. L'image ci-dessous démontre la liste des tables avec les champs qui les composent. Les lignes
indiquent les relations entre les tables.

Figure 1 : Représentation des relations entre les tables

N.B. La relation de types plusieurs à plusieurs requiert une tables intermédiaire composé, au minimum
de la clé primaire des deux tables à relier. C'est la raison d'être de la table Transition Fact-Inv qui
pourrait tout aussi s'appeler « Items » de la facture.

5. La normalisation et les formes normales

L'avantage d'une base de données relationnelle est d'éviter au maximum les répétitions ou les
redondances d'information. La normalisation sert à séparer la liste des champs en plusieurs tables pour
avoir une base de données qui est plus efficace.

On parle de retirer progressivement quelques problèmes que l'on retrouve dans les bases de données
pour afficher la base de données sous différentes formes normales. Pour le moment, nous allons
seulement regarder les trois premières formes normales.

-7-
  Première forme normale: répétition des données
Pour atteindre la première forme normale, il faut éliminer les groupes répétitifs en les séparant en
plusieurs tables. Le travail à accomplir pour atteindre la première forme normale est d'éviter
complètement les répétitions d'entrée de données. Par exemple, une facture peut contenir plusieurs
produits.

Numéro de facture Numéro de produit

1 1, 3, 5

 Tableau 4 : Répétition de données susceptible

Donc, il peut avoir plusieurs numéros de produits pour une même facture. Ceci est de la redondance et
ce n'est pas une forme appropriée pour conserver de l'information dans une base de données relationnelle.
Comment fera-t-on ensuite pour relier une modification au bon produit ? Il faut donc mettre Numéro de
produit dans une table autre que Facture.

On peut en même temps déplacer les champs similaires dans l'autre table. Le test de la deuxième forme
normale va s'assurer que les champs sont à la bonne place.

Il faut s'assurer que l'utilisateur ne va entrer plusieurs fois la même information. Par exemple, cela ne
serait pas efficace d'avoir une table « Facture » qui contiendrait aussi les champs « Nom du client »,
« Adresse de livraison », « personne contact ». Cela ne passerait pas à la première forme normale. La
raison est qu'il faudrait que l'utilisateur rentre pour chaque facture la même information qu'il a déjà entrée
dans les factures précédentes pour le même client.

C'est pour cette raison qu'il faut « découper » la liste des champs dont on a besoin dans plusieurs tables
pour avoir une forme efficiente d'entrée et d'utilisation des données. La même situation se répète pour les
informations sur le vendeur. Ainsi, dans notre exemple, on aura les tables :

Facture: Numéro de facture, date, bon de commande, escompte

Clients: Numéro de client, adresse de facturation, ville, numéro de téléphone, numéro de télécopieur,
adresse de courriel, adresse de livraison, personne contact, escompte, conditions de paiement
Employés: Numéro du vendeur, nom, prénom, numéro d'assurance social
Inventaire: Numéro de produit, description, prix unitaire, quantité achetée, quantité disponible

Il faut ensuite déterminer la clé primaire pour chaque table. Cela est nécessaire pour la seconde forme
normale. Pour la table Facture, la clé primaire est le champ Numéro de facture. Le contenu de tous les
autres champs de la table peut se répéter ce qui serait contraire à la convention d'une clé primaire.

 Deuxième forme normale: Dépendance directe à la clé primaire

Il faut ensuite éliminer les dépendances partielles. Cela veut dire qu'il faut s'assurer que tous les
champs de la table dépendent de la clé primaire de la table. Sinon, il faudra créer une nouvelle table ou
déplacer le champ.

Le problème pour ce niveau est le champ « Quantité ». Il dépend en même temps du numéro de facture
et du numéro de produit. Une facture peut avoir plusieurs produits. Mais un produit peut aussi se
retrouver sur plusieurs factures. Il y a donc une relation de type « plusieurs à plusieurs » entre ces deux
tables.

Dans un tel cas, il est nécessaire de créer une table « intermédiaire » entre les tables facture et
inventaire afin de maintenir le type de relation, au plus, à un à plusieurs. C’est la table « Items ». Le
contenu de cette dernière est représenté ci-dessous.

-8-
Facture: Numéro de facture, Date, bon de commande, escompte
Clients: Numéro de client, adresse de facturation, ville, numéro de téléphone, numéro de télécopieur,
adresse de courriel, adresse de livraison, personne contact, escompte, conditions de paiement
Employés: Numéro du vendeur, nom, prénom, numéro d'assurance social
Inventaire: Numéro de produit, description, prix unitaire, quantité disponible
Items: Numéro de facture, Numéro de produit, Quantité achetée

Pour notre base de données, la table items est appelée « Transition Fact-Inv » puisqu'elle permet de
relier les tables Facture et Inventaire. L’on remarquera aussi que la clé primaire de cette table est
composée de deux champs: Numéro de facture et Numéro de produit. Ce sont aussi les clés primaires des
tables Facture et Inventaire.

Numéro de facture Numéro de produit Quantité achetée

1 1 10
1 2 25
2 1 50
2 2 100
 Tableau 5 : Organisation des données selon la 2ème forme normale

Dans cette table, un même numéro de facture et un même numéro de produit peuvent être utilisé
plusieurs fois.

 Troisième forme normale: Dépendances partielles de la clé

C’est l’élimination des dépendances transitives. Il faut s'assurer qu'il n'y a pas de tables qui soient
cachées parmi les autres. Aussi, les tables ne devraient jamais contenir de champs calculés. Par exemple,
il ne devrait pas avoir les champs « sous total », « Total », etc. dans les tables puisqu'il est possible de les
calculer à partir des données qui sont déjà dans les tables. Il est possible d'avoir le « sous total » en
multipliant la « Quantité vendue » par le « Prix unitaire » donc, il est inutile de l'avoir dans les tables.

La troisième étape étant de déterminer les relations entre les différentes tables, il faut regarder quelles
sont les relations possibles entre les entités.

Pour avoir une relation, deux tables doivent avoir au moins un champ en commun. On peut relier une
facture à un client par le champ « ID_Client ». Ou encore, relier un produit à une facture par le champ
« ID_Produit » etc.

On devra à ce moment s’apercevoir que certains champs seraient mieux placés dans une autre entité.
Une fois que l’on ait réalisé les regroupements et déterminé les relations, on a la base pour la création des
tables.

Maintenant que l’on a les entités et les champs qui les composent, on doit penser à quoi devrait
ressembler les formulaires et les états. Les champs que l’on a choisis doivent répondre à tous les besoins.
Il faut prendre tout le temps nécessaire pour l'analyse.

-9-
 Chapitre II
La programmation

Dans ce chapitre :

1. Préliminaires .......................................................................................................................................... 11
2. Ouverture ............................................................................................................................................... 12
3. Enregistrement ....................................................................................................................................... 13
4. Modification ........................................................................................................................................... 14
5. Suppression ............................................................................................................................................ 14
6. Navigation .............................................................................................................................................. 15

- 10 -
1. Préliminaire
La programmation d'une base de données relationnelle consiste, en général, à travailler sur les
enregistrements que contiennent les tables de la base. Une opération spécifique sur ces enregistrements
est aisément appelée « requête ».

La programmation peut être effectuée au sein même du logiciel MS Office Access, logiciel avec lequel
nous avons créé notre base de données, mais, notre but étant d'étudier la manipulation de ces données
d'une manière plus personnalisée, nous allons utiliser MS Visual BASIC.

De ce fait, comme notre projet se compose de plusieurs fichiers issus de différents logiciels, il est
nécessaire d'insérer, dans l'environnement Visual BASIC, une bibliothèque spécifique. Dans notre cas
cette bibliothèque se dénomme Microsoft DAO 2.5/3.51 Compatibility Library. L'insertion d'une
référence dans un projet s'effectue à partir du menu « Projet (Project) – Référence (Reference)». Ceci
nous permettra d'utiliser les types de variables « Database » et « Recordset ». A l'aide de ces objets, on
créera une copie de la base et des tables de la base dans le projet1. Ainsi, on aura une variable de type
« Database » et, éventuellement, plusieurs variables de type « Recordset » dont le nombre peut dépendre
de celui des tables que la base de données contient. Ces variables sont, en général, de niveau projet car,
selon la complexité des opérations à effectuer au sein de la base de données, elles seront manipulées dans
plusieurs « Forms2 ».

Syntaxes :
'Déclaration des variables base de données et tables
Public MaBase As Database
Public MaTable As Recordset

Figure 2b : Boite de dialogue référence

Figure 2a : Accès aux références

La programmation d'une base de données repose, en général, sur la manipulation des enregistrements tels
que : l'insertion de nouveaux enregistrements, la suppression, la modification ainsi que les recherches (ou
navigations entre enregistrements). Nous allons détailler chacune de ces opérations.

1
Il est à noter que l'omission de cette référence interdit l'accès aux types Database et Recordset
2
cf. portées des variables – cours de programmation.
- 11 -
2. Ouverture de la base de données et celle des tables :
Il est évident qu’avant d'accéder aux enregistrements, il faut ouvrir la base ainsi que la table où se trouve
l'enregistrement dont on a l'intention de manipuler. « L’OUVERTURE » est donc la première procédure à
écrire dans le programme. Les méthodes « OpenDatabase » et « OpenRecordset » permettent d'effectuer
cette opération.

La méthode OpenDatabase d'un objet « Database » impose la spécification de l'endroit où se situe la base
de données (dans notre cas le fichier .mdb, créé à l'aide de MS Office Access). C’est le « chemin » (en
anglais path). Il peut être absolu (ex. : C:\Gestion.mdb), comme pour une base de données en réseau en
général, ou relatif afin de rendre l'installation plus souple pour une base de données monoposte.

OpenRecordset est aussi une des méthodes d'un objet Database. Elle s'effectue en second plan (après
l'ouverture de la base) car elle permet l'ouverture d'une table de la base.

Syntaxes :
'Ouverture de la base de données
Set MaBase = OpenDatabase(Chemin)
'Ouverture de la table
Set MaTable = MaBase.OpenRecordset(NomTable)

Voici donc les premières lignes de code de notre programme :

Figure 3 : Les premières lignes de codes

La base ainsi que la table (ou les tables) étant ouvertes, on peut procéder aux opérations se rapportant sur
les enregistrements.

N.B. Dans ce tutoriel, nous n’allons détailler que tout ce qui concerne la table « Clients ». Voici, à quoi
ressemble le formulaire servant à manipuler les informations sur un client :

- 12 -
 Figure 4 : Le formulaire d'informations sur un client (frmClients)

3. Enregistrement
Enregistrer veut dire insérer des nouvelles informations sur une entité dans une table spécifique. Elle
s'effectue par le biais de la méthode « Addnew » d'un objet recordset dont la syntaxe est la suivante :

Syntaxes :
MaTable.AddNew
MaTable ![PremierChamp] = Valeur_1
MaTable ![DeuxiemeChamp] = Valeur_2
…
MaTable.Update

Ici, « Valeur_1 » et « Valeur_2 » correspondent à la valeur que doit contenir respectivement

« PremierChamp » et « DeuxiemeChamp » qui ne sont autres que les champs que la table « MaTable »
contient. Il faut donc spécifier les valeurs respectives de chaque champ de la table.

La méthode « Update » met à jour la structure de la table. Ainsi, si tous se passe bien, les nouvelles
informations seront enregistrées dans la table. Voici, par exemple, le code d'enregistrement d'un client,
instructions qui se répètent chaque fois que l'utilisateur appui sur le bouton « cmdEnregistrer » :

Figure 5 : Code d'enregistrement des informations sur un client

- 13 -
Quelques remarques :
- Le Bloc « With…End With » permet de se passer de la répétition d'une entité particulière (ici,
« MaTableClient »
- Il faut tenir compte du type de chaque champ. Un transtypage peut parfois être nécessaire.

4. Modification
La syntaxe de la modification ressemble à celle de l'enregistrement. A la différence qu’ici, on opère sur
un enregistrement existant. L'algorithme est donc le suivant :
- Spécifier la clé avec laquelle l'enregistrement à modifier sera recherché (Index)
- Rechercher cet enregistrement en entrant la valeur de la clé de recherche (Seek)
- Procéder à la modification de la valeur de chaque champ correspondant à la clé (Edit)
- Mettre la structure de la table à jour (Update)

Syntaxes :
MaTable.Index = NomDeLaCle
MaTable.Seek "=", Valeur
MaTable.Edit
MaTable ![PremierChamp] = Valeur_1
MaTable ![DeuxiemeChamp] = Valeur_2
…
MaTable.Update

Noter la syntaxe de l'instruction « Seek » : elle doit contenir un opérateur de comparaison selon la valeur
de la clé de l'enregistrement à rechercher. Cet opérateur ne doit cependant retourner qu’une et une seule
valeur correspondant à un seul enregistrement.

Voici le code de modification d'un client spécifique

Figure 6 : Code de modification des informations sur un client existant

5. Suppression
Supprimer un enregistrement consiste à effacer un enregistrement de la table. Elle doit respecter
l'algorithme suivant :
- Spécifier la clé avec laquelle l'enregistrement à supprimer sera recherché (Index)
- Rechercher cet enregistrement en entrant la valeur de la clé de recherche (Seek)
- Procéder à la suppression (Delete)

Il faut noter que cette opération est irréversible : quand un enregistrement a été supprimé de la table, il n’y
aucun moyen de le récupérer. Il est donc indispensable d'attendre que l'utilisateur confirme l'exécution de
cette opération.

- 14 -
En outre, la méthode « Delete » met la table à jour automatiquement. Il n’est donc plus nécessaire de faire
appel à la méthode « Update » pour effectuer cette tâche.

Syntaxes :
MaTable.Index = NomDeLaCle
MaTable.Seek "=", Valeur
MaTable.Delete

Voici comment peut se présenter le code de la suppression d'un client spécifique :

Figure 7 : Code de suppression des informations sur un client spécifique

6. Navigation
La navigation entre enregistrement peut se résumer en quatre (4) méthodes dont les syntaxes respectives
sont présentées ci-après. Cette opération consiste à parcourir les enregistrements que contient une table.

Syntaxes :
' Aller au premier enregistrement
MaTable.MoveFirst

' Aller au dernier enregistrement

MaTable.MoveLast

' Aller à l'enregistrement suivant

With MaTable
If Not .EOF Then
.MoveNext
End If
End With

' Aller à l'enregistrement précédent

With MaTable
If Not .BOF Then
.MovePrevious
End If
End With

- 15 -
 Chapitre III
Notion SQL

- 16 -
 Introduction

SQL (Structured Query Language) est un langage de programmation informatique destiné à stocker, à
manipuler et à retrouver des données enregistrées dans des bases de données relationnelles. Le langage
SQL est apparu pour la première fois en 1974 lorsqu’un groupe d’IBM a mis sur pied le premier
prototype d’une base de données relationnelle. La première base de données relationnelle a été
commercialisée par Relational Software (plus tard Oracle).

SQL a des standards. Toutefois, le SQL qui peut être actuellement utilisé sur la plupart des SGBDR3se
trouve sous différents aspects. Pour deux raisons telles que, premièrement, le standard SQL est assez
complexe, et il n’est pas pratique d’implémenter le standard entier et, deuxièmement, chaque fournisseur
de bases de données a le besoin de différencier ses produits parmi tant d’autres. Dans le présent
didacticiel, ce type de différences sera pris en main au moment opportun.

Ce chapitre dresse la liste des commandes SQL couramment utilisées, et se présente sous les titres
suivants :
- Commandes SQL : Instructions SQL de base pour stocker, retrouver et manipuler des données dans
une base de données relationnelle.
- Manipulation d'enregistrement: Manière dont les instructions SQL sont utilisées pour gérer des
tables au sein de la base de données.
- Commandes SQL Avancé: Commandes de SQL avancé.

La syntaxe de chaque commande SQL sera décrite et expliquée en premier lieu, puis illustrée par un
exemple.

3
SGBDR : Système de gestion de base de données relationnelle
- 17 -
 Partie I
Les commandes SQL

Dans cette partie :

Select........................................................................................................................................................... 19
Distinct ........................................................................................................................................................ 19
Where .......................................................................................................................................................... 20
And-Or ........................................................................................................................................................ 20
In ................................................................................................................................................................. 21
Between ...................................................................................................................................................... 21
Like ............................................................................................................................................................. 22
Order by ...................................................................................................................................................... 22
Les fonctions usuelles (Avg, count, max, min, sum).................................................................................. 23
Groupe by ................................................................................................................................................... 24
Having......................................................................................................................................................... 25
Alias ............................................................................................................................................................ 25
Les jointures internes .................................................................................................................................. 26
Les Jointures externes ................................................................................................................................. 27
Fonction de concaténation .......................................................................................................................... 27
Sous-chaîne ................................................................................................................................................. 28
Trim ............................................................................................................................................................ 28

- 18 -
SELECT
Une utilisation courante des commandes SQL consiste à sélectionner les données de tables contenues
dans une base de données. Nous venons tout juste de mentionner deux mots-clés : il faut
SÉLECTIONNER (SELECT) des informations PROVENANT (FROM) d’une table4. Nous avons ainsi
la structure SQL la plus basique :

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table"

Exemple :
Supposons que nous avons la table suivante :

Table Store_Information
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999
Los Angeles 300 € 08-Jan-1999
Boston 700 € 08-Jan-1999
Note :
Cette table sera utilisée comme exemple tout au long du cours.

L’instruction suivante permet de sélectionner tous les magasins dans cette table :

SELECT store_name FROM Store_Information

Le résultat de l’instruction ci-dessus est le suivant :

store_name
Los Angeles
San Diego
Los Angeles
Boston

Il est à remarquer que cette syntaxe nous donne la possibilité de sélectionner plusieurs champs et de
tables.

Exemple :
Supposons que nous voulions sélectionner les deux premiers champs de la table. On écrira alors :

SELECT store_name, Sales FROM Store_Information

Pour sélectionner tous les champs de la table, on utilise le caractère « * » au lieu des noms de ces champs.
Dans notre cas, par exemple, on écrit :

SELECT * FROM Store_Information

DISTINCT
Le mot-clé SELECT permet d’extraire toutes les informations d’un champ (ou de plusieurs champs)
d’une table. Les résultats retournés comporteront, dans certains cas, des redondances5.

4
Notez qu’une table est un conteneur qui réside dans la base de données où sont stockées les données. Pour en savoir plus sur
la manipulation d’une table, voir Partie II Manipulation de table
5
Dans notre cas, la valeur « Los Angeles »
- 19 -
Nous devons alors compléter cette clause pour ne sélectionner que des éléments DISTINCT-s.
Syntaxe :
SELECT DISTINCT "Nom_Champ" FROM "Nom_Table"

Exemple :
Pour sélectionner tous les différents magasins dans la table Store_Information, il faut saisir :

SELECT DISTINCT store_name FROM Store_Information

Cette instruction donne le résultat suivant :

store_name
Los Angeles
San Diego
Boston

WHERE
Il est ainsi possible de sélectionner conditionnellement les données d’une table. Par exemple, en utilisant
le mot-clé WHERE, il est possible de retrouver uniquement des magasins dont les ventes sont
supérieures à 1000 €. La syntaxe est comme suit :

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" FROM "Condition"

Exemple :
Pour sélectionner tous les magasins dont les ventes sont supérieures à 1000 € dans la table
Store_Information, il faut saisir :

SELECT store_name FROM Store_Information WHERE Sales > 1000

Nous obtiendrons alors :

store_name
Los Angeles

AND - OR
Dans la section précédente, nous avons vu que le mot-clé WHERE peut s’utiliser pour sélectionner
conditionnellement des données d’une table. Cette condition peut être une condition simple (comme celle
de la section précédente), ou combinée. Les conditions combinées se constituent de plusieurs conditions
simples connectées par AND ou OR. Une seule instruction SQL peut contenir un nombre illimité de
conditions simples.

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" WHERE "ConditionSimple1"{(AND|OR)
ConditionSimple2"}+6

Notez que AND et OR peuvent être utilisés de manière interchangeable. En outre, nous devons utiliser les
parenthèses ( ) pour indiquer l’ordre de la condition.

Exemple :
Pour sélectionner tous les magasins dont les ventes sont supérieures à 1000 € ou inférieures à 500 €, mais
supérieures à 275 € dans la Table Store_Information, il faut saisir :

6
{}+ signifie que l’expression entre parenthèses pourra apparaître une ou plusieurs fois.
- 20 -
SELECT store_name FROM Store_Information WHERE Sales > 1000 OR (Sales < 500 AND Sales >
275)
Ce qui nous donne, comme résultat :
store_name
Los Angeles
San Francisco

IN
Deux utilisations du mot-clé IN sont possibles dans SQL, et cette section décrit celle qui est relative à la
clause WHERE. Utilisé dans ce contexte, ce mot clé nous permet de connaître exactement la valeur des
valeurs retournées que nous souhaitons voir au moins pour l’un des champs.

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" WHERE "Nom_Champ"
IN(′Valeur1′,′Valeur2′,…)

Il est possible de saisir une ou plusieurs valeurs entre parenthèses, tout en veillant bien de les séparer par
une virgule. Les valeurs peuvent être saisies en chiffres ou en lettres. S’il n’y a qu’une valeur entre
parenthèses, cette commande sera équivalente à

WHERE "Nom_Champ" = 'valeure1'

Exemple :
Pour sélectionner tous les enregistrements des magasins de Los Angeles et de San Diego dans la Table
Store_Information, il faut saisir :

SELECT * FROM Store_Information WHERE store_name IN ('Los Angeles', 'San Diego')

Ce qui donne:
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999

BETWEEN
Alors que le mot-clé IN aide les utilisateurs à limiter le critère de sélection à une ou plusieurs valeurs
distinctes, le mot-clé BETWEEN permet de sélectionner un intervalle.
Syntaxe :

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" WHERE "Nom_Champ" BETWEEN ′Valeur1′
AND ′Valeur2′

Cette instruction sélectionnera toutes les lignes dont les colonnes ont une valeur comprise entre 'valeur1'
et 'valeur2'.
Exemple :
Pour visualiser toutes les informations de vente comprises entre le 6 janvier 1999 et le 10 janvier 1999
dans la Table Store_Information, il faut saisir :

SELECT * FROM Store_Information WHERE Date BETWEEN '06-Jan-1999' AND '10-Jan-1999' 7

7
Le format de la date peut différer selon la base de données utilisée.
- 21 -
Le résultat obtenu après l’exécution de cette commande sera :
store_name Sales Date
San Diego 250 € 07-Jan-1999
San Francisco 300 € 08-Jan-1999
Boston 700 € 08-Jan-1999

LIKE
LIKE est un autre mot-clé utilisé dans la clause WHERE. LIKE permet d’effectuer une recherche basée
plutôt sur un modèle qu’une spécification exacte de ce qui est souhaité (comme dans IN) ou une
définition d’un intervalle (comme dans BETWEEN).

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" WHERE "Nom_Champ" LIKE {Modèle}

{modèle} représente souvent des caractères de remplacement. Voici quelques exemples :

- 'A_Z' : toutes les chaînes commençant par 'A', ou un autre caractère, et terminant par 'Z'. Par exemple,
'ABZ' et 'A2Z' satisferaient la condition, alors 'AKKZ' ne le ferait pas (car il y a deux caractères entre
A et Z au lieu d’un).
- 'ABC%' : toutes les chaînes commençant par 'ABC'. Par exemple, 'ABCD' et 'ABCABC' satisferaient
la condition.
- '%XYZ' : toutes les chaînes se terminant par 'XYZ'. Par exemple, 'WXYZ' et 'ZZXYZ' satisferaient la
condition.
- '%AN%' : toutes les chaînes contenant le modèle 'AN' quelle que soit sa position. Par exemple, 'LOS
ANGELES' et 'SAN FRANCISCO' satisferaient la condition.

Exemple :
Pour rechercher tous les magasins dont le nom contient 'AN', il faut saisir :

SELECT * FROM Store_Information WHERE store_name LIKE '%AN%'

Le résultat de cette commande sera :

store_name Sales Date
LOS ANGELES 1500 € 05-Jan-1999
SAN DIEGO 250 € 07-Jan-1999
SAN FRANCISCO 300 € 08-Jan-1999

ORDER BY
Jusqu’à présent, nous avons vu comment extraire des données d’une table à l’aide des commandes
SELECT et WHERE. Il convient souvent de lister les résultats dans un ordre particulier. Le classement
peut se faire dans un ordre ascendant ou descendant, ou peut être établi par des valeurs saisies en chiffres
ou en lettres. Dans de tels cas, il est possible d’utiliser le mot-clé ORDER BY pour atteindre notre
objectif.

Syntaxe :
SELECT "Nom_Champ" FROM "Nom_Table" [WHERE "condition"] ORDER BY
″Nom_Champ″ [ASC|DESC]

Les crochets signifient que l’instruction WHERE est optionnelle. Toutefois, si une clause WHERE est
déjà présente, elle se trouvera devant la clause ORDER BY. La clause ASC ou DESC provoque
respectivement un tri des résultats dans un ordre ascendant ou descendant. En cas d’omission de l’une
d’elles, la clause ASC est implicitement appelée, provoquant donc un tri en ordre ascendant par défaut.

Il est possible d’ordonner par plusieurs colonnes. Dans ce cas, la clause ORDER BY ci-dessus devient :
- 22 -
ORDER BY ″Nom_Champ1″ [ASC|DESC], ″Nom_Champ2″ [ASC|DESC],

Supposons que nous avons choisi l’ordre ascendant pour les deux colonnes, la colonne de sortie sera
classée dans un ordre ascendant selon la colonne 1. S’il y a une liaison pour la valeur de la colonne 1, le
tri se fera dans un ordre ascendant selon la colonne 2.

Exemple :
Pour trier les contenus de la Table Store_Information par montant en dollar, dans un ordre descendant il
faut saisir :

SELECT store_name, Sales, Date FROM Store_Information ORDER BY Sales DESC

Résultat obtenu :
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
Boston 700 € 08-Jan-1999
San Francisco 300 € 08-Jan-1999
San Diego 250 € 07-Jan-1999

En plus du nom de colonne, il est également possible d’utiliser une position de colonne (basée sur la
requête SQL) pour indiquer la colonne à laquelle nous souhaitons appliquer la clause ORDER BY. La
première colonne est 1, la seconde 2, et ainsi de suite. Dans l’exemple précédent, il serait possible
d’obtenir les mêmes résultats en utilisant la commande suivante :

SELECT store_name, Sales, Date FROM Store_Information ORDER BY 2 DESC

Les fonctions usuelles

Puisque nous avons commencé à utiliser des chiffres, la question qui nous vient à l’esprit naturellement
est de nous demander s’il est possible d’effectuer des calculs arithmétiques avec ces chiffres, tels que
l’addition ou le calcul de la moyenne. Pour cela, SQL dispose des fonctions arithmétiques suivantes :
- AVG
- COUNT
- MAX
- MIN
- SUM

Syntaxe d’utilisation des fonction :

SELECT "Nom_Fonction" (″Nom_Champ″) FROM "Nom_Table"

Exemple :
Pour obtenir la somme de toutes les ventes à partir de la table Store_Information il faut saisir :

SELECT SUM(Sales) FROM Store_Information

On aura alors:
SUM(Sales)
2750 €

2 750 € représente la somme de toutes les entrées Sales : 1500 € + 250 € + 300 € + 700 €.

En plus d’utiliser des fonctions, avec SQL nous pouvons aussi effectuer de simples tâches telles que
l’addition (+) et la soustraction (-). Pour les données à type de caractères, plusieurs fonctions de chaînes
- 23 -
sont disponibles, telles que les fonctions de concaténation, de Trim et de sous-chaîne. Chaque fournisseur
SGBDR dispose de sa propre implémentation de fonctions de chaîne. Il est donc recommandé de
consulter les références du fournisseur SGBDR pour en savoir plus sur l’utilisation de ces fonctions.

Une autre fonction arithmétique est COUNT. Cette fonction permet de compter le nombre
d’enregistrements inclus dans une table.

Syntaxe d’utilisation des fonction :

SELECT COUNT (″Nom_Champ″) FROM "Nom_Table"

Exemple :
Pour rechercher le nombre d’entrées d’un magasin dans notre table, il faut saisir :

SELECT COUNT(store_name) FROM Store_Information

Ce qui donne, comme résultat :

Count(store_name)
4

Les clauses COUNT et DISTINCT peuvent être utilisées ensemble dans une instruction pour obtenir le
nombre d’entrées distinctes d’une table. Pour déterminer, par exemple, le nombre des différents
magasins, il faut saisir :

SELECT COUNT(DISTINCT store_name) FROM Store_Information

Ce qui donnera :
Count(DISTINCT store_name)
3

GROUP BY
Nous passons maintenant aux fonctions d’agrégation. Nous avons déjà utilisé le mot-clé SUM pour
calculer les ventes totales de tous les magasins. La question qui se pose maintenant est de savoir comment
calculer les ventes totales pour chaque magasin. Pour cela, il existe deux manières : tout d’abord, il est
nécessaire de s’assurer d’avoir sélectionné le nom du magasin, ainsi que les ventes totales. Ensuite, tous
les chiffres d’affaires doivent être groupés par (GROUP BY) magasin.

Syntaxe :
SELECT ″Nom_Champ_1″ , SUM (″Nom_Champ_2″) FROM "Nom_Table" GROUP BY
"Nom_Champ_1"

Exemple : Pour retrouver les ventes totales de chaque magasin, il faut saisir :

SELECT store_name, SUM(Sales) FROM Store_Information GROUP BY store_name

Le résultat de cette commande sera:

store_name SUM(Sales)
Los Angeles 1800 €
San Diego 250 €
Boston> 700 €

Le mot-clé GROUP BY s’utilise lorsque divers champs d’une ou de plusieurs tables sont sélectionnées et
qu’au moins, un opérateur arithmétique apparaît dans l’instruction SELECT. Nous devons, le cas

- 24 -
échéant, regrouper (GROUP BY) tous les autres champs sélectionnés, c’est-à-dire, tous les champs sauf
ceux utilisés par l’opérateur arithmétique.

HAVING
Une autre chose que les utilisateurs souhaiteraient faire, c’est de limiter la sortie basée sur la somme
correspondante (ou sur toute autre fonction d’agrégation). Par exemple, pour visualiser uniquement les
magasins dont les ventes sont supérieures à 1 500 €, il faut utiliser la clause HAVING, réservée pour les
fonctions d’agrégation, à la place de la clause WHERE dans l’instruction SQL. Généralement, la clause
HAVING est placée en fin d’instruction SQL, et cette dernière peut ou non inclure la clause GROUP
BY.

Syntaxe :
SELECT ″Nom_Champ_1″ , SUM (″Nom_Champ_2″) FROM "Nom_Table" GROUP BY
"Nom_Champ_1" HAVING (condition|Fonction)8

Exemple : La commande suivante :

SELECT store_name, SUM(sales) FROM Store_Information GROUP BY store_name HAVING

SUM(sales) > 1500

Donne comme résultat :

store_name SUM(Sales)
Los Angeles 1800 €

ALIAS
Deux types d’alias sont fréquemment utilisés : alias de champ et alias de table.
En résumé, les alias de champ concourent à améliorer la lisibilité d’une requête. Dans l’exemple
précédent, les ventes totales sont listées comme SUM(sales). Cette procédure est facile à comprendre,
mais pensons à des cas où l’en-tête de champs est plus compliqué (surtout s’il provoque plusieurs
opérations arithmétiques).
L’utilisation d’un alias de champ permet de rendre le résultat beaucoup plus lisible.

Le second type d’alias est l’alias de table. Cet alias s’obtient en plaçant directement un alias après le nom
de table dans la clause FROM. Les alias sont très utiles lorsque l’on souhaite obtenir des informations de
deux tables séparées (le terme technique est « perform joins »). L’avantage d’utiliser un alias de table au
moment d’exécuter des commandes de jointure est manifeste.

Syntaxe :
SELECT ″table alias ″.″Nom_Champ_1″ ″Nom_Champ_alias″ FROM "Nom_Table" ″table
alias″

Ici, les deux types d’alias sont directement placés après les éléments qu’ils représentent, séparés par un
espace blanc.

Exemple : Il s’agit du même exemple que celui de la section GROUP BY de SQL, sauf que nous avons
défini l’alias de champs et l’alias de table :

SELECT A1.store_name Store, SUM(A1.Sales) "Total Sales" FROM Store_Information A1 GROUP

BY A1.store_name

8
la clause GROUP BY est optionnelle.
- 25 -
Résultat :
Store Total Sales
Los Angeles 1800 €
San Diego 250 €
Boston 700 €

A noter cette différence dans le résultat (les titres de champs ont changé) est le résultat obtenu à l’aide de
l’alias de champ. A noter également qu’au lieu d’un en-tête complexe comme « Sum(Sales) », nous avons
maintenant « Total Sales », qui est beaucoup plus compréhensible. L’avantage d’utiliser un alias de table
n’est pas clair dans cet exemple. Toutefois, l’utilité des alias sera beaucoup plus évidente lors que l’on
parle de jointure.

Les jointures internes

Pour définir correctement des jointures sous SQL, il faudra se reporter à la plupart des éléments que nous
avons exposés jusqu’à présent. Supposons que nous avons les deux tables suivantes :

Table Store_Information Table Geography

store_name Sales Date region_name store_name
Los Angeles 1500 € 05-Jan-1999 East Boston
San Diego 250 € 07-Jan-1999 East New York
Los Angeles 300 € 08-Jan-1999 West Los Angeles
Boston 700 € 08-Jan-1999 West San Diego

Supposons que nous souhaitons connaître les ventes par région. La table Geography comprend des
informations sur des régions et magasins, et la table Store_Information contient des données relatives
aux ventes de chaque magasin. Afin d’obtenir les informations sur les ventes par région, il faut combiner
les informations de ces deux tables. En les examinant, nous constatons qu’elles sont mises en relation par
le champ commun « store_name ». Voici l’instruction SQL permettant d’effectuer cette opération :

SELECT A1.region_name REGION, SUM(A2.Sales) SALES FROM Geography A1,

Store_Information A2 WHERE A1.store_name = A2.store_name GROUP BY A1.region_name

Résultat :
REGION SALES
East 700 €
West 2050 €

Les deux premières lignes (SELECT et FROM) permettent à SQL de sélectionner deux champs : le
premier est le champ « region_name » de la table Geography (dont l’alias est REGION), et le second est
la somme du champ « Sales » de la table Store_Information (dont l’alias est SALES). Notez comment les
alias de tables sont utilisés ici : A1 est l’alias de Geography et A2 de Store_Information. Sans l’alias, la
première ligne deviendrait :

SELECT Geography.region_name REGION, SUM(Store_Information.Sales) SALES

ce qui n’est pas très concis. Par essence, les alias de table sont destinés à faciliter la compréhension des
instructions SQL, surtout en présence de plusieurs tables.

Nous passons maintenant à la ligne 3 (à l’instruction WHERE). C’est là où se spécifie la condition de la

jointure. Dans ce cas, pour nous assurer que le contenu dans « store_name » de la table Geography
corresponde à celui de la table Store_Information, il faut les définir comme valeur égale. L’instruction
WHERE est essentielle pour obtenir une requête correcte. Sans une clause WHERE adéquate, nous
- 26 -
obtiendrons une jointure, dite, cartésienne. Ces types de jointures retournent toute combinaison possible
des deux tables (ou tout nombre de tables indiqué dans l’instruction FROM). Une jointure cartésienne
retournerait donc un résultat d’un total de .

Les jointures externes

Nous avons précédemment analysé la jointure gauche ou jointure interne où nous avons sélectionné des
lignes communes aux tables désignées pour une jointure. Mais comment procéder dans les cas où nous
serions intéressés à sélectionner des éléments d’une table qu’ils soient contenus dans la deuxième table ou
non. Il est nécessaire d’utiliser maintenant la commande OUTER JOIN de SQL.

Note :
La syntaxe pour exécuter une jointure externe sous SQL dépend de la base de données utilisée. Par
exemple, dans Oracle, il faut placer un « (+) » dans la clause WHERE de l’autre côté de la table dans
laquelle nous souhaitons inclure tous les enregistrements.

Exemple :
Supposons que nous avons les deux tables précédentes et que nous souhaitons trouver le montant des
ventes de tous les magasins. Dans le cas d’une jointure régulière, il n’est pas possible d’obtenir le critère
de recherche souhaité étant donné que « New York » n’apparaît pas dans la table Store_Information. Par
conséquent, il est nécessaire d’exécuter une jointure externe sur les deux tables. La commande est alors la
suivante :

SELECT A1.store_name, SUM(A2.Sales) SALES FROM Geography A1, Store_Information A2

WHERE A1.store_name = A2.store_name (+) GROUP BY A1.store_name9
Résultat obtenu :
store_name SALES
Boston 700 €
New York
Los Angeles 1800 €
San Diego 250 €

Remarque :
A défaut d’une correspondance dans la deuxième table, la valeur NULL sera retournée. Dans ce cas,
comme « New York » n’apparaît pas dans la table Store_Information, son champ « SALES »
correspondant contient une valeur NULL.

Fonction de concaténation
Il est parfois nécessaire de combiner ensemble (concaténer) les résultats de plusieurs champs différents.
Chaque base de données a sa propre méthode de concaténation:
- MySQL: CONCAT( )
- Oracle: CONCAT( ), ||
- SQL Server : +

Syntaxe :
CONCAT(str1,str2,str3,…)

La fonction CONCAT( ) d’Oracle ne permet que deux arguments : cette fonction ne permet de concaténer
ensemble que deux chaînes à la fois. En utilisant '||', il est toutefois possible de concaténer plus de deux
chaînes à la fois dans Oracle.
Exemples : de la table Geography

9
Notez que dans ce cas de figure, c’est la syntaxe Oracle qui est utilisée pour la jointure externe.

- 27 -
a. MySQL/Oracle:
SELECT CONCAT(region_name,store_name) FROM Geography WHERE store_name = 'Boston';

b. Oracle :
SELECT region_name || ' ' || store_name FROM Geography WHERE store_name = 'Boston';

c. SQL Server :
SELECT region_name + ' ' + store_name FROM Geography WHERE store_name = 'Boston';
Résultat :
'EastBoston'
Sous-chaîne (Substring)
La fonction de sous-chaîne sous SQL est utilisée pour extraire une partie des données stockées. Le nom
de cette fonction diffère selon la base de données utilisée:
- MySQL: SUBSTR( ), SUBSTRING( )
- Oracle: SUBSTR( )
- SQL Server: SUBSTRING( )

Les utilisations les plus fréquentes sont comme suit (SUBSTR( ) sera ici utilisé):
Syntaxe (Pour SUBSTR( )):
1. SUBSTR(str,pos) : sélectionne tous les caractères de en commençant par position
2. SUBSTR(str,pos,len): en commençant par le caractère dans la chaîne , sélectionne
les caractères suivants
Exemples : De la table Geography

SELECT SUBSTR(store_name, 3) FROM Geography WHERE store_name = 'Los Angeles';

Résultat :
's Angeles'

SELECT SUBSTR(store_name,2,4) FROM Geography WHERE store_name = 'San Diego';

Résultat :
'an D'

TRIM
La fonction TRIM sous SQL permet de supprimer des préfixes ou suffixes spécifiques d’une chaîne de
caractères. Les modèles fréquemment supprimés sont les espaces blancs. Le nom de cette fonction diffère
selon la base de données utilisée :
- MySQL: TRIM( ), RTRIM( ), LTRIM( )
- Oracle: RTRIM( ), LTRIM( )
- SQL Server: RTRIM( ), LTRIM( )

Syntaxe :
TRIM([[Location] [remstr] FROM ] str)

Note :
[Location] peut être LEADING, TRAILING ou BOTH.

D’après cette syntaxe, la fonction TRIM efface le modèle [remstr] à partir du début [Leading] ou de la fin
[Trailing] de la chaîne de caractères, ou des deux [Both]. Si [remstr] n’est pas spécifié, les espaces blancs
seront effacés.

LTRIM(str): Efface tous les espaces blancs situés en début de chaîne.

RTRIM(str): Efface tous les espaces blancs situés en fin de chaîne.

- 28 -
Exemples :
SELECT TRIM(' Sample ');
Résultat :
'Sample'

SELECT LTRIM(' Sample ');

Résultat :
'Sample '

SELECT RTRIM(' Sample ');

Résultat :
' Sample'

- 29 -
 Partie II
Manipulation d'enregistrements

Dans cette partie :

Insert into .................................................................................................................................................... 31

Update ......................................................................................................................................................... 31
Delete from ................................................................................................................................................. 32

- 30 -
INSERT INTO
Dans les sections précédentes, nous avons appris comment retrouver des informations dans les tables.
Maintenant, nous allons voir comment ajouter des lignes de données (enregistrements) dans ces tables en
première position. Ce thème et l’instruction INSERT seront décrits dans cette section, tandis que
l’instruction UPDATE sera décrite dans la section suivante.

Sous SQL, il existe deux manières de base pour INSÉRER des données dans une table : l’une consiste à
insérer des données une ligne à la fois, et l’autre plusieurs à la fois.

Syntaxe:
INSERT INTO ″Nom_Table″ (″Champ1″,″champ2 ″,…) VALUES (″Valeur1″,″Valeur2 ″,…)

Exemple :
Pour insérer un enregistrement supplémentaire dans la table Store_Information, enregistrement
représentant les données de ventes pour Los Angeles le 10 janvier 1999, dont les ventes de ce magasin, à
ce jour, s’élevaient à 900 €, il faudra utiliser le script SQL suivant :

INSERT INTO Store_Information (store_name, Sales, Date) VALUES ('Los Angeles', 900, '10-Jan-
1999')

Le deuxième type de la commande INSERT INTO permet d’ajouter plusieurs enregistrements à une
table. Contrairement à l’exemple précédent, où nous avons inséré un seul enregistrement en spécifiant ses
valeurs pour tous les champs, nous devons maintenant utiliser une instruction SELECT pour spécifier les
données à ajouter à la table. Nous sommes donc en train d’insérer dans une table des données provenant
d’une autre table.

Syntaxe:
INSERT INTO ″Table1″ (″Champ1″,″champ2 ″,…) SELECT ″Champ1″,″champ2 ″,… FROM
″Table1″
Note :
C’est la méthode la plus simple. L’instruction entière peut facilement contenir les clauses WHERE,
GROUP BY, et HAVING, ainsi que les jointures et alias de table.

Exemple :
Pour avoir une table Store_Information, regroupant les données de ventes de l’année 1998, et que nous
savons d’avance que les données d’origine sont contenues dans la table Sales_Information, il faut saisir :

INSERT INTO Store_Information (store_name, Sales, Date) SELECT store_name, Sales, Date FROM
Sales_Information WHERE Year(Date) = 199810

UPDATE
Nous pouvons, parfois, être amenés à modifier les données contenues dans une table. Pour ce faire, il
convient d’utiliser la commande UPDATE.

Syntaxe:
UPDATE ″Nom_Table″ SET ″Champ1″=[New_Value] WHERE {Condition}

10
C’est la syntaxe SQL Server qui a été utilisée ici pour extraire les informations annuelles périmées. Chaque base de données
relationnelle a sa propre syntaxe. Par exemple, sous Oracle, on utilisera to_char(date,'yyyy')=1998.

- 31 -
Exemple :
Dans le cas d’une table Store_Information, supposons que nous nous rendons compte que les ventes pour
Los Angeles du 08-Jan-1999 sont en réalité de 500 € au lieu de 300 €, et que cette entrée particulière doit
être corrigée. Pour ce faire, nous utiliserons la requête SQL suivante :

UPDATE Store_Information SET Sales = 500 WHERE store_name = "Los Angeles" AND Date =
"08-Jan-1999"

La table résultante ressemblerait à :

Table Store_Information
store_name Sales Date
Los Angeles 1500 € 05-Jan-1999
San Diego 250 € 07-Jan-1999
Los Angeles 500 € 08-Jan-1999
Boston 700 € 08-Jan-1999

Dans ce cas, il n’y a qu’un enregistrement qui satisfait la condition de la clause WHERE. Tous les
enregistrements qui satisfont la condition seront modifiés.

Il est également possible de METTRE À JOUR plusieurs champs à la fois.

Syntaxe:
UPDATE ″Nom_Table″ SET ″Champ1″=[New_Value1], ″Champ2″=[New_Value2] WHERE
{Cond}

DELETE FROM
Pour supprimer des enregistrements d’une table, il est possible d’utiliser la commande DELETE FROM.

Syntaxe:
DELETE FROM ″Nom_Table″ WHERE {Condition}

Exemple :
Supposons que nous décidons de ne conserver aucune information de Los Angeles dans la table
Store_Information. Pour ce faire, nous saisissons la requête SQL suivante :

DELETE FROM Store_Information WHERE store_name = "Los Angeles"

Le contenu de la table devrait paraître à

Table Store_Information
store_name Sales Date
San Diego 250 € 07-Jan-1999
Boston 700 € 08-Jan-1999

- 32 -
 Partie III
Les commandes SQL avancées

Dans cette partie :

En premier lieu, nous allons voir les mots-clés et les concepts SQL suivants :
UNION ....................................................................................................................................................... 34
UNION ALL ............................................................................................................................................... 34
INTERSECT ............................................................................................................................................... 35
MINUS ....................................................................................................................................................... 35
SOUS-REQUETE....................................................................................................................................... 36
EXISTS ....................................................................................................................................................... 36
CASE .......................................................................................................................................................... 37

En outre, nous examinerons comment SQL peut être utilisé pour réaliser certaines des opérations des plus
complexes :
RANG ......................................................................................................................................................... 38
MEDIANE .................................................................................................................................................. 38
EXECUTION TOTALE ............................................................................................................................. 39
POURCENTAGE DU TOTAL ................................................................................................................. 39
POURCENTAGE DU TOTAL CUMULATIF ......................................................................................... 40

- 33 -
UNION
L’objectif de la commande UNION de SQL est de combiner ensemble les résultats de deux requêtes. La
commande UNION est un peu similaire à Jointure du fait qu’elles sont utilisées pour mettre en liaison des
informations provenant de plusieurs tables. Une restriction de UNION est que tous les champs
correspondants doivent inclure le même type de données. Aussi, lors de l’utilisation de UNION, seules
les valeurs distinctes sont sélectionnées (similaire à SELECT DISTINCT).

Syntaxe:
[Instructions_SQL_1] UNION [Instructions_SQL_2]

Exemple :
Supposons que nous avons les deux tables suivantes :

Table Store_Information Table Internet_Sales

store_name Sales Date Date Sales
Los Angeles 1500 € 05-Jan-1999 07-Jan-1999 250 €
San Diego 250 € 07-Jan-1999 10-Jan-1999 535 €
Los Angeles 300 € 08-Jan-1999 11-Jan-1999 320 €
Boston 700 € 08-Jan-1999 12-Jan-1999 750 €

Pour retrouver toutes les dates où il y a des ventes, il faudra utiliser l’instruction SQL suivante :

SELECT Date FROM Store_Information UNION SELECT Date FROM Internet_Sales

Résultat :
Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
10-Jan-1999
11-Jan-1999
12-Jan-1999

Notez qu’en saisissant « SELECT DISTINCT Date» pour les deux instructions SQL, nous obtiendrons
le même jeu de résultats.

UNION ALL
L’objectif de la commande UNION ALL de SQL est aussi de combiner ensemble les résultats de deux
requêtes. La différence entre UNION ALL et UNION est la suivante : UNION sélectionne seulement
des valeurs distinctes alors que UNION ALL sélectionne toutes les valeurs.

Syntaxe:
[Instructions_SQL_1] UNION ALL [Instructions_SQL_2]

Exemple :
Pour retrouver toutes les dates où il y a des ventes au magasin et aussi sur Internet (Selon les informations
des deux tables précédentes), il faudra utiliser l’instruction SQL suivante :

SELECT Date FROM Store_Information UNION ALL SELECT Date FROM Internet_Sales

- 34 -
Résultat :
Date
05-Jan-1999
07-Jan-1999
08-Jan-1999
08-Jan-1999
07-Jan-1999
10-Jan-1999
11-Jan-1999
12-Jan-1999

INTERSECT
À l’instar de la commande UNION, INTERSECT opère aussi sur deux instructions SQL. La différence
entre les deux commandes est la suivante : UNION agit essentiellement comme un opérateur OR (OU :
la valeur est sélectionnée si elle apparaît dans la première ou la deuxième instruction), la commande
INTERSECT agit comme un opérateur AND (ET : la valeur est sélectionnée seulement si elle apparaît
dans les deux instructions).

Syntaxe:
[Instructions_SQL_1] INTERSECT [Instructions_SQL_2]

Exemple :
Pour retrouver toutes les dates où il y a les deux types de ventes (Tables précédentes) : au magasin et sur
Internet, il faudra utiliser l’instruction SQL suivante :

SELECT Date FROM Store_Information INTERSECT SELECT Date FROM Internet_Sales

Résultat :
Date
07-Jan-1999

Note :
La commande INTERSECT ne retournera que des valeurs distinctes.

MINUS
MINUS opère sur deux instructions SQL. Elle prend tous les résultats de la première instruction SQL,
puis soustrait ceux de la deuxième instruction SQL pour obtenir la réponse finale. Si la deuxième
instruction SQL comprend des résultats qui ne sont pas inclus dans la première instruction SQL, ils seront
ignorés.

Syntaxe:
[Instructions_SQL_1] MINUS [Instructions_SQL_2]

Exemple :
Toujours en utilisant les deux tables précédentes, pour trouver toutes les dates où il y a des ventes au
magasin, mais pas sur Internet, il faudra utiliser l’instruction SQL suivante :

SELECT Date FROM Store_Information MINUS SELECT Date FROM Internet_Sales

Résultat :
Date
05-Jan-1999
08-Jan-1999
- 35 -
"05-Jan-1999", "07-Jan-1999",et "08-Jan-1999" sont les valeurs distinctes retournées à partir de
"SELECT Date FROM Store_Information." "07-Jan-1999" est également retourné à partir de la
deuxième instruction SQL, "SELECT Date FROM Internet_Sales", il sera donc exclu du jeu de
résultats final.

Note :
La commande MINUS ne retournera que des valeurs distinctes.
Certaines bases de données peuvent utiliser EXCEPT au lieu de MINUS. Pour une utilisation correcte,
consulter la documentation de la base de données.

SOUS-REQUETE
Il est possible d’imbriquer une instruction SQL dans une autre. Lorsque cette opération est effectuée sur
les instructions WHERE ou HAVING, nous obtenons une construction de sous-requête.

Syntaxe:
SELECT ″Nom_Champ_1″ FROM ″Nom_Table_1″ WHERE ″Nom_Champ_2″ [Opérateur]
(SELECT ″Nom_Champ_3″ FROM ″Nom_Table_2″ WHERE [Condition])

[Opérateur] peut être un opérateur d’égalité tel que . Il peut être aussi un opérateur de
texte tel que "LIKE".

La deuxième partie (la partie entre parenthèse) de la syntaxe est considérée comme "requête interne",
alors que la première partie est considérée comme "requête externe".

Exemple : Table Store_Information et Table Geography

En utilisant une sous-requête pour trouver les ventes de tous les magasins dans la région West (Ouest), il
faudra utiliser l’instruction SQL suivante :

SELECT SUM(Sales) FROM Store_Information WHERE Store_name IN (SELECT store_name

FROM Geography WHERE region_name = 'West')

Résultat :
SUM(Sales)
2050

Dans cet exemple, au lieu de joindre directement les deux tables et d’ajouter seulement le montant des
ventes des magasins de la région West (Ouest), nous allons d’abord utiliser la sous-requête pour trouver
les magasins situés dans la région West (Ouest), puis additionner le montant des ventes de ces magasins.

Dans l’exemple ci-dessus, la requête interne est d’abord exécutée, puis le résultat est envoyé à la requête
externe. Ce type de sous-requête est appelé sous-requête simple. Si la requête interne dépend de la
requête externe, nous aurons une sous-requête corrélée. Voici un exemple de sous-requête corrélée :

SELECT SUM(a1.Sales) FROM Store_Information a1 WHERE a1.Store_name IN (SELECT

store_name FROM Geography a2 WHERE a2.store_name = a1.store_name)

Noter la clause WHERE dans la requête interne, où la condition nécessite une table de la requête externe.

EXISTS
Dans la section précédente, nous avons utilisé IN pour mettre en liaison la requête interne et la requête
externe dans une instruction de sous-requête. L’utilisation de IN n’est pas la seule manière de procéder ;

- 36 -
il est aussi possible d’utiliser plusieurs opérateurs tels que . EXISTS est un opérateur spécial
que nous verrons dans cette section.

EXISTS teste simplement si la requête interne retourne un enregistrement. Si elle le fait, la requête
externe peut s’exécuter. Sinon, la requête externe ne s’exécutera pas, et l’instruction SQL entière ne
retournera aucun résultat.

Syntaxe:
SELECT ″Nom_Champ_1″ FROM ″Nom_Table_1″ WHERE EXISTS (SELECT * FROM
″Nom_Table_2″ WHERE [Condition])

Note :
Au lieu de l’étoile , nous pouvons sélectionner une ou plusieurs colonnes dans la requête interne. L’effet
sera identique.

Exemple : Utilisons les mêmes tables précédentes comme exemple :

Définissons la requête SQL suivante :

SELECT SUM(Sales) FROM Store_Information WHERE EXISTS (SELECT * FROM Geography

WHERE region_name = 'West')

Le résultat obtenu sera le suivant :

SUM(Sales)
2750

A première vue, cette opération peut paraître un peu confuse, car la sous-requête inclut la condition
[region_name = 'West']. La requête n’a pas encore ajouté les magasins pour toutes les régions. Par une
analyse plus approfondie, nous parvenons à la condition suivante : puisque la sous-requête retourne plus
de 0 enregistrement, la condition EXISTS est vraie, et la condition placée au sein de la requête interne
n’affecte pas le mode d’exécution de la requête externe.

CASE
CASE permet de fournir le type de logique si-alors-autre à SQL.

Syntaxe:
SELECT CASE (″Nom_Champ″) WHEN ″Condition1″ THEN ″Resultat1″ WHEN ″Condition2″
THEN ″Resultat2″… [ELSE ″ResultatN″] END FROM ″Nom_Table″

"condition" peut être une valeur ou une expression statique. La clause ELSE est optionnelle.

Exemple : Table Store_Information

Pour multiplier le montant des ventes de 'Los Angeles' par 2 et le montant des ventes de 'San Diego' par
1,5, il faut saisir :
SELECT store_name, CASE store_name WHEN 'Los Angeles' THEN Sales * 2 WHEN 'San Diego'
THEN Sales * 1.5 ELSE Sales END "Nouvelles Ventes", Date FROM Store_Information
"Nouvelles Ventes" est le nom donné à la colonne avec l’instruction CASE.

Résultat :
store_name Nouvelles Ventes Date
Los Angeles 3000 € 05-Jan-1999
San Diego 375 € 07-Jan-1999
San Francisco 300 € 08-Jan-1999
Boston 700 € 08-Jan-1999
- 37 -
RANG
Afficher le rang associé à chaque ligne est une requête courante, mais cette procédure est plus délicate
sous SQL. Pour afficher le rang sous SQL, il est nécessaire d’effectuer une jointure réflexive, de lister les
résultats dans l’ordre, et de compter le nombre d’enregistrements énumérés (y compris) devant
l’enregistrement de votre choix. Utilisons un exemple pour illustrer. Supposons que nous avons la table
suivante
Table Total_Sales
Name Sales
John 10
Jennifer 15
Stella 20
Sophia 40
Greg 50
Jeff 20

L’exécution de la commande suivante :

SELECT a1.Name, a1.Sales, COUNT(a2.sales) Sales_Rank FROM Total_Sales a1, Total_Sales a2

WHERE a1.Sales <= a2.Sales or (a1.Sales=a2.Sales and a1.Name = a2.Name) GROUP BY a1.Name,
a1.Sales ORDER BY a1.Sales DESC, a1.Name DESC;

donnera comme Résultat :

Name Sales Sales_Rank
Greg 50 1
Sophia 40 2
Stella 20 3
Jeff 20 3
Jennifer 15 5
John 10 6

Concentrons-nous sur la clause WHERE. La première partie de la clause, (a1.Sales a2.Sales), nous
permet de ne pas compter le nombre d’occurrences où la valeur du champ Sales est inférieure ou égale à
elle-même. Si ce champ ne contient pas de doublons, cette partie de la clause WHERE serait en elle-
même suffisante pour générer le rang correct.

La deuxième partie de la clause, (a1.Sales a2.Sales and a1.Name a2.Name), garantit qu’en présence
de doublons dans le champ Sales, chaque valeur obtiendrait le rang correct.

MEDIANE
Pour calculer la médiane, nous devons procéder de la manière suivante :
- Classifier les enregistrements dans l’ordre et trouver le rang de chaque enregistrement.
- Déterminer ce qu’est le rang du "milieu". Par exemple, s’il y a 9 enregistrements, ce rang serait 5.
- Obtenir la valeur pour l’enregistrement situé au milieu.
Exemple : Table Total_Sales
La commande suivante :

SELECT Sales Median FROM (SELECT a1.Name, a1.Sales, COUNT(a1.Sales) Rank FROM
Total_Sales a1, Total_Sales a2 WHERE a1.Sales < a2.Sales OR (a1.Sales=a2.Sales AND a1.Name <=
a2.Name) group by a1.Name, a1.Sales order by a1.Sales desc) a3 WHERE Rank = (SELECT
(COUNT(*)+1) DIV 2 FROM Total_Sales);

- 38 -
Donne le résultat suivant :
Median
20

La détermination du rang des enregistrements 2-6 a été effectuée de la même manière. L’enregistrement 7
trouve le rang du "milieu". DIV permet de trouver le quotient sous MySQL, et il est possible que cette
méthode diffère selon la base de données utilisée. Finalement, l’enregistrement 1 obtient la valeur pour
l’enregistrement au milieu.

EXECUTION TOTALE
L’affichage d’exécution totale est une requête commune, mais cette procédure est plus délicate sous SQL.
Exécution totale sera affichée sous SQL de la même façon que le rang : on effectue d’abord une jointure
réflexive, puis, on liste les résultats dans l’ordre. Alors que la recherche du rang requiert un comptage du
nombre d’enregistrements listés (y compris) devant l’enregistrement souhaité, trouver exécution totale
requiert l’addition des valeurs pour les enregistrements listés devant (y compris) l’enregistrement de notre
choix.

Exemple : Table Total_Sales

La commande suivante :

SELECT a1.Name, a1.Sales, SUM(a2.Sales) Running_Total FROM Total_Sales a1, Total_Sales a2

WHERE a1.Sales <= a2.sales or (a1.Sales=a2.Sales and a1.Name = a2.Name) GROUP BY a1.Name,
a1.Sales ORDER BY a1.Sales DESC, a1.Name DESC;

Donne :
Name Sales Running_Total
Greg 50 50
Sophia 40 90
Stella 20 110
Jeff 20 130
Jennifer 15 145
John 10 155

La combinaison de la clause WHERE et de clause ORDER BY permet d’assurer que les exécution totale
appropriées soient tabulées lorsqu’il y a des doublons.

POURCENTAGE DU TOTAL
Pour afficher le pourcentage du total sous SQL, il est nécessaire de se reporter aux concepts que nous
avons utilisés pour le rang/cumul, en plus de la sous-requête. À la différence de ce que nous avons vu
dans la section Sous-requête de SQL, nous allons utiliser ici la sous-requête en tant que partie de
SELECT.

Exemple : table Total_Sales

La commande :
SELECT a1.Name, a1.Sales, a1.Sales/(SELECT SUM(Sales) FROM Total_Sales) Pct_To_Total
FROM Total_Sales a1, Total_Sales a2 WHERE a1.Sales <= a2.sales or (a1.Sales=a2.Sales and
a1.Name = a2.Name) GROUP BY a1.Name, a1.Sales ORDER BY a1.Sales DESC, a1.Name DESC;

- 39 -
Donne, comme résultat :
Name Sales Pct_To_Total
Greg 50 0.3226
Sophia 40 0.2581
Stella 20 0.1290
Jeff 20 0.1290
Jennifer 15 0.0968
John 10 0.0645

La sous-requête "SELECT SUM(Sales) FROM Total_Sales" calcule la somme. Nous pouvons alors
diviser les valeurs individuelles par cette somme pour obtenir le pourcentage du total de chaque ligne.

POURCENTAGE DU TOTAL CUMULATIF

Pour afficher le pourcentage du total cumulatif sous SQL, nous utilisons la même idée que nous avons
traitée dans la section Pourcentage du total. La différence est que nous souhaitons obtenir le
pourcentage du total cumulatif, et non la contribution de pourcentage de chaque ligne individuelle.

Exemple : Table Total_Sales

La commande SQL suivante :

SELECT a1.Name, a1.Sales, SUM(a2.Sales)/(SELECT SUM(Sales) FROM Total_Sales) Pct_To_Total

FROM Total_Sales a1, Total_Sales a2 WHERE a1.Sales <= a2.sales or (a1.Sales=a2.Sales and
a1.Name = a2.Name) GROUP BY a1.Name, a1.Sales ORDER BY a1.Sales DESC, a1.Name DESC;

Donne pour résultat :

Name Sales Pct_To_Total
Greg 50 0.3226
Sophia 40 0.5806
Stella 20 0.7097
Jeff 20 0.8387
Jennifer 15 0.9355
John 10 1.0000

La sous-requête "SELECT SUM(Sales) FROM Total_Sales" calcule la somme. Il est alors possible de
diviser le cumul, "SUM(a2.Sales)", par cette somme pour obtenir le pourcentage du total cumulatif pour
chaque ligne.

- 40 -