Professional Documents
Culture Documents
NF17
Génie Informatique
© UTC 2005
GÉNIE INFORMATIQUE
NF17
Conception de bases de
données
Stéphane Crozat
Objectifs pédagogiques
Maîtriser les outils méthodologiques pour la conception de bases de données
Savoir mettre en pratique les outils technologiques classiques pour la réalisation de bases de données
Acquérir une expérience de conception et de réalisation informatique en équipe à travers un projet de développement d’un
site web
Découvrir des projets industriels réels en rapport avec les bases de données
Développer un esprit critique face aux technologies (veille, évaluation, choix)
Faire réfléchir sur ce qu’est le métier d’ingénieur (articulation méthode-technique)
Résumé
L'objectif de l'UV est de d'amener les étudiants à maîtriser la conception de bases de données relationnelles et
relationnelles-objet. Cette maîtrise reposera sur des compétences méthodologiques de modélisation conceptuelle et logique,
ainsi que sur des compétences technologiques de mise en oeuvre au sein de SGBD typiques (tels que Access, MySQL, Oracle
et PosgreSQL) et à travers les langages couramment utilisés en BD (tels que SQL, PHP ou Java). Les étudiants mèneront tout
au long du semestre un projet qui servira de cadre d'application en situation des concepts préalablement étudiés et
expérimentés. Des présentations de projets réels de conception de BD seront également proposés par des intervenants
praticiens de la discipline.
Table des matières
Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Licence. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
I- Modélisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
II- Relationnel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
En résumé.... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
Qu'appelle-t-on SQL? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Section A1. Le LMD de SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
1. Sélection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
2. Opérateurs de comparaisons et opérateurs logiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
3. Expression du produit cartésien. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
4. Expression d'une projection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5. Expression d'une restriction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6. Expression d'une jointure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
7. Opérateurs ensemblistes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
8. Tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
9. Fonctions de calcul. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10. Agrégats. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
11. Requêtes imbriquées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
10 Conception de bases de données
Partie A. La normalisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
V- Access. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
Section A1. SQL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
1. Types de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
2. Particularités LMD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
3. Opérateur de concaténation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
4. Les séquences. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
5. Fonctions à connaître. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
6. Dictionnaire de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Table des matières 13
X- Optimisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
En résumé.... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Exercice récapitulatif I. Retour sur les fonctions fondamentales des SGBD. . . . . . . . . . . . . . . . . . 219
16 Conception de bases de données
Bibliographie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
Glossaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Les BD [Base de Données] sont nés vers la fin des années 1960 pour combler les limites des systèmes de fichiers. Les BD
relationnelles, issues de la recherche de Codd, sont celles qui ont connu le plus grand essor depuis plus de 20 ans, et qui reste
encore aujourd'hui les plus utilisées. Le langage SQL [Structured Query Language] est une couche technologique, idéalement
indépendante des implémentations des SGBDR [Système de Gestion de Bases de Données Relationnelles], qui permet de
créer et manipuler des BD relationnelles.
Les usages de BD se sont aujourd'hui généralisés pour entrer dans tous les secteurs de l'entreprise, depuis les "petites" BD
utilisées par quelques personnes dans un service pour des besoins de gestion de données locales, jusqu'aux "grosses" BD qui
gèrent centralement pour toute l'entreprise des données partagées par tous les acteurs de l'entreprise. Parallèlement
l'accroissement de l'utilisation du numérique comme outil de manipulation de toutes données (bureautique, informatique
applicative, etc.) et comme outil d'extension des moyens de communication (réseaux) d'une part et les évolutions
technologiques (puissance des PC, Internet, etc.) d'autre part ont à la fois rendu indispensable et complexifié la problématique
des BD.
Les conséquences de cette généralisation et de cette diversification des usages se retrouvent dans l'émergence de solutions
conceptuelles et technologiques nouvelles et sans cesse renouvellées.
Ce cours se proposera de donner les bases conceptuelles et technologiques qui permettront à l'ingénieur de mobiliser des
compétences générales pour la réalisation de projets informatiques mobilisant les BD. Il ne cherchera pas, par contre, à
fournir des compétences techniques spécialisées (tel ou tel SGBD), ni à de cas d'exploitation privilégié (Internet, gros
systèmes, BD applicatives, etc.). Le travail de l'élève-ingénieur consistera donc, à partir des savoirs généraux et des
savoir-faire particuliers acquis, à chercher à prendre du recul sur le domaine pour être capable, lorsqu'il sera en situation
professionnelle réelle, d'apprendre rapidement les compétences spécifiques qui seront alors nécessaires dans son contexte
d'application.
Ce support est structuré en 11 cours, correspondant aux 11 cours magistraux de l'UV, en commençant par les bases
théoriques indispensables à la conception des bases de données, en continuant par l'apprentissage du language SQL
incontournable dans ce domaine, pour prolonger sur l'application technologique à travers deux SGBD très différents (Access
et Oracle) et pour finir sur des problématiques plus avancées des BD (le relationnel-objet et l'usage dans le contexte Web).
♦ Mes remerciements les plus sincères vont à Dritan Nace, enseignant-chercheur à l'Université de Technologie de
Compiègne, qui a enseigné NF17 avant moi jusqu'en 2002, et dont le fonds documentaire en terme de cours et d'exercices
a été largement récupéré pour la constitution de ce support ; ainsi qu'à Yacine Challal, Achene Beneyache et Hamida Seba
qui ont apporté leur contribution à travers quelques exercices et auto-évaluation. Mes remerciements enfin à l'ensemble
des acteurs très dynamiques sur le Web qui m'ont aidé sans le savoir dans ce travail (on se reportera à la bibliographie
pour les connaître).
♦ Ce support ne saurait être considéré comme un travail achevé ou suffisant pour un auto-apprentissage. Il s'agit de notes
organisées destinées à accompagner le cours, ainsi que les activités de travaux dirigés de NF17. Il n'est certainement pas
exempt d'erreurs et j'invite les lecteurs, étudiants et enseignants, à me faire part de leurs remarques pour m'aider dans ce
travail sans fin d'amélioration de ce support.
♦ Ce support est disponible à l'adresse www4.utc.fr/~nf17.
Préambule
Licence
Cette création est mise à disposition sous un contrat Creative Commons (contrat Paternité - Pas d'Utilisation Commerciale -
Partage des Conditions Initiales à l'Identique) par Stéphane Crozat - Université de Technologie de Compiègne.
This work is licensed under a Creative Commons License. (Attribution-NonCommercial-ShareAlike licence) by Stéphane
Crozat - Université de Technologie de Compiègne .
I
Modélisation
La modélisation est l'étape fondatrice du processsus de conception de BD. Elle consiste à abstraire le problème réel posé pour
en faire une reformulation qui trouvera une solution dans le cadre technologique d'un SGBD [Système de Gestion de Bases
de Données]. Après avoir rappelé succintement les fondements et objectifs des SGBD, ce chapitre proposera les outils
méthodologiques nécessaires à la modélisation, à travers les formalismes E-A [Entité-Association] et UML [Unified
Modeling Language].
Objectifs pédagogiques
Comprendre ce qu'est un SGBD.
Comprendre l'utilité des BD.
Connaître les différences entre modèle conceptuel, modèle logique et implémentation phyique.
Comprendre l'importance de la modélisation conceptuelle.
1. Qu'est ce qu'une BD ?
Base de données
Une BD est un ensemble volumineux, structuré et minimalement redondant de données, reliées entre elles, stockées
sur supports numériques centralisés ou distribués, servant pour les besoins d'une ou plusieurs applications,
interrogeables et modifiables par un ou plusieurs utilisateurs travaillant potentiellement en parallèle.
Exemples de SGBD
♦ Oracle est un SGBD relationnel (et Relationnel-Objet dans ses dernières versions) très reconnu pour les
applications professionnelles.
♦ MySQL est un SGBD relationnel libre (licence GPL et commerciale), simple d'accès et très utilisé pour la
réalisation de sites Web dynamiques. Depuis la version 4 MySQL implémente la plupart des fonctions attendues
d'un SGBD relationnel.
♦ PosgreSQL est un SGBD relationnel et relationnel-objet très puissant qui offre une alternative open-source aux
solutions commerciales comme Oracle ou IBM.
♦ Access est un SGBD relationnel Microsoft, qui offre une interface conviviale permettant de concevoir
rapidement des applications de petite envergure ou de réaliser des prototypes à moindre frais.
Problèmes...
Les conséquences précédemment citées se répercutent sur l'entreprise en générant des problèmes humains et matériels.
Coûts en personnels qualifiés et en formations
♦ Remise des pouvoirs de décision entre les mains de spécialistes informatiques
♦ Tout changement matériel ou logiciel a un impact sur les applications
♦ Tout changement de la structure des données nécessite de modifier les programmes
Or...
En réalité les applications ne sont jamais totalement disjointes, des données similaires (le coeur de l'information d'entreprise)
sont toujours à la base des traitements.
On peut citer typiquement :
♦ Les données comptables
♦ Les données clients et fournisseurs
♦ Les données relatives à la gestion des stocks
♦ Les données relatives aux livraisons
♦ Les données marketting et commerciales
♦ Les données relatives au personnel
♦ etc.
1. Notion de données
Type de données
Ensemble d'objets qui possèdent des caractéristiques similaires et manipulables par des opérations identiques.
♦ Synonyme : Classe.
Données
Elément effectif, réel, correspondant à une type de données.
Exemple : Données
♦ L'entier 486
♦ Le véhicule (460HP59, Renault, Megane, Jaune)
24 Conception de bases de données
Il permet de décrire les entités et les associations du monde réel, mais vues d'un utilisateur ou d'un groupe d'utilisateurs
particuliers (on parle d'ailleurs également de "vue" pour un shéma externe). Il s'agit d'une restriction du schéma
conceptuel orientée vers un usage précis. Il existe généralement plusieurs schémas externes pour un même schéma
conceptuel.
Le niveau externe correspond à un sous ensemble du modèle conceptuel restreint aux points de vue de certains
utilisateurs.
♦ Le niveau interne
Il correspond à l'implémentation physique des entités et associations dans les fichiers de la base.
Le niveau interne correspond aux modèles logiques et physiques.
Remarque : ANSI/X3/SPARC
Les trois niveaux, conceptuel, externe et interne, sont les trois niveaux distingués par le groupe de normalisation
ANSI/X3/SPARC en 1975.
Exemple : SQL
SQL est le langage orienté données consacré aux SGBD relationnels et relationnels-objet.
26 Conception de bases de données
Cette instruction permet de donner tous les droits à l'utilisateur "Utilisateur" sur la relation "Etudiant".
En résumé...
Conception
**
*
Les SGBD assurent la gestion efficace et structurée des données partagées. Leur conception repose sur une approche à trois
niveaux : conceptuel et externe, logique, physique.
Objectifs pédagogiques
Comprendre la méthodologie de conception d'une BD.
Savoir réaliser et interpréter un modèle conceptuel.
Maîtriser la modélisation E-A.
Maîtriser la modélisation UML dans le cas particulier de la conception de BD.
28 Conception de bases de données
La méthode MERISE a pour fondement le modèle E-A, qui a fait son succès.
Les principales caractéristiques du modèle E-A sont :
♦ Une représentation graphique simple et naturelle
♦ Une puissance d'expression élevée pour un nombre de symboles raisonnables
♦ Une lecture accessible à tous et donc un bon outil de dialogue entre les acteurs techniques et non techniques
♦ Une formalisation non ambigüe et donc un bon outil de spécification détaillée
Exemples d'utilisateurs
♦ Personnes qui vont effectuer les saisies d'information (à partir de quelles sources ? Quelle est leur reponsabilité ?
etc.)
♦ Personnes qui vont consulter les informations saisies (pour quel usage ? pour quel destinataire ? etc.)
♦ Personnes qui vont mettre à jour les informations (pour quelles raisons ? comment le processus est enclenché ?
etc.)
♦ etc.
4. Le MCD
MCD
Le MCD [Modèle Conceptuel de Données] est l'élément le plus connu de MERISE et certainement le plus utile. Il
permet d'établir une représentation claire des données du SI [Système d'Information] et définit les dépendances des
données entre elles.
Exemple
Le modèle E-A est un formalisme de MCD.
Remarque
Un MCD est indépendant de l'état de l'art technologique. A ce titre il peut donc être mis en oeuvre dans n'importe
quel environnement logiciel et matériel, et il devra être traduit pour mener à une implémentation effective.
5. Le MLD
On ne sait pas implémenter directement un modèle conceptuel de données dans une machine et il existe différentes sortes de
SGBD qui ont chacun leur propre modèle : SGF [Système de Gestion de Fichiers] (qui ne sont pas vraiment des SGBD),
SGBD hiérarchiques (organisés selon une arborescence), SGBD réseau (encore appelés CODASYL), SGBDR, SGBDOO
[Système de Gestion de Bases de Données Orientées Objets], SGBDRO [Système de Gestion de Bases de Données
Relationnelles-Objets], etc.
MLD
Un MLD [Modèle Logique de Données] est une représentation du système tel qu'il sera implémenté dans un
ordinateur.
Exemple
Le modèle relationnel est un formalisme de MLD.
Remarque
Il ne faut pas confondre le MLD (relationnel par exemple) avec le MCD (E-A par exemple).
Il ne faut pas confondre le MLD avec son implémentation logicielle en machine (avec Oracle par exemple)
1. Entité
Entité
Une entité est un objet du monde réel avec une existence indépendante.
Une entité (ou type d’entité) est une chose (concrète ou abstraite) qui existe et est distinguable des autres entités.
L'occurrence d’une entité est un élément particulier correspondant à l’entité et associé à un élément du réel. Chaque
entité a des propriétés (ou attributs) qui la décrivent. Chaque attribut est associé à un domaine de valeur. Une
occurence a des valeurs pour chacun de ses attributs, dans le domaine correspondant.
32 Conception de bases de données
Syntaxe
Remarque
♦ Un attribut est atomique, c'est à dire qu'il ne peut prendre qu'une seule valeur pour une occurence.
♦ Un attribut est élémentaire, c'est à dire qu'il ne peut être exprimé par (ou dérivé) d'autres attributs.
♦ Un attribut qui identifie de façon unique une occurence est appelé attribut clé.
2. Association
Association
Une association (ou type d’association) représente un lien quelconque entre différentes entités.
Une occurrence d’une association est un élément particulier de l’association constitué d’une et une seule occurrence
des objets participants à l’association. On peut définir des attributs sur les associations. Le degré d'une association
est le nombre d'entités y participant (on parlera notamment d'association binaire lorsque deux entités sont
concernées).
Modélisation 33
Syntaxe
Remarque
On peut avoir plusieurs associations différentes définies sur les mêmes entités.
Syntaxe
Exemple
IMG. 8 : LIVRE-AUTEUR
Le diagramme E-A précédent exprime qu'un auteur peut avoir écrit plusieurs livres (mais au moins un), et que tout
livre ne peut avoir été écrit que par un et un seul auteur.
34 Conception de bases de données
Les autres associations peuvent toujours être ramenées à des associations N:M (dans le cas général) ou à plusieurs
associations 1:N (cas des associations 2:N ou 3:N par exemple).
Remarque
Le domaine d'un attribut composite n'est donc plus un domaine simple (entier, caractères, etc.).
Attributs multivalués
Tout attribut peut être monovalué ou multivalué.
Exemple
Les âges des enfants d’un employé.
Remarque
Un attribut multivalué n'est donc plus atomique.
Attributs dérivé
La valeur d'un attribut peut être dérivée d'une ou plusieurs autres valeurs d'attributs.
Exemple
L'âge d'une personne peut être dérivé de la date du jour et de celle de sa naissance.
Remarque
Un attribut dérivé n'est donc plus élémentaire.
Sous-type d'entité
Une entité peut-être définie comme sous-type d'une entité plus générale.
Exemple
Les entités Cadre et Technicien sont des sous-types de l'entité Employé.
Remarque
La notion de sous-type est équivalente à la notion d'héritage en modélisation objet.
Exemple
L'entité Tâche est complètement dépendante de l'entité Projet et sa clé locale (No_tâche) n'est pas suffisante à
l'identifier de façon absolue.
Attention
Le repérage des entités de type faible est très important dans le processus de modélisation, il permet de réfléchir à la
meilleure façon d'identifier de façon unique les entités et donc de trouver les meilleures clés. Notons de plus que le
repérage d'entités faibles aura une influence importante sur le modèle relationnel résultant.
SCH. 3 : GÉOGRAPHIE
Explication
Dans le schéma ci-avant, on remarque que l'entité "ville" est faible par rapport à l'entité "département", qui est faible
par rapport à "région", qui est faible par rapport à "pays". Cela signifie que la clé de ville, son nom, est une clé
locale et donc que l'on considère qu'il ne peut pas y avoir deux villes différentes avec le même nom, dans un même
département. Il est par contre possible de rencontrer deux villes différentes avec le même nom, dans deux
départements différents. De la même façon chaque département possède un nom qui l'identifie de façon unique dans
une région, et chaque région possède un nom qui l'identifie de façon unique dans un pays.
Si les entités n'étaient pas faibles, l'unicité d'un nom de ville serait valable pour l'ensemble du modèle, et donc,
concrêtement, cela signifierai qu'il ne peut exister deux villes avec le même nom au monde (ni deux départements,
ni deux régions).
Remarque
Notons pour terminer que, puisque "pays" n'est pas une entité faible, sa clé "nom" est bien unique pour l'ensemble
du modèle, et donc cela signifie qu'il ne peut exister deux pays avec le même nom au monde.
36 Conception de bases de données
Question1
Analyser ce schéma et discuter ses cardinalités. Chercher par exemple si un patient peut effectuer plusieurs visites,
si un médecin peut recevoir plusieurs patients pendant la même consultation, si un médecin peut prescrire plusieurs
médicaments lors d'une même consultation, si deux médecins différents peuvent prescrire le même médicament, etc.
Question2
A partir de votre analyse, pensez vous que ce modèle soit un bon modèle pour la gestion d'un centre médical ?
Question1
Analyser ce schéma et discuter ses cardinalités. Chercher par exemple si le tournoi permet les matchs de double, si
les joueurs peuvent gagner des matchs auxquels ils n'ont pas participé, si deux matchs différents peuvent se dérouler
sur le même terrain à la même heure, etc.
Question2
A partir de votre analyse, pensez vous que ce modèle soit un bon modèle pour la gestion d'un tournoi de tennis ?
IMG. 12 : JOURNAL
Question1
Analyser ce schéma et discuter ses cardinalités. Chercher par exemple combien de journalistes peuvent co-signer un
article, si un article peut être publié deux fois dans le même numéro, si un numéro est associé à un journal, etc.
Question2
A partir de votre analyse, pensez vous que ce modèle soit un bon modèle pour la gestion d'un journal ?
Question1
Analyser ce schéma et discuter ses cardinalités. Chercher par exemple si les conducteurs peuvent avoir plusieurs
permis, si un conducteur peut conduire plusieurs camions, si plusieurs conducteurs peuvent conduire le même
camion, etc.
Question2
Chercher les cardinalités (A,B), (C,D) et (E,F) manquantes, en fonction de ce qui vous paraît être le plus logique.
Question3
Qu'exprime l'association 5-aire "EstLivré" ? Pourquoi associe-t-elle deux instances de l'entité "Entrepôt" ?
Question4
Qu'exprime l'association réflexive "EstDistantDe" sur l'entité Ville ?
Question5
A partir de votre analyse, pensez vous que ce modèle soit un bon modèle pour la gestion d'une société de transport
routier ?
Bref aperçu
UML est un langage de représentation destiné en particulier à la modélisation objet. UML est devenu une norme OMG en
1997[OMG est un organisme à but non lucratif créé en 1989 à l'initiative de sociétés comme HP, Sun, Philips, etc.].
UML propose un formalisme qui impose de "penser objet" et permet de rester indépendant d'un langage de programmation
donné. Pour ce faire, UML normalise les concepts de l'objet (énumération et définition exhaustive des concepts) ainsi que
leur notation graphique. Il peut donc être utilisé comme un moyen de communication entre les étapes de spécification
conceptuelle et les étapes de spécifications techniques.
Dans le domaine des bases de données, UML peut être utilisé à la place du modèle E-A pour modéliser le domaine. De la
même façon, un schéma conceptuel UML peut alors être traduit en schéma logique (relationnel ou relationnel-objet
typiquement).
1. Classes
Classe
Une classe est un type abstrait caractérisé par des propriétés (attributs et méthodes) communes à un ensemble
d'objets et permettant de créer des instances de ces objets, ayant ces propriétés.
Syntaxe
Remarque : Clé
En UML on ne repère en général pas les clés. La définition des clés se fera donc au niveau logique.
Modélisation 41
Remarque
La modélisation sous forme de diagramme de classes est une modélisation statique, qui met en exergue la structure
d'un modèle, mais ne rend pas compte de son évolution temporelle. UML propose d'autres types de diagrammes
pour traiter, notamment, de ces aspects.
2. Attributs
Attribut
Un attribut est une information élémentaire qui caractérise une classe et dont la valeur dépend de l'objet instancié.
Remarque
♦ Un attribut est typé
Le domaine des valeurs que peut prendre l'attribut est fixé a priori
♦ Un attribut peut être multivalué
Il peut prendre plusieurs valeurs distinctes dans son domaine
♦ Un attribut peut être dérivé
Sa valeur alors est une fonction sur d'autres attributs de la classe (il peut donc aussi être représenté comme une
méthode, et c'est en général préférable)
Dans cet exemple, les attributs Nom, Prénom sont de type string, l'un de 20 caractères et l'autre de 10, tandis que
DateNaissance est de type date et Age de type integer. Prénom est un attribut multivalué, ici une personne peut
avoir de 1 à 3 prénoms. Age est un attribut dérivé, il peut être calculé par une fonction sur DateNaissance.
3. Héritage
Héritage
L'héritage est relation entre deux classes permettant d'exprimer que l'une est plus générale que l'autre. L'héritage
implique une transmission automatique des propriétés (attributs et méthodes) d'une classe A à une classe A'.
Dire que A' hérite de A équivaut à dire que A' est une sous-classe de A. On peut également dire que A est une
généralisation de A' et que A' est une spécialisation de A.
42 Conception de bases de données
Syntaxe
Remarque
L'héritage permet de représenter la relation "est-un" entre deux objets.
Remarque
Outre qu'il permet de représenter une relation courante dans le monde réel, l'héritage a un avantage pratique, celui
de factoriser la définition de propriétés identiques pour des classes proches.
Dans cet exemple la classe Conducteur hérite de la classe Personne, ce qui signifie qu'un objet de la classe
conducteur aura les attributs de la classe Conducteur (TypePermis et DatePermis) mais aussi ceux de la classe
Personne (Nom, Prénom, DateNaissance et Age). Si la classe Personne avait des méthodes, la classe Conducteur en
hériterait de la même façon.
4. Classes abstraites
Classe abstraite
Une classe abstraite est une classe non instanciable. Elle exprime donc une généralisation abstraite, qui ne
correspond à aucun objet existant du monde.
Dans la représentation précédente on a posé que les hommes, les femmes et les chiens étaient des objets
instanciables, généralisés respectivement par les classes mammifère et humain, et mammifère.
Selon cette représentation, il ne peut donc exister de mammifères qui ne soient ni des hommes, ni des femmes ni des
chiens, ni d'humains qui ne soient ni des hommes ni des femmes.
5. Association
Association
Une association est une relation logique entre deux classes (association binaire) ou plus (association n-aire) qui
définit un ensemble de liens entre les objets de ces classes.
Une association est nommée, généralement par un verbe. Une association peut avoir des propriétés (à l'instar d'une
classe). Une association définit le nombre minimum et maximum d'instances autorisée dans la relation (on parle de
cardinalité).
44 Conception de bases de données
Syntaxe
Remarque
Une association est généralement bidirectionnelle (c'est à dire qu'elle peut se lire dans les deux sens). Les
associations qui ne respectent pas cette propriété sont dites unidirectionnelles ou à navigation restreinte.
L'association Conduit entre les classes Conducteur et Voiture exprime que les conducteurs conduisent des voitures.
6. Cardinalité
Cardinalité d'une association
La cardinalité d'une association permet de représenter le nombre minimum et maximum d'instances qui sont
autorisées à participer à la relation. La cardinalité est définie pour les deux sens de la relation.
Syntaxe
Si mina (resp. maxa) est le nombre minimum (resp. maximum) d'instances de la classe A autorisées à participer à
l'association, on note sur la relation, à côté de la classe A : mina..maxa.
Si le nombre maximum est indéterminé, on note n ou *.
Attention
La notation de la cardinalité en UML est opposée à celle adopté en E-A. En UML on note à gauche (resp. à droite)
le nombre d'instances de la classe de gauche (resp. de droite) autorisées dans l'association. En E-A, on note à gauche
(resp. à droite) le nombre d'instances de la classe de droite (resp. de gauche) autorisées dans l'association.
Remarque
Les cardinalité les plus courantes sont :
♦ 0..1 (optionnel)
♦ 1..1 ou 1 (un)
♦ 0..n ou 0..* ou * (plusieurs)
♦ 1..n ou 1..* (obligatoire)
Modélisation 45
Ici un conducteur peut possèder plusieurs voitures (y compris aucune) et une voiture n'est possédée que par un seul
conducteur.
7. Classe d'association
Association de composition
On utilise la notation des classes d'association lorsque l'on souhaite ajouter des propriétés à une association.
IMG. 25 : EMPLOIS
8. Composition
Association de composition
On appelle composition une association particulière qui possède les propriétés suivantes :
♦ La composition associe une classe composite et des classes parties, tel que tout objet partie appartient à un et un
seul objet composite. C'est donc une association 1:N.
♦ La composition n'est pas partageable, donc un objet partie ne peut appartenir qu'à un seul objet composite à la
fois.
♦ Le cycle de vie des objets parties est lié à celui de l'objet composite, donc un objet partie disparaît quand l'objet
composite auquel il est associé disparait.
Remarque
La composition est une association particulière.
Composition et cardinalité
La cardinalité côté composite est toujours de exactement 1.
Côté partie la cardinalité est libre, elle peut être 0..1, 1, * ou bien 1..*.
Exemple de composition
IMG. 27 : UN LIVRE
On voit bien ici qu'un chapitre n'a de sens que faisant partie d'un livre, qu'il ne peut exister dans deux livres
différents et que si le livre n'existe plus, les chapitres le composant non plus.
Les relations de ce diagramme expriment que les conducteurs sont des personnes qui ont un permis ; que toute
voiture est possédée par une unique personne (qui peut en posséder plusieurs) ; que les voitures peuvent être
conduites par des conducteurs et que les conducteurs peuvent conduire plusieurs voitures.
Remarque
Les mots clés in, out et in/out devant un paramètre de méthode permettent de spécifier si le paramètre est une
donnée d'entrée, de sortie, ou bien les deux.
Remarque
Le but d'une modélisation UML n'est pas de représenter la réalité dans l'absolu, mais plutôt de proposer une vision
d'une situation réduite aux éléments nécessaires pour répondre au problème posé. Donc une modélisation s'inscrit
toujours dans un contexte, et en cela l'exemple précédent reste limité car son contexte d'application est indéfini.
Question1
Décrivez en français ce que représente ce diagramme.
Question2
Etant donné ce modèle, est-il possible de savoir dans quelle usine a été fabriqué un moteur et qui est responsable de
sa production ?
Question3
La responsabilité d'un modèle est elle toujours assumée par un employé travaillant dans l'usine dans laquelle ce
modèle est produit ?
Question4
Pourquoi avoir fait le choix d'une classe Type pour codifier les défauts, plutôt qu'un attribut de type énuméré
directement dans la classe Défaut ?
Question5
Pourquoi l'attribut kilométrage apparait-il à la fois dans les classes Défaut et Moteur et pourquoi avoir fait
apparaître la méthode SetKilométrage ?
Question6
Ce diagramme permet-il de répondre à la question : Quel est le nombre moyen de défauts rencontrés pour un moteur
dont le modéle a été mis en service avant 2000 ? Quelles sont les classes et attributs utiles ?
Question7
Peut-on également répondre à la question : Quel est le kilométrage moyen pour lequel un moteur est concerné par
au moins deux défauts de gravité supérieure à 5 ?
50 Conception de bases de données
Question1
Réaliser le diagramme de classes permettant de modéliser ce problème.
Modélisation 51
En résumé...
Schéma conceptuel
Un schéma conceptuel peut être
représenté sous forme de modèle E-A
ou sous forme de diagramme de classe
UML.
Question Réponse 1.
Est ce qu'il y'a des règles particulières pour le passage E-A à UML ?
Il n'y a pas de règle de passage UML à E-A car normalement on fait l'un ou l'autre. Mais les deux modèles sont
effectivement équivalents, à part quelques détails (méthodes, classes abstraites, etc.).
Question1
Lister toutes les types d'entité à considérer et les attributs associés à chaque type d'entité. Indiquer aussi pour chaque
type d'entité sa clé et les domaines de valeurs de ses attributs.
52 Conception de bases de données
Question2
Lister toutes les associations à considérer, leurs attributs et indiquer leurs cardinalités.
Question3
Donner le diagramme E-A de cette situation.
Question4
Donner le diagramme UML de cette situation.
Cours
II
Relationnel
Le modèle relationnel, à la base des SGBDR, est historiquement et aujourd'hui encore le modèle théorique dominant pour la
représentation logique en BD. Le modèle relationnel permet de reformuler le modèle conceptuel dans un formalisme
beaucoup plus proche de son implémentation en machine, tout en restant encore indépendant d'une solution technologique
donnée.
Le modèle relationnel, à travers l'algèbre qui lui est associée, est également le fondement théorique du langage normalisé
SQL qui permettra d'exploiter les données stockées en BD
Objectifs pédagogiques
Connaître les fondements du modèle relationnel.
Savoir effectuer le passage d'un schéma conceptuel à un schéma relationnel.
Le niveau logique
Le niveau logique est le lien entre le niveau conceptuel et l'implémentation effective de l'application. Le modèle conceptuel
étant un modèle formel, le modèle logique a pour vocation d'être également un modèle formel, mais spécifiant non plus la
réalité existante ou recherchée comme le modèle conceptuel, mais les données telles qu'elles vont exister dans l'application
informatique.
Pour assumer cette fonction, le modèle relationnel s'est imposé (Codd, "A relational model for large shared data
banks", "Communications de l'ACM", juin-1970, n°.6, pp.377-387) , en réaction aux insuffisances des modèles précédents,
les modèles hiérarchique et réseau, et de part la puissance de ses fondements mathématiques.
Encore aujourd'hui dominant le modèle relationnel est un fondement indispensable à la conception de bases de données. De
plus le modèle émergeant actuellement est le modèle relationnel-objet, et ce dernier est bien une extension du modèle
relationnel qui le renforce et s'y appuie.
1. Le modèle relationnel
Le modèle relationnel a été introduit par Codd, en 1970 au laboratoire de recherche d'IBM de San José (Codd, "A relational
model for large shared data banks", "Communications de l'ACM", juin-1970, n°.6, pp.377-387) . Il s'agit d'un modèle simple
et puissant à la base de la majorité des bases de données aujourd'hui.
Modèle relationnel
Ensemble de concepts pour formaliser logiquement la description d'articles de fichiers plats, indépendamment de la
façon dont ils sont physiquement stockés dans une mémoire numérique.
Le modèle relationnel inclut des concepts pour la description de données, ainsi que des concepts pour la
manipulation de données.
54 Conception de bases de données
Les objectifs du modèle relationnel, formulés par Codd, sont les suivants :
♦ Assurer l'indépendance des applications et de la représentation interne des données
♦ Gérer les problèmes de cohérence et de redondance des données
♦ Utiliser des langages de données basés sur des théories solides
2. Domaine
Domaine
Ensemble, caractérisé par un nom, dans lequel des données peuvent prendre leurs valeurs.
Remarque
Un domaine peut-être défini en intention (c'est à dire en définissant une propriété caractéristique des valeurs du
domaine) ou en extension (c'est à dire en énumérant toutes les valeurs du domaine)
3. Produit cartésien
Produit cartésien
Le produit cartésien, noté "X", des domaines D1, D2, ... , Dn, noté "D1 X D2 X ... X Dn" est l'ensemble des tuples
(ou n-uplets ou vecteurs) <V1,V2,...,Vn> tel que Vi est une valeur de Di et tel que toutes les combinaisons de
valeurs possibles sont exprimées.
Exemple
D1 = {A, B, C}
D2 = {1, 2, 3}
D1 X D2 = {<A,1>, <A,2>, <A,3>, <B,1>, <B,2>, <B,3>, <C,1>, <C,2>, <C,3>,}
4. Relation
Relation
Une relation sur les domaines D1, D2, ..., Dn est un sous-ensemble du produit cartésien "D1 X D2 X ... X Dn". Une
relation est caractérisée par un nom.
♦ Synonyme : Table.
Relationnel 55
Syntaxe
On peut représenter la relation R sur les domaine D1, ... , Dn par une table comportant une colonne pour chaque domaine et
une ligne pour chaque tuple de la relation.
D1 ... Dn
V1 ... Vn
... ... ...
V1 ... Vn
TAB. 1 : RELATION R
Remarque
Une relation est toujours définie en extension, par l'énumération des tuples la composant.
5. Attribut et enregistrement
Attribut
On appelle attribut d'une relation, une colonne de cette relation. Un attribut est caractérisé par un nom et un
domaine dans lequel il prend ses valeurs.
Enregistrement
On appelle enregistrement d'une relation, une ligne de cette relation. Un enregistrement prend une valeur pour
chaque attribut de la relation.
Exemple
A B
1 1
1 2
2 2
TAB. 2 : RELATION R
La relation R comporte les deux attributs A et B et les trois enregistrements <1,1>, <1,2> et <2,2>
6. La relation Vol
Exemple
7. Clé
Clé
Groupe d'attributs minimum qui détermine un tuple unique dans une relation.
Exemple
♦ L'attribut numéro de sécurité sociale d'une relation personne est une bonne clé car son unicité est assurée
sémantiquement.
♦ Le groupe d'attributs nom, prénom d'une relation personne est en général une mauvaise clé, car les homonymes
existent.
Lien
Le lien entre deux tuples A=>B de deux relations différentes est matérialisable par une référence depuis l'un des
tuples, A, à la clé primaire de l'autre tuple, B.
Exemple
SCH. 4 : ILLUSTRATION
Dans la représentation précédente, les voyages en train sont représentés dans une unique relation, qui contient des
informations relatives au voyage lui même (numéro, date, départ, arrivée), mais aussi au train utilisé pour le voyage (type de
train et vitesse maximale), et au conducteur du train (nom et prénom).
Cette représentation, bien que très simplifiée par rapport à la réalité (on imagine facilement plusieurs dizaines d'attibuts
possibles) est redondante. En effet chaque fois qu'un voyage mobilisera un train TGV, la vitesse maximale de 450 km/h devra
aussi être rappelée. De même pour chaque conducteur, il faudra rappeler le nom et le prénom.
Cette redondance pose un certain nombre de problèmes :
♦ Incohérence
Imaginons qu'une faute de saisie se glisse dans l'orthographe du nom de Dupont (un "d" à la place du "t") pour le voyage
1010, il sera impossible de savoir que c'est la même personne qui conduit le train pour le voyage 1012 (car Joëlle Dupond
peut exister et être conductrice de train).
♦ Mise à jour
Imaginons que Joëlle Dupont se marie et change de nom, il faudra changer cette information pour tous les voyages
auxquels participe cette conductrice. Ceci est également un risque d'erreur, qui renvoie au risque d'incohérence
précédemment mis en exergue.
♦ Perte d'information
Imaginons que temporairement plus aucun voyage n'existe pour des TGV. Tous les enregistrements portant sur les TGV
disparaitront. On perdra alors l'information comme quoi la vitesse d'un TGV est de 450 km/h, car cette information
n'existera plus dans la base. Or l'information intrinsèque au TGV, qui est sa vitesse maximale, n'est pas liée à un voyage
en particulier, et donc il est dommage de ne pas conserver cette information indépendamment du fait que les TGV sont ou
non utilisés à un instant t.
♦ Dépendance des insertions
Imaginons que nous souhaitions représenter dans la base de données un nouveau conducteur, qui n'est encore affecté à
aucun voyage. Il est impossible d'ajouter une telle information, car l'insertion d'une personne est dépendant de l'insertion
d'un tuple complet portant également sur un voyage. Il est évidemment très mauvais d'imaginer des solutions de
contournement, telles que par exemple un tuple avec des valeurs nulles sur toutes les propriétés sauf les nom et prénom.
Relation éclatée
Le bon usage du modèle relationnel consiste donc à éclater les informations dans de multiples relations, afin de ne pas
conserver de redondance. Dans le cas précédent, on préfèrera donc un découpage de la relation VoyageEnTrain en trois
relations, Voyage, Modele et Conducteur, chacune représentant des informations correspondant à des objets différents
(notons l'ajout d'une clé artificielle numéro pour la nouvelle relation conducteur, non identifiable de façon unique par les
attributs nom et prénom).
Modele Vitesse
TGV 450
TER 200
1 Dupont Joëlle
2 Durand Jean-Pierre
Syntaxe : Relation
Relation (Attribut1:Domaine1, Attribut2:Domaine2, ... , AttributN:DomaineN)
La relation "Relation" contient N attributs chacun défini sur son domaine.
Clés candidates
On ne représente pas, en général, sur le schéma relationnel les clés candidates afin de ne pas alourdir la notation. On
recommande néanmoins de dresser la liste des clés candidates (non choisies comme clés primaires) en annotation du
schéma relationnel afin d'en conserver la mémoire.
On peut néanmoins noter les clés candidates en les soulignant en pointillé.
Association 1:1
Pour chaque association binaire A de type 1,1:1,1 ou 1,1:1,0 entre les entités S et T (représentées par les relations
RS et RT respectivement) on substitut dans la définition de RS l'éventuelle clé primaire (si RS était identifiée) par la
clé primaire de RT qui est également définie comme clé étrangère vers RT. On ajoute également à RS l'ensemble
des attributs de A. Notons que dans le cas d'une association 1,1:1,1 RT peut-être choisie à la place de RS pour
accueillir la clé étrangère.
Pour chaque association binaire A de type 0,1:0,1 entre les entités S et T (représentées par les relations RS et RT
respectivement) on inclut dans la définition de RS comme clé étrangère la clé de RT ainsi que tous les attributs
simples de A. La clé étrangère vers RT incluse dans RS est également définie comme étant unique, afin d'assurer la
cardinalité maximum de 1. Notons qu'il n'était pas possible dans ce cas 0,1:0,1 que la clé étrangère vers RT incluse
dans RS soit également la clé primaire, car la cardinalité de 0 supposerait que la clé primaire puisse être "null", ce
qui est illégal pour une clé.
homme (nom)
femme (nomMariage=>homme, nomJeuneFille) avec nomJeuneFille clé
Si l'association avait été de cardinalité 0,1:0,1 (certains hommes et femmes ne sont pas mariés), le même choix se
serait imposé et l'on aurait abouti au résultat suivant:
homme (nom)
femme (nomJeuneFille, nomMariage=>homme) avec nomMariage unique
Dans le doute il est préférable d'adopter l'approche systématique consistant à séparer les deux relations.
Attributs composites
Pour chaque attribut composite C, comprenant N sous-attributs, d'une entité E (idem pour les associations), on crée
N attributs correspondants à C sur la relation RE correspondant à E.
Attributs multivalués
Pour chaque attribut multivalué M d'une entité E (idem pour les associations), on crée une nouvelle relation RM qui
comprend un attribut monovalué correspondant à M ainsi qu'une clé étrangère vers RE (relation représentant E). La
clé de RM est la concaténation des deux attributs.
On gère donc M comme s'il s'agissait d'une entité faible RM, dont la clé locale serait M, et qui serait associée à E
par une relation 1:N.
Attributs dérivés
On ne représente pas en général les attributs dérivés dans le modèle relationnel, ils seront calculés dynamiquement
soit par des procédures internes à la BD (procédures stockées), soit par des procédures au niveau applicatif.
On peut néanmoins décider (pour des raisons de performance essentiellement) de représenter l'attribut dérivé
comme s'il s'agissait d'un attribut simple, mais il sera nécessaire dans ce cas d'ajouter des mécanismes de validation
de contraintes dynamiques (avec des déclencheurs par exemple) pour assurer que la valeur stockée évolue en même
temps que les attributs sur lesquels le calcul dérivé porte. Notons qu'introduire un attribut dérivé dans le modèle
relationnel équivaut à introduire de la redondance, ce qui est en gérénal déconseillé, et ce qui doit être dans tous les
cas contrôlé.
Exemple
Il existe trois façons de traduire la relation d'héritage : par référence, par absorption par les sous-types d'entité, par
absorption par l'entité générale.
En conclusion
Conseil
L'héritage est toujours délicat à traduire en relationnel, ce qui est dommage car son pouvoir de représentation
conceptuel est fort.
Un conseil pour assumer une gestion correcte de la traduction de la relation d'héritage serait d'appliquer à la lettre
les règles de transformation (ce qui conduira le plus souvent à un héritage par référence) et, l'expérience aidant, de
tolérer dans des cas bien maîtrisés des digressions à cette règle.
Question1
Etablissez une version simplifiée du dictionnaire de données, en présentant dans un tableau : Les entités, les clés, les
propriétés avec leur signification.
Question2
Lister les associations reliant les entités.
Question3
Donnez le schéma Entité-Association correspondant et décrivez les associations figurant dans le schéma.
Question4
Définissez le schéma relationnel correspondant.
Question5
Présentez les contraintes d'intégrité que l'on pourrait associer au schéma relationnel.
Les classes abstraites sont ignorées à ce stade, et n'étant pas instanciables, ne donnent jamais lieu à la création de
relation.
Relationnel 67
Association 1:1
Pour chaque association binaire A de type 1,1:1,1 ou 1,1:1,0 entre les classes S et T (représentés par les relations RS
et RT respectivement) on substitut dans la définition de RS l'éventuelle clé primaire (si RS était identifiée) par la clé
primaire de RT qui est également définie comme clé étrangère vers RT. Notons que dans le cas d'une association
1,1:1,1 RT peut-être choisi à la place de RS pour accueillir la clé étrangère.
Pour chaque association binaire A de type 0,1:0,1 entre les classes S et T (représentés par les relations RS et RT
respectivement) on inclut dans la définition de RS comme clé étrangère la clé de RT. La clé étrangère vers RT
incluse dans RS est également définie comme étant unique, afin d'assurer la cardinalité maximum de 1. Notons qu'il
n'était pas possible dans ce cas 0,1:0,1 que la clé étrangère vers RT incluse dans RS soit également la clé primaire,
car la cardinalité de 0 supposerait que la clé primaire puisse être "null", ce qui est illégal pour une clé.
Cardinalité minimale 0 ou 1
Selon que la cardinalité minimale est 0 ou 1 (ou plus) du côté de la relation référençante on ajoutera ou non une
contrainte de non nullité sur la clé étrangère.
Selon que la cardinalité minimale est 0 ou 1 (ou plus) du côté de la relation référencée on ajoutera ou non une
contrainte d'existance de tuples référençant pour chaque tuple de la relation référencée.
homme (nom)
femme (nomMariage=>homme, nomJeuneFille) avec nomJeuneFille clé
Si l'association avait été de cardinalité 0..1:0..1 (certains hommes et femmes ne sont pas mariés), le même choix se
serait imposé et l'on aurait abouti au résultat suivant:
homme (nom)
femme (nomJeuneFille, nomMariage=>homme) avec nomMariage unique
♦ etc.
Dans le doute il est préférable d'adopter l'approche systématique consistant à séparer les deux relations.
Attributs composites
Pour chaque attribut composite C, comprenant N sous-attributs, d'une classe E (idem pour les associations), on crée
N attributs correspondants à C sur la relation RE correspondant à E.
Attributs multivalués
Pour chaque attribut multivalué M d'une classe E (idem pour les associations), on crée une nouvelle relation RM qui
comprend un attribut monovalué correspondant à M plus la clé de RE (relation représentant E). La clé de RM est la
concaténation des deux attributs.
Compositions
Soit la composition entre la classe composite C et la classe partie P (représentés par les relations RC et RP
respectivement) on inclut dans la définition de RP comme clé étrangère la clé de RC. La clé de RP est redéfinie
comme la concaténation de la clé de P (clé locale) avec la clé étrangère vers RC.
Mode de
Limite Cas d'usage Exemple Vue
transformation
Par
-- + = = - = =
référence
Par les
classes + - ++ -- = = =
filles
Par la
classe - + +. = ++ = -
mère
Solution générale
Cette solution est la plus générale, elle fonctionne correctement dans tous les cas. Le seul problème est la
complexité de la structure de donnée qu'elle induit.
Si A n'avait pas été abstraite elle aurait donné naissance à une relation A possédant les attributs A1 et A2 et qui
n'auraient alors contenu que les tuples qui ne sont ni des B ni des C.
Héritage exclusif
Cette solution est optimum dans le cas d'un héritage exclusif, c'est à dire si aucun objet d'une classe fille n'appartient
aussi à une autre classe fille. Dans le cas contraire, le problème est que des redondances vont être introduites
puisqu'un même tuple devra être répété pour chaque classe fille à laquelle il appartient.
Héritage complet
Cette solution est optimum dans le cas d'un héritage complet, c'est à dire si les classes filles ne définissent pas
d'attributs autre que ceux hérités. Dans le cas contraire cela engendre des valeurs null.
En pratique l'héritage complet est rare, mais nombre d'héritages le sont presque et pourront alors être
raisonnablement gérés sellon cette approche, a fortiori si la classe mère n'est pas abstraite.
Il existe trois façons de traduire la relation d'héritage : par référence, par absorption par les classes filles, par
absorption par la classe mère.
En conclusion
Conseil
L'héritage est toujours délicat à traduire en relationnel, ce qui est dommage car son pouvoir de représentation
conceptuel est fort.
Un conseil pour assumer une gestion correcte de la traduction de la relation d'héritage serait d'appliquer à la lettre
les règles de transformation (ce qui conduira le plus souvent à un héritage par référence) et, l'expérience aidant, de
tolérer dans des cas bien maîtrisés des digressions à cette règle.
Exemple :
Ainsi si C hérite de B qui hérite de A, c'est la clé de A qui permettra d'identifier les classes A, B et C, et ce quelque
soit le mode de transformation retenu.
Question1
Réaliser le modèle conceptuel E-A ou UML de ce problème.
Question2
Réalisez le passage au modèle logique relationnel.
Objectifs pédagogiques
Connaître les fondements du modèle relationnel.
Savoir effectuer le passage d'un schéma conceptuel à un schéma relationnel.
Maîtriser l'algèbre relationnelle.
Relationnel 75
Concepts manipulatoires
La représentation d'information sous forme relationnelle est intéressante car les fondements mathématiques du relationnel,
outre qu'ils permettent une modélisation logique simple et puissante, fournissent également un ensemble de concepts pour
manipuler formellement l'information ainsi modélisée.
Ainsi une algèbre relationnelle, sous forme d'un ensemble d'opérations formelles permet d'exprimer des questions, ou
requêtes, posées à une représentation relationnelle, sous forme d'expressions algébriques.
L'algèbre relationnelle est composée par les cinq opérateurs de base et les trois opérateurs additionnels suivants :
♦ Opérateurs de base
- Union
- Différence
- Projection
- Restriction
- Produit cartésien
♦ Opérateurs additionels
- Intersection
- Jointure
- Division
1. Opérateurs ensemblistes
Attention
Les opérateurs ensemblistes sont des relations binaires (c'est à dire entre deux relations) portant sur des relations de
même schéma.
Union
L'union de deux relations R1 et R2 de même schéma produit une relation R3 de même schéma constituée de
l'ensemble des tuples appartenant à R1 et/ou à R2.
Différence
La différence entre deux relations R1 et R2 de même schéma produit une relation R3 de même schéma constituée
de l'ensemble des tuples de R1 n'appartenant pas à R2. Notons que la différence entre R1 et R2 n'est pas égale à la
différence entre R2 et R1.
Intersection
L'intersection de deux relations R1 et R2 de même schéma produit une relation R3 de même schéma constituée de
l'ensemble des tuples appartenant à la fois à R1 et à R2. Notons que l'intersection n'est pas une opération de base,
car elle est équivalent à deux opérations de différence successives.
Exemple
Soit les deux relations suivantes :
2. Projection
Projection
La projection est une opération unaire (c'est à dire portant sur une seule relation). La projection de R1 sur une partie
de ses attributs {A1, A2, ...} produit une relation R2 dont le schéma est restreint aux attributs mentionnés en
opérande, comportant les mêmes tuples que R1, et dont les doublons sont éliminés.
Exemple
Soit la relation suivante :
(Dupont, 20)
(Durand, 30)
3. Restriction
Restriction
La restriction est une opération unaire (c'est à dire portant sur une seule relation). La restriction de R1, étant donnée
une condition C, produit une relation R2 de même schéma que R1 et dont les tuples sont les tuples de R1 vérifiant la
condition C.
Exemple
Soit la relation suivante :
4. Produit
Produit cartésien
Le produit cartésien est une opération binaire (c'est à dire portant sur deux relations). Le produit de R1 par R2
(équivalent au produit de R2 par R1) produit une relation R3 ayant pour schéma la juxtaposition de ceux des
relations R1 et R2 et pour tuples l'ensemble des combinaisons possibles entre les tuples de R1 et ceux de R2.
♦ Synonyme : Produit.
Remarque
Le nombre de tuples résultant du produit de R1 par R2 est égal au nombre de tuples de R1 multiplié par le nombre
de tuples de R2.
Exemple
Soit les deux relations suivantes :
5. Jointure
Jointure
La jointure est une opération binaire (c'est à dire portant sur deux relations). La jointure de R1 et R2, étant donné
une condition C portant sur des attributs de R1 et de R2, de même domaine, produit une relation R3 ayant pour
schéma la juxtaposition de ceux des relations R1 et R2 et pour tuples l'ensemble de ceux obtenus par concaténation
des tuples de R1 et de R2, et qui vérifient la condition C.
Exemple
Soit les deux relations suivantes :
(Dupont, Georges, 1)
(Dupont, Jacques, 3)
Soit l'opération suivante :
6. Jointure naturelle
Jointure naturelle
La jointure naturelle entre R1 et R2 est une jointure pour laquelle la condition est l'égalité entre les attributs de
même nom de R1 et de R2. Il est donc inutile de spécifier la condition dans une jointure naturelle, elle reste toujours
implicite.
Exemple
Soit deux relations R1 (A, B, C) et R2 (A, D), l'opération Jointure(R1,R2,R1.A=R2.A) est équivalente à l'opération
JointureNaturelle(R1,R2).
Remarque
Pour appliquer une jointure naturelle, il faut que les deux relations opérandes aient au moins un attribut ayant le
même nom en commun.
7. Jointure externe
La jointure est une opération qui entraîne la perte de certains tuples : ceux qui appartiennent à une des deux relations
opérandes et qui n'ont pas de correspondance dans l'autre relation. Il est nécessaire dans certains cas de palier cette lacune, et
l'on introduit pour cela la notion de jointure externe.
Jointure externe
La jointure externe entre R1 et R2 est une jointure qui produit une relation R3 à laquelle on ajoute les tuples de R1
et de R2 exclus par la jointure, en complétant avec des valeurs nulles pour les attributs de l'autre relation.
Exemple
Soit les deux relations suivantes :
(Dupont, Georges, 1)
(Martin, Isabelle, 15)
Soit l'opération suivante :
8. Division
Division
La division est une opération binaire (c'est à dire portant sur deux relations). La division de R1 par R2, sachant que
R1 et R2 ont au moins un attribut commun (c'est à dire de même nom et de même domaine), produit une relation R3
qui comporte les attributs appartenant à R1 mais n'appartenant pas à R2 et l'ensemble des tuples qui concaténés à
ceux de R2 donnent toujours un tuple de R1.
Exemple
Soit les deux relations suivantes :
(Ingénieur)
(Professeur)
Soit l'opération suivante :
(Dupont, Pierre)
9. Proposition de notations
Il existe plusieurs syntaxes pour écrire des opérations d'algèbre relationnelle, certaines inspirées de l'algèbre classiques,
d'autres reposant sur des notations graphiques. Nous proposons une notation fonctionnelle qui a le mérite d'être facile à écrire
et d'être lisible. Si cette notation peut parfois perdre en simplicité, lorsqu'elle concerne un nombre élevé d'opérateurs, il est
possible de décomposer une opération compliquée afin de l'alléger.
Syntaxe
R = Union (R1, R2)
R = Différence (R1, R2)
R = Intersection (R1, R2)
R = Projection (R1, A1, A2, ...)
R = Restriction (R1, condition)
R = Produit (R1, R2)
R = Jointure (R1, R2, condition)
R = JointureNaturelle (R1, R2)
R = JointureExterne (R1, R2, condition)
R = JointureGauche (R1, R2, condition)
R = JointureDroite (R1, R2, condition)
R = Division (R1, R2)
Question2
Réécrivez Jointure à partir de Produit et Restriction
Question3
Réécrivez Division à partir de Produit, Restriction et Difference
Question1
Quels sont les invités du repas du 01/05/97 ?
Question2
Quels sont les plats qui ont été servis à Alice ?
Question3
Quels sont les invités qui lors d'un repas ont eu au moins un de leur plat préféré ?
Question4
Quelles sont les personnes qui n'ont jamais été invitées ?
Question5
Quels sont les invités qui sont venus à tous les repas ?
La relation LESFILMS donne pour chaque film, identifié par son titre, le pays, l'année de sortie, réalisateur et la durée.
La relation LESACTEURS donne pour chaque film l'ensemble des principaux acteurs.
A l'aide de l'algèbre relationnelle exprimer les requêtes suivantes :
Question1
Lister les films français (titre, année, réalisateur).
Relationnel 81
Question2
Donnez les années de sortie des fims où a joué GABIN.
Question3
Trouver les acteurs qui ont tourné avec TRUFFAUT comme réalisateur.
Question4
Trouver tous les acteurs qui ont été partenaires de DENEUVE.
Question5
Lister les films dans lesquels le réalisateur est aussi acteur.
Question6
Lister les réalisateurs n'ayant joué comme acteurs que dans des films qu'ils ne réalisaient pas eux-mêmes.
Question7
Lister les réalisateurs ayant joué comme acteurs dans des fims qu'ils ne réalisaient pas eux-mêmes.
Question8
Donnez les acteurs qui jouent dans tous les fims de TRUFFAUT.
Question1
Réaliser le modèle E-A ou UML de ce problème en faisant apparaître les domaines et les clés candidates, ainsi que
les éventuelles entités faibles.
Question2
Réaliser le passage au modèle relationnel, en faisant apparaître les clés primaires et les clés étrangères.
Question3
Ecrivez en algèbre relationnelle la question permettant de connaître les numéros d'immatriculation des voitures
rouges sur lesquelles sont montées un moteur et au moins un pneu de même marque que la voiture.
Pour chaque logement on possède plusieurs informations comme l'adresse, le nom du propriétaire, le type
(maison/appartement), le nombre de pièces, la surface habitable, l’état de l’habitation (neuf, bon état, très bon état, à
rénover), l’objectif de gestion (vente, location), le prix de mise en vente ou de location mensuelle, la date de disponibilité, la
ville, etc. Chaque propriété peut avoir un ou plusieurs garages. Ces derniers sont caractérisés par le type (box, emplacement
numérotés, etc.) et dans certain cas peuvent avoir des adresses différentes de celle de la propriété.
Une personne, qui sera identifiée par son nom et son adresse, peut mettre en location ou en vente un de ses logements auprès
de l’agence.
Un logement à vendre (resp. à louer) peut être acheté (resp. loué) par une personne. Pour chaque transaction de vente,
l'agence touche une commission qui correspond à un pourcentage du prix de vente (qui est composé d’une valeur fixe à
laquelle on additionne entre 3 et 5% en fonction du montant de la transaction et des négociations particulière). Un logement
vendu ou loué est rendu indisponible pour d’autres éventuels clients. Un locataire peut donner son préavis, l’agence signalant
alors le logement disponible dans un délai de trois mois.
L’agence organise et gère également les visites faites par ses clients (les acheteurs ou locataires potentiels).
Question1.1
Reformuler l'énoncé du problème sous la forme de règles claires afin de poser les connaissances sous une forme
littérale. Formuler des hypothèses, si nécessaire, pour compléter les informations manquantes.
Question1.2
Réaliser le modèle Entité-Association du problème.
Repérer le domaine de valeur des propriétés. Repérer les clés. Repérer les entités de type faible. Répérer les attributs
dérivés.
Question1.3
Réaliser le modèle relationnel en appliquant les règles de passage E-A vers relationnel.
Indiquer les règles appliquées. Expliquer et détailler les cas particuliers.
Utiliser la notation textuelle du modèle relationnel, du type : RELATION (PROP1, PROP2, PROPn). Souligner la
clé primaire (les propriétés concernées seront en premier dans la liste). Les clés étrangères seront placées en dernier
dans la liste, et l'on indiquera par un "=>" à quelle relation elles font références. Indiquer dans un tableau pour
chaque propriété, son domaine de valeur et les contraintes supplémentaires qui la concerne (existentielle, par
rapport à d'autres propriétés du tuple, etc.),
Enoncé n°2
L'agence cherche à présent à interroger sa base de données, afin d'en exploiter les informations recueillies.
Ecrire à l'aide de l'algèbre relationnelle les requêtes ci-après. On utilisera les notations suivantes :
♦ R = Restriction(Relation, Condition)
♦ R = Projection(Relation, Propriété1, Propriété2, ...)
♦ R = Jointure(Relation1, Relation2, Condition)
♦ R = JointureExterne(Relation1, Relation2, Condition)
♦ R = JointureNaturelle(Relation1, Relation2)
♦ R = Union(Relation1, Relation2)
♦ R = Difference(Relation1, Relation2)
♦ R = Intersection(Relation1, Relation2)
♦ R = Produit(Relation1, Relation2)
Question2.1
Pour constituer un fichier client complet, lister toutes les personnes.
Question2.2
Pour relancer les anciens clients de l'agence, lister les noms et prénoms de tous les clients ayant effectué au moins
une location ou un achat.
Question2.3
En vue d'une enquête de satisfaction et de suivi par courrier, lister les noms et adresses des propriétaires ayant loué
des logements à Lyon avant l'année 2000.
Question2.4
En vue d'optimiser l'organisation du personnel et de préparer le passage aux 35 heures pour l'antenne de
Compiègne, lister les jours pendant lesquels il y a eu au moins une visite pour des logements à Compiègne.
Relationnel 83
Question2.5
Pour répondre à une demande particulière d'un client exigeant, chercher, si cela existe, à quelles adresses on peut
trouver des F6 neufs, disponibles avant le 31 novembre 2002, de plus de 150m2, avec garage à la même adresse, rue
de la Paix à Paris.
Question2.6
Pour mettre en valeur l'activité de l'agence lors d'un conseil d'administration, préparer la liste de toutes les
commissions réalisées pour des ventes supérieures à 500.000 euros.
Question2.7
Pour convaincre un propriétaire d'accepter une proposition d'achat inférieure à son prix de mise en vente, lister
toutes les transactions (date, montant, prix de vente, nom du client et nom du propriétaire) pour lesquelles le
montant de vente est inférieur de plus de 10% au prix de mise en vente.
Question2.8
Pour vérifier si quelques solutions idéales ne sont pas latentes, chercher les clients toujours en recherche (i.e.
n'ayant jamais effectué de transaction) et habitant à une adresse à laquelle se trouve un logement disponible.
Question2.9
Pour leur faire des offres particulières, chercher les personnes qui sont à la fois clients et propriétaires.
Question2.10
Pour occuper votre temps pendant l'inactivité chronique du mois d'août, chercher les rues qui se retrouvent dans
toutes les villes.
En résumé...
Schéma relationnel
Un schéma relationnel permet une
formalisation d'un modèle logique.
III
SQL LMD
SQL est un langage standardisé, implémenté par tous les SGBDR, qui permet, indépendemment de la plate-forme
technologique et de façon déclarative, de définir le modèle de données, de le contrôler et enfin de le manipuler.
Ce chapitre traite du LMD de SQL, c'est à dire de la partie de ce langage, fondé sur l'algèbre relationnelle, qui permet
d'interroger les données stockées en BD.
Objectifs pédagogiques
Maîtriser les bases du SQL pour écrire des questions exigeant des jointures, projections, restriction, des tris et des
agrégats.
Etre capable d'apprendre des notions particulières de SQL liés à un SGBD en particulier ou à des évolutions futures de
SQL.
Qu'appelle-t-on SQL?
[Copyright 2003 Jean-François Pillou - Ce document issu de CommentCaMarche.net est soumis à la licence GNU FDL] SQL
(pour langage de requêtes structuré) est un langage de définition de données (LDD, ou en anglais DDL Data Definition
Language), un langage de manipulation de données (LMD, ou en anglais DML, Data Manipulation Language), et un langage
de contrôle de données (LCD, ou en anglais DCL, Data Control Language), pour les bases de données relationnelles.
Le modèle relationnel a été inventé par E.F. Codd (Directeur de recherche du centre IBM de San José) en 1970, suite à quoi
de nombreux langages ont fait leur apparition :
♦ IBM Sequel (Structured English Query Language) en 1977
♦ IBM Sequel/2
♦ IBM System/R
♦ IBM DB2
Ce sont ces langages qui ont donné naissance au standard SQL, normalisé en 1986 par l'ANSI pour donner SQL/86. Puis en
1989 la version SQL/89 a été approuvée. La norme SQL/92 a désormais pour nom SQL 2.
1. Sélection
La requête de sélection ou question est la base de la recherche de données en SQL.
Sélection
La selection est la composition d'un produit cartésien, d'une restriction et d'une projection (ou encore la composition
d'une jointure et d'une projection).
Syntaxe
SELECT <liste d'attributs projetés>
FROM <liste de relations>
WHERE <condition>
La partie SELECT indique le sous-ensemble des attributs qui doivent apparaître dans la réponse (c'est le schéma de la
relation résultat).
La partie FROM décrit les relations qui sont utilisables dans la requête (c'est à dire l'ensemble des attributs que l'on peut
utiliser).
La partie WHERE exprime les conditions que doivent respecter les attributs d'un tuple pour pouvoir être dans la réponse.
Une condition est un prédicat et par conséquent renvoie un booléen. Cette partie est optionnelle.
Afin de décrire un attribut d'une relation dans le cas d'une requête portant sur plusieurs relations, on utilise la notation
"RELATION.ATTRIBUT".
Exemple
SELECT Nom, Prenom
FROM Personne
WHERE Age>18
Cette requête sélectionne les attributs Nom et Prenom des tuples de la relation Personne, ayant un attribut Age
supérieur à 18.
Exemple
SELECT Parent.Prenom, Enfant.Prenom
FROM Parent, Enfant
WHERE Enfant.Nom=Parent.Nom
Cette requête sélectionne les prénoms des enfants et des parents ayant le même nom. On remarque la notation
Parent.Nom et Enfant.Nom pour distinguer les attributs Prenom des relations Parent et Enfant.
On notera que cette sélection effectue une jointure sur les propriétés Nom des relations Parent et Enfant.
Remarque : SELECT *
Pour projeter l'ensemble des attributs d'une relation, on peut utiliser le caractère "*" à la place de la liste des
attributs à projeter.
Exemple
SELECT *
FROM Avion
Cette requête sélectionne tous les attributs de la relation Avion.
Notons que dans cet exemple, la relation résultat est exactement la relation Avion
Exemple
SELECT DISTINCT Avion
FROM Vol
WHERE Date=31-12-2000
Cette requête sélectionne l'attribut Avion de la relation Vol, concernant uniquement les vols du 31 décembre 2000
et renvoie les tuples dans doublons.
SELECT *
FROM R1, R2, Ri
WHERE <condition>
Avec Condition permettant de joindre des attributs des Ri
88 Conception de bases de données
SELECT *
FROM R1 INNER JOIN R2
ON <condition>
Et pour plusieurs relations :
SELECT *
FROM (R1 INNER JOIN R2 ON <condition>) INNER JOIN Ri ON <condition>
Remarque : Auto-jointure
Pour réaliser une auto-jointure, c'est à dire la jointure d'une relation avec elle-même, on doit utiliser le renommage
des relations. Pour renommer une relation, on note dans la clause FROM le nom de rennomage après le nom de la
relation : "FROM NOM_ORIGINAL NOUVEAU_NOM".
Exemple : Auto-jointure
SELECT E1.Nom
FROM Employe E1, Employe E2
WHERE E1.Nom= E2.Nom
Remarque
Remarquons que "Avion LEFT OUTER JOIN Vol" est équivalent à "Vol RIGHT OUTER JOIN Avion" en terme
de résultat.
Intuitivement, on préfère utiliser la jointure gauche pour sélectionner tous les tuple du côté N d'une relation 1:N,
même si il ne sont pas référencés ; et la jointure droite pour pour sélectionner tous les tuples d'une relation 0:N, y
compris ceux qui ne font pas de référence. Cette approche revient à toujours garder à gauche de l'expression "JOIN"
la relation "principale", i.e. celle dont on veut tous les tuples, même s'ils ne référencent pas (ou ne sont pas
référencés par) la relation "secondaire".
7. Opérateurs ensemblistes
Les opérateurs ensemblistes ne peuvent être exprimés à l'aide de l'instruction de sélection seule.
Syntaxe : Union
SELECT * FROM R1
UNION
SELECT * FROM R2
Syntaxe : Intersection
SELECT * FROM R1
INTERSECT
SELECT * FROM R2
Syntaxe : Différence
SELECT * FROM R1
EXCEPT
SELECT * FROM R2
Remarque
Les opérations INTERSECT et EXCEPT n'existe que dans la norme SQL2, et non dans la norme SQL1. Certain
SGBD sont susceptibles de ne pas les implémenter.
SQL LMD 89
8. Tri
On veut souvent que le résultat d'une requête soit trié en fonction des valeurs des propriétés des tuples de ce résultat.
Syntaxe : ORDER BY
SELECT <liste d'attributs projetés>
FROM <liste de relations>
WHERE <condition>
ORDER BY <liste ordonnée d'attributs>
Les tuples sont triés d'abord par le premier attribut spécifié dans la clause ORDER BY, puis en cas de doublons par le
second, etc.
Exemple
SELECT *
FROM Personne
ORDER BY Nom, Age DESC
9. Fonctions de calcul
Fonction de calcul
Une fonction de calcul s'applique à l'ensemble des valeurs d'une propriété d'une relation avec pour résultat la
production d'une valeur atomique unique (entier, chaîne, date, etc).
Les cinq fonctions prédéfinies sont :
♦ Count(Relation.Propriété)
Renvoie le nombre de valeurs non nulles d'une propriété pour tous les tuples d'une relation ;
♦ Sum(Relation.Propriété)
Renvoie la somme des valeurs d'une propriété des tuples (numériques) d'une relation ;
♦ Avg(Relation.Propriété)
Renvoie la moyenne des valeurs d'une propriété des tuples (numériques) d'une relation ;
♦ Min(Relation.Propriété)
Renvoie la plus petite valeur d'une propriété parmi les tuples d'une relation .
♦ Max(Relation.Propriété)
Renvoie la plus grande valeur d'une propriété parmi les tuples d'une relation.
Syntaxe
SELECT <liste de fonctions de calcul>
FROM <liste de relations>
WHERE <condition à appliquer avant calcul>
Exemple
SELECT Min(Age), Max(Age), Avg(Age)
FROM Personne
WHERE Qualification='Ingénieur'
10. Agrégats
Agrégat
Un agrégat est un partitionnement horizontal d'une table en sous-tables, en fonction des valeurs d'un ou plusieurs
attributs de partitionnement, suivi de l'application d'une fonction de calcul à chaque attribut des sous-tables
obtenues (Gardarin, 1999).
90 Conception de bases de données
Syntaxe
SELECT <liste d'attributs de partionnement à projeter et de fonctions de calcul>
FROM <liste de relations>
WHERE <condition à appliquer avant calcul de l'agrégat>
GROUP BY <liste ordonnée d'attributs de partitionnement>
HAVING <condition sur les fonctions de calcul>
Exemple
SELECT Societe.Nom, AVG(Personne.Age)
FROM Personne, Societe
WHERE Personne.NomSoc = Societe.Nom
GROUP BY Societe.Nom
HAVING Count(Personne.NumSS) > 10
Cette requête calcul l'âge moyen du personnel pour chaque société comportant plus de 10 salariés.
Remarque : Restriction
Une restriction peut être appliquée avant calcul de l'agrégat, au niveau de la clause WHERE, portant ainsi sur la
relation de départ, mais aussi après calcul de l'agrégat sur les résultats de ce dernier, au niveau de la clause
HAVING.
Remarque : Projection
Si dans la clause SELECT, un attribut est projeté directement, sans qu'une fonction lui soit appliquée, alors il faut
impérativement que cet attribut apparaisse dans la clause GROUP BY (car ce ne peut être qu'un attribut de
partionnement).
Syntaxe
SELECT <projections>
FROM <relations>
WHERE <sous-requête>
Exemple
SELECT Nom
FROM Chercheur
WHERE Nom IN
(SELECT Nom FROM Enseignant)
Remarque : NOT IN
On peut tester la non existence du tuple dans la sous requête en utilisant la clause NOT IN à la place de la clause IN.
Exemple
SELECT Chercheur.Nom
FROM Chercheur
WHERE EXISTS
(SELECT *
FROM Universite
WHERE Universite.Nom=Chercheur.Universite)
Exemple
SELECT Nom
FROM Chercheur
WHERE Age > ALL
(SELECT Age
FROM Etudiant)
Exemple
SELECT Nom
FROM Chercheur
WHERE Age < ANY
(SELECT Age
FROM Etudiant)
Remarque : SOME
SOME peut être utilisé comme un synonyme de ANY.
Remarque
Les propriétés non valorisées sont affectées à la valeur null.
Il est possible de ne pas spécifier les propriétés à valoriser, dans ce cas, toutes les propriétés de la relation seront
considérées, dans leur ordre de définition dans la relation (à n'utiliser que dans les cas les plus simples).
Question1
Tous les détails de tous les clients.
Question2
Les numéros et les noms des produits de couleur rouge et de poids supérieur à 100.
Question3
Les différents représentants ayant vendu au moins un produit.
Question4
Les noms des clients de Lyon ayant acheté un produit pour une quantité supérieure à 180.
Question5
Les noms des représentants et des clients à qui ces représentants ont vendu un produit de couleur rouge pour une
quantité supérieure à 100.
Question6
Le nombre de clients.
94 Conception de bases de données
Question7
Le nombre de produits de couleur rouge.
Question8
Le nombre de clients par ville.
Question9
La quantité totale des produits rouge vendus par chaque représentant.
Question10
La quantité totale des produits rouge par chaque représentant ayant vendu plus de 10 produits rouges.
Question11
Les noms des vendeurs qui n'ont jamais rien vendu.
Question12
Les numéros de tous les produits tel qu'ils n'en existe aucun autre ayant un poids plus faible.
Question13
Les noms des représentants ayant vendu quelque chose à tous les clients.
Question14
Les noms des représentants ayant vendu quelque chose aux clients NC1 et NC2.
Question15
Les numéros des produits vendus à un client par un représentant issu de la même ville.
Question16
Les numéros des produits vendus à un client de Lyon par un représentant de Lyon.
Question17
Les numéros des clients ayant acheté quelque chose à au moins un représentant issu de la même ville.
Question18
Les numéros des clients qui n'ont rien acheté d'un représentant de Lyon.
Question19
Les couples des représentants et le nom de la ville dans laquelle le premier a vendu plus que le second.
Question1
Ecrivez une requête SQL permettant de sélectionner les noms de tous les directeurs de France.
Question2
Ecrivez une requête SQL permettant de vérifier que les salaires de chaque employé correspond bien à ce qui est
autorisé par leur fonction.
Question3
Ecrivez une requête SQL permettant de licencier tous les employés qui travaillent en Allemagne.
SQL LMD 95
Question4
Ecrivez une requête SQL permettant le passage aux 35 heures, en modifiant le nombre d'heures travaillées pour
chaque fonction, et en réajustant les échelles de salaire au pro-rata du nombre d'heures travaillées avant le passage
aux 35 heures.
Question5
Ecrivez une requête SQL permettant de calculer le nombre d'employés dans chaque société. Les sociétés présentant
le plus grand nombre d'employés seront présentées en premier.
Question1
Réaliser le modèle logique correspondant en relationnel, en faisant apparaître les clés primaires et étrangères.
Question2
Ecrivez une requête SQL permettant de préparer l'implémentation de la méthode NbIngrédients. Cette requête devra
renvoyer le nombre d'ingrédients pour chaque potion. La méthode n'est bien entendu pas à écrire.
Question3
Ecrivez une requête SQL permettant de trouver la recette de la potion magique.
Question4
Ecrivez une requête SQL permettant de trouver les ingrédients utilisés par aucune potion.
Question5
Critiquer le schéma conceptuel de l'apprenti : Est-ce qu'un même ingrédient peut apparaître deux fois dans la même
potion ? Peut-on gérer la quantité d'ingrédients pour chaque potion ? Proposer une solution et redessiner le schéma
conceptuel en Entité-Association, en y intégrant votre amélioration.
Question2
Traduire le MCD en modèle logique relationnel. Enoncer les éventuelles contraintes non représentables en
relationnel.
96 Conception de bases de données
Question3
Proposer une implémentation SQL du modèle relationnel, en intégrant le maximum de contraintes. Enoncer les
éventuelles contraintes non représentables en SQL.
Question4
Ecrivez en algèbre relationnel l'expression permettant de sélectionner les équipes ayant gagné au moins un match et
perdu au moins un match.
Question5
Ecrire une requête SQL permettant de lister toutes les équipes ayant gagné un match, avec leur nombre de points
(un match gagné valant 2 points et un match perdu 0 point), triées par leur nombre de points (avec l'équipe ayant le
plus de points en premier).
Cours
IV
Normalisation, SQL
LDD et LCD
La théorie de la normalisation relationnelle est très importante pour la conception de BD, dans la mesure où elle donne le
cadre théorique pour la gestion de la redondance, et dans la mesure où une bonne maîtrise de la redondance est un aspect
majeur de cette conception.
Après avoir expliqué la théorie de la normalisation et donné les outils méthodologiques pour la gestion de la redondance, ce
chapitre terminera la description du langage SQL par la description des instructions des langages LDD et LCD, qui
composent avec le LMD les trois parties du langage SQL.
Partie A. La normalisation
Objectifs pédagogiques
Comprendre la problématique de la redondance et des dépendances fonctionnelles.
Savoir créer des schémas relationnels en troisième forme normale.
A B C D E F G
0 1 1 10 5 X A
0 2 1 10 9 X G
0 1 2 10 6 X S
0 1 3 10 7 X D
1 2 3 20 7 Y D
0 3 3 10 9 X G
1 4 3 20 8 Y F
1 1 4 20 9 Y G
TAB. 13 : RELATION R
Question1
Proposez une clé primaire pour cette relation. Justifiez brièvement.
98 Conception de bases de données
Question2
Cette relation contient-elle des redondances ? Si oui lesquelles ? Justifiez brièvement.
Question3
Si la relation contient des redondances, proposez une solution contenant exactement la même information, mais
sans redondance.
S'il est difficile de définir un bon modèle conceptuel, on peut par contre poser qu'un bon modèle logique relationnel est un
modèle où la redondance est contrôlée. On peut alors poser qu'un bon modèle conceptuel est un modèle conceptuel qui
conduit à un bon modèle relationnel, après application des règles de passage E-A ou UML vers relationnel. Mais on ne sait
pas pour autant le critiquer avant ce passage, autrement qu'à travers l'oeil d'un expert.
A défaut de disposer d'outils systématiques pour obtenir de bons modèles conceptuels, on cherche donc à critiquer les
modèles relationnels obtenus. La théorie de la normalisation est une théorie qui permet de critiquer, puis d'optimiser, des
modèles relationnels, de façon à en contrôler la redondance.
On conseillera de lire le chapitre 2 (pages 42 à 49) qui propose une très bonne démonstration par l'exemple des
problèmes posés par une mauvaise modélisation relationnelle.
2. Principes de la normalisation
La théorie de la normalisation est une théorie destinée à concevoir un bon schéma d’une BD sans redondance
d’information et sans risques d'anomalie de mise à jour. Elle a été introduite dès l'origine dans le modèle relationnel
(Codd, "A relational model for large shared data banks", "Communications de l'ACM", juin-1970, n°.6, pp.377-387) .
Normalisation, SQL LDD et LCD 99
La mise en oeuvre de la normalisation est fondée sur la décomposition progressive des relations jusqu'à obtenir des relations
normalisées.
3. Dépendance fonctionnelle
Dépendance fonctionnelle
Soient R(A1, A2, ... , An) un schéma de relation, X et Y des sous-ensembles de A1, A2, ... , An. On dit que X
détermine Y, ou que Y dépend fonctionnellement de X, si est seulement s'il existe une fonction qui à partir de toute
valeur de X détermine une valeur unique de Y.
Plus formellement on pose que X détermine Y pour une relation R ssi quelle que soit l'instance r de R, alors pour
tous tuples t1 et t2 de r on a :
Projection (t1,X) = Projection (t2,X) ⇒ Projection (t1,Y) = Projection (t2,Y)
Syntaxe
Si X détermine Y, on note : X→ Y
Exemple
Soit la relation R suivante :
Augmentation
Si un attribut X détermine un attribut Y, alors tout groupe composé de X enrichi avec d'autres attributs détermine un
groupe composé de Y et enrichi des mêmes autres attributs.
Soient X, Y et Z des attributs :
X→ Y ⇒ XZ→ YZ
100 Conception de bases de données
Transitivité
Si un attribut X détermine un attribut Y et que cet attribut Y détermine un autre attribut Z, alors X détermine Z.
Soient X, Y et Z des attributs :
X→ Y et Y→ Z ⇒ X→ Z
Union
Si un attribut détermine plusieurs autres attributs, alors il détermine tout groupe composé de ces attributs.
Soient X, Y et Z des attributs :
X→ Y et X→ Z ⇒ X→ YZ
Cette propriété est déduite de la réflexivité, de l'augmentation et de la transitivité :
X→ Y et X→ Z ⇒ X→ XX et XX→ XY et YX→ YZ ⇒ X→ YZ
Décomposition
Si un attribut détermine un groupe d'attribut, alors il détermine chacun des attributs de ce groupe pris
individuellement.
Soient X, Y et Z des attributs :
X→ YZ ⇒ X→ Z et X→ Y
Cette propriété est déduite de la réflexivité et de la transitivité :
X→ YZ ⇒ X→ YZ et YZ→ Z ⇒ X→ Z
6. DF élémentaire
Dépendance fonctionnelle élémentaire
Soit G un groupe d'attributs et A un attribut, une DF G→ A est élémentaire si A n'est pas inclu dans G et qu'il
n'existe pas d'attribut A' de G qui détermine A.
Exemple : DF élémentaires
♦ AB→ C est élémentaire si ni A, ni B pris individuellement ne déterminent C.
♦ Nom, DateNaissance, LieuNaissance→ Prénom est élémentaire.
Remarque
On peut toujours réécrire un ensemble de DF en un ensemble de DFE [Dépendance Fonctionnelle Elémentaire], en
supprimant les DF triviales obtenues par réflexivité et en décomposant les DF à partie droite non atomique en
plusieurs DFE.
Exemple
Soit l'ensemble F = {A→ B, B→ C, B→ D, A→ E}.
La fermeture transitive de F est F+ = { A→ B, B→ C, B→ D, A→ E, A→ C, A→ D }
Remarque
Tout ensemble de DFE (et donc tout ensemble de DF) admet au moins une couverture minimale (et en pratique
souvent plusieurs).
Exemple
L'ensemble F = {A→ B, A→ C, B→ C, C→ B} admet les deux couvertures minimales :
CM1 = {A→ C, B→ C, C→ B} et CM2 = {A→ B, B→ C, C→ B}
Remarque
Toute clé candidate détermine les autres clés candidates, puisque qu'une clé détermine tous les attributs de la
relation.
La troisième forme normale est généralement reconnue comme étant la plus importante à respecter.
Attribut atomique
Un attribut est atomique si il ne contient qu'une seule valeur pour un tuple donné, et donc s'il ne regroupe pas un
ensemble de plusieurs valeurs.
Personne(Nom, Profession)
(Dupont, Géomètre)
(Durand, Ingénieur-Professeur)
La relation n'est pas en 1NF, car l'attribut Profession peut contenir plusieurs valeurs.
Pour que la relation soit en 1NF, on pourrait par exemple ajouter Profession à la clé et faire apparaître deux tuples
pour Durand, on obtiendrait :
Personne(Nom, Profession)
(Dupont, Géomètre)
(Durand, Ingénieur)
(Durand, Professeur)
Une autre solution aurait été d'ajouter un attribut ProfessionSecondaire. On obtiendrait ainsi :
On note alors que la première DF est issue de la clé et qu'elle n'est pas élémentaire (puisque Profession détermine
Salaire) et donc que le schéma n'est pas en 2NF.
Pour avoir un schéma relationnel en 2NF, il faut alors décomposer Personne en deux relations :
Personne(Nom, Profession)
Profession(Profession, Salaire)
On remarque que ce schéma est en 2NF (puisque Salaire dépend maintenant fonctionnellement d'une clé et non plus
d'une partie de clé).
On remarque aussi que la décomposition a préservé les DF, puisque nous avons à présent :
♦ Profession→ Salaire (DF de la relation Profession)
♦ Nom,Profession→ Profession (par Réflexivité)
♦ Nom,Profession→ Salaire (par Transitivité)
Remarque
La définition de la 2NF doit être vérifiée pour toutes les clés candidates et non seulement la clé primaire (dans le cas
où il y a plusieurs clés).
Remarque
Si toutes les clés d'une relation ne contiennent qu'un unique attribut, et que la relation est en 1NF, alors la relation
est en 2NF.
Cette relation n'est pas en 3NF car Salaire, qui n'est pas une clé, détermine Prime.
Pour avoir un schéma relationnel en 3NF, il faut décomposer Profession :
Profession(Profession, Salaire)
Salaire(Salaire, Prime)
Ce schéma est en 3NF, car Prime est maintenant déterminé par une clé.
On remarque que cette décomposition préserve les DF, car par transitivité, Profession détermine Salaire qui
détermine Prime, et donc Profession détermine toujours Prime.
On n'en conclut qu'il ne peut exister de DFE, donc a fortiori pas de DF, issues d'une partie d'une clé, et donc que
toutes les DF issues d'une clé sont élémentaires.
Il est souhaitable que les relations logiques soient en 3NF. En effet, il existe toujours une décomposition sans perte
d'information et préservant les DF d'un schéma en 3NF. Si les formes normales suivantes (BCNF [Forme Normale de
Boyce-Codd], 4NF [Quatrième Forme Normale] et 5NF [Cinquième Forme Normale]) assurent un niveau de
redondance encore plus faible, la décomposition permettant de les atteindre ne préserve plus les DF.
Normalisation, SQL LDD et LCD 105
Exemple : Employés
Soit la relation Personne :
Il existe une DFE qui n'est pas issue d'une clé et qui détermine un attribut appartenant à une clé. Cette relation est en
3NF, mais pas en BCNF (car en BCNF toutes les DFE sont issues d'une clé).
Pour avoir un schéma relationnel en BCNF, il faut décomposer Personne :
Remarque : Simplicité
La BCNF est la forme normale la plus facile à appréhender intuitivement et formellement, puisque les seules DFE
existantes sont de la forme K→ A où K est une clé.
**
*
La normalisation permet de décomposer un schéma relationnel afin d'obtenir des relations non redondantes.
La 3NF est souhaitable car toujours possible à obtenir, sans perte d'information et sans perte de DF. La BCNF est également
indiquée, car elle est un peu plus puissante, et plutôt plus simple que la 3NF.
La BCNF n'est pas encore suffisante pour éliminer toutes les redondances. Il existe pour cela les 4NF et 5NF qui ne sont pas
abordées dans ce cours. Notons également que les cas de non-4NF et de non-5NF sont assez rares dans la réalité.
Question1
Parmi les dépendances fonctionnelles suivantes, lesquelles ne s'appliquent pas à r ?
♦ E-->D
♦ D-->E
♦ C-->A
♦ E-->B
♦ E-->A
♦ B-->C
♦ B-->D
♦ B-->A
Question2
Trouver une clé pour r.
Question3
En quelle NF est cette relation ?
Question1
Donner l'ensemble des dépendances fonctionnelles élémentaires engendrées par E.
Question2
Quelles sont les clés candidates de R ?
Question3
R est elle en 3ème forme normale ?
C --> P
H,S --> C
H,P --> S
C,E --> N
H,E --> S
Question1
Donner l'ensemble des dépendances fonctionnelles élémentaires engendrées par E.
Question2
Quelle est la clé de la relation R ? Montrer qu'elle est unique.
Normalisation, SQL LDD et LCD 107
Question3
On décompose la relation R en quatre relations : R1(C,E,N), R2(C,P), R3(C,H,S), R4(C,H,E).
Pour chacune de ces relations, donner sa clé et sa forme normale. Cette décomposition est-elle sans perte
d'information ? Préserve-t-elle les dépendances fonctionnelles ? Justifiez votre réponse.
Objectifs pédagogiques
Maîtriser les bases du SQL pour créer des tables, attribuer des droits et entrer, modifier et effacer des données dans les
tables.
Bref aperçu
SQL est un langage déclaratif destiné aux SGBD et plus particulièrement aux SGBDR. Ce langage est défini par une norme
ISO datant de 1986 pour SQL1 et 1992 pour SQL2[La norme SQL3 en 1999 étend SQL aux SGBD Relationnels-Objets].
SQL n'est pas a proprement parlé un langage de programmation, mais plutôt une interface standard pour accéder aux bases de
données.
Il est composé de trois sous ensembles :
♦ Le LDD pour créer et supprimer des objets dans la base de données (tables, contraintes d'intégrité, vues, etc.).
♦ Le LCD pour gérer les droits sur les objets de la base (création des utilisateurs et affectation de leurs droits).
♦ Le LMD pour la recherche, l'insertion, la mise à jour et la suppression de données.
Le LMD est basé sur les opérateurs relationnels, auxquels sont ajoutés des fonctions de calcul d'agrégats et des
instructions pour réaliser les opérations d'insertion, mise à jour et suppression.
1. Types de données
Un attribut d'une relation est défini pour un certain domaine. On peut également dire qu'il est d'un type particulier. Les types
de données disponibles en SQL varient d'un SGBD à l'autre, on peut néanmoins citer un certain nombre de types standards
que l'on retrouve dans tous les SGBD.
1.1. Les types numériques
♦ Les nombres entiers
INTEGER(X), où X est optionnel et désigne le nombre de chiffres maximum pouvant composer le nombre. Il existe
également un certain nombre de variantes permettant de définir des entiers plus ou moins volumineux, tels que TINYINT,
SMALLINT ou LONGINT.
♦ Les nombres décimaux
DECIMAL(X,Y), où X et Y sont optionnels et désignent respectivement le nombre de chiffres maximum pouvant
composer le nombre avant et après la virgule. NUMERIC est également utilisé de façon équivalente.
♦ Les nombres à virgule flottante
REAL(X,Y), avec X et Y optionnels et définissant le nombre de chiffres avant et après la virgule.
Il existe également un certain nombre de variantes permettant de définir une précision plus grande, telles que DOUBLE.
108 Conception de bases de données
2. Création de tables
La création de table est le fondement de la création d'une base de données en SQL.
Création de table
La création de table est la définition d'un schéma de relation en intension, par la spécification de tous les attributs le
composant avec leurs domaines respectifs.
Syntaxe
CREATE TABLE <nom de table> (
<nom colonne1> <type colonne1>,
<nom colonne2> <type colonne2>,
...
<nom colonneN> <type colonneN>,
);
Exemple
CREATE TABLE Personne (
Nom VARCHAR(25),
Prenom VARCHAR(25),
Age INTEGER(3)
);
Contrainte d'intégrité
La définition des attributs n'est pas suffisante pour définir un schéma relationnel, il faut lui adjoindre la définition de
contraintes d'intégrité, qui permette de poser les notions de clé, d'intégrité référentielle, de restriction de domaines,
etc.
Normalisation, SQL LDD et LCD 109
3. Contraintes d'intégrité
Contraintes d'intégrité
Une contrainte d'intégrité est une règle qui définit la cohérence d'une donnée ou d'un ensemble de données de la
BD.
Il existe deux types de contraintes :
♦ sur une colonne unique,
♦ ou sur une table lorsque la contrainte porte sur une ou plusieurs colonnes.
Syntaxe
CREATE TABLE <nom de table> (
<nom colonne1> <type colonne1> <contraintes colonne1>,
<nom colonne2> <type colonne2> <contraintes colonne2>,
...
<nom colonneN> <type colonneN> <contraintes colonneN>,
<contraintes de table>
);
Remarque
Les contraintes sur une colonne et sur une table peuvent être combinées dans la définition d'un même schéma de
relation.
Une contrainte sur une colonne peut toujours être remplacée par une contrainte sur une table.
Exemple
CREATE TABLE Personne (
N°SS CHAR(13) PRIMARY KEY,
Nom VARCHAR(25) NOT NULL,
Prenom VARCHAR(25) NOT NULL,
Age INTEGER(3) CHECK (Age BETWEEN 18 AND 65),
Mariage CHAR(13) REFERENCES Personne(N°SS),
Codepostal INTEGER(5),
Pays VARCHAR(50),
UNIQUE (Nom, Prenom),
FOREIGN KEY (Codepostal, Pays) REFERENCES Adresse (CP, Pays)
);
♦ Nom, Prénom ne peuvent pas être null et (Nom, Prénom) est une clé.
♦ Age doit être compris entre 18 et 65 et Initiale doit être la première lettre de Pays (avec la fonction LEFT qui
renvoie la sous chaîne à gauche de la chaîne passée en premier argument, sur le nombre de caractères passés en
second argument)
♦ Mariage est clé étrangère vers Personne et (Codepostal, Pays) est une clé étrangère vers Adresse.
4. Création de vues
Vue
Une vue est une définition logique d'une relation, sans stockage de données, obtenue par interrogation d'une ou
plusieurs tables de la BD. Une vue peut donc être perçue comme une fenêtre dynamique sur les données, ou encore
une requête stockée (mais dont seule la définition est stockée, pas le résultat, qui reste calculé dynamiquement).
Une vue permet d'implémenter le concept de schéma externe d'un modèle conceptuel.
Syntaxe
CREATE VIEW <nom de vue> <nom des colonnes>
AS <spécification de question>
La spécification d'une question se fait en utilisant le LMD.
Le nombre de colonnes nommées doit être égal au nombre de colonnes renvoyées par la question spécifiée. Le nom des
colonnes est optionnel, s'il n'est pas spécifié, c'est le nom des colonnes telle qu'elles sont renvoyées par la question, qui sera
utilisé.
Exemple
CREATE VIEW Employe (Id, Nom)
AS
SELECT N°SS, Nom
FROM Personne
La vue Employe est ici une projection de la relation Personne sur les attributs N°SS et Nom, renommés
respectivement Id et Nom.
5. Supression d'objets
Il est possible de supprimer des objets de la BD, tels que les tables ou les vues.
Syntaxe
DROP <type objet> <nom objet>
Exemple
DROP TABLE Personne;
DROP VIEW Employe;
6. Modification de tables
L'instruction ALTER TABLE permet de modifier la définition d'une table (colonnes ou contraintes) préalablement créée.
Cette commande absente de SQL-89 est normalisée dans SQL-92
Syntaxe : Ajout de colonne
ALTER TABLE <nom de table> (
ADD (<définition de colonne>);
Normalisation, SQL LDD et LCD 111
Question1
Dessinez le modèle E-A.
Question2
Traduisez le modèle E-A en modèle logique relationnel.
Question3
Après avoir identifié les DF, normalisez le modèle relationnel en BCNF.
Question4
Ecrivez les instructions SQL de création d'un tel modèle.
1. Attribution de droits
SQL propose une commande pour attribuer des droits à des utilisateurs sur des tables.
Syntaxe
GRANT <liste de droits> ON <nom table> TO <utilisateur> [WITH GRANT OPTION]
Les droits disponibles renvoient directement aux instructions SQL que l'utilisateur peut exécuter :
♦ SELECT
♦ INSERT
♦ DELETE
♦ UPDATE
♦ ALTER
De plus il est possible de spécifier le droit ALL PRIVILEGES qui donne tous les droits à l'utilisateur (sauf celui de
transmettre ses droits).
La clause WITH GRANT OPTION est optionnelle, elle permet de préciser que l'utilisateur a le droit de transférer ses propres
droits sur la table à d'autres utilisateur. Une telle clause permet une gestion décentralisée de l'attribution des droits et non
reposant uniquement dans les mains d'un administrateur unique.
La spécification PUBLIC à la place d'un nom d'utilisateur permet de donner les droits spécifiés à tous les utilisateurs de la
BD.
Exemple
GRANT SELECT, UPDATE ON Personne TO Pierre;
GRANT ALL PRIVILEGES ON Adresse TO PUBLIC;
2. Révocation de droits
SQL propose une commande pour révoquer les droits attribués à des utilisateurs.
Syntaxe
REVOKE <liste de droits> ON <nom table> FROM <utilisateur>
Exemple
REVOKE SELECT, UPDATE ON Personne TO Pierre;
REVOKE ALL PRIVILEGES ON Adresse TO PUBLIC;
Question1.1
Donner les principales contraintes d'intégrité associées à ce schéma (en français).
Question1.2
Proposer une définition du schéma en SQL qui prenne en compte le plus possible de contraintes.
Enoncé n°2
On suppose que 3 classe d'utilisateurs ont accès à tout ou partie de ce schéma relationnel :
♦ L'administrateur de la base, qui initialise la base et donne notamment en début de saison tous les spectacles avec toutes les
représentations associées.
♦ Les guichetiers qui gèrent les réservations à ces réprésentations et donc émettent les billets.
♦ Et enfin les clients potentiels qui peuvent consulter la base pour connaître les spectacles joués (éventuellement par type) et
savoir les représentations où il reste des places disponibles.
Question2.1
Proposer un schéma externe sous forme de vues pour chacune de ces différentes classes d'utilisateurs.
114 Conception de bases de données
Question2.2
Donner les droits associés à chaque classe d'utilisateurs.
En résumé...
Langage SQL
Le langage SQL permet la création, le
contrôle et la manipulation d'une BD.
Normalisation de relations
Soit un modèle conceptuel E-A représentant :
♦ un type d'entité "chercheur", identifié par le numéro de sécurité sociale, et possédant les autres propriétés suivantes : le
nom, le nom de l'université à laquelle il appartient, la ville dans laquelle est basée cette université.
♦ un type d'entité "professeur", héritant de "chercheur"
♦ un type d'entité "doctorant", héritant de "chercheur"
♦ une association de type "encadrement" entre professeur et doctorant (un professeur pouvant encadrer plusieurs doctorants
et un doctorant n'ayant qu'un et un seul directeur de thèse).
Modèle E-A
IMG. 35
Modèle relationnel
Professeur ( N°SS:int(13), Nom:char(20), NomUniv:char(50), VilleUniv:char(20))
Doctorant(N°SS:int(13), Nom:char(20), NomUniv:char(50), VilleUniv:char(20),
EncadrePar=>Professeur)
Dépendances Fonctionnelles
Professeur :
♦ N°SS→ Nom, NomUniv, VilleUniv
♦ NomUniv→ VilleUniv
Doctorant :
♦ N°SS→ Nom, NomUniv, VilleUniv
♦ NomUniv→ VilleUniv
Formes normales
La schéma n'est pas en 3NF :
NomUniv→ VilleUniv
Normalisation en BCNF
Professeur (N°SS:int(13), Nom:char(20), NomUniv=>Univ)
Doctorant (N°SS:int(13), Nom:char(20), NomUniv=>Univ, EncadrePar=>Professeur)
Univ(Nom:char(50) , Ville:char(20))
116 Conception de bases de données
Implémentation SQL
Create Table Professeur (
N°SS INTEGER(13) PRIMARY KEY,
Nom CHAR(20) NOT NULL,
NomUniv CHAR(50) REFERENCES Univ(Nom));
Create Table Doctorant (
N°SS INTEGER(13) PRIMARY KEY,
Nom CHAR(20) NOT NULL,
NomUniv CHAR(50) REFERENCES Univ(Nom),
EncadrePar INTEGER(13) REFERENCES Professeur(N°SS) );
Create Table Univ(
Nom CHAR(50) PRIMARY KEY,
Ville CHAR(20) );
Question1
Quel attribut est la clé primaire de "t_personnes" ? Comment appelle-t-on ce genre de clé ? Quel est le statut de
"numss" ? Quel est le statut de "conjoint" ?
Question2
Expliquez pourquoi si "conjoint" référence la table "t_personnes", alors son domaine n'est pas correct.
Modifiez le domaine de "conjoint", puis ajouter une contraite à la table "t_personnes" pour que "conjoint" soit une
clé étrangère vers "t_personnes", en s'assurant que les contraintes d'intégrité référentielles seront respectées. Vous
utiliserez pour cela deux instructions ALTER.
Question3
Enoncez les DF du modèle relationnel sous-jacent à cette implémentation (en se fondant sur la vraisemblance) sous
la forme d'une couverture minimale des DFE.
A partir de la couverture minimale des DFE, prouvez que ce schéma est en 2NF mais pas en 3NF.
Question4
Proposez un programme SQL permettant de décomposer le schéma de cette BD afin qu'il soit en 3NF, sans perdre
d'information, sans perdre de DF et sans perdre les données déjà existantes dans la BD.
Pour ce faire vous utiliserez une instruction CREATE TABLE permettant de créer la nouvelle table engendrée par
la décomposition, puis une instruction INSERT permettant d'initialiser correctement cette nouvelle table avec les
valeurs existantes dans "t_personnes", et enfin deux instructions ALTER pour modifier la table "t_personne" de
façon à en supprimer la redondance et à établir la référence à la nouvelle table.
On fera l'hypothèse que la BD ne contient pas d'incohérence.
Normalisation, SQL LDD et LCD 117
Question5
A l'aide d'UML rétro-concevez le MCD qui aurait permis d'arriver directement à votre modèle après normalisation.
Justifiez.
On notera la présence des vues dans le schéma initial de la BD et l'on ne reportera pas sur ce schéma les clés
artificielles.
Question6
Ecrivez une requête qui compte le nombre de personnes qui ont le même chanteur préféré que leur conjoint.
On notera que cette requête est équivalente sur le schéma avant ou après normalisation.
Question7
Ecrivez un trigger en PL/SQL qui à assure que : X conjoint de Y implique Y conjoint de X ; X conjoint de X est
impossible ; et X conjoint de Y implique que X et Y sont de sexes opposés.
Cours
V
Access
Access est un SGBDR du monde Microsoft Windows qui présente des particularités intéressantes dans le cadre de ce cours. Il
propose une implémentation sticte des concepts relationnels, et ce dans un cadre facile d'accès techniquement : il constitue un
bon moyen d'accès aux technologies des BD. C'est également un outil intéressant pour prototyper des applications de BD ou
pour réaliser des applications finales dans des cadres d'usage restreint ou bureautique.
Objectifs pédagogiques
Découvrir un SGBD simple d'usage
Découvrir des principes de maquettage rapide d'application BD
Connaître les principes du langage de requête QBE et savoir lire une requête QBE
Connaître les éléments techniques de base pour apprendre à créer une BD sous Access
Connaître les éléments techniques de base pour apprendre à créer une application sous Access
Présentation d'Access
Access est un SGBDR et un outil de création d'application qui permet de :
♦ Créer des schémas relationnels et donc créer des tables, des contraintes sur les champs de ces tables et des contraintes
référentielles entre ces tables
♦ Saisir des données dans les tables, à travers une interface graphique standard, sans passer par l'instruction LMD INSERT
♦ Ecrire des requêtes en utilisant le langage SQL ou bien le formalisme graphique QBE [Query By Example]
♦ Réaliser des formulaires permettant d'alimenter ou interroger la BD
♦ Réaliser des états permettant de mettre en forme des résultats de requête
♦ Réaliser des macros permettant de programmer une application complète
♦ Réaliser des modules VBA permettant également de programmer une application complète, avec un spectre plus évolué
que celui des macros
120 Conception de bases de données
1.1. Avantages
♦ Rapidité de mise en oeuvre
♦ Facilité de maintenance ou reprise
♦ Rapidité de création d'IHM
♦ Langage graphique permettant un apprentissage rapide
♦ Schéma de données robustes (intégrité référentielle, contraintes, type de données, etc.)
♦ Utilisation restreinte aux plateformes Microsoft Windows
1.2. Inconvénient
♦ Fiabilité douteuse
♦ Résistance faible à la montée en charge
♦ Peu adapté à des logiques réseaux
♦ Système de sécurité non standard, complexe et inadapté
♦ Faiblesse des IHM pour des applications complexes
Séparation BD / Application
Pour créer une application complète sous Access, créer deux fichiers ".mdb", l'un contiendra la base de données
(uniquement les tables et les vues sous forme de requêtes), l'autre l'application (les formulaires, états, macros et
modules VBA).
Pour relier les deux applications, créer des tables liés dans le fichier "application", à l'aide du menu "Fichier /
Données externes / Lier les tables"
2.2. Domaine
Remarque
Le domaine est un type de données pour lequel on a éventuellement ajouté certaines contraintes supplémentaires
(telles que la taille du champs, la précision d'un numérique, des contraintes de validité restreingnant les valeurs
possibles, la présence ou non de la valeur de nullité, etc.)
Remarque : Enumération
Pour créer un type énumération, il faut partir d'un type de données standard, et restreindre le domaine aux valeurs
autorisées spécifiées par l'énumération. On utilise pour cela la propriété "Valide si" relative à l'attribut concerné,
avec une expression du type "Valeur1 ou Valeur2 ou ValeurN".
3. Contraintes
Attention
Dans Access le mot "relation" désigne en fait les contraintes d'intégrités référentielles, et non les tables comme c'est
le cas dans la terminologie relationnelle. Ceci est un abus de langage.
4. Vues
Sous Access, les objets "Requête" sont en fait des vues.
5. Requêtes LDD
Il est possible de spécifier des créations de schémas relationnel en utilisant le LDD de SQL classique sous Access.
Pour cela créer un objet requête, puis spécifier que c'est une requête SQL LDD à l'aide du menu "Requête", sous menu
"Spécifique SQL", commande "Définition de données".
1. Questions QBE
QBE permet la création de requête LMD en mode interactif, sans écrire de code.
Il faut pour cela :
1. Ajouter les tables
2. Réaliser les jointures en glissant-déposant une des propriétés à joindre sur l'autre.
3. Glisser-déposer les propriétés à projeter sur la grille
4. Effectuer les restrictions sur la ligne "critère" de la grille.
Problèmes de traduction
Des problèmes de traduction dans certaines versions d'Access conduisent à des formulations hasardeuses des
menus. Ainsi "Mettre à jour une requête" signifie "Requête de mise à jour" et "Supprimer une requête" signifie
"Requête de supression". L'erreur de traduction vient probablement du double sens de "Update query" et "Delete
query" en anglais...
Remarque : HAVING
Pour ajouter une clause HAVING, il suffit d'utiliser la ligne "critère" sous une propriété à laquelle est appliquée une
opération.
Access 125
2. Formulaires indépendants
Formulaire indépendants
Les formulaires indépendants ne sont pas liés à une table (leur propriété "Source" est vierge).
Ils servent à récupérer des valeurs en mémoire, dans des variables, avant d'en faire un traitement par programmation
(on pourra par exemple utiliser cette valeur dans une requête SQL LMD de type INSERT pour ajouter des
enregistrements dans une table.
Il est toujours possible de faire, avec un formulaire indépendant et une requête SQL, ce qu'il est possible de faire
avec un formulaire lié (et l'on peut bien entendu faire beaucoup plus)
Syntaxe : Utiliser une valeur saisie dans le contrôle d'un formulaire indépendant
Pour utiliser les valeurs indépendantes (en mémoire) de contrôle d'un formulaire, dans d'autres objets (formulaires, états,
requêtes, macros ou modules), utiliser la syntaxe suivante :
Formulaires!NomDuFormulaire!NomDuContrôle
3. Contrôles listes
Les listes déroulantes sont des contrôles très intéressants qui permettent de récupérer des valeurs dynamiques grâce à une
requête ou de spécifier des valeurs statiques parmi lesquelles l'utilisateur choisira.
♦ Pour que les valeurs de la liste soit définies dynamiquement à partir du résultat d'une requête, fixer la propriété "Origine
source" à la valeur "Table/Requête", puis écrire la requête dans la propriété "Contenu".
♦ Pour que les valeurs de la liste soit définies statiquement, fixer la propriété "Origine source" à la valeur "Liste Valeurs",
puis lister les valeurs en les séparant par des points-virgules dans la propriété "Contenu".
Access 127
1. Création de macro
Attention
Un objet "macro" est en fait un objet "groupe de macro". Il faudra toujours :
♦ Afficher la colonne "nom de macro" (menu Affichage / Nom de macro)
♦ Afficher la colonne "condition" (menu Affichage / Condition)
Une macro est définie par un nom (première colonne) et une succession d'instructions (actions dans la dernière colonne)
éventuellement soumises à des conditions d'exécution (seconde colonne). Chaque action requiert de fixer un certain nombre
de paramètres qui s'affiche dans la partie basse de l'interface après que l'action ait été sélectionnée.
4. Macro AutoExec
Si une macro porte le nom "AutoExec", elle sera exécutée automatiquement à l'ouverture de la base de données.
Cette macro peut servir typiquement à afficher un menu général d'entrée dans l'application.
Syntaxe
{Sub | Function} nom (param1 As type, ...) {As type retourné}
Dim variable1 As type
...
programme
{End Sub | End Function}
2. Fonctions à connaître
♦ Traitement de chaîne : LCase(S), UCase(S), Left(S, 1), Right(S, 1), Len(S), +, ...
♦ Génération aléatoire : Randomize, Rnd
♦ Gestion nombre : Cast : Int(),
3. Objets à connaître
♦ Recordset : méthodes MoveNext, MoveFirst, MoveLast, AddNew, Update, RecordCount, !nom_champs, ...
♦ QueryDef : méthode OpenRecordset, SQL, ...
♦ CurrentDb : méthodes openRecordset, CreateQueryDef, ...
For i = 0 To vChamps.Count - 1
If vChamps(i).Name = pChamps Then NumChamps = i
Next i
For i = 1 To vRs.RecordCount
Debug.Print vRs.Fields(NumChamps)
vRs.MoveNext
Next i
End Sub
For i = 0 To vChamps.Count - 1
If vChamps(i).Name = pChamps Then NumChamps = i
Next i
For i = 1 To vRs.RecordCount
Debug.Print vRs.Fields(NumChamps)
vRs.MoveNext
Next i
Exit_ParcoursTable:
Exit Sub
Erreur_ParcoursTable:
Debug.Print "Erreur"
MsgBox "Erreur"
End Sub
2. Run-time
♦ Ca existe
VBA
DoCmd.SetWarnings False
Macro
Avertissements=Non
http://access.developpez.com/faq/
http://access.developpez.com/faq/
Rst.MoveFirst
While not rst.EOF
' code
rst.MoveNext
Wend
ou
Do Until rst.EOF
' code
rst.MoveNext
Loop
http://access.developpez.com/faq/
Quand Access passe sur un point d'arrêt l'exécution du code s'arrête et attends une manoeuvre de votre part pour continuer.
132 Conception de bases de données
Quand le code est arrêté vous pouvez connaître la valeur des variables de votre code simplement en passant le pointeur de la
souris dessus.
Vous pouvez choisir de continuer à exécuter le code en mode pas à pas en appuyant sur F8.
Vous pouvez poursuivre l'exécution du code normalement avec F5.
http://access.developpez.com/faq/
Question Réponse 6. ! et .
L'opérateur "!" (point d'exclamation) indique que l'élément qui suit est défini par l'utilisateur (un élément d'une collection).
Par exemple, vous pouvez utiliser l'opérateur "!" pour faire référence à un formulaire ouvert, à un état ouvert, ou à un
contrôle figurant sur un formulaire ou sur un état.
L'opérateur "." (point) indique généralement que l'élément qui suit est défini par Microsoft Access. Par exemple, vous pouvez
utiliser l'opérateur "." pour faire référence à une propriété d'un formulaire, d'un état, ou d'un contrôle.
http://access.developpez.com/faq/
En résumé...
Access
A la fois un SGBDR pour créer des BD
et un outil de développement
d'applications
BD Application
Dimension relevant de la conception de Dimension relevant de la conception
BD. d'application.
Question1
Qu'exprime cette requête ?
Question2
Ecrivez une requête équivalente en SQL.
Cours
VI
Transactions
Les transactions sont une réponse générale aux problèmes de fiabilité et d'accès concurrents dans les BD, et en particulier
dans les BD en mode client-serveur. Elles sont le fondement de toute implémentation robuste d'une BD. Des systèmes
comme Oracle ne fonctionnent nativement qu'en mode transactionnel.
Objectifs pédagogiques
Comprendre les principes et l'intérêt des transactions
Apréhender la gestion des pannes dans les SGBD
Apréhender la gestion de la concurrence dans les SGBD
Connaître les syntaxes SQL standard, Oracle et Access pour utiliser des transactions
Maîtriser les modalités d'utilisation des transactions
La gestion de transactions par un SGBD est à la base des mécanismes qui permettent d'assurer le maintien de la cohérence
des BD. C'est à dire encore qu'il assure que tous les contraintes de la BD seront toujours respectées, même en cas de panne et
même au cours d'accès concurrents.
136 Conception de bases de données
1. Notion de transaction
Transaction
Une transaction est une unité logique de travail, c'est à dire une séquence d'instructions, dont l'exécution assure le
passage de la BD d'un état cohérent à un autre état cohérent.
Remarque
Tant qu'une transaction n'a pas été terminée correctement, elle doit être assimilée à une tentative ou une mise à jour
virtuelle, elle reste incertaine. Une fois terminée correctement la transaction ne peut plus être annulée par aucun
moyen.
Remarque
Les initiales de Atomicité, Cohérence, Isolation et Durabilité forme le mot mnémotechnique ACID.
Transactions 137
4. Transactions en SQL
Le langage SQL fournit trois instructions pour gérer les transactions.
Syntaxe : Début d'une transaction
BEGIN TRANSACTION
Cette syntaxe est optionnelle (voire inconnue de certains SGBD), une transaction étant débutée de façon implicite dès
qu'instruction est initiée sur la BD.
Remarque : Programme
Un programme est généralement une séquence de plusieurs transactions.
BEGIN
UPDATE compte
SET total=total-1000
WHERE nom="dupont";
IF vTotal<0 THEN
ROLLBACK;
ELSE
COMMIT;
END IF;
END;
♦ Synonyme : Log.
1. Les pannes
Une BD est parfois soumise à des défaillances qui entraînent une perturbation, voire un arrêt, de son fonctionnement.
On peut distinguer deux types de défaillances :
♦ Les défaillances système
ou défaillances douces (soft crash), par exemple une coupure de courant ou une panne réseau. Ces défaillances affectent
toutes les transactions en cours de traitement, mais pas la BD au sens de son espace de stockage physique.
♦ Les défaillances des supports
ou défaillances dures (hard crash), typiquement le disque dur sur lequel est stockée la BD. Ces défaillances affectent
également les transactions en cours (par rupture des accès aux enregistrements de la BD), mais également les données
elles-mêmes.
2. Point de contrôle
Point de contrôle
Un point de contrôle est une écriture dans le journal positionnée automatiquement par le système qui établit la liste
de toutes les transactions en cours (au moment où le point de contrôle est posé) et force la sauvegarde des données
alors en mémoire centrale dans la mémoire secondaire.
Le point de contrôle est positionné à intervale de temps ou de nombre d'entrées dans le journal prédéfinis.
Le dernier point de contrôle est le point de départ d'une reprise après panne, dans la mesure où c'est le dernier
instant où toutes les données ont été sauvegardées en mémoire non volatile.
♦ Synonyme : Syncpoint.
Transactions 139
Le schéma ci-après illustre les cinq cas de figure possibles pour une transaction au moment de la panne.
♦ Transactions de type T1
Elles ont débuté et se sont terminées avant tc. Elles n'interviennent pas dans le processus de reprise.
♦ Transactions de type T2
Elles ont débuté avant tc et se sont terminées entre tc et tf. Elles devront être rejouées (il n'est pas sûr que les données
qu'elles manipulaient aient été correctement inscrites en mémoire centrale, puisque après tc, or le COMMIT impose la
durabilité).
♦ Transactions de type T3
Elles ont débuté avant tc, mais n'était pas terminées à tf. Elles devront être annulées (pas de COMMIT).
♦ Transactions de type T4
Elles ont débuté après tc et se sont terminées avant tf. Elles devront être rejouées.
♦ Transactions de type T5
Elles ont débuté après tc et ne se sont pas terminées. Elles devront être annulées.
Remarque
Les transactions sont des unités d'intégrité.
♦ Transactions de type T1
Non prises en compte par l'algorithme.
♦ Transactions de type T2
Ajoutées à la liste UNDO (étape 1b) puis déplacée vers REDO (étape 2b) puis rejouée (étape 3b).
♦ Transactions de type T3
Ajoutées à la liste UNDO (étape 1b) puis annulée (étape 3a).
♦ Transactions de type T4
Ajoutées à la liste UNDO (étape 2a) puis déplacée vers REDO (étape 2b) puis rejouée (étape 3b).
♦ Transactions de type T5
Ajoutées à la liste UNDO (étape 2a) puis annulée (étape 3a).
On remarquera que pour que la reprise de panne soit en mesure de rejouer les transactions, la première action que doit
effectuer le système au moment du COMMIT est l'écriture dans le journal de cette fin correcte de transaction. En effet
ainsi la transaction pourra être rejouée, même si elle n'a pas eu le temps de mettre effectivement à jour les données dans
la BD, puisque le journal est en mémoire secondaire.
**
*
Transactions 141
On voit que la gestion transactionnelle est un appui important à la reprise sur panne, en ce qu'elle assure des états cohérents
qui peuvent être restaurés.
t1 LIRE T
t2 ... LIRE T
t3 UPDATE T ...
t4 ... UPDATE T
t5 COMMIT ...
t4 COMMIT
Exemple
LIRE COMPTE
t1
C=1000
LIRE COMPTE
t2 ...
C=1000
UPDATE COMPTE
t3 ...
C=C+100=1100
UPDATE COMPTE
t4 ...
C=C+10=1010
COMMIT
t5 ...
C=1100
COMMIT
t6
C=1010
t1 UPDATE T
t2 LIRE T ...
t3 ROLLBACK
Exemple
LIRE COMPTE
t1
C=1000
UPDATE COMPTE
t2
C=C+100=1100
LIRE COMPTE
t3 ...
C=1100
ROLLBACK
t4 ...
C=1000
UPDATE C
t5
C=C+10=1110
COMMIT
t6
C=1110
t1 LIRE T
t2 ... UPDATE T
t3 ... COMMIT
t4 LIRE T
Remarque
Le problème se pose bien que la transaction B ait été validé, il ne s'agit donc pas du problème d'accès à des données
non validées.
Exemple
LIRE COMPTE1
t1
C1=100
LIRE COMPTE 1
t2 ...
C1=100
t3 LIRE COMPTE 2
...
C2=100
t4 UPDATE COMPTE 1
...
C1=100-10=90
t5 UPDATE COMPTE 2
...
C2=100+10=110
t6 ... COMMIT
t7 LIRE COMPTE 2
C2=110
t8 CALCUL S
S=C1+C2=210
2. Le verrouillage.
Une solution générale à la gestion de la concurrence est une technique très simple appelée verrouillage.
Verrou
Poser un verrou sur un objet (typiquement un tuple) par une transaction signifie rendre cet objet innaccessible aux
autres transactions.
♦ Synonyme : Lock.
Verrou partagé
Un verrou partagé, noté S, est posé par une transaction lors d'un accès en lecture sur cet objet.
Un verrou partagé interdit aux autres transaction de poser un verrou exclusif sur cet objet et donc d'y accéder en
écriture.
Verrou exclusif
Un verrou exclusif, noté X, est posé par une transaction lors d'un accès en écriture sur cet objet.
Un verrou exclusif interdit aux autres transactions de poser tout autre verrou (partagé ou exclusif) sur cet objet et
donc d'y accéder (ni en lecture, ni en écriture).
Règles de verrouillage
Soit la transaction A voulant poser un verrou S sur un objet O
1. Si O n'est pas verrouillé alors A peut poser un verrou S
2. Si O dispose déjà d'un ou plusieurs verrous S alors A peut poser un verrou S
3. Si O dispose déjà d'un verrou X alors A ne peut pas poser de verrou S
3. Le déverrouillage.
Déverrouillage
Lorsqu'une transaction se termine (COMMIT ou ROLLBACK) elle libère tous les verrous qu'elle a posé.
♦ Synonyme : Unlock.
144 Conception de bases de données
LIRE T
t1
Verrou S
LIRE T
t2 ...
Verrou S
UPDATE T
t3 ...
Attente...
... UPDATE T
t4
Attente... Attente...
... Inter-blocage
Remarque
Le problème de perte de mise à jour est réglé, mais soulève ici un autre problème, celui de l'inter-blocage.
UPDATE T
t1
Verrou X
LIRE T
t2 ...
Attente...
ROLLBACK
t3
Libération du verrou X
t4 Verrou S
LIRE T
t1
Verrou S
UPDATE T
t2 ...
Attente...
t3 LIRE T ...
Verrous S
... ... libération des verrous ... ... reprise de la transaction ...
6. Inter-blocage
Inter-blocage
L'inter-blocage est le phénomène qui apparait quand deux transactions (ou plus, mais généralement deux) se
bloquent mutuellement par des verrous posés sur les données. Ces verrous empêchent chacune des transactions de
se terminer et donc de libérer les verrous qui bloquent l'autre transaction. Un processus d'attente sans fin s'enclenche
alors.
Les situations d'inter-blocage sont détectées par les SGBD et gérées, en annulant l'une, l'autre ou les deux
transactions, par un ROLLBACK système. Les méthodes utilisées sont la détection de cyle dans un graphe d'attente
et la détection de délai d'attente trop long.
Délai d'attente
Principe de décision qu'une transaction doit être abandonnée (ROLLBACK) lorsque son délai d'attente est trop
long.
Ce principe permet d'éviter les situations d'inter-blocage, en annulant une des deux transactions en cause, et en
permettant donc à l'autre de se terminer.
♦ Synonyme : Timeout.
COMMIT;
Validation effectuée.
ROLLBACK;
Annulation (rollback) effectuée.
DECLARE
minX TransTest.X%TYPE;
BEGIN
UPDATE TransTest SET X=X-1;
SELECT min(X) INTO minX FROM TransTest;
IF minX < 0 THEN
ROLLBACK;
ELSE
COMMIT;
END IF;
END;
Première exécution
X
---
1
2
X
---
0
1
Seconde exécution
X
---
0
1
X
---
0
1
Transactions 147
3. Simulation de panne
CREATE TABLE TransTest (X number(1));
INSERT INTO TransTest VALUES (1);
COMMIT;
DECLARE
i number(5);
BEGIN
i:=0;
WHILE i=0 LOOP
i:=0;
END LOOP;
END;
COMMIT;
Exécution
Table créée.
1 ligne créée.
Validation effectuée.
1 ligne créée.
X
---
1
2
COMMIT;
Validation effectuée.
En résumé...
Transactions
Unité logique de travail pour assurer la
cohérence de la BD même en cas de
pannes ou d'accès concurrents.
Question1.1
Réaliser la conception complète de la BD
Transactions 149
Enoncé n°2
Soient les évènements suivants survenants sur la BD :
♦ Le client Robert Dupont est créé dans l'agence du centre ville de Compiègne, qui vient d'ouvrir.
♦ Le client Alphonse Durand est créé dans la même agence, mais il veut également un compte d'épargne sur lequel il dépose
tout de suite 1000€ .
♦ Le client Robert Dupont dépose deux chèques de 100€ sur son compte courant.
♦ Le client Alphonse Durand transfère 500€ de son compte d'épargne à son compte courant.
Question2.1
Ecrire le code SQL permettant de traiter ces évènements, sans utiliser de transactions.
Enoncé n°3
Suite à des problèmes de coupure réseaux, on constate des problèmes sur les comptes. Ainsi suite à l'exécution des opérations
précédentes, la requête suivante renvoie des résultats érronés.
SELECT tCompteCourant.fkClient AS N, tCompteCourant.aSolde + NVL(tCompteEpargne.aSolde,0) AS
SoldeDeTousComptes
FROM tCompteCourant LEFT JOIN TCompteEpargne
ON tCompteCourant.fkClient=TCompteEpargne.fkClient ;
N SoldeDeTousComptes
2 500
1 100
Question3.1
Expliquez à quoi peuvent être dus les problèmes rencontrés
Indice
La fonction NVL renvoie comme valeur le second paramètre, si le premier à pour valeur NULL.
Question3.2
Proposez une solution permettant d'assurant la cohérence des opérations, en aménageant cotre code SQL.
Cours
VII
Oracle
Oracle est un SGBD très intéressant du point de vue de ce cours. Historiquement c'est le premier SGBDR a avoir été mis sur
le marché, c'est encore aujourd'hui le leader mondial du domaine. Oracle propose une implémentation très large des principes
avancées de SGBD (triggers, RO [Relationnel-Objet], etc.). Si Oracle (à l'instar des autres produits commerciaux tels que
SQL Server de Microsoft ou DB2 d'IBM) est de plus en plus concurrencé par les produits Open Source (tels que PosgreSQL
et MySQL), il reste un bon terrain d'apprentissage généraliste sur le sujet. Ainsi la connaissance d'Oracle permettra le passage
à PosgreSQL ou MySQL sans difficulté.
Les principaux inconvénients d'Oracle restent son coûts d'achat ainsi que sa complexité dès lors que l'on s'attache à des
implémentations robustes et performantes en situation réelle.
Présentation
♦ Le premier SGBDR commercialisé en 1979
♦ Il occupe actuellement la première place dans le marché des SGBDR (avec IBM)
♦ Evolutions du produit :
- depuis la version 7, architecture client-serveur
- depuis la version 8, le serveur est objet-relationnel
- depuis la version 8i, intégration de couches applicatives Web et multimédia
- depuis la version 9i, intégration de types de données XML, extension des couches Web et introduction de fonctions de
data warehousing et de business intelligence
♦ Il fonctionne sous Unix, Linux, Windows.
♦ Site officiel en France :
♦ Il est possible de télécharger gratuitement Oracle à des fins de développement et de prototypage :
1. Types de données
♦ NUMBER(e,d)
♦ DATE
♦ CHAR(l), VARCHAR2(lmax)
♦ LONG, CLOB, BLOB, BFILE
152 Conception de bases de données
Remarque
♦ Pas de données booléennes
2. Particularités LMD
♦ L'opération relationnelle de différence s'écrit MINUS (au lieu de EXCEPT en SQL)
♦ UNION ALL (une opération d'union qui ne supprime pas les doublons)
♦ LEFT JOIN peut s'écrire grâce à l'opérateur "(+)" utilisé dans la clause WHERE : SELECT x,y FROM t1,t2 WHERE
y(+)=x;
Remarque
Les expressions mathématiques contenant une valeur Null sont systématiquement évaluées à Null.
"SELECT x+y FROM t;" renverra des valeurs Null, si x ou y ont la valeur Null.
Remarque
Le AS servant pour le renommage de colonne est optionnel.
3. Opérateur de concaténation
♦ Concatène des colonnes ou chaînes de caractères avec d'autres colonnes
♦ Est représenté par deux barres verticales : ||
♦ La colonne résultante est une expression caractère
Exemple
SELECT Attribut1 || Attribut2 AS "A1+A2" FROM...
4. Les séquences
♦ Objet partageable, s'utilise en générale pour créer une valeur de clé primaire artificielle.
♦ Génère automatiquement des numéros uniques
Remarque : user_sequences
Table du catalogue où se trouvent les informations concernant les séquences.
5. Fonctions à connaître
Les fonctions "mono-ligne" :
♦ Manipulent des éléments de données
♦ Acceptent des arguments et rendent des valeurs
♦ Agissent sur chaque ligne
♦ Ramènent un seul résultat par ligne
♦ Peuvent modifier les types de données
Méthode
Utiliser les fonctions mono-ligne pour :
♦ Transformer les données
♦ Formater des dates et des nombres pour l'affichage
♦ Convertir des types de données de colonnes
♦ Etc.
6. Dictionnaire de données
Collection des tables créées et maintenues par le serveur Oracle.
Contient des informations sur les objets de base de données existants.
♦ Describe nom_objet
1. Présentation
♦ Environnement Oracle d'exécution du SQL.
♦ L'environnement SQL*PLus ne travaille ni sur le contenu ni sur la structure.
2. Quelques commandes
♦ Largeur de la colonne : An
♦ Chiffre (avec ou sans zéro à gauche) : 9 / 0
♦ Symboles monétaires : $ / L
♦ Séparateurs de virgule et de milliers : . / ,
♦ etc.
Exemple
COLUMN ename FORMAT A15
COLUMN sal FORMAT $99,990.00
COLUMN mgr FORMAT 999999999
Options supplémentaires
♦ HEADING nom de l'entête
♦ JUSTIFY left | right | center
♦ NULL text
♦ etc.
1. Présentation
1.1. Description
♦ Langage de programmation d'Oracle.
♦ Permet une manipulation procédurale de requêtes SQL.
1.2. Avantages
♦ Intégration
Il est possible d'écrire des fonctions complexes de manipulation de données sans recourir à un langage externe.
♦ Amélioration des performances
Le code PL/SQL est très proche du moteur Oracle. De plus pour le code stocké, les requêtes qu'il manipule sont
pré-compilées, et donc son exécution est optimisée.
3.1. Anonyme
Syntaxe
[DECLARE]
...
BEGIN
...
[EXCEPTION]
...
END
3.2. Procédure
Syntaxe
PROCEDURE nom_proc
IS
...
BEGIN
...
[EXCEPTION]
...
END
3.3. Fonction
Syntaxe
FUNCTION nom_func
RETURN type_retourné
IS
...
BEGIN
...
RETURN valeur;
[EXCEPTION]
...
END
4.3. Triggers
Bloc anonyme stockés dont l'exécution est contrôlée par des évènements sur les données.
Oracle 157
5. Variables
♦ Scalaires
VARCHAR, DATE, CHAR, LONG, BOOLEAN, INTEGER
♦ Composées
RECORD
Déclaration d'un type RECORD : TYPE nom_type IS RECORD (déclaration de propriétés);
Déclaration d'une variable enregistrement de ce type : nom_variable nom_type;
♦ Curseurs
Permettent de manipuler des résultats de requête.
6. Variables scalaires
Syntaxe
identifiant [CONSTANT] type [NOT NULL] [:= valeur];
Exemple
v_deptno NUMBER(2) NOT NULL := 10;
v_hiredate DATE;
v_location VARCHAR2(13) := 'Atlanta';
c_comm CONSTANT NUMBER := 1400;
nom_table.nom_colonne%TYPE
7. Affectation classique
Syntaxe
variable := valeur | variable
Exemple
x:=10;
x:=y;
Exemple
DECLARE
v_deptno NUMBER(2);
v_loc VARCHAR2(15);
BEGIN
SELECT deptno, loc
INTO v_deptno, v_loc
FROM dept
WHERE dname = 'SALES';
...
END;
158 Conception de bases de données
9. Affichage à l'écran
Syntaxe
SET SERVEROUTPUT ON
BEGIN
DBMS_OUTPUT.PUT_LINE ('Hello World');
END;
Remarque : Erreur
Si l'exécution du trigger échoue, l'action (insert, update ou delete dans la table) est annulée (et retourne une erreur
Oracle).
Syntaxe : Trigger
create [or replace] trigger nom_trigger {before|after}
[insert or][update [of nom_colonne] or][delete]
on nom_Table
[for each row [when (condition)] ]
begin
instructions
end;
160 Conception de bases de données
Attention
Il ne faut pas modifier de données dans les colonnes des "primary key", "foreign key", ou "unique key" d'une table.
Attention
Il ne faut pas lire des données d'une table en cours de modification autrement que par les accès ":old" et ":new".
Prédicats pour savoir dans quel contexte d'appel du trigger on est, ce qui permet dans un même trigger de s'adapter aux
différents cas de déclenchement.
Oracle 161
1. Définition de données
Création des tables
CREATE TABLE tIntervenant (
pkNom char(20) primary key,
aPrenom char(20) not null,
aPoste number(4),
aBureauCentre char(2) check (aBureauCentre='BF' or aBureauCentre='R' or
aBureauCentre='PG'),
aBureauBat char(1) check (aBureauBat>'A' and aBureauBat<'M'),
aBureauNum number(3)
);
SEQUENCE_NAME
------------------------
TCOURSSEQ
2. Triggers
Calcul de valeur dérivée
CREATE TRIGGER trCours
after insert on tCours
BEGIN
UPDATE tCours
SET aDateFin=aDateDebut+5;
END;
/
Archivage de données
CREATE TABLE tIntervenantSav (
pkNom char(20) primary key,
aPrenom char(20) not null
);
3. Fonctions
Etude de lien inverse
CREATE FUNCTION fIntervient (pIntervenant varchar2)
RETURN varchar2
IS
vNbInterventions number;
BEGIN
SELECT Count(fkIntervenant) INTO vNbInterventions
FROM tCours
WHERE fkIntervenant=pIntervenant;
4. Initialisation de données
Ajout de données
INSERT INTO tIntervenant (pkNom, aPrenom, aPoste)
VALUES ('CROZAT', 'STEPHANE', '4287');
INSERT INTO tCours (pkAnnee, pkSemestre, pkNum, aTitre, aType, aDateDebut, fkIntervenant)
VALUES ('2003', 'P', tCoursSeq.NEXTVAL, 'Introduction','C', '01-JAN-2001', 'CROZAT');
INSERT INTO tCours (pkAnnee, pkSemestre, pkNum, aTitre, aType, aDateDebut, fkIntervenant)
VALUES ('2003', 'P', tCoursSeq.NEXTVAL, 'Introduction','C', '01-JAN-2001', 'CROZAT');
PKNUM ADATEFIN
--------------
1 06/01/01
2 06/01/01
Suppression de données
DELETE FROM tCours;
DELETE FROM tIntervenant;
PKNOM APRENOM
--------------------
CROZAT STEPHANE
PKNUM
----------
2
Oracle 163
5. Procédures
Ajout de données et exception
CREATE PROCEDURE pInsertIntervenant (pNom varchar2, pPrenom varchar2)
IS
BEGIN
INSERT INTO tIntervenant (pkNom, aPrenom)
VALUES (pNom, pPrenom);
EXCEPTION
when DUP_VAL_ON_INDEX then
DBMS_OUTPUT.PUT_LINE('Intervenant déjà existant : ' || pNom);
when others then
RAISE;
END;
/
Traitement de données et curseur
CREATE PROCEDURE pAfficheIntervenants
IS
CURSOR cIntervenants IS
SELECT pkNom, aPrenom FROM tIntervenant;
vNom varchar2(20);
vPrenom varchar2(20);
BEGIN
DBMS_OUTPUT.PUT_LINE('** Liste des intervenants **');
OPEN cIntervenants;
LOOP
FETCH cIntervenants INTO vNom, vPrenom;
EXIT WHEN cIntervenants%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('-' || vPrenom || vNom);
END LOOP;
END;
/
6. Questions
Mise en forme d'état
SET LINESIZE 100
SET PAGESIZE 100
COLUMN Titre FORMAT A30
COLUMN Intervenant FORMAT A30
COLUMN aDateDebut HEADING Du
COLUMN aDateFin HEADING Au
COLUMN Sem FORMAT A5
Nom Intervient
--------------------
CROZAT OUI
Jouglet NON
Agrégat et jointure gauche
UPDATE tCours SET aDuree=2;
Nom CHARGE
--------------------
CROZAT 2
Jouglet 0
164 Conception de bases de données
7. Scripts
Exécution
SET SERVEROUTPUT ON
@ "C:\nf17.oracle\nf17.ldd.sql";
@ "C:\nf17.oracle\nf17.ldd.fonctions.sql";
@ "C:\nf17.oracle\nf17.lmd.init.sql";
@ "C:\nf17.oracle\nf17.lmd.question.sql";
Test de procédures
BEGIN
DBMS_OUTPUT.PUT_LINE('*** Programme indépendant ***');
pInsertIntervenant('Jouglet', 'Antoine');
pAfficheIntervenants;
EXCEPTION
when others then
RAISE;
END;
/
Question1
Ecrivez le code SQL pour créer cette table sous Oracle.
Question2
Vérifier que la table a bien été créée.
Indice
Utiliser DESCRIBE.
Question3
Modifier la table EMPLOYEE pour pouvoir allonger les noms de famille des employés à 50 caractères. Vérifiez
cette modification.
Question4
Vérifiez l'existence de la table EMPLOYEE dans le dictionnaire de données.
Indice
Faites une requête de sélection sur la table du dictionnaire USER_TABLES.
Question5
Ajouter une contrainte PRIMARY KEY de niveau de table dans la table EMPLOYEE en utilisant la colonne ID.
Question6
Vérifier que la contrainte a bien été ajoutée en utilisant la table USER_CONSTRAINTS ainsi que dans le mode
graphique.
Oracle 165
Question7
Rechercher les noms et types d'objets dans la vue USER_OBJECTS du dictionnaire de données correspondant à la
table EMPLOYEE.
Question8
Modifier la table EMPLOYEE. Ajouter une colonne SALARY de type NUMBER avec une précision 7.
Question9
Renommez la table EMPLOYEE en EMPLOYEE2.
Question10
Supprimez la table EMPLOYEE2.
Question2
Afficher le nom et la date d'embauche ("hiredate") des employés embauchés entre le 20 février 1981, et 1 mai 1981.
Classez le résultat par date d'embauche.
Indice
Attention à l'utilisation du format "YY" qui pose des problème vis à vis du passage à l'an 2000, préférer le format
"YYYY".
Question3
Afficher le nom de tous les employés, dont le nom contient deux fois la lettre "L".
Question4
Afficher le nom, poste et salaire ("sal') de tous les personnes qui ont comme poste 'Clerk' ou 'Analyst' et dont le
salaire est différent de $1000, $3000, ou $5000.
Question5
Afficher le nom de chaque employé et calculer le nombre de mois qu'il a travaillé jusqu'à ce jour (après l'avoir
arrondi celui-ci à la plus proche valeur entière). Nommer la colonne MONTHS_WORKED.
Question6
Ecrivez la requête qui affiche pour chaque employé le résultat suivant :
"X" gagne "Y" par mois mais il veut "3 fois Y".
Nommer la colonne SALAIRES DE REVES.
Question7
Afficher le salaire maximum, minimum, la somme des salaires et le salaire moyen de tous les employés. Nommer
les colonnes respectivement Maximum, Minimum, Sum, and Average. Arrondissez les résultats à zéro décimales.
166 Conception de bases de données
En résumé...
Oracle
VIII
Relationnel-objet
Si le modèle logique relationnel a prouvé sa puissance et sa fiabilité au cours des 20 dernières années, les nouveaux besoins
de l'informatique industrielle ont vu l'émergence de structures de données complexes mal adaptées à une gestion
relationnelle. La naissance du courant "orienté objet" et des langages associées (Java et C++ par exemple) ont donc
également investi le champ des SGBD afin de proposer des solutions pour étendre les concepts du relationnel et ainsi mieux
répondre aux nouveaux besoins de modélisation.
Partie A. Relationnel-objet
Objectifs pédagogiques
Comprendre les limites du modèle relationnel
Comprendre pourquoi et comment le modèle relationnel peut être étendu
3. Les SGBDOO
Les SGBDOO ont été créés pour gérer des structures de données complexes, en profitant de la puissance de modélisation des
modéles objets et de la puissance de stockage des BD classiques.
Explication
Les SGBDOO apportent donc des concepts fondamentaux pour l'évolution des BD, mais leur réalité est encore en
grande partie du domaine de la recherche ou d'applications "de niche".
Ils apportent donc une innovation sur des aspects que les SGBDR ne savent pas faire, mais sans être au même
niveau sur ce que les SGBDR savent bien faire.
Une description des principes et apports des SGBDOO, en perspectives des autres modèles de gestion de données.
4. Les SGBDRO
Les SGBDRO sont nés du double constat de la puissance nouvelle promise par les SGBDOO et de l'insuffisance de leur
réalité pour répondre aux exigences de l'industrie des BD classiques. Leur approche est plutôt d'introduire dans les SGBDR
les concepts apportés par les SGBDOO plutôt que de concevoir de nouveaux systèmes.
Objectifs pédagogiques
Connaître les caractéristiques principales du modèle relationnel-objet
Comprendre les avantages du modèle relationnel-objet
1. Les SGBDRO
Modèle relationnel-objet
Modèle relationnel étendu avec des principes objet pour en augmenter les potentialités.
2. Le modèle imbriqué
♦ nested model
♦ La 1NF est relachée pour permettre d'affecter des valeurs non atomiques à un attribut, pour modéliser des objets
complexes.
♦ Gestion directe des attributs multivalués, sans passer par une nouvelle relation
♦ Gestion directe des attributs composés
♦ Un attribut ne sera plus seulement valuée par une valeur simple, mais pourra l'être par une collection d'objets complexes
Exemple
Syntaxe
Type nom_type : <
attribut1 typeattribut1,
attribut2 typeattribut2,
...
attributN typeattributN,
=methode1 (paramètres) typeretourné1,
=methode2 (paramètres) typeretourné2,
=...
=methodeN (paramètres) typeretournéN
>
Remarque
Les type des attributs ou des méthodes d'un type peuvent également être des types utilisateurs.
4. Les collections
Collection
Une collection est un type de données générique défini afin de supporter les attributs multi-valués.
Syntaxe
Type nom_type : collection de <type_objet>
Remarque
Les objets d'une collection peuvent être d'un type utilisateur.
auteurslivres(idauteur=>auteur, ISBN=>document
On conseillera de consulter l'exemple (pages 331-338) qui offre une comparaison entre deux implémentations, une
relationnelle et une relationnelle-objet, d'un même modèle conceptuel (UML).
172 Conception de bases de données
6. Tables d'objets
Une table peut être définie en référençant un type de données plutôt que par des instructions LDD classiques.
On parle alors de table d'objets.
Syntaxe
nom_table de nom_type (attributs_clés)
Remarque : OID
Une telle définition de table peut permettre d'identifier les objets par un OID [Object Identifier]
Remarque : Héritage
Cette modalité de définition de schéma permet de profiter de l'héritage de type pour permettre l'héritage de schéma
de table.
Syntaxe
Type sous_type hérite de type : <
attributs et méthodes spécifiques
>
Avantages
♦ Permet de créer des associations entre des objets sans effectuer de jointure (gain de performance).
♦ Fournit une identité à l'objet indépendamment de ses valeurs (clé artificielle).
♦ Fournit un index de performance maximale (un seul accès disque).
♦ Permet de garder en mémoire des identificateurs uniques dans le cadre d'une application objet, et ainsi gérer la persistance
d'objets que l'on ne peut pas garder en mémoire, avec de bonnes performances (alors que sinon il faudrait exécuter des
requêtes SQL pour retrouver l'objet)[Voir exemple "Cadre d'usage" ci-après].
Inconvénient
♦ Plus de séparation entre le niveau logique et physique.
♦ L'adresse physique peut changer si le schéma de la table change (changement de la taille d'un champs par exemple)
♦ Manipulation des données plus complexes, il faut un langage applicatif au dessus de SQL pour obtenir, stocker et gérer
des OID dans des variables.
En effet si le nombre d'objets est trop grand, les objets ne peuvent tous être conservés en mémoire vive par
l'application objet qui les manipule. Il est alors indispensable de les faire descendre et remonter en mémoire
régulièrement. Or dans le cadre d'un traitement portant sur de très nombreux objets, la remonté en mémoire d'un
objet est un point critique en terme de performance. A fortiori si l'identification de l'objet à remonter demande une
interrogation complexe de la BD, à travers de nombreuses jointures. Le fait d'avoir conservé en mémoire un OID
permet de retrouver et de recharger très rapidement un objet, sans avoir à le rechercher à travers des requêtes SQL
comportant des jointures et donc très couteuses en performance.
Remarque : Débat
la communauté des BD est plutôt contre les OID, qui rompent avec la séparation entre manipulation logique et
stockage physique des données.
La communauté objet est à l'origine de l'intégration des OID dans SQL3, en tant qu'ils sont une réponse au
problème de persistence dans les applications objets.
Objectifs pédagogiques
Savoir déduire un modèle logique relationnel-objet depuis un modèle conceptuel E-A ou UML.
Intégrer les apports du modèle relationnel-objet par rapport au relationnel dans ce processus
1. Entité
Pour chaque entité, créer un type d'objet avec les attributs de l'entité.
Créer une table d'objets de ce type pour instancier l'entité, en ajoutant les contraintes d'intégrité.
2. Attributs composites
Pour chaque type d'attribut composé, créer un type d'objet.
3. Attributs multi-valués
Pour chaque attribut multi-valué créer une collection du type de cet attribut.
Remarque : Attributs composites multi-valués
Si l'attribut multi-valué est composite, alors créer une collection d'objets.
4. Attributs dérivés
Pour chaque attribut dérivé créer une méthode associée au type d'objet de l'entité.
5. Association 1:N
Les associations 1:N sont gérées comme en relationnel.
On peut néanmois favoriser l'usage d'objets pour les clés étrangères composées de plusieurs attributs, ainsi que pour les
attributs migrants de l'association vers le relation côté N.
Il est aussi possible de gérer la clé étrangère avec un OID à la place d'une clé étrangère classique.
174 Conception de bases de données
6. Association N:M
Les associations N:M peuvent être gérées comme en relationnel.
Il est aussi possible de gérer ces relations, en utilisant une collection de références (une collection de clés étrangères) (NB :
on favorise ainsi une des deux relations).
Il est aussi possible de gérer ces relations en utilisant un OID comme clé étrangère.
Il est aussi possible de gérer ces relations en utilisant une collection de référence OID.
7. Héritage
L'héritage est géré comme en relationnel classique, avec la possibilité de profiter de l'héritage de type pour éliminer la
redondance dans la définition des schémas.
En résumé...
Types
En général il est préférable de transformer comme pour le relationnel, avec une clé étrangère. Il est néanmoins
possible d'utiliser des nested tables, mais dans ce cas les tuples de la table côté N deviennent de simples attributs
(composites) de la table côté 1 (il ne pourront plus être référencés à leur tour par exemple). Si cela ne pose pas de
problème et que cela simplifie l'implémentation, le modèle imbriqué peut être choisi à la place du référencement par
la clé étrangère.
Relationnel-objet 175
Lorsque l'on choisit une transformation de l'association N:M par une collection de références, la référence ne se fait
que dans un sens, au choix, le sens inverse peut-être retrouvé par parcours de la table référençante. Bien sûr, dans ce
cas, une relation est favorisée par rapport à l'autre en terme de performance de recherche notamment.
Recopier la référence dans les deux sens n'est pas souhaitable, car elle introduit de la redondance, mais l'on peut
néanmoins le faire si les performances l'exige et si l'on contrôle cette redondance.
Question2
Transformation des associations, en fonction des cardinalités. Transformation des compositions. Transformation des
classes d'association.
Question3
Transformation des attributs, en gérant les attributs multi-valués et dérivés.
Question4
Transformation des relations d'héritage.
Question5
Transformation des méthodes.
Cours
IX
SGBDRO
Objectifs pédagogiques
Connaître les extensions SQL proposées par l'implémentation du modèle relationnel-objet
Savoir implémenter un modèle logique exprimé en relationnel-objet dans un SGBDRO
Les SGBDRO sont un compromis entre les SGBDR classiques, fiables et puissants, mais limités conceptuellement pour la
gestion de données complexes et les SGBDOO conceptuellement très intéressant, mais technologiquement limités pour des
applications industrielles classiques.
Oracle propose à partir de sa version 8 et plus encore depuis la 9i des extensions qui permettent une implémentation de
modèle logique relationnel-objet. Ce nouveau modèle, encore naissant dans le monde industriel, semble promis à un avenir
intéressant et d'autres systèmes, comme PosgreSQL, en proposent également des implémentations évoluées.
Partie A. Implémentation du RO
Objectifs pédagogiques
Connaître l'extension du LDD, et en particulier les types abstrait, les relations imbriquées et l'héritage.
Connaître l'exension du MDL pour naviguer dans les objets manipulés
3. Nested tables
Implémentation des collections sous forme de tables imbriquées.
Syntaxe : Déclaration de type de données
--Création d'un type abstrait d'objet
CREATE TYPE nom_type AS OBJECT (...);
4. Tables d'objets
Implémentation d'une définition de table depuis un type.
Syntaxe : Déclaration de type de données
CREATE TABLE nom_table_principale OF nom_type (;
PRIMARY KEY(attribut1),
attribut2 NOT NULL,
UNIQUE (attribut3)
FOREIGN KEY (attribut4) REFERENCES ...
);
Remarque : Méthodes
Si le type sur lequel s'appuie la création de la table défini des méthodes, alors les méthodes seront associées à la
table.
Remarque : Contraintes
Il est possible, sur une table ainsi définie, de spécifier les mêmes contraintes que pour une table créée avec une
clause CREATE TABLE (contraintes de table). Ces contraintes doivent être spécifiées au moment de la création de
la table, et non au moment de la création du type. (bien que la définition d'objet permet de spécifier des contraintes
du type NOT NULL, etc.)
5. Insertion d'objets
La manipulation de données est étendue pour assurer la gestion des objets et des collections.
SGBDRO 179
SELECT t2.*
FROM t t1, TABLE(t1.nt) t2;
COLUMN_VALUE
TITRE COLUMN_VALUE
-----------------------------
Malvil 1
Malvil 2
TITRE NOM
-----------------------------
Malvil Merle
Malvil Barjavel
8. Manipulation d'OID
Une table d'objets, i.e. créée depuis un type, dispose d'un OID pour chacun de ses tuples.
Cet OID est accessible depuis la syntaxe REF dans une requête SQL.
Syntaxe : REF
SELECT REF(alias)
FROM nom_table alias
Exemple : OID
0000280209DB703686EF7044A49F8FA67530383B36853DE7106BC74B6781275ABE5A553A5F01C000340000
SELECT t.clé_étrangère.attribut_table2
FROM table1 t;
SGBDRO 181
Objectifs pédagogiques
Savoir déduire un modèle logique relationnel-objet depuis un modèle conceptuel E-A ou UML.
Intégrer les apports du modèle relationnel-objet par rapport au relationnel dans ce processus
1. Gestion de cours
Modèle conceptuel
Modèle logique
Type Bureau : <
poste:entier,
centre:chaîne,
bâtiment:chaîne,
numéro:entier,
=coordonnées():chaîne
>
Implémentation
CREATE TYPE Bureau AS OBJECT (
poste number(4),
centre char(2),
batiment char(1),
numero number(3),
MEMBER FUNCTION coordonnees RETURN varchar2
);
CREATE TYPE BODY Bureau
IS
MEMBER FUNCTION coordonnees RETURN varchar2
IS
BEGIN
RETURN centre||batiment||numero||' - poste '||poste;
END;
END;
Initialisation
INSERT INTO tIntervenant VALUES ('CROZAT', 'Stéphane', Bureau('4287','R','A',108));
INSERT INTO tIntervenant VALUES ('JOUGLET', 'Antoine', Bureau('4423','R','C',100));
QUI OU
-------------------------------------
CROZAT Stéphane R A108 - poste 4287
JOUGLET Antoine R C100 - poste 4423
SELECT c.pkSemestre AS Quand,c.aTitre AS Quoi,ci.Nom AS Qui
FROM tCours c, TABLE(c.lIntervenant) ci;
Modèle logique
Type Intervenant : < nom:chaîne, prénom:chaîne >
tIntervenant de Intervenant (nom)
Implémentation
CREATE TYPE Intervenant AS OBJECT (
pkNom varchar2(50),
aPrenom varchar2(50)
);
PKNUM PKNOM
-------------------------
1 CROZAT
2 CROZAT
Sélection : Navigation d'objets
SELECT pkNum, c.fkIntervenant.pkNom
FROM tCours c
PKNUM PKNOM
-------------------------
1 CROZAT
2 CROZAT
Type Directeur : <nom :chaîne, prenom : chaîne, date_nais date, =Age() : entier>
Type Produit : <num: entier, designation: chaîne, prix: réel>
Type RefProduit :<oidProduit REF Produit, qte: entier>
Type ListRefProduit : collection de <RefProduit>
Type Entreprise : <n_siret : entier, nom : chaîne, oidDirecteur REF Directeur, lProduit :
ListRefProduit, =impot(percent IN réel) : réel>
TAB. 25 : TDIRECTEUR
1 Chocolat BIGHAND 2
2 Bonbon TICTOC 4
3 Mecano3 140
4 BiBa4 200
TAB. 26 : TPRODUIT
Question1
Soit la méthode impot implémentée comme suit.
begin
imp:=0;
for i in 1..self.lProduit.count loop
refProd:=self.lProduit(i);
select deref(refProd.oidProduit) into prod from dual;
imp:=imp+refProd.qte*prod.prix;
end loop;
return imp*percent;
end;
end;
Cette méthode peut-elle servir à renvoyer l'impôt à payer si cet impôt est un pourcentage du chiffre d'affaire ?
Justifier.
Question2
Soit le déclencheur monTrigger implémenté comme suit.
SET SERVEROUTPUT ON ;
DECLARE
prod2 REF Produit;
prod1 REF Produit;
prod3 REF Produit;
prod4 REF Produit;
direc2 REF Directeur;
direc1 REF Directeur;
BEGIN
update tEntreprise
set lProduit=listRefProduit(refProduit(prod1,6000),refProduit(prod2,4000))
where n_siret=1;
update tEntreprise
set lProduit=listRefProduit(refProduit(prod3,10),refProduit(prod4,20))
where n_siret=2;
END;
SGBDRO 187
Question3
Ecrivez une requête permettant de calculer le chiffre d'affaire généré par chacun des directeurs pour toutes les
entreprises qu'ils dirigent.
Question4
Ecrivez la méthode de la classe directeur permettant de calculer son age.
Question1
A partir de ce modèle conceptuel établissez un modèle logique en relationnel-objet, sachant que le coeur du
problème concerne la gestion des voitures.
Indice
On utilisera des OID pour disposer de clés artificielles.
Question2
Proposer une implémentation sous Oracle de votre modèle logique.
Question1
A partir de ce que vous pouvez déduire de l'exemple ci-avant, citer les quatre attributs, ainsi que leurs valeurs, pour
l'objet dont l'OID est 0900055080005f2d.
Question2
Rappeler la façon dont on gère les attributs multi-valués sous Oracle en relationnel-objet.
Question3
Comparez et critiquez les deux approches.
SGBDRO 189
En résumé...
Modèle RO
Question1
Proposez un modèle logique relationnel correspondant au modèle conceptuel UML.
Question2
Si vous avez fait le bon choix de traduction de la relation d'héritage, une des classes du modèle conceptuel doit-être
représentée sous forme de vue. Proposez l'opération relationnelle qui permet de calculer la vue.
Question3
Proposez le code SQL2 permettant l'implémentation du modèle relationnel.
Question4
Proposez le code SQL2 permettant l'implémentation de la vue.
Question5
Proposez un modèle logique relationnel-objet correspondant au modèle conceptuel UML.
On utilisera les OID.
NB : On notera que la création de la vue est identique au cas relationnel, aussi l'on ne s'en préoccupera plus pour la
suite de cet exercice.
Question6
Proposez le code SQL3 permettant l'implémentation du modèle relationnel-objet.
NB : On utilisera les OID et les collections seront implémentées sous forme de NESTED TABLE.
Cours
X
Optimisation
Objectifs pédagogiques
Assimiler la problématique de la performance en bases de données
Connaître les grandes classes de solutions technologiques existantes aux problèmes de performance
Connaître et savoir mobiliser les techniques de conception permettant d'optimiser les performances d'une BD
La conception des SGBDR exige qu'une attention particulière soit portée à la modélisation conceptuelle, afin de parvenir à
définir des modèles logiques relationnels cohérents et manipulables. De tels modèles relationnels, grâce au langage standard
SQL, présentent la particularité d'être implémentables sur toute plate-forme technologique indépendamment de
considérations physiques.
Néanmoins l'on sait que dans la réalité, il est toujours nécessaire de prendre en considération les caractéristiques propres de
chaque SGBDR, en particulier afin d'optimiser l'implémentation. Les optimisations concernent en particulier la question des
performances, question centrale dans les applications de bases de données, qui, puisqu'elles manipulent des volumes de
données importants, risquent de conduire à des temps de traitement de ces données trop longs par rapport aux besoins
d'usage.
Chaque SGBDR propose généralement des mécaniques propres pour optimiser les implémentations, et il est alors nécessaire
d'acquérir les compétences particulières propres à ces systèmes pour en maîtriser les arcanes. Il existe néanmoins des
principes généraux, que l'on retrouvera dans tous les systèmes, comme par exemple les index, les groupements ou les vues
matérialisées. Nous nous proposerons d'aborder rapidement ces solutions pour en examiner les principes dans le cadre de ce
cours.
Nous aborderons également quelques techniques de conception, qui consistent à revenir sur la structure proposée par l'étape
de modélisation logique, pour établir des modèles de données plus aptes à répondre correctement à des questions de
performance. La dénormalisation ou le partitionnement en sont des exemples.
Objectifs pédagogiques
Assimiler la problématique de la performance en bases de données
Connaître les grandes classes de solutions technologiques existantes aux problèmes de performance
Connaître et savoir mobiliser les techniques de conception permettant d'optimiser les performances d'une BD
On peut néanmoins extraire certains principes d'optimisation des schémas internes suffisamment généraux pour être
applicables dans la plupart des cas.
Proposition de solutions
Une fois certains problèmes de performance identifiés, des solutions d'optimisation sont proposées, puis évaluées pour
vérifier leur impact et leur réponse au problème posé.
Parmi les solutions d'optimisation existantes, on pourra citer :
♦ L'indexation
♦ La dénormalisation
♦ Le regroupement (clustering) de tables
♦ Le partionnement vertical et horizontal
♦ Les vues concrètes
2. Indexation
Index
Un index est une structure de données qui permet d'accélérer les recherches dans une table en associant à une clé
d'index (la liste des attributs indexés) l'emplacement physique de l'enregistrement sur le disque. Les accès effectuées
sur un index peuvent donc se faire sur une liste triée au lieu de se faire par parcours séquentiel des enregistrements.
Cas d'usage
Les index doivent être utilisés sur les tables qui sont fréquemment soumises à des recherches. Ils sont d'autant plus
pertinents que les requêtes sélectionnent un petit nombre d'enregistrements (moins de 25% par exemple).
Optimisation 193
Les index diminuent les performances en mise à jour (puisqu'il faut mettre à jour les index en même temps que les
données). Les index ajoutent du volume à la base de données et leur volume peut devenir non négligeable.
Syntaxe Oracle
CREATE INDEX nom_index ON nom_table (NomColonneClé1, NomColonneClé2, ...);
SELECT *
FROM T
WHERE ABS(X) > 100
Cette non prise en compte de l'index est logique dans la mesure où, on le voit sur l'exemple précédent, une fois
l'attribut soumis à une fonction, le classement dans l'index n'a plus forcément de sens (l'ordre des X, n'est pas l'ordre
des valeurs absolues de X).
Lorsqu'un soucis d'optimisation se pose, on cherchera alors à sortir les attributs indexés des fonctions.
Notons que certains SGBD, tel qu'Oracle à partir de la version 8i, offrent des instructions d'indexation sur les
fonctions qui permettent une gestion de l'optimisation dans ce cas particulier (Delmal, 2001).
3. Dénormalisation
La normalisation est le processus qui permet d'optimiser un modèle logique afin de le rendre non redondant. Ce processus
conduit à la fragmentation des données dans plusieurs tables.
Dénormalisation
Processus consistant à regrouper plusieurs tables liées par des références, en une seule table, en réalisant
statiquement les opérations de jointure adéquates.
L'objectif de la dénormalisation est d'améliorer les performances de la BD en recherche sur les tables considérées,
en implémentant les jointures plutôt qu'en les calculant.
4. Groupement de tables
Groupement de table
Un groupement ou cluster est une structure physique utilisée pour stocker des tables sur lesquelles doivent être
effectuées de nombreuses requêtes comprenant des opérations de jointure.
Dans un groupement les enregistrements de plusieurs tables ayant une même valeur de champs servant à une
jointure (clé du groupement) sont stockées dans un même bloc physique de la mémoire permanente.
Cette technique optimise donc les opérations de jointure, en permettant de remonter les tuples joints par un seul
accès disque.
Clé du groupement
Ensemble d'attributs précisant la jointure que le groupement doit optimiser.
Remarque
Le clutering diminue les performances des requêtes portant sur chaque table prise de façon isolée, puisque les
enregistrements de chaque table sont stockés de façon éclatée.
5. Partitionnement de table
Partitionnement de table
Le partitionnement d'une table consiste à découper cette table afin qu'elle soit moins volumineuse, permettant ainsi
d'optimiser certains traitement sur cette table.
On distingue :
♦ Le partitionnement vertical, qui permet de découper une table en plusieurs tables, chacune ne possédant qu'une
partie des attributs de la table initiale.
♦ Le partitionnement horizontal, qui permet de découper une table en plusieurs tables, chacune ne possédant
qu'une partie des enregistrements de la table initiale.
Implémentation de projection
Partitionnement vertical
Technique consistant à implémenter deux projections ou plus d'une table T sur des table T1, T2, etc. en répétant la
clé de T dans chaque Ti pour pouvoir recomposer la table initiale par jointure sur la clé (Gardarin, 1999).
Remarque
Ce découpage équivaut à considérer l'entité à diviser comme un ensemble d'entités reliées par des associations 1:1.
Cas d'usage
Un tel découpage permet d'isoler des attributs peu utilisés d'autres très utilisés, et ainsi améliore les performances
lorsque l'on travaille avec les attributs très utilisés (la table étant plus petite).
Cette technique diminue les performances des opérations portant sur des attributs ayant été répartis sur des tables
différentes (une opération de jointure étant à présent requise).
Le partitionnement vertical est bien entendu sans intérêt sur les tables comportant peu d'attributs.
Implémentation de restriction
Partitionnement horizontal
Technique consistant à diviser une table T en plusieurs sous-table T1, T2, etc. selon des critères de restriction
(Gardarin, 1999) et tel que tous les tuples soit conservés de T. La table T est alors recomposable par union sur les
Ti.
Optimisation 195
Cas d'usage
Un tel découpage permet d'isoler des enregistrements peu utilisés d'autres très utilisés, et ainsi améliore les
performances lorsque l'on travaille avec les enregistrements très utilisés (la table étant plus petite). C'est le cas
typique de l'archivage. Un autre critère d'usage est le fait que les enregistrements soient toujours utilisés selon un
partitionnement donné (par exemple le mois de l'année).
Cette technique diminue les performances des opérations portant sur des enregistrements ayant été répartis sur des
tables différentes (une opération d'union étant à présent requise).
Le partitionnement horizontal est bien entendu sans intérêt sur les tables comportant peu d'enregistrements.
6. Vues concrètes
Un moyen de traiter le problème de requêtes dont les temps de calcul sont très longs et les fréquences de mise à jour faible est
l'utilisation de vues concrètes.
Vue concrète
Une vue concrète est un stockage statique (dans une table) d'un résultat de requête.
Un accès à une vue concrète permet donc d'éviter de recalculer la requête et est donc aussi rapide qu'un accès à une
table isolée. Il suppose par contre que les données n'ont pas été modifiées (ou que leur modification est sans
conséquence) entre le moment où la vue a été calculée et le moment où elle est consultée.
Une vue concrète est généralement recalculée régulièrement soit en fonction d'un évènement particulier (une mise à
jour par exemple), soit en fonction d'un moment de la journée ou elle n'est pas consultée et où les ressources de
calcul sont disponibles (typiquement la nuit).
Question1
Ecrivez en SQL les questions qui seront posées à la BD.
Indice
--On pose :
--[X] désigne le paramètre X
-- Now() est une fonction qui renvoie la date du jour
196 Conception de bases de données
Question2
Proposez des solutions pour optimiser l'implémentation physique de cette base de données.
Indice
On cherchera à utiliser les partionnement horizontaux et verticaux, les index et les vues matérialisées.
Question3
Réécrivez les requêtes avec le nouveau schéma de la base.
En résumé...
Optimisation
Modification du schéma interne d'une
BD pour en améliorer les
performances.
Horizontal Vertical
Cours
XI
Web et Java
Si les SGBD offrent les technologies de modélisation et de gestion des données, ils nécessitent la plupart du temps d'être
interfacés avec des applications qui fournissent un accès orienté métier aux utilisateurs, notamment à travers des IHM
évoluées. Même des systèmes comme Oracle ou PostgreSQL qui proposent un langage procédural (comme PL/SQL) au
dessus de la couche SQL, ne sont pas auto-suffisants. Les langages évolués comme Java, C ou Perl sont couramment utilisés
pour implémenter la couche applicative d'exploitation des BD.
Les applications de BD sont aujourd'hui généralement réalisées selon des architectures réseaux. L'explosion d'Internet de son
côté a favorisé le langage HTML pour implémenter les IHM et a vu la naissance de langages de script pour implémenter la
couche applicative côté serveur, tels que PHP, ASP ou JSP, plus simples que les langages classiques.
Partie A. Web
Objectifs pédagogiques
Comprendre les principes des architectures d'applications (en particulier 3-tier et Web) de BD
Comprendre le rôle des langages applicatifs comme sur-couche au dessus des SGBD et SQL
Savoir appliquer les principes d'une architecture Web dans le cadre des technologies Servlets ou PHP, et HTML
Remarque
Etant donné l'emploi massif du terme d'architecture à 3 niveaux, celui-ci peut parfois désigner aussi les architectures
suivantes :
♦ Partage d'application entre client, serveur intermédiaire, et serveur d'entreprise
♦ Partage d'application entre client, base de données intermédiaire, et base de données d'entreprise
200 Conception de bases de données
Un serveur web est un logiciel permettant à des clients d'accèder à des pages web, c'est-à-dire en réalité des fichiers au format
HTML à partir d'un navigateur (aussi appelé browser) installé sur leur ordinateur distant.
Un serveur web est donc un "simple" logiciel capable d'interpréter les requêtes HTTP arrivant sur le port associé au protocole
HTTP (par défaut le port 80), et de fournir une réponse avec ce même protocole.
Les principaux serveurs web sur le marché sont entre autres :
♦ Apache
♦ Microsoft IIS (Internet Information Server)
♦ Microsoft PWS (Personal Web Server)
♦ ...
4. Architecture Web
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Web et Java 201
1. Formulaires HTML
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Grâce à la balise FORM du langage HTML, il est très simple de créer des formulaires comprenant :
♦ des cases à cocher
♦ des champs de saisie
♦ des boutons radio
♦ des listes à choix multiples
♦ ...
Exemple : Formulaire
<FORM Method="GET" Action="test.php3">
Nom : <INPUT type=text name=nom><BR>
Prénom : <INPUT type=text name=prenom><BR>
Age : <INPUT type=text name=age><BR>
<INPUT type=submit>
</FORM>
1. Présentation de PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
PHP est un langage interprété (un langage de script) exécuté du côté serveur (comme les scripts CGI, ASP, ...) et non du côté
client (un script écrit en Javascript ou une applet Java s'exécute sur votre ordinateur...). La syntaxe du langage provient de
celles du langage C, du Perl et de Java.
Ses principaux atouts sont :
♦ La gratuité et la disponibilité du code source (PHP est distribué sous licence GNU GPL)
♦ La simplicité d'écriture de scripts
♦ La possibilité d'inclure le script PHP au sein d'une page HTML (contrairement aux scripts CGi, pour lesquels il faut écrire
des lignes de code pour afficher chaque ligne en langage HTML)
♦ La simplicité d'interfaçage avec des bases de données (de nombreux SGBD sont supportés, le plus utilisé avec ce langage
est MySQL).
♦ L'intégration au sein de nombreux serveurs web (Apache, Microsoft IIS, ...)
2. Principes de PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
2.1. L'interprétation du code par le serveur
Un script PHP est un simple fichier texte contenant des instructions écrites à l'aide de caractères ASCII 7 bits (des caractères
non accentués) incluses dans un code HTML à l'aide de balises spéciales et stocké sur le serveur. Ce fichier doit avoir une
extension particulière (qui dépend de la configuration du serveur HTTP, en général ".php") pour pouvoir être interprété par le
serveur.
Ainsi, lorsqu'un navigateur (le client) désire accéder à une page dynamique réalisée en php :
1. Le serveur reconnait qu'il s'agit d'un fichier php
2. Il lit le fichier php
3. Dès que le serveur rencontre une balise indiquant que les lignes suivantes sont du code php, il "passe" en mode php, ce
qui signifie qu'il ne lit plus les instructions: il les exécute.
4. Lorsque le serveur rencontre une instruction, il la transmet à l'interpréteur
5. L'interpréteur exécute l'instruction puis envoie les sorties éventuelles au serveur
6. A la fin du script, le serveur transmet le résultat au client (le navigateur)
3. Syntaxe PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
4. Variables en PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Exemple
$Entier=1;
$Reel=1.0;
$Chaine="1";
$Tableau[0]=1
$Tableau[1]="1"
$TableauMulti[0][0]="1.0"
$TableauAssoc["Age"]=18
Remarque : Switch
switch / case / default / break
204 Conception de bases de données
6. Boucles en PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
for (compteur; condition; modification du compteur) {
liste d'instructions
}
while (condition réalisée) {
liste d'instructions
}
7. Fonctions en PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
function Nom_De_La_Fonction(argument1, argument2, ...) {
liste d'instructions
...
return valeur_ou_variable;
...
}
8. Objets en PHP
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Syntaxe : Déclaration d'une classe
class Nom_de_la_classe {
// Déclarations des données membres
var $Donnee_Membre_1;
var $Donnee_Membre_2;
...
// Déclarations des méthodes
function Nom_de_la_fonction_membre1(parametres) {
liste d'instructions;
}
...
}
Remarque : This
Le mot clé $this permet d'accéder à l'objet en cours lors de la déclaration des méthodes.
Remarque : Print
La fonction "print" est iso-fonctionnelle avec "echo" et printf plus complexe permet en plus le formattage des
données (peu utilisée).
Php rend très simple la récupération de données envoyées par l'intermédiaire de formulaires HTML.
Lorsque l'on soumet un formulaire à un fichier PHP, toutes les données du formulaire lui sont passées en tant que variables,
c'est-à-dire chacun des noms associés aux champs (ou boutons) du formulaire précédés du caractère $.
Remarque : $HTTP_GET_VARS[]
Selon la configuration du module PHP, il est possible que la récupération directe des données issue du formulaire
HTML ne fonctionne pas. On peut dans ce cas utiliser les tableaux associatifs $HTTP_GET_VARS['variable'] ou
$HTTP_POST_VARS['variable'].
<?php
$MaVarLocale=$HTTP_GET_VARS['MaVar']
echo $MaVarLocale;
?>
Exemple
if (! $conn=Ora_Logon($user, $passwd)) {
echo "Impossible d'établir la connexion ";
exit;
}
Exemple
if(! $cursor=Ora_Open($conn)) {
echo "Impossible de créer le curseur";
exit;
}
206 Conception de bases de données
Exemple
if(! Ora_Parse($cursor, $sql, $defer)) {
echo "Impossible de préparer la requête";
exit;
}
Exemple
if(! Ora_Exec($cursor)) {
echo "Impossible d'exécuter la requête";
exit;
}
Remarque : Auto-commit
Cette fonction active la validation automatique après chaque ora_exec().
Exemple
$results=array();
while (ora_fetch_into($cursor, $results)) {
echo $results[0];
echo $results[1];
echo $results[2];
}
Exemple
if (! Ora_Logoff($conn)) {
echo "Impossible de fermer la connexion ";
exit;
}
Exemple
if (! $conn=OCILogon($user, $passwd, $bd)) {
echo "Impossible d'établir la connexion ";
exit;
}
Exemple
if(! $statement=OCIParse($conn, $sql)) {
echo "Impossible de préparer la requête";
exit;
}
Exemple
if(! OCIExec($statement, OCI_DEFAULT)) {
echo "Impossible d'exécuter la requête";
exit;
}
Exemple
if(! OCICommit($conn)) {
echo "Impossible de valider la transaction";
exit;
}
Remarque : Rollback
"OCIRollback" permet d'annuler une transaction.
Exemple
$results=array();
while (OCIFetchInto($statement, $results, OCI_RETURN_NULLS)) {
echo $results[0];
echo $results[1];
echo $results[2];
}
Remarque : Mode
Le mode OCI_RETURN_NULLS permet de retourner toutes les colonnes, même si elles sont nulles. Le mode
OCI_ASSOC permet de retourner un tableau associatif au lieu d'un tableau à index numérique. Il est possible de les
combiner en les aditionnant : OCI_RETURN_NULLS+OCI_ASSOC.
208 Conception de bases de données
Exemple
if (! OCILogOff($conn)) {
echo "Impossible de fermer la connexion ";
exit;
}
3. Architecture PHP/Oracle
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Partie B. Java
Objectifs pédagogiques
Comprendre le rôle des langages applicatifs comme sur-couche au dessus des SGBD et SQL
Connaître les principes de l'interfaçage d'un langage de programmation avec une BD
Savoir appliquer les principes de l'interfaçage d'un langage de programmation avec une BD en Java
1. JBDC
JDBC [Java DataBase Connectivity] est une API permettant la communication entre un programme Java et un serveur de BD
JDBC permet donc à la fois une indépendance vis à vis de la machine accueillant l'application (pourvu qu'elle dispose d'une
machine virtuelle Java) et vis à vis du serveur de BD (pourvu qu'il dispose d'un pilote JDBC).
Web et Java 209
Remarque : ODBC
ODBC [Open DataBase Connectivity] est équivalent à JDBC, dans le monde Windows (i.e. il offre une API de
communication entre une application Windows et un serveur de BD possédant un pilote ODBC).
Syntaxe : Connexion à la BD
Connection vCon = DriverManager.getConnection(paramètres de connexion);
Paramètres Oracle : "jdbc:oracle:thin:user/password@host:port:database"
Paramètres MySQL : "jdbc:mysql://host/database","user","password"
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import oracle.jdbc.OracleDriver;
while(vRs.next()){
String vNom = vRs.getString(1);
String vPrenom = vRs.getString(2);
System.out.println("Nom="+vNom+"Prenom="+vPrenom);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
vSt.execute();
Exemple
PreparedStatement vSt = fCon.prepareStatement("SELECT * FROM t1 WHERE x=?");
vSt.setString(1, "test")
vSt.execute()
Web et Java 211
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import oracle.jdbc.OracleDriver;
} catch (Exception e) {
e.printStackTrace();
}
}
}
vSt.execute();
vRs = vSt.getString(index?)
vRs = vSt.getInt(index?)
...
Exemple
CallableStatement vSt = fCon.prepareCall("begin ?:=pInsertIntervenant(?,?); end;");
vSt.setString(2, "CROZAT");
vSt.setString(3, "Stéphane");
vSt.registerOutParameter(1, Types.VARCHAR);
vSt.execute();
String vRs = vSt.getString(1);
212 Conception de bases de données
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;
import oracle.jdbc.OracleDriver;
vSt.execute();
String vRs = vSt.getString(1);
System.out.println(vRs);
} catch (Exception e) {
e.printStackTrace();
}
}
}
Remarque : applet
Ne pas confondre les servlets avec les applets, qui sont des applications Java exécutées côté client (téléchargées par
le navigateur Web et exécutées par une machine Java locale)
Remarque : Portabilité
En tant que programme Java, les servlets peuvent être exécutées sur toutes plates-formes.
Les servlets sont exécutée grâce à un moteur de servlet (tels que Tomcat, Jserv, etc.) Le moteur de servlet est indépendant du
serveur HTTP (Apache , IIS, etc.) et doit lui être connecté (pour que le serveur HTTP redirige les exécutions des servlets au
moteur de servlet). Un moteur de servlet peut néanmoins faire office de serveur HTTP.
Web et Java 213
IMG. 62 : ARCHITECTURE SERVLET (DEPUIS COMMENTCAMARCHE.ORG, COPYRIGHT 2003 JEAN-FRANÇOIS PILLOU, IMAGE SOUMISE
À LA LICENCE GNU FDL).
Exemple
PrintWriter vOut = pResp.getWriter();
vOut.println("<html><body>Hello World</body></html>");
vSt.execute();
} catch (Exception e) {
PrintWriter vOut = pResp.getWriter();
e.printStackTrace(vOut);
}
}
}
Remarque : PreparedStatement
La syntaxe utilise ici l'objet Prepared Statement plutôt que directement un objet Statement.
216 Conception de bases de données
vSt.execute();
String vRs = vSt.getString(1);
} catch (Exception e) {
PrintWriter vOut = pResp.getWriter();
e.printStackTrace(vOut);
}
}
}
Remarque : CallableStatement
L'usage de l'objet Callable Statement est obligatoire pour faire des appels PL/SQL.
3. Architecture servlet/Oracle
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Web et Java 217
I
Retour sur les
fonctions
fondamentales des
SGBD
Pour chacune des fonctions citées ci-après, rappeler comment les SGBD les mettent en oeuvre conceptuellement et
technologiquement, en donnant des exemples concrêts.
Question1
Indépendance physique des données
Question2
Indépendance logique des données
Question3
Manipulation des données par des non-informaticiens
Question4
Administration facilitée des données
Question5
Optimisation de l'accès aux données
Question6
Contrôle de cohérence (intégrité sémantique) des données
Question7
Partageabilité des données
220 Conception de bases de données
Question8
Sécurité des données
Question9
Sûreté des données
Exercice
récapitulatif
I
Gestion de comptes
bancaires
Enoncé n°1
Nouvel employé d'une entreprise bancaire, vous avez pour mission de restructurer une base de données existante pour la
gestion des opérations bancaires (débits et crédits sur un compte).
La base de données existante a été conçue sous MS Access, avec une unique table.
NB : Un débit est différencié d'un crédit par la valeur de MontantOperation : Si elle est négative il s'agit d'un débit, si elle est
positive il d'agit d'un crédit.
En vue de préparer la re-conception de cette base, un stagiaire a effectué le rescencement des DF de ce schéma.
Voici le résultat de ses travaux, sous la forme de la fermeture transitive des DF :
♦ NumClient→ Nom, Prenom
♦ NumCompte→ NumClient, Nom, Prenom, Agence, Ville, Pays, Monnaie
♦ Agence→ Ville, Pays, Monnaie
♦ Pays→ Monnaie
♦ DateOperation, NumCompte→ MontantOperation
222 Conception de bases de données
Question1.1
En quelle forme normale est le schéma de la base existante ? Justifier.
Question1.2
Trouvez la meilleure clé primaire pour ce schéma. Justifier.
Question1.3
Afin de préparer la décomposition du schéma relationnel, trouvez une couverture minimale des DFE pertinente.
Question1.4
Décomposer le schéma relationnel de la base existante, en préservant les DF, pour aboutir à un schéma en 3NF.
Choisissez la meilleure clé primaire pour chaque relation. Présentez le schéma relationnel resultant et justifiez.
Question1.5
A des fins de documentation, retro-concevez le MCD, à l'aide du formalisme E-A, qui aurait permis d'aboutir
directement à ce schéma relationnel.
Enoncé n°2
Une équipe technique est désignée afin de réaliser la nouvelle base de données que vous avez préconisée sous Oracle. Une
fois le schéma relationnel créé, elle fait appel à vous pour récupérer les données existantes.
Question2.1
Ecrivez une série d'instructions SQL permettant la récupération des données depuis l'ancienne base de données vers
la nouvelle.
Enoncé n°3
L'équipe technique ne connaissant pas Access, elle fait appel à vous pour traduire les requêtes qui existaient dans l'ancien
système. On s'attache en particulier à la requête QBE suivante :
Vous avez accès à son équivalent SQL grâce au générateur automatique de SQL de Access :
Question3.1
En SQL (fonctionnant sous Oracle), créez une vue équivalente à cette requête QBE.
Enoncé n°4
L'équipe technique fait à présent appel à vous pour certains aspects particuliers de l'application.
Notez la table suivante qui a été ajoutée au schéma relationnel :
Gestion de comptes bancaires 223
Question4.2
Ecrivez une méthode booléenne Java qui prend en paramètre d'entrée un numéro de client et renvoie vrai si ce client
a déjà été en déficit. On notera que la base se nomme "bank", qu'elle est accédée par la méthode sur la machine
"www.oracle.bank.com" (port "1521"), par l'utilisateur "Java" (mot de passe "Tango").
Enoncé n°5
L'équipe informatique fait maintenant appel à vous pour fiabiliser la base de données, à présent utilisée. Un problème
récurrent survient sur la procédure PL/SQL "pVirement" donnée ci-dessous. En effet suite à des micro-coupures réseau, il
arrive que le débit du "Compte1" soit effectué, tandis que le crédit du "Compte2" n'est jamais effectué.
CREATE procedure pVirement (Compte1 number, Compte2 number, Montant number, DateOp date)
IS
BEGIN
INSERT INTO TOperation VALUES (Compte1, DateOp, Montant * -1);
INSERT INTO TOperation VALUES (Compte2, DateOp, Montant);
END;
Question5.1
Expliquez pourquoi le problème survient. Proposer une solution générale au problème. Implémentez cette solution
en réécrivant la procédure PL/SQL.
Enoncé n°6
L'équipe informatique fait enfin appel à vous pour optimiser la base, et en particulier la requête suivante qui, étant donné un
nombre d'opérations très grand existant, est trop longue à s'exécuter.
SELECT NumCompte, MontantOperation
FROM TOperation
WHERE MontantOperation > 10000;
ORDER BY MontantOperation;
Question6.1
Expliquez pourquoi cette requête sera longue à s'exécuter si le nombre d'enregistrements est très grand dans la table
TOperation. Proposer une solution générale au problème. Proposer une définition SQL implémentant cette solution
pour ce cas particulier.
Cours
XII
Annexes
Dans cette rubrique on retrouvera des éléments de contenus qui ne figurent pas au programme du cours mais pourront
néanmoins servir à l'étudiant, à des fins d'approfondissement et dans le cadre du projet.
Objectifs pédagogiques
Découvrir un SGBDR libre et répandu dans le monde Internet
Savoir utiliser un SGBDR avec une interface SQL standard
Connaître les éléments techniques de base pour apprendre à créer une BD sous MySQL
Savoir manipuler un dictionnaire de données
MySQL est un SGBDR du monde "open source" (licence libre GPL et licence commerciale). Il propose une implémentation,
lacunaire dans ses premières version, mais assez complète depuis la version 4, des concepts relationnels. MySQL est facile à
installer et à administrer, performant, facilement interfaçable avec des couches applicatives Web. En particulier la plupart des
hébergeurs, y compris gratuits, proposent la mise à disposition d'une BD MySQL et d'un serveur PHP.
MySQL constitue donc à la fois un bon cadre d'apprentissage par son interface SQL standard et une technologie aisément
déployable en conditions réelles pour des applications Internet ou Intranet.
1. Présentation
♦ MySQL est un SGBDR.
♦ Unix, Linux, Windows.
♦ Licence GPL (et licence commerciale).
♦ Version de production MySQL 4 en 2004.
♦ Site officiel :
MySQL compte plusieurs millions d'applications dans le monde en 2003.(Dubois & al., 2004)
1. Instructions spécifiques
1.1. Administration
♦ USE Nom_Base
♦ SHOW DATABASES
♦ SHOW VARIABLES
♦ SHOW STATUS
♦ PASSWORD(chaîne)
1.2. Conception
♦ SHOW TABLES
♦ DESCRIBE Nom_Table
♦ DESCRIBE Nom_Table Nom_Champs
1.3. Divers
♦ SELECT DATABASE()
♦ SELECT USER()
♦ user
Droits de connection d'un utilisateur (nom, hôte, mot de passe) et privilèges sur toutes les bases de données du serveur.
♦ db
Droits d'un utilisateur sur une base de données.
♦ tables_priv
Droits d'un utilisateur sur une table d'une base de données.
♦ columns_priv
Droits d'un utilisateur sur une propriété d'une table d'une base de données.
Remarque : host
Table "host" sans fonction (ancien usage)
228 Conception de bases de données
1. Types de données
♦ INT (TINY, SMALL, MEDIUM, BIG)
♦ FLOAT, DOUBLE, DECIMAL, etc.
♦ DATE, DATETIME, TIME, YEAR, etc.
♦ CHAR, VARCHAR
♦ TEXT, BLOB
♦ ENUM, SET
2. BLOB
♦ load_file("c:/chemin_fichier/nom_fichier")
3. Fonctions à connaître
1. Limites de MySQL
♦ Sous requêtes
En général, on peut s'en passer. Prévu dans les versions à venir.
♦ Transactions
Alternative avec LOCK TABLE/UNLOCK TABLE.
Depuis MySQL 4, les tables de type InnoDB permettent la gestion réelle de transactions avec "commit" et "rollback" et
récupération de pannes.
♦ Procédures stockées
A venir.
♦ Triggers
Non prévu.
♦ Clé étrangères
Ni contrôle d'intégrité référentielle, ni mise à jour en cascade.
Depuis MySQL 4, les tables de type InnoDB permettent une gestion réelle de clés étrangères avec contrôle d'intégrité
référentielle et mises à jour et supressions en cascade.
♦ Vues
A venir.
230 Conception de bases de données
IMG. 70 : INTERFACE D'INSERTION DIRECTS D'ENREGISTREMENT (LMD AJOUT, MISE À JOUR, SUPPRESSIONS)
+-----------------+
| Tables_in_mysql
+-----------------+
| columns_priv
| db
| func
| host
| tables_priv
| user
+-----------------+
6 rows in set (0.00 sec)
Toutes ces tables sont vides, à l'exeption de la table user qui contient un enregistrement autorisant l'utilisateur "root" à se
connecter depuis une machine locale avec tous les droits.
Question1
Quelles sont les tables du dictionnaire de données modifiées par cette instruction ? Expliquez en quelques mots.
Question2
Quelle(s) table(s) contiennent une ou plusieurs valeurs 'Y' pour l'utilisateur invite, une valeur 'Y' signifiant que
l'utilisateur a des droits ? Expliquez en quelques mots.
Question3
Pour chaque table, combien de colonnes sont-elles concernées par la valeur 'Y' pour l'utilisateur invite ? Expliquez
en quelques mots.
Question4
Réécrivez l'instruction grant en intervenant directement dans les tables en SQL.
2. Architecture PHP/MySQL
Fait à partir de . Copyright 2003 Jean-François Pillou. Document soumis à la licence GNU FDL.
Annexes 233
Cela permet de gérer des transactions avec commit, rollback, et restauration apres crash. Au niveau verouillage ce
moteur gere le verouillage de lignes. Il ajoute le support des clés etrangeres.
Le précedent moteur etait MyIsam, qui utilisait un fichier par table. Pour InnoDB, le moteur stocke les tables dans
un tablespace reparti sur plusieurs fichiers. (cela permet de s'affranchir sur certains systeme de la limite de
2go/fichier).
Il y a un site dédié : www.innodb.com/
Objectifs pédagogiques
Expérimenter le langage SQL
Utiliser basiquement MySQL
Consigne
Pour chaque exécution de code SQL, il vous est demandé de produire le code entré et le résultat obtenu.
234 Conception de bases de données
Enoncé n°1
Soit le schéma relationnel d'une base de données pour le gestion des projets dans une association :
Projet (Num, Nom, Debut, Fin, ChefDeProjet=>Membre, Specialite=>Specialite)
Tache (Num, Projet=>Projet, Nom, Debut, Fin)
Specialite (Intitule)
Membre (Prenom, Nom, Specialite=>Specialite)
Partenaire (Nom, Description)
Participe (Prenom=>Membre, Tache=>Tache, Projet=>Tache, Fonction)
EstAssocie (Nom=>Partenaire, Projet=>Projet, Role)
Question1.1
Ecrivez le schéma E-A ayant permis de déduire ce modèle relationnel.
Enoncé n°2
Pour faire fonctionner MySQL, il faut un serveur et un client. Pour lancer le serveur le programme est "mysqld" et pour
lancer le client le programme est "mysql".
L'option "mysqld --standalone" permet de lancer un serveur dans un process autonome.
Pour connaître les options exécutable sur le client "mysql" exécuter : "mysql -h".
"mysql -user utilisateur -pmotdepasse -D basededonnées" permet de se connecter en tant qu'utilisateur "utilisateur" avec le
mot de passe "motdepasse" sur la base de données "basededonnées".
Pour se connecter à une base de données exécuter "connect basededonnées".
Pour créer une base de données, utiliser l'instruction "create database".
Utiliser la commande "show databases" pour voir toutes les bases existantes et "show tables" pour voir les tables d'une base
de données.
Question2.1
Lancer un serveur et un client mysql, connectez vous.
Question2.2
Initialiser une nouvelle base de données "Projetxx", avec xx votre numéro de binôme.
Enoncé n°3
Par défaut, à l'installation de MySQL, n'importe qui peut se connecter en "root", sans mot de passe. Inutile de préciser que,
l'utilisateur root ayant tous les droits, cela est la plus mauvaise situation possible du point de vue de la sécurité !
Pour mettre en place la sécurité dans le SGBD MySQL, il faut au minimum :
♦ Affecter un mot de passe à l'utilisateur "root" qui sera administrateur du SGBD. Ce mot de passe devra être complexe, car
toute personne le possédant à tout pouvoir de nuisance sur toutes les bases de données.
♦ Faire en sorte que les autres utilisateurs aient uniquement des droits sur les bases de données applicatives et non sur la
base "mysql" qui spécifie tous les droits au sein du SGBD.
Les droits sont spécifiés dans la base "mysql" et sont ainsi organisés :
♦ Les droits généraux sur toutes les bases de données sont spécifiés dans la table "mysql.user"
♦ Les droits sur chaque base de données sont spécifiés dans la table "mysql.db"
Il est possible de définir tous les droits en travaillant directement dans la base mysql. On peut également faire appel à des
commandes plus spécialisée.
Ainsi par exemple :
♦ La commande "grant all privileges on db.* to 'user' identified by 'motdepasse' with grant option" permet de donner tous
les privilèges à l'utilisateur "user" sur la base de données "db" y compris le droit de donner les droits, de redéfinir le mot
de passe de l'utilisateur, et même, si l'utilisateur n'existait pas, de le créer.
♦ La commande "show grants for user" permet de voir les privilèges d'un utilisateur.
♦ La commande "set password for user=password('pass')" permet d'affecter le mot de passe "pass" à l'utilisateur "user". La
commande "set password for user=''" permet de supprimer le mot de passe de l'utilisateur "user".
♦ La suppression d'un utilisateur se fait en supprimant l'enregistrement dans la table "mysql.user" et éventuellement dans les
autres tables de la base mysql pour les droits particuliers.
♦ La commande "flush privileges" permet de rendre actifs les changement effectués concernant les droits.
Question3.1
En travaillant directement dans les tables de la base mysql et/ou en utilisant les commandes spécialisées, organisez
la sécurité du SGBD de façon à ce que :
♦ L'utilisateur "root" ait à présent le mot de passe "nx17"
♦ Les accès ne puissent se faire que depuis le "localhost"
♦ Un utilisateur "nx170xx" (avec xx votre numéro) ait le mot de passe "u" et l'accès complet à la base Projetxx
Annexes 235
♦ Un utilisateur "invite" (sans mot de passe) ait les droits en lecture seul sur la base Projetxx
♦ Aucun n'autre accès ne soit autorisé sur la base
Enoncé n°4
A présent que le SGBD est correctement protégé et que la base de données est disponible pour créer l'application, il s'agit
d'implémenter le shéma de la base de données de gestion de projet.
Pour se faire, on utilisera MySQL en mode "batch", c'est à dire que plutôt que de taper chaque commande en ligne, on utilise
un fichier, qui contient plusieurs commandes qui seront ensuite exécutées d'une seule traite. L'avantage du mode batch est
qu'il permet de refaire plusieurs fois une même séquence d'opérations SQL.
L'instruction "mysql -u nx17000 -pu -D Projet00 < c:\mysql\create.sql -t > c:\mysql\out.txt" permet d'exécuter le fichier
"create.sql" en mode batch, sur la base de données "Projet00", par l'utilisateur "nx17000" (ayant le mot de passe "u") ; le
résultat est mis dans le fichier "out.txt" ; le paramètre optionnel "-t" signifie que la mise en forme est tabulaire (avec noms et
séparateurs de colonnes) ; bien entendu, il est possible de ne pas spécifier de fichier de sortie, auquel cas le résultat est
présenté à l'écran.
Question4.1
Créer les relations nécessaires pour implémenter le modèle relationnel.
Question4.2
Définissez les contraintes (clé primaires, nullité et unicité) et des domaines pertinents pour chaque propriété. Notez
que MySQL ne gère pas les contraintes de clés étrangères (et donc pas l'intégrité référentielle).
Question4.3
Définissez des index pertinents.
Enoncé n°5
On dispose des informations suivantes :
♦ L'association gère pour le moment trois projets, "Comédie Musicale" gérée par Nathalie sur les trois premiers mois du
semestre d'automne 2002, "Science en fête" gérée par Pierre sur tout le semestre de printemps 2003. et "Nuit du picolo"
gérée par Julien en novembre 2002.
♦ Les specialités ressencées pour le moment sont : Ville, Université, Sport, Entreprise, Culture, International.
♦ L'association dispose de dix membres, que je vous laisse libre d'imaginer (sans oublier les chefs de projet déjà investis !).
♦ Aidez l'association à diviser ses projets en tâches.
♦ Les partenaires existants sont : la mairie pour la comédie musicale et la science en fête, qui apporte un soutien financier ;
le ministère de la culture qui apporte son soutien logistique à la science en fête ; l'association des commerçants de la ville
qui apporte son soutien publicitaire à la comédie musicale ; 1664 qui offre ses bières à moitié prix pour la nuit du picolo.
Question5.1
Initialiser les relations.
Enoncé n°6
On reporte à présent les évènements suivants :
♦ 1664 n'apporte plus son soutien suite au refus des étudiants de faire de la publicité pour la bière dans les lycées de la ville.
♦ Le projet de comédie musicale est renommé projet "Chance aux chansons" suite à une décision unilatérale du chef de
projet (par ailleurs président de l'association et fils du ministre de l'intérieur).
♦ Le projet "Chance aux chansons" et reporté d'un an suite à la démission du chef de projet (pour cause d'incompatibilité
d'humeur avec le reste des membres).
On pourra utiliser l'instruction "describe nom_table" pour revoir les schémas des tables créées.
il est possible de faire des opération sur les dates, avec des fonctions telles que "DATE_ADD(date, INTERVAL valeur
type)". Par exemple : "select DATE_ADD('2001-01-01', INTERVAL 1 DAY)" renvoie "2001-01-02".
Question6.1
Gérer ces évènements en procédant aux mises à jour nécessaires dans la base de données
Enoncé n°7
L'association désire à présent exploiter sa base de données pour obtenir les informations suivantes :
236 Conception de bases de données
♦ La liste de tous les projets avec les noms des projets, les chefs de projet et tous les membres participants. Cette requête
est-elle exécutable par un utilisateur "invite" ? Si oui assurez vous-en.
♦ Une liste mettant en correspondance tous les chefs de projet qui n'ont pas la spécialité requise pour un projet.
♦ Une liste de tous les partenaires, avec les projets soutenus et leur rôle dans chaque projet.
♦ Le nombre de tâches en retard pour chaque projet.
♦ Les chefs de projet qui sont en relation avec au moins deux partenaires.
Question7.1
Créer et exécuter les requêtes permettant de répondre à ces questions.
La relation IMMEUBLE décrit un ensemble d'immeubles. Chaque immeuble a un propriétaire. La relation APPIM décrit
pour chaque immeuble l'ensemble des appartements qui le compose. Chaque appartement peut héberger plusieurs personnes
mais il y en a une qui est responsable (par exemple la personne qui a signe le contrat de location) et qui est désignée par le
constituant OCCUP. Si l'appartement est inoccupé, ce constituant prend la valeur NULL. La relation PERSONNE décrit un
ensemble de personnes. ADR et NAPR représentent l'adresse où réside une personne. Une personne peut avoir plusieurs
enfants décrits par la relation ENFANT. Pour simplifier, on ne considère que les enfants allant à l'école primaire. Les écoles
et les classes sont décrites dans les relations ÉCOLE et CLASSE.
Question1
Identifier les clés étrangères dans chaque relation.
Question2
Retro-conception : reconstruire le schéma E/A.
La relation IMMEUBLE décrit un ensemble d'immeubles. Chaque immeuble a un propriétaire. La relation APPIM décrit
pour chaque immeuble l'ensemble des appartements qui le compose. Chaque appartement peut héberger plusieurs personnes
mais il y en a une qui est responsable (par exemple la personne qui a signe le contrat de location) et qui est désignée par le
constituant OCCUP. Si l'appartement est inoccupé, ce constituant prend la valeur NULL. La relation PERSONNE décrit un
ensemble de personnes. ADR et NAPR représentent l'adresse où réside une personne. Une personne peut avoir plusieurs
enfants décrits par la relation ENFANT. Pour simplifier, on ne considère que les enfants allant à l'école primaire. Les écoles
et les classes sont décrites dans les relations ÉCOLE et CLASSE.
Répondez aux questions suivantes à l'aide de l'algèbre relationnelle.
Question1
Donner l'adresse des immeubles ayant plus de 10 étages et construits avant 1970.
Question2
Donner les noms des personnes qui habitent dans un immeuble dont ils sont propriétaires.
Question3
Donner les noms des personnes qui ne sont pas propriétaires.
Annexes 239
Question4
Donner les adresses des immeubles possédés par des informaticiens dont l'âge est inférieur à 40 ans .
Question5
Donner la liste des occupants (nom, âge, profession) des immeubles possédés par DUPONT.
Question6
Donner le nom et la profession des propriétaires d'immeubles dans lesquels il y a des appartements vides.
Question7
Donner les noms des maîtres qui habitent dans le même immeuble (à la même adresse) qu'au moins un de leurs
élèves (on suppose que les enfants vivent sous le même toit que leur parents).
Question8
Donner l'adresse de l'immeuble, la date de construction, le type d'appartement et l'étage où habitent chacun des
maîtres des enfants de DUPONT.
Question1
Lister les employés ayant des revenus supérieurs à 10.000 euros.
Question2
Trouver le nom et la profession de l'employé de numéro 10.
Question3
Lister des noms des employés qui travaillent à Paris.
Question4
Trouver le nom du directeur du département ''Commercial''.
Question5
Trouver les professions des directeurs des départements.
240 Conception de bases de données
Question6
Trouver le nom des directeurs de département ayant comme profession "Ingénieur".
Consigne
Une vue est un ensemble de relations déduites d'une BD, par composition des relations de base. Dans la norme
SQL, la notion de vue à été réduite à la notion de relation déduite. La déclaration d'une vue s'effectue par la
commande : CREATE VIEW <nom de vue> [(liste d'attributs)] AS <question>
La suppression d'une vue s'effectue par la requête : DROP <nom de vue>
Question1
Donnez les commandes SQL permettant de créer les vues suivantes décrivant les buveurs et les vins de Beaujolais :
♦ BUVEURB (NB, NOM, PRENOM, NV, DATE, QUANTITE)
♦ VINB (NV, CRU, MILLESIME, DEGRE)
Question2
Un utilisateur ayant droit d'interroger à partir des vues précédentes pose la question suivant :
"donner le nom de buveurs ayant bu du Beaujolais de millésime 1983 en quantité supérieur à 100, le même jour".
Exprimez cette question telle que doit le faire l'utilisateur en SQL.
Bibliographie
API
Une API est une définition d'un ensemble de fonctions ou méthodes (en programmation objet) dont l'appel paramétré permet
de piloter une application. Une API permet donc d'utiliser un librairie informatique sans avoir besoin d'en connaître le
fonctionnement interne.
Client
Un client est un programme informatique qui a pour fonction d'envoyer des requêtes à un autre programme informatique,
appelé serveur, d'attendre le résultat de cette requête et de traiter le résultats de la requête. Notons qu'un programme peut-être
client vis à vis d'un programme et serveur vis à vis d'un autre. On ne prend pas ici le terme client dans son acception
matérielle, qui signifie alors un ordinateur qui a pour fonction d'héberger des programmes clients.
Constructeur d'objet
En programmation orientée objet, un constructeur d'objet est une méthode particulière d'une classe qui permet d'instancier un
objet de cette classe. L'appel à cette méthode de classe a donc pour conséquence la création d'un nouvel objet de cette classe.
Exception
Une exception est un évènement généré par un système informatique pour signifier une erreur d'exécution. La gestion des
exceptions est un aspect de la programmation informatique, qui consiste à intercepter ces évènements particuliers et à les
traiter pour, soit les corriger automatiquement, soit en donner une information appropriée à un utilisateur humain.
Impedance mismatch
Le terme d'impedance mismatch renvoie au décalage qui peut exister entre le niveau d'abstraction de deux langages qui ont à
travailler sur des structures de données communes, par exemple un langage applicatif objet et un langage de données
relationnel. L'impedance mismatch a des conséquences négatives en terme de complexification de l'implémentation et en
terme de performance, puisqu'il faut constamment passer d'une strucuture de données à l'autre.
244 Conception de bases de données
RAID
La techologie RAID pemet de répartir de l'information à stocker sur plusieurs "petits" disques, au lieu de la concentrer sur un
seul "gros" disque. Cette technologie permet donc d'améliorer les performances (les accès disques pouvant être parallélisés)
et d'améliorer la sureté (en répartissant les risques de crash et en jouant sur une redondance des données). Il existe plusieurs
types d'architecture RAID, privilégiant ou combinant la parallélisation et la redondance.
Serveur
Un serveur est un programme informatique qui a pour fonction de recevoir des requêtes d'un autre programme, appelé client,
de traiter ces requêtes et de renvoyer en retour une réponse. Notons qu'un programme peut-être serveur vis à vis d'un
programme et client vis à vis d'un autre. On ne prend pas ici le terme serveur dans son acception matérielle, qui signifie alors
un ordinateur qui a pour fonction d'héberger des programmes serveurs.
Signification des sigles
1:N p. 173
2NF p. 103
Abstraite p. 42
Acces p. 137
p. 119, 119, 119, 120, 121, 125, 127, 129, 130, 131,
Access
132, 221
ACID p. 136
Administration p. 22, 26
Algèbre p. 54, 75, 75, 75, 76, 76, 77, 77, 78, 78, 79, 79, 80, 81
ALL p. 91
AND p. 87
Annulation p. 136
ANY p. 92
API p. 209
Application p. 121, 126, 127, 131, 132, 154, 154, 154, 166, 197
Architecture p. 197, 197, 198, 200, 200, 208, 216, 225, 232
Association p. 32, 43, 45, 46, 57, 57, 61, 67, 68, 68, 173, 174
Atomicité p. 103
248 Conception de bases de données
Attente p. 144
Attribut p. 34, 41, 45, 55, 55, 56, 59, 62, 68, 68
AutoExec p. 128
BCNF p. 105
BETWEEN p. 87
BLOB p. 177
Boolean p. 177
Boucle p. 204
Calcul p. 89
Cardinalité p. 33, 44
Cartésien p. 77
Catalogue p. 26
CHECK p. 109
Classe p. 23, 40, 42, 48, 48, 50, 66, 68, 170, 204
Clé artificielle p. 56
Client-serveur p. 197
Cluster p. 194
Codd p. 53
Comparaison p. 87
Composition p. 46, 68
Index 249
p. , 24, 24, 27, 28, 28, 29, 31, 31, 31, 39, 40, 51, 60,
Conceptuel
65, 66, 74, 81, 221
Condition p. 87
Constructeur p. 178
Création p. 107
Critique p. 120
Déclaratif p. 107
Défaillance p. 135
Dépendance p. 97
Déverrouillage p. 143
Différence p. 75
DISTINCT p. 86
250 Conception de bases de données
Division p. 79
Données p. 23
Driver p. 209
Droits p. 112
DROP p. 110
Durabilité p. 138
p. 24, 28, 29, 31, 31, 31, 31, 32, 33, 34, 34, 36, 43, 44,
E-A
51, 53, 60, 60, 61, 62, 62, 63, 64, 65, 66, 74, 75, 81, 221
Ecriture p. 143
Enregistrement p. 55, 55
Enumération p. 122
Erreur p. 158
Evaluation p. 192
EXCEPT p. 88
Exécution p. 136
EXISTS p. 91
Fermeture p. 101
Fonction p. 89, 129, 129, 153, 156, 156, 162, 164, 177, 204
Fonctions p. 165
FOR p. 158
FORM p. 201
Formulaires p. 125
FROM p. 86
Index 251
FUNCTION p. 177
GRANT p. 112
Groupement p. 194
Héritage p. 34, 41, 42, 63, 64, 68, 70, 70, 71, 72, 73, 172, 174
HTTP p. 200
IN p. 87, 90
INNER p. 87
Instance p. 23, 24
Interne p. 24, 27
INTERSECT p. 88
Intersection p. 75
INTO p. 157
IOD p. 180
IS NULL p. 87
p. 208, 209, 209, 210, 210, 211, 211, 212, 212, 215,
Java
216, 221
JavPHPa p. 204
JOIN p. 87
Langage p. 22, 25, 85, 85, 86, 97, 107, 155, 155, 157, 157, 157,
252 Conception de bases de données
Lecture p. 143
LEFT p. 87
Lien p. 57, 57
LIKE p. 87
p. , 22, 24, 27, 31, 53, 53, 53, 53, 60, 65, 66, 74, 75,
Logique
81, 87, 97, 167, 221
Manipulation p. 75
p. , 23, 24, 27, 31, 31, 31, 48, 53, 53, 53, 59, 60, 75,
Modèle
81, 97, 167, 169, 187, 221
N:M p. 174
Naturelle p. 78
Nomalisation p. 97
p. 97, 97, 98, 99, 99, 100, 100, 101, 101, 101, 102,
Normalisation
102, 103, 103, 104, 105, 168, 193
NOT p. 87
OBDC p. 208
Objet p. 129, 167, 168, 172, 172, 174, 177, 178, 204
Occurence p. 23
OMG p. 40
On Error p. 130
Opérateur p. 87
Index 253
Opération p. 54
OR p. 87
p. 137, 146, 146, 147, 147, 151, 151, 166, 205, 206,
Oracle
208, 209, 210, 211, 211, 212, 215, 216, 221
ORDER BY p. 89
OUTER p. 87
Perte p. 141
p. 202, 202, 203, 203, 203, 204, 204, 204, 205, 205,
PHP
206, 208, 212, 232, 232
Problème p. 98
Prototypage p. 120
REFERENCES p. 109
p. 21, 24, 31, 53, 53, 53, 53, 54, 54, 59, 60, 60, 60, 61,
62, 62, 63, 64, 65, 66, 66, 66, 67, 68, 68, 68, 68, 70, 70,
Relationnel
71, 72, 73, 73, 74, 74, 75, 75, 75, 79, 80, 81, 83, 97, 105,
167, 168
Relationnel-objet p. 53, 53, 167, 169, 177, 181, 183, 187, 189
REPEAT p. 158
REVOKE p. 113
RIGHT p. 87
Script p. 164
Servlets p. 212
SGBDOO p. 168
SGBR p. 22
Spécifications p. 29
p. 25, 80, 85, 85, 86, 93, 97, 107, 107, 107, 112, 114,
SQL
137, 146, 146, 151, 177, 221
Statement p. 210
TABLE p. 179
Transaction p. 22, 136, 137, 137, 146, 146, 147, 147, 148
Tri p. 89
Trigger p. 221
Tuple p. 55
type p. 157
Type p. 23, 107, 170, 170, 172, 172, 173, 173, 174, 177, 178
Types p. 122
p. 24, 28, 39, 40, 40, 41, 41, 42, 45, 46, 48, 48, 48, 50,
UML 51, 65, 66, 66, 67, 68, 68, 68, 68, 70, 70, 71, 72, 73, 73,
74, 187
UNDO-REDO p. 139
Union p. 75
UNION p. 88
UNIQUE p. 109
Utilisateur p. 112
Validation p. 136
Variables p. 203
VBA p. 129, 129, 129, 129, 129, 130, 130, 130, 130, 137
WHILE p. 158
Fiche de synthèse
Vue d'ensemble
En quoi une base de données est-elle plus intéressante qu'un système de fichier classique ?
.
.
.
.
.
Notions générales
Pourquoi est-ce que l'on distingue trois niveaux de modélisation lors de la conception d'une base
de données ?
.
.
.
.
.
Enoncer quelques actions à mener pour réaliser une spécification générale de l'existant et des
besoins ?
.
.
.
.
.
Le modèle E-A
Enoncer les principaux éléments composants le modèle E-A ?
.
.
.
.
.
Quelles sont les différences et points communs entre la diagramme de classe UML et le modèle
E-A étendu ?
.
.
.
.
.
Fiche de synthèse 259
Est ce que l'un des deux modèles conceptuels, E-A ou UML, est plus adapté au passage au
relationnel ?
.
.
.
.
.
Pourquoi dispose-t-on de trois méthodes pour traduire l'héritage dans un modèle relationnel ?
Ces trois méthodes sont-elles équivalentes ?
.
.
.
.
.
260 Conception de bases de données
Pourquoi dispose-t-on de trois méthodes pour traduire l'héritage dans un modèle relationnel ?
Ces trois méthodes sont-elles équivalentes ?
.
.
.
.
.
Algèbre relationnelle
Quels sont les opérateurs algébriques de base ? Quels sont les autres opérateurs ? Qu'est ce qui
les différencie ?
.
.
.
.
.
Le LMD de SQL
A quoi sert le LMD ?
.
.
.
.
.
Pourquoi est-il primordial de repérer les dépendances fonctionnelles sur un schéma relationnel ?
.
.
.
.
.
Le LDD de SQL
A quoi sert le LDD ?
.
.
.
.
.
Le LCD de SQL
Quels types de droits peuvent être accordés ou révoqués en SQL ?
.
.
.
.
.
Pourquoi peut-on dire que la gestion des droits est décentralisée en SQL ?
.
.
.
.
.
Généralités
Citez un bon et un mauvais cas d'usage d'Access.
.
.
.
.
.
Expliquer pourquoi Access est à la fois un SGBDR et un outil de création d'application. Est-ce
que des précautions particulières doivent-être prises à ce propos ?
.
.
.
.
.
Expliquer pourquoi les objets "requête" d'Access sont en fait des vues ?
.
.
.
.
.
Qu'est ce que QBE par rapport à SQL ? Quels sont ses avantages et inconvénients ?
.
.
.
.
.
Formulaires
A quoi servent les formulaires ?
.
.
.
.
.
Macro
A quoi servent les macros ?
.
.
.
.
.
Faut-il préférer l'usage des macros ou bien de code plus bas niveau ?
.
.
.
.
.
264 Conception de bases de données
Modules
A quoi servent le code VBA ?
.
.
.
.
.
Que peut-on faire avec un langage comme VBA que l'on ne peut pas faire en SQL en terme de
manipulation de données ?
.
.
.
.
.
Transactions
Pourquoi une transaction est-elle atomique ?
.
.
.
.
.
Fiabilité
A quoi sert le journal des transactions ?
.
.
.
.
.
Concurrence
Laquelle des propriétés ACID des transactions est-elle particulièrement utile pour gérer les accès
concurrents ?
.
.
.
.
.
SQL
A quoi servent les séquences sous Oracle ?
.
.
.
.
.
SQL*Plus
L'environnement SQL*Plus fournit-il des instructions pour accéder à la BD ?
.
.
.
.
.
PL/SQL
Un langage procédural est-il toujours utile à la réalisation d'une application d'exploitation d'une
BD ?
.
.
.
.
.
Exemple
Un trigger permet-il d'améliorer le contrôle des données ?
.
.
.
.
.
Oracle, avec les langages SQL, SQL*Plus et PL/SQL est-il, à votre avis, suffisant pour la
réalisation d'une application complète de base de données ?
.
.
.
.
.
Fiche de synthèse 267
Introduction : R, OO, RO
Quels sont les atouts du modèle relationnel-objet par rapport au modèle relationnel ?
.
.
.
.
.
Le modèle relationnel-objet
Quels sont les extensions les plus importantes apportés par le modèle relationnel-objet au
modèle relationnel ?
.
.
.
.
.
En quoi le modèle relationnel-objet peut-il être considéré comme plus proche que le modèle
relationnel du modèle conceptuel ?
.
.
.
.
.
Quelles solutions de modélisation apporte les instructions de création de type sous Oracle ?
.
.
.
.
.
268 Conception de bases de données
Exemples
L'utilisation d'OID pour les références est-elle préférable à l'utilisation de clés étrangères
classique, en particulier dans le cas où la clé étrangère est composée ?
.
.
.
.
.
Peut-on anticiper sur des problèmes de performance futurs lors de la conception d'une BD ?
.
.
.
.
.
Rappels HTML
A quoi sert un formulaire en HTML ?
.
.
.
.
.
Introduction à PHP
Comment se situe PHP dans une architecture Web ?
.
.
.
.
.
Pourquoi un langage comme PHP s'est-il développé ces dernières années à votre avis ?
.
.
.
.
.
PHP et BD
A quoi sert une API PHP d'accès à une base de données ?
.
.
.
.
.
Java et BD (JDBC)
Pourquoi un langage comme Java est-il appelé à être mobilisé dans le cadre de la conception de
BD ?
.
.
.
.
.
270 Conception de bases de données
Quelle sont les avantages des servlets par rapport à un langage comme PHP ?
.
.
.
.
.
Quelle sont les inconvénients des servlets par rapport à un langage comme PHP ?
.
.
.
.
.
Servlets et BD
Puisque Java et PL/SQL sont tous deux des langages de programmation applicatifs, quel est
l'intérêt de combiner Java et PL/SQL ?
.
.
.
.
.
MySQL et PHP
A quoi sert une API PHP d'accès à une base de données ?
.
.
.
.
.