Cours 2009

10/07/2009 [Tapez un texte]
1 Introduction

2009
Jean Yves CHIESA
Universit de Rouen
10/07/2009
Cours Bases de Donnes

2 Cours Bases de Donnes

3 Introduction

1. Introduction ................................................................................................................................................... 4
2. Le modle Entit-Association .................................................................................................................... 15
3. Le modle UML ........................................................................................................................................... 27
4. Le Modle Relationnel ................................................................................................................................ 32
5. Le langage de dfinition de donnes ........................................................................................................ 49
Cration de table ............................................................................................................................................. 49
Modification de table ...................................................................................................................................... 53
Suppression de table ....................................................................................................................................... 53
Renommage ..................................................................................................................................................... 53
6. Langage de contrle des donnes ............................................................................................................. 55
Privilges d'accs ............................................................................................................................................ 55
7. Le langage d'interrogation des donnes .................................................................................................. 57
Consultation des donnes. ............................................................................................................................. 57
Insertion de donnes ...................................................................................................................................... 70
Suppression de donnes ................................................................................................................................ 72
Mise jour de donnes ................................................................................................................................... 73
8. SQL - Programmation ................................................................................................................................ 75
ORACLE Triggers, procdures, fonctions et packages .............................................................................. 75
Oracle PL/SQL ................................................................................................................................................ 84
MySQL Triggers, procdures, fonctions ...................................................................................................... 97
MySQL Langage de Programmation ........................................................................................................ 102
SQL et JAVA .................................................................................................................................................. 105
SQL et L3G (C) .............................................................................................................................................. 123
9. 08Normalisation ........................................................................................................................................ 134
Formes Normales ............................................................................................................................................ 39
Normalisation d'une relation ........................................................................................................................ 43
10. 09MethodesDeConception ................................................................................................................... 144
11. 10StockageSurDisque ........................................................................................................................... 145
12. Indexation .............................................................................................................................................. 146
Cration d'index ............................................................................................................................................ 146
Suppression d'index ..................................................................................................................................... 147
Quelques indications sur les stratgies de cration d'index ................................................................... 147
13. 12ConceptTraitementTransactions ..................................................................................................... 148
Position du problme. .................................................................................................................................. 148
Mthodes de srialisation ............................................................................................................................ 150
Exclusion mutuelle. ...................................................................................................................................... 151
Proprits ACID ............................................................................................................................................ 151
Gestion des transactions .............................................................................................................................. 152
Les niveaux disolation ................................................................................................................................. 153
Les Verrous .................................................................................................................................................... 154
14. 13BasesDistribues ................................................................................................................................ 156

1. Introduction
CONCEPT DE BASES DE DONNEES
Pourquoi des bases de donnes ?
Le concept de bases de donnes n'est pas apparu tout d'un coup par magie dans le monde de
l'informatique, mais il tait "en l'air" depuis longtemps. Ds les premiers fichiers sur bande magntique,
on s'tait rendu compte des difficults qu'il y avait utiliser des informations spares, rparties, voire
mme dissmines, sur plusieurs supports.
Dans une entreprise, chaque programme possde son propre ensemble de donnes sur lequel porte le
traitement. Tant que ces ensembles ne se recouvrent pas, tout va bien. Mais ce n'est pratiquement jamais
le cas et une ou plusieurs informations sont frquemment prsentes sur plusieurs fichiers. On trouvera
ainsi habituellement des informations relatives la clientle la fois dans la chane de traitement de la
gestion commerciale (commandes, facturation, rglement), dans la chane de traitement de la
comptabilit (comptabilit, gestion de trsorerie, banque), voire dans la gestion des produits. Le
"gaspillage" des ressources matrielles (duplication du stockage) et humaines (re-saisie de l'information)
est alors patent.

Figure 1
De plus, par le simple fait des mises jour, ces informations ont de fortes chances de ne jamais tre au
mme niveau d'actualit. Ainsi, une mme information est souvent prsente sur un site informatique
avec des valeurs diffrentes.

5 Introduction
Ces problmes dits de la cohrence de l'information et de la redondance de l'information n'avaient bien
entendu pas chapps aux utilisateurs des dbuts de l'informatique de gestion, et de nombreuses
tentatives d'homognisation des fichiers taient mises en place dans la plupart des centres
informatiques. Vont dans ce sens la plupart des systmes de pointeurs entre les fichiers ou les
mcanismes de mise jour en mode "lot" (batch) voire les diffrentes routines d'extraction/intgration
souvent prsentes dans les logiciels de gestion.
Il parat vident de dire que, pour chercher une information, il est essentiel de savoir o elle se trouve !
En informatique traditionnelle, on est souvent amen se poser la question cause des nombreux
fichiers physiques mis en uvre. Une des ides qui a prsid l'mergence des bases de donnes est de
chercher avant tout privilgier la non redondance des informations. L'objectif est de rduire UN le
nombre de reprsentation physiques identiques d'une mme donne
1
.

Figure 2

1
La vrit oblige prciser qu'il s'agit du nombre de reprsentations "vues" par les utilisateurs, et non du nombre rel
d'occurrences en mmoire ou sur un support disque. En effet, les SGBD sont parfois amens dupliquer physiquement certaines
informations afin d'optimiser les moyens d'accs et donc les performances.
Ceci n'est cependant pas en contradiction avec le principe de base, car cette duplication est ralise par le systme lui-mme, avec
toutes les prcautions ncessaires

QUELQUES DEF I NI TI ONS
Base de donnes (BD) et Systme de gestion de bases de donnes (SGBD)

Une base de donnes (BD) reprsente lensemble (cohrent, intgr, partag, scuris, structur) des
informations ncessaires au fonctionnement dune entreprise, ensemble dont la gestion est assure par
un logiciel appel systme de gestion de base de donnes(SGBD). (1)
On entend ici par entreprise toute collectivit dindividus travaillant en coordination la ralisation
dun objectif commun.
Exemples de bases de donnes : celle qui permet la gestion des personnels, tudiants, cours,
inscriptions,... dune universit ou cole, celle du systme de rservation de places davion des
compagnies ariennes, celle qui permettent la gestion des comptes clients des socits bancaires,...
Banque de donnes

Une base de donnes est dveloppe au sein dune entreprise pour son propre fonctionnement.
Inversement, une banque de donnes est un ensemble de donnes, propres un domaine dapplication,
que des producteurs runissent pour ensuite en commercialiser lusage vers le public extrieur.
Exemples : les banques de donnes juridiques, conomiques, mdicales, des brevets, des proprits des
matriaux,...La constitution et lexploitation des banques de donnes font appel des techniques
spcifiques (tlmatique, par exemple), diffrentes des techniques bases de donnes.
On peut citer comme exemple des renseignements de bibliographie, de linguistique de justice, de
chimie, d'architecture, de cinmatographie, de biologie, d'astronomie, de gographie, de mdecine ou de
jeu. La banque de donnes est souvent quipe d'un moteur de recherche. Elle repose sur une ou des
bases de donnes.
Fichier

Dans une entreprise, il convient de faire appel lapproche base de donnes lorsque les donnes grer
sont de natures diverses (exemple : tudiants, cours, enseignants, salles,..) et possdent de nombreux
liens entre elles (exemple : un tudiant suit un cours, un cours est assur par un enseignant,..).
Il existe des cas o les donnes grer, bien quimportantes en volume, sont homognes : les abonns
dune revue, le personnel dune entreprise, les produits vendus par un magasin,... Dans ce cas, on
parlera de fichier (le fichier des abonns,...) et lon utilisera un systme de gestion de fichiers (SGF),
moins complexe quun SGBD. Toutefois, le prix dcroissant et la facilit dutilisation croissante des
SGBD sur micro-ordinateurs tendent faire disparatre progressivement ces pratiques. Elles ne
subsistent plus aujourdhui que pour des application dj existantes.
Tout systme dexploitation dun ordinateur contient un SGF spcifique. Toutefois, pour les
applications, on fait plutt appel des progiciels du commerce ( dBase, Filemaker,..), dun usage plus
simple et offrant des fonctionnalits plus labores.
Il est noter que limplantation physique dune base de donnes sur les mmoires secondaires se fait via
la notion de fichier. Le choix de ceux-ci, toutefois, reste de la comptence du SGBD et est invisible
lutilisateur.

7 Introduction
FONCTI ONS D UN SGBD
- Persistance des donnes sur disque
- Partage des donnes (gestion des conflits daccs)
- Intgrit (respect de contraintes de cohrence)
- Sret de fonctionnement (reprises aprs panne)
- Confidentialit (attribution de droits daccs)
- Archivage sur support externes (back-up)

MODELES DE DONNEES ET SCHEMAS
Au cours des diffrentes phases de la vie d'une base de donnes, plusieurs descriptions sont
successivement labores, chacune d'elle rpondant un objectif dtermin et complmentaire. Dans
l'tat actuel de l'art, ces descriptions ne peuvent tre faites avec le langage naturel, celui-ci tant trop
ambigu et trop difficile comprendre pour un ordinateur. On fait donc appel des langages formels,
bass sur un petit nombre de concepts bien tablis (les objets, les liens, les proprits, )
On appelle modle de donnes l'ensemble des concepts qui permettent la description en langage formel
d'une base et les rgles d'utilisation de ces concepts (leur grammaire). On appelle schma d'une base de
donnes l'expression de la description de la base obtenue en employant un modle de donne.
Lors de la conception d'une base de donnes, on passe en gnral par plusieurs tapes, chacune d'elles
pouvant tre plus ou moins informatise. Dans le cas gnral d'un projet d'une certaine envergure, on
peu distinguer au moins les phases de conception, d'implantation, de chargement des donnes,
d'utilisation. Dans le cas de petites bases de donnes simples, certaine de ces phases sont absentes voire
dans certains cas imposes par le SGBD.
Conception d'une base de donnes.
C'est la phase d'analyse du rel qui conduit dterminer le contenu futur de la base. Le premier
problme rsoudre est de dterminer les informations qu'il convient de stocker dans la base.
Dans cette phase, il s'avre ncessaire que les utilisateurs puissent changer avec les informaticiens du
contenu de leurs besoins. Il faut qu'ils puissent exprimer ceux-ci sous forme d'une description,
ventuellement partielle, de la future base. Dans cette phase, il est important de dterminer quelles sont
les informations ncessaires la vie de l'entreprise, indpendamment de la solution technique qui sera
retenue. La description de ces informations s'appuie ne gnral sur un ensemble de concepts qui ne font
pas rfrence l'informatique. Les modles utiliss sont dits "conceptuels".
La description ainsi obtenue est dite modle conceptuel des besoins. Un tel modle comprend en
gnral deux parties, le modle statique, permettant de dcrire la structure des donnes et le modle
dynamique, description des oprations sur les donnes.
De plus, quelque soit le modle conceptuel choisi, il n'est pas possible de dcrire toute la connaissance
que l'on possde sur le fonctionnement de l'entreprise, notamment les rgles de gestion. On complte
donc le modle en nonant des descriptions explicites de contraintes supplmentaires, dites contraintes
d'intgrit.
Cette activit est peut tre une des plus dlicates qui puissent exister dans le domaine des bases de
donnes. Cest pourquoi de nombreuses mthodes danalyse existent. Actuellement, celle dont on parle
le plus (mais est elle rellement la plus utilise ?) est la mthode UML, conue au dpart comme une
mthode danalyse des applications en gnral, mais qui a trs vite tendu son domaine aux bases de
donnes. En France, la mthode Merise continue tre trs applique dans les projets dune certaine
envergure.

Implantation d'une base de donnes.
La phase suivante, celle d'implantation, demande que les donnes du schma conceptuel soient
traduites dans les concepts du modle utilis par le SGBD choisi. On appelle modle logique (ou modle
machinable) le modle sur lequel est construit un SGBD actuel.
Il existe aujourd'hui plusieurs modles logiques, certains tant massivement prdominants
(hirarchique, rseau, relationnel, objet). Le schma obtenu en traduisant le modle conceptuel des
donnes sera appel le schma logique des donnes.
Quelques SGBD prennent en compte la totalit de la notion de schma.
Chargement de la base
Le chargement de la base de donnes avec la version initiale ncessite que soient fixs les choix en
matire de structuration des donnes sur le disque (quels type(s) de fichier(s), quels index ?). Ces choix
ne sont pas faits par les utilisateurs, mais par les administrateurs de base de donnes qui, en fonction de
leur analyse des traitements qui seront effectus sur la base, fixent les paramtres effectifs pour
l'implantation de la base de donnes dans le SGBD.
L'ensemble de ces choix sera consign dans ce qu'on appelle le schma interne de la base. Cette
description fait appel un nouveau modle, appel modle interne, o les concepts cls seront ceux de
fichier, organisation, index, chemin d'accs, cl,
Seuls les SGBD de haut de gamme permettent la mise en place de tels schmas. La plupart des SGBD sur
micro-ordinateur sont eux totalement pr-configurs.
Utilisation de la base
Au cours de la phase d'utilisation de la base de donnes, d'autres schmas sont labors pour rpondre
aux besoins spcifiques des utilisateurs. La plupart de ceux ci n'ont pas besoin de connatre l'ensemble
du contenu de la base. Chaque utilisateur n'a que des exigences limites (il n'est intress que par
certaines informations) et particulires (il souhaite une reprsentation qui lui convienne des
informations).
A ces utilisateurs, on peut associer un schma, dit schma externe, qui dfinit le sous ensemble de la
base auquel il a accs.

Figure 3

9 Introduction
Ce choix darchitecture a pour objectif daccrotre le niveau dindpendance entre les donnes et les
traitements, a savoir :
- lindpendance physique,
- lindpendance logique,
- lindpendance vis--vis des stratgies daccs.

Lindpendance physique consiste rendre lutilisation des donnes indpendante de leur organisation
physique (support de stockage et mthodes daccs). La modification de lorganisation physique des
donnes ne doit pas entraner, par exemple, la rcriture de programmes accdant ces donnes.
Lindpendance logique consiste rendre lutilisation des donnes indpendante de la structure logique
globale. La modification du schma conceptuel ne doit pas entraner la modification des programmes
dapplication. Une modification des schmas externes est cependant ncessaire dans ce cas.
Lindpendance vis--vis des stratgies daccs nintervient quau moment de la manipulation des
donnes. Un programme dapplication na pas prciser comment accder telle ou telle donne mais
uniquement ce quil dsire (le quoi et non pas le comment ). Cest le SGBD qui doit dduire le
meilleur chemin daccs aux donnes.
STRUCTURE TYPES DE DONNEES
Nous allons prsenter dans cette section quelques reprsentations de lorganisation et de laccs aux
donnes utiliss en base de donnes. Certaines nont plus quun intrt historique ou sont
ventuellement utilises dans des applications spcialises (hirarchique, rseau). Dautres sont en
concurrence difficile avec le modle relationnel, qui a envahi lensemble de lespace et ne rencontre
aujourdhui plus aucune rsistance.

Historique sommaire
Recherche Concepts Produits
1950 Structure hirarchique : les donnes sont reprsentes sous forme
dune arborescence
1960
1960 Structure rseau : les donnes sont reprsentes sous forme dun
graphe quelconque
1970
1970 Structure relationnelle : les donnes sont reprsentes sous forme
de tables
1980
1980 Modle objet : reprsentation sous forme dobjet et relationnel
objet : reprsentation relationnelle et extensions afin de stocker
les mthodes.
1990
Structure hirarchique
Ce modle est capable de crer et de grer des bases de donnes dont les relations entre les divers
lments logiques sont du type communment appel "un n".
Prenons l'exemple des cartes grises des automobiles.
Pour dcrire une carte grise, il faut un fichier contenant le nom de la personne, la marque du vhicule, le
numro d'immatriculation. Une personne pouvant possder plus d'un vhicule, on admettra que la
partie relative celui ci, marque et numro d'immatriculation, est prsente de "une" "n" fois. On voit
donc qu'il existe dans ce fichier deux types de relations entre les donnes : d'une part des relations "1

n" entre une personne et les vhicules qui lui appartiennent et d'autre part une relation "1 1" entre un
vhicule et son propritaire.
La dcomposition hirarchique de ce fichier est illustre par la figure qui met en vidence les divers
ensembles et sous ensembles de donnes.
A partir de cette dcomposition, il est possible de reprsenter schmatiquement l'arborescence de la base
de donnes (figure ) : un nom d'individu "pointe" sur un sous-ensemble d'informations relatives un
vhicule, ce sous ensemble tant prsent "n" fois, c'est--dire autant de fois que l'individu possde de
vhicules. On peut constater que cette dcomposition en ensembles et sous ensembles n'est pas rserve
une approche du problme par les bases de donnes ; une solution classique de fichier aurait eu
recours la mme structure de donnes. Cependant, dans ce cas, tout choix d'organisation tait dfinitif,
cause de la dpendance entre l'organisation physique des donnes et les techniques de
programmation.
Une ralisation sous forme de base de donnes permettra en partie de s'affranchir de cette contrainte,
mais en partie seulement. En effet, il est obligatoire de dfinir, au moment de la cration de la base,
l'ensemble des liens logiques crer (figure).
Un des principaux inconvnients d'un tel systme rside dans sa relative rigidit. Il faudra veiller
organiser la base selon un schma correspondant aux accs les plus courants. En effet, dans un tel
modle, les lments terminaux ne peuvent tre atteints que par les lments racines. Un problme
majeur intervient lorsque les questions poses sont du type : "Donne moi tous les lments pres
possdant des racines de tel type".
Un parcours intgral de la base sera alors ncessaire et, si ces parcours sont nombreux, l'utilisation de la
base sera alors aussi onreuse que celle d'un bte fichier squentiel.
De plus, le parcours oblig de la structure darbre pour accder aux donnes provoque forcment une
redondance des donnes. Or la redondance crant lincohrence
Structure en rseau
Dans les annes 1970 commence la dfinition dun nouveau type de gestionnaire de bases de donnes,
destin pallier toutes les faiblesses cites du modle hirarchique. Cest en 1971 que sort le rapport
dun groupe de travail runissant fabricants dordinateurs et utilisateurs, connu sous le nom de
Codasyl Data Base Task Group Report . Ce rapport reprenait, en les dveloppant, les ides qui
venaient dtre mises en uvre par C. Bachman dans la conception du SGBD IDS. Ce rapport eut un
retentissement suffisant pour que trs rapidement se rpandent des SGBD de type rseau, aux normes
Codasyl .
Fournisseur
...
...
Article
...
...
Type Article

Figure 4
Une des ides de base est de permettre laccs aux informations par diffrents liens, de saffranchir de la
relation parents/enfants qui est contenue dans une structure hirarchique. Considrons lexemple
suivant : une entreprise a un certain nombre de fournisseurs. Chaque fournisseur propose des articles
regroups suivant diffrents type articles (chaudronnerie, lectricit, gros-uvre, charpente, ).

11 Introduction
Chaque article est caractris par une rfrence chez le fournisseur et un prix. Cette ralit est facilement
mise en uvre par le diagramme hirarchique de la Figure 4. Cependant il arrive frquemment que
plusieurs fournisseurs proposent le mme article. Si alors on souhaite effectuer une recherche sur les
diffrents prix des articles similaires, on imagine facilement que le parcours de la base hirarchique va
devenir dune complexit importante. Le principe dune base rseau est de permettre de crer des liens
entre des lments sans dpendance de type parents/enfants entre eux, comme les articles dans notre
cas.
Fournisseur
...
...
Article
...
...
Type Article
Fournisseur
...
...
Article
...
...
Type Article

Figure 5
Bien entendu, la complexit dune telle base va crotre trs vite en fonction du nombre de liens
supplmentaires que lon va vouloir mettre en uvre. Partant, les temps daccs vont aussi crotre et il
faudra souvent tudier srieusement les cots compars dun accroissement du nombre de liens par
rapport des redondances (nous retrouverons dailleurs ces mmes problmatiques sous une forme
lgrement diffrente dans le modle relationnel). Il faut galement noter que dans les deux modles de
bases de donnes hirarchique et rseau, la souplesse apparente lie la possibilit de faire crer par le
systme tous les pointeurs dsirs est en pratique limite par la ncessit de dfinir, au moment de la
cration de la base, lensemble des pointeurs et des chemins daccs voulus. Toute modification
ultrieure implique souvent une refonte de la base et (et des programmes dexploitation).
Structure relationnelle
Face cet ensemble de difficults se sont progressivement imposes sur le march les bases de donnes
relationnelles, dans lesquelles ces contraintes de navigation par des pointeurs prdtermins nexistent
plus. Ces dernires fonctionnent sur le principe selon lequel cest le contenu de la question qui va
dterminer les chemins daccs tablir . Les liens ne sont plus fixs une fois pour toutes dans le
SGBD, cest le systme qui les fabriquent dynamiquement selon les besoins. Le systme agit par
dduction partir de la question. Lorsque celle ci implique la consultation des fichiers W et X, les
liens entre ces fichiers seront raliss entre ceux ci en fonction des noms de zones communs ces
fichiers. Il sera possible tout moment dajouter ou de supprimer des fichiers dans la base de donnes.
PAIE
Matricule
Date
Montant
...
EMPLOYES
Matricule
Date entre
Nombre enfants
...
HISTORIQUE
Matricule
Date d'entre
Anciennet
...

Figure 6
La Figure 6 montre le principe du regroupement en tables des donnes appartenant des fichiers
diffrents dune base relationnelle. Lors dune interrogation portant sur le montant de la paie et
lanciennet de lemploy, les deux tables PAIE et HISTORIQUE seront chans pour trouver la rponse.
Si la donne nombre denfants est aussi mentionne, la table EMPLOYES sera aussi connecte

logiquement et physiquement pour participer la recherche. Il va de soit que la donne commune
matricule doit figurer dans chacune des tables, sinon tout chanage serait impossible.
Bases de donnes objet
La technologie oriente objet est un domaine la situation un peu floue dans le domaine de la gestion
des donnes. Laugmentation du niveau dabstraction introduit par les concepts dobjet, de classes, de
mthodes, de messages entre les objets a prouv sa valeur dans le domaine de la programmation. Il tait
donc naturel que la communaut des bases de donnes tente dappliquer ces concepts. De plus, partir
du moment ou les informaticiens manipulaient des objets, il tait naturel que se pose la question de la
persistance des donnes, autrement dit du stockage de ces donnes. Et l, les bases de donnes
relationnelles, avec la pauvret de leur structure, apparaissaient nettement dfavorises.
Aprs un moment de confusion, ou certains ont pu prdire la fin du modle relationnel, la situation est
actuellement relativement claire.
Dun ct, de nouveaux concepts de bases de donnes, purement objet, permettent de dvelopper des
produits dont lobjectif essentiel est de prolonger les dveloppements objets dans le domaine du
stockage. Cest le cas de J2EE qui propose depuis longtemps un modle de composants prdfinis (les
EJB Entities) conu pour faciliter la mise au point de cette couche de persistance. Certaines socits ont
galement tent laventure de produits commerciaux, avec plus ou moins de bonheur. Il semble que le
problme des performances soit difficile rgler.
Dautre part, les grands diteurs de bases de donnes relationnelles prolongent maintenant leurs
produits avec des extensions orientes objet, permettant de continuer lutilisation des concepts
relationnels, en les tendant si ncessaire. Cest le cas dOracle ou de Postgres par exemple.

SGBD : LES ACTEURS DU MARCHE
La thorie est une chose, la ralit commerciale en est une autre. Il existe des centaines de bases de
donnes (sans parler des prototypes universitaires ou autres). Cependant il faut avoir conscience que,
dans la ralit des entreprises, le march se partage entre quelques grands acteurs. Essayons den
donner un rapide panorama. Je ne dirai rien des SGBD de type bureautique comme Access, FoxPro,
FileMaker, 4D, Omnis. Non pas quils ne soient pas intressants, mais la plupart, pour des raisons
diverses, sont trop loin des concepts qui caractrisent un SGBD.
Les bases de donnes relationnelles commerciales
Editeur Version et OS Remarques
Oracle
www.oracle.com
Tous OS Acteur historique du march. Faible marketing, mais
sans cesse lafft de complments et de nouveauts.
Peu facile utiliser
IBM
www.ibm.com
DB2
Tous OS
Llphant a du mal danser face Microsoft. Mais
reste un acteur incontournable et mne un combat
impitoyable, en se dfendant pied pied face son
challenger.
Microsoft
www.microsoft.com
SQL Serveur
Uniquement Windows
Ultra facile utiliser et administrer. Nombreuses
extensions intressantes (data mining, replication, ).
Sybase
www.sybase.com
Quasiment tous OS
Informix
www.informix.com
Unix Like et Windows Un acteur historique, rcemment rachet par IBM. La
fin dune histoire ?

13 Introduction

Les bases de donnes relationnelles Open Source
MySQL
www.mysql.com
Linux, Windows,
Mac OS X
Optimis pour la vitesse, pche encore par de
nombreux manques sur des concepts relationnels
comme les transactions ou lintgrit rfrentielle (qui
devraient tre introduites dans la version 5)
PostgreSQL
www.postgresql.org
Linux, Unix, MacOS X et
Windows
Cest lantithse de MySQL. Implmentation de la
plupart des concepts relationnels, au dtriment de la
vitesse disent certains
SAP
www.sapdb.org
Linux, Unix, MacOS X et
Windows
A ne pas confondre avec lERP du mme nom. Semble
actuellement (Fvrier 2003) en processus de fusion
avec MySQL
Borland
www.borland.com
Linux, Windows, Solaris Le produit sappelle Interbase. Il est surtout
commercialis avec les outils de dveloppement de
lditeur (Delphi, C++, Kilyx, )
Four Thought
www.4suite.org
Windows, Linux
Sleepycat Software
www.sleepycat.com
Windows , Linux, Solaris Le produit sappelle Berkeley DB

www.ozone-db.org
Tous systmes
(dveloppement en Java)

Les bases de donnes objet
Matisse
www.matisse.com
Windows, Unix Stockage direct dobjets provenant de Java, C#, VB,
Delphi, Eiffel, Smalltalk, Perl, Python, PHP
Objectivity
www.objectivity.com
Windows, Unix
Versant
www.versant.com
Solaris, Windows Stockage direct des objets de J2EE
Les bases de donnes XML
Avec la gnralisation de lengouement pour XML, il tait fatal que les SGBD sy collent. Deux
approches existent actuellement. Chez Oracle ou IBM, le principe est de fournir une surchouche de
procdures permettant de stocker et de retrouver de manire transparente des donnes XML dans une
base de donnes relationnelle. Une autre approche consiste stocker directement les donnes sous
forme XML. Cest un peu celle de Microsoft dans le projet Yukon , future version de SQL Server.
Certains diteurs tentent aussi le pari. Peu de commentaires, javoue peu connatre ce domaine.
Wolfgang Meyer
exist.sourceforge.net
eXist 0.9.2
sous Java

Apache
xml.apache.org/xindice
Apache Xindice 1.0
Windows, Linux

Software AG
www.softwareag.com
Tamino 4.1.4
Windows, Solaris, Unix

Ipedo
www.ipedo.com
Windows, Unix
IxiaSoft
www.ixiasoft.com
Windows, Unix

Rpartition du march
Les chiffres suivants concernent lanne 2006 (source http://www.journaldunet.com (2)) :
Taille du march: 16,45 milliards de dollars (revenus des licences)

PDM 2006
(source IDC)
PDM 2004 PDM 2002 PDM 2001
IBM 21,2 % 34,1% 36,2% 33,9%
Oracle 44,4 % 33,7 % 33,9% 39,7%
Microsoft 18,6 % 20 % 18,0% 14,3%
NCR 2,8 % 2,9 % 2,7% 2,4%
Autres 9,2% 9,7%

Si IBM se taille la part du lion (mais son offre est trs diversifie sur plusieurs gammes de machines, du
poste individuel au serveur dpartemental, avec diffrents types de bases de donnes), on constate que
la lutte se situe essentiellement entre Oracle, crateur historique de la base de donnes relationnelle, et
Microsoft, challenger encore handicap par son approche mono plate forme (Windows exclusivement).
Les parts de march dOracle dcroissent continuellement au profit de Microsoft, en raison
essentiellement dune politique de prix extrmement agressive de la part de Microsoft, mais aussi de la
monte en puissance de Windows Server, avec lequel SQL Server est de plus en plus propos comme
produit de Back Office . Microsoft essaye avec ce produit de rejouer le coup de lintgration qui
avait tellement bien russi avec Internet Explorer. Ces chiffres ne font cependant pas apparatre que, en
production, Oracle reste le support de bases de donnes nettement plus volumineuses et complexes que
SQL Server.
Dans le monde de lOpen Source, MySQL se taille la part du lion
Parts de march des SGBD Open Source parmi les dveloppeurs de bases de donnes qui en
utilisent au moins un
Rgion Part de march 2004
MySQL 52,9%
FireBirdSQL 51,6%
PostgreSQL 14,8%
Sleepycat's Berkeley DB 4,1%
GNU SQL 3,3%
SAP DB 1,2%
Source : Evans Data
Le march des SGBDR dans le monde en 2006
(en millions de dollars)
Acteur CA 2004 CA 2005 CA 2006 PdM 2006
Variation
2005 / 2006
Oracle 6 003 6 376 7 312 44,4% +14,7%
IBM 2 923 3 113 3 483 21,2% +11,9%
Microsoft 2 013 2 442 3 052 18,6% +25,0%
Sybase 471 503 524 3,2% +4,3%
NCR 390 423 457 2,8% +8,0%
Autres 1 495 1 542 1 624 9,9% +5,3%
Total 13 296 14 398 16 451 100,0% +14,3%
Source : IDC

15 Le modle Entit-Association
2. Le modle Entit-Association
CONCEPTS DE BASE ET DI AGRAMMES EA
Le modle entit-association (EA, appel aussi entit-relation) est un modle de donnes de type
conceptuel. Il est actuellement utilis par la plupart des mthodes et outils daide la conception
(MERISE,...). C'est un modle limit la description statique : son but est de permettre la description des
structures de donnes exclusivement, sans prjuger des traitements qui s'effectueraient sur ces
structures.
Lide fondamentale de ce modle est de retenir comme concepts de base les concepts gnriques
(objets, liens, proprits) utiliss dans le processus dabstraction qui conduit de lobservation dune
ralit sa description. On suppose que la perception d'une situation observe se fait naturellement sur
la base de l'identification des objets prsents (concrets ou abstraits), des liens entre ces objets et des
proprits observables de ces objets.
Afin de distinguer le discours sur la ralit (fait en termes d'objets, de liens et de proprits) du discours
sur la reprsentation de la ralit, le modle EA renomme ces mmes trois concepts avec une
terminologie particulire :
OBJET ENTITE
LIEN ASSOCIATION
PROPRIETE ATTRIBUT

Entit objet du monde rel (concret ou abstrait), propos duquel on veut
enregistrer des informations et qui a une existence propre. Une
entit existe indpendamment du fait quelle est lie dautres
objets de la base de donnes.
Exemples : Mme Dupont, Mr. Durand, la cafetire X32,
latelier de fabrication A22, le service Comptabilit,...

Type dentit (TE) reprsentation dune classe dentits perues comme similaires et
ayant les mmes caractristiques.
Exemples : employs (reprsentation de la classe des
employs), produit, atelier de fabrication, service,...

Association lien entre plusieurs entits o chacune delles joue un certain rle.
Si lassociation lie deux (ou plus) entits du mme type, elle est
dite cyclique et, dans ce cas, la spcification du rle de chaque
entit est indispensable pour supprimer les ambiguts possibles.
Exemples : latelier de fabrication A22 fabrique la cafetire
X32; lemploy Durand travaille dans le service
Comptabilit; Mr Durand, poux, est mari avec Mme
Dupont, son pouse,...

Type dassociation (TA) reprsentation dun ensemble dassociations similaires ayant les
mmes caractristiques (liant des entits de mme type avec les
mmes rles, et possdant les mmes proprits).
Exemples : fabrique lie un atelier de fabrication un
produit; travaille lie un employ un service; est mari
avec lie une personne, lpoux une personne, lpouse,..

Attribut proprit associe un TE, ou un TA, ou participant la
composition dun autre attribut.
Exemples : nom, prnoms, salaire sont des attributs du TE
employ; quantit-en-fabrication est un attribut du TA
fabrique; date-de-mariage est un attribut du TA est mari
avec; jour, mois, anne sont des attributs composant un
attribut date,...

On appelle occurrence dun TE (TA) la reprsentation dans la base de donnes dune entit (association)
appartenant la classe dcrite par le TE (TA). On appelle population dun TE (TA) lensemble des
occurrences du TE (TA). La base de donnes dcrite par le schma EA est l'ensemble des populations
des TE et TA apparaissant dans le schma
Une occurrence de TE est constitue dun ensemble de valeurs : une valeur pour chaque attribut du TE
(NB : il est possible que la valeur dun attribut soit en fait une absence de valeur ou un ensemble de valeurs).
Une occurrence de TA est constitue dun ensemble de valeurs (ventuellement vide) et dun ensemble
doccurrences de TE : une valeur pour chaque attribut du TA, (sil en existe), et, pour chaque rle du TA,
une occurrence du TE qui joue ce rle.
Il faut remarquer que les termes type, population, occurrence sont gnriques (ne sont pas propres au
modle EA).
Le modle EA permet une reprsentation graphique assez lisible dun schma dune base de donnes.
Dans cette reprsentation, appele diagramme EA, les types dentits sont reprsents par des
rectangles; les types dassociations sont reprsents par des losanges ou autre symbole similaire (ellipse,
hexagone, rectangle arrondi,...). Les attributs sont soit rattachs au TE (TA) par des traits, soit lists
lintrieur du rectangle TE (losange TA), au dessous du nom du TE (TA) et spars de celui-ci par une
barre (voir diagrammes MERISE, par exemple).

Par exemple, le diagramme EA suivant illustre un schma possible pour la gestion d'un supermarch :
Employ
Rayon
chef Fournisseur
Article
emploi
vente
livraison
NomA
Type
NomF
Adresse
sup
inf
Quantit
Quantit
Nom
Sal
NomR
Etage
F
A
R
A R
E
R

Dans ce diagramme, sont reprsents quatre types dentits :
- Employ, dattributs nom et sal,
- Rayon, dattributs nomR et tage,
- Article, dattributs nomA et type,
- Fournisseur, dattributs nomF et adresse.

Ces types dentit sont relis par les types dassociation suivants :
- Livraison, dattribut quantit, liant Fournisseur (avec le rle F), Article (avec le rle A) et Rayon
(avec le rle R),
- Vente, dattribut quantit, liant Rayon (avec le rle R) et Article (avec le rle A),
- Emploi, liant Employ (avec le rle E) et rayon (avec le rle R),
- Chef, cyclique, liant Employ (avec le rle Inf) et Employ (avec le rle Sup).

GENERALI SATI ON / SPECI ALI SATI ON
Un type entit reprsente une classe dobjets du monde rel perus comme similaires et ayant les mmes
caractristiques. Or, il arrive parfois quun mme ensemble dobjets soit peru dun certain point de vue
comme une seule classe, mais en mme temps peru dun autre point de vue, comme plusieurs classes,
diffrentes malgr lexistence de caractristiques communes.
Exemple : dans le diagramme du paragraphe prcdent, le TE Article regroupe tous les articles
vendus, quels quils soient; certains traitements doivent pouvoir accder de faon uniforme tous
les articles : inventaire, recherche des caractristiques dun article dont on connat le code,...
Pour dautres usages, on peut nanmoins vouloir sparer les articles en plusieurs classes
(alimentation, habillement, Hi-Fi, hygine,..). Par exemple, la gestion des ventes promotionnelles
naura pas les mmes critres suivant la catgorie, les articles dalimentation doivent tre retirs
des rayons lorsque la date limite de vente est dpasse. Chaque classe peut avoir des
caractristiques qui lui sont propres, par exemple : date limite de vente (alimentation), taille et
couleur (habillement),...
On sera donc amen dcrire, en plus du TE gnrique Article, des TE plus spcialiss, reprsentant les
classes intressantes (celles sur lesquelles on a effectivement quelque chose de particulier faire). Par
exemple, un TE Article alimentaire , un TE Article dhabillement et un TE Article Hi-Fi .
Ceci, toutefois, introduit une situation atypique : celle o les mmes objets sont reprsents par deux TE
(le TE gnrique et lun des TE spcialiss), alors que normalement les populations de deux TE
reprsentent des classes dobjets disjointes.

Pour dcrire une telle situation, les modles de donnes rcents incluent le concept de
gnralisation/spcialisation : un lien, orient, dun TE spcialis (ou spcifique) vers un TE gnrique.
La smantique de ce lien est que toute occurrence du TE spcifique est galement occurrence du TE
gnrique. Graphiquement, ce lien est reprsent par une flche oriente du TE spcifique vers le TE
gnrique.
Pour lexemple de lhypermarch, cela donne le diagramme suivant pour la reprsentation des
articles :
Article
Art. Alimentaire Art. Habillement Art Hi-Fi

Les liens de gnralisation/spcialisation sont souvent appels liens est-un ; on dit que Article
alimentaire est-un Article . On dit gnralement que le TE spcifique est un sous-type du TE gnrique
qui lui est un sur-type du TE spcifique.
Par convention, les attributs communs au TE gnrique et aux TE spcialiss ne sont dcrits, dans le
schma, que comme attributs du TE gnrique. Nanmoins, ils sont implicitement inclus dans les
attributs des TE spcifiques : on dit que ces derniers hritent des attributs du TE gnrique. En plus
des attributs hrits, les TE spcifiques peuvent avoir des attributs propres.
Ce qui a t dit pour les attributs sapplique galement aux TA (description, hritage). Par exemple, le
TE Article Hi-Fi , comme les autres TE spcifiques, est implicitement li par les TA Vente et
Livraison, hrits du TE Article. Il pourrait, en plus tre li par un TA Rparation un TE Service aprs-
vente (tel type darticle est rpar par tel service aprs-vente). Ce dernier TA nest dfini alors que pour
les articles du TE Article Hi-Fi.
Un diagramme plus complet pour lexemple hypermarch est donc :
Service
Aprs-Vente
Rparation
Article
Hi-Fi
Article
Habillement
Article
Alimentaire
Article Vente
Livraison
Marque
NomA
Type
Ncode
Quantit en stock
Puissance
limite vente
Tailles Couleurs


Il nest pas ncessaire que les TE spcifiques reprsentent, dans leur ensemble, tous les objets
reprsents par le TE gnrique. Ainsi, dans lexemple, les articles dhygine, de bricolage,.. ne
constituent pas dautres classes spcifiques et sont donc uniquement reprsents par le TE Article.
Un TE gnrique peut son tour tre sous-type dun autre TE : on dit alors que lon a une hirarchie de
gnralisations.
On parle de gnralisation multiple lorsqu'un TE est sous-type de plusieurs autres TE. C'est le cas dans
cet exemple du charg de cours, qui est la fois thsard et vacataire. La gnralisation multiple pose des
problmes lis l'hritage : viter d'hriter deux fois d'un anctre commun, viter d'avoir des conflits
d'hritage (par exemple sur des problmes d'attributs de mme nom).

Personne
Etudiant Employ
Thsard Enseignant Technicien Administratif
Vacataire Professeur
Laboratoire
Sujet
Classe de
Traitement
Section
Nmatricule
Nom
Prnom

DESCRI PTI ON D UN SCHEMA EA
Un TE est dcrit par les spcifications suivantes :
- le nom du type dentit;
- le nom du sur-type dentit, sil existe;
- une dfinition libre (commentaire) prcisant la population exacte du type dentit,
- la description des attributs du TE

Exemple : description du TE Employ
- nom : Employ
- dfinition : toute personne salarie par lentreprise en ce moment
- attributs : nom, salaire (avec leurs description)

Remarques :
- deux TE diffrents ne peuvent avoir le mme nom;

- la dfinition libre est une partie trs importante de la description dun TE. Cest elle qui permet de
dfinir exactement, de faon non ambigu, la population du TE. Elle inclut notamment la spcification
temporelle (souligne dans lexemple), qui permet de savoir si le contexte modlis couvre uniquement
la situation actuelle ou aussi lhistorique (les situations antrieures) et/ou la prospective (situation
venir).
Un TA est dcrit par les spcifications suivantes :
- le nom du type dassociation;
- une dfinition libre (commentaire) prcisant la population exacte du type dassociation;
- les noms des TE participant au TA, avec leur rle;
- pour chaque rle, ses connectivits (souvent appeles cardinalits) : cest une information
supplmentaire exprimant la rgle de participation des entits dans les associations (au niveau
des occurrences). Les connectivits consistent en deux nombres, min et max, spcifiant le nombre
minimal et le nombre maximal doccurrences du TA qui peuvent, un instant donn, lier par ce
rle une occurrence dtermine du TE en question. min et max sont deux entiers tels que
max>min, min>0, max>1;
- - la description des attributs du TA, sil en existe.

Exemple : description du TA Emploi
- nom : Emploi
- dfinition : lie un employ au rayon dans lequel cet employ travaille aujourdhui
- TE participants : <Employ, E>, <Rayon, R>
- connectivits : E: min=0, max=1 R: min=0, max=n;
- attributs : ---
Les connectivits possibles pour un rle (ici, E de Emploi) et leur signification sont les suivantes :
min=0 : un employ peut ne travailler dans aucun rayon
min=1 : un employ doit travailler dans au moins un rayon
max=1 : un employ ne peut travaiiler dans plus dun rayon
max=n : un employ peut travailler dans plusieurs rayons

Conventions graphiques :
min=0, max=1 sont reprsents par un trait unique discontinu
min=1, max=1 sont reprsents par un trait unique continu
min=0, max=n sont reprsents par deux traits discontinus
min=1, max=n sont reprsents par deux traits lun continu et lautre discontinu.
Une autre faon de faire est de reprsenter les connectivits par deux chiffres (min,max ou min:max) au
voisinage du trait continu reprsentant le lien correspondant :
Parent est parent de Enfant est parent de
0,n 2,2

Signification des connectivits dans ce diagramme : un parent peut avoir de 0 n enfants; un enfant a toujours
(dans cette base de donnes) deux parents.

Cas particuliers des TA cycliques : un TA est dit cyclique sil lie plusieurs fois le mme type dentit
(avec des rles diffrents). Dans ce cas , le nom des rles est essentiel et il faut, dans un diagramme, les
noter sur les pattes de TA.
Exemples : les produits sont composs dautres produits
Produit Composition
est compos de
est composant de
quantit

Si lon enregistre dans la base de donnes la composition du produit 10001 : 5 units de produit 512 et 3
units de produit 123, on obtiendra les occurrences suivantes :
TE Produit produit 123
produit 512
produit 10001

TA Composition est compos de est composant de quantit
produit 10001 produit 123 3
produit 10001 produit 512 5

Les produits peuvent leur tour apparatre dans le TA composition avec le rle est compos de , si ce
ne sont pas des produits de type matire premire.
Un attribut est dcrit par les spcifications suivantes :
- nom de lattribut
- dfinition libre (libell en clair)
- connectivits : min et max, spcifiant combien de valeurs de cet attribut sont autorises (au
minimum, au maximum) dans une occurrence du TE (TA), si lattribut est directement rattach
au TE (TA), dans une valeur de lattribut dont il est composant sinon (voir ci-dessous);
- si lattribut nest pas compos dautres attributs : domaine de valeurs associ, spcifiant quel
ensemble des valeurs est autoris pour lattribut;
- si lattribut est compos dautres attributs : description des attributs composants.

Exemple 1 : description de lattribut nom du TE Employ
nom : nom
dfinition : nom de lemploy, nom de jeune fille pour une femme
connectivits : min=1, max=1 (tout employ a un nom et un seul)
domaine de valeurs : l'ensemble des chanes de caractres de longueur infrieure 15.

Exemple 2 : description dun attribut date de naissance dun TE Personne
nom : date de naissance
dfinition : date de naissance de la personne
connectivits : nim=1, max=1
composition :
nom : jour
dfinition : jour de naissance de la personne
domaine de valeurs : les entiers de lintervalle [1,31]

nom : mois
dfinition : mois de naissance de la personne

nom : anne
dfinition : anne de naissance de la personne

TERMI NOLOGI E
On appelle
attribut simple : un attribut qui nest pas dcompos en dautres attributs. Ses valeurs sont atomiques.
Un domaine lui est associ.
Exemple : salaire, tlphone

attribut complexe : un attribut qui est dcompos en dautres attributs. Ses valeurs sont des valeurs
composes.
Exemple : adresse compose de rue, ville, code postal.

attribut monovalu : un attribut qui ne peut prendre quune seule valeur par occurrence (connectivit
max=1)
Exemple : nom, date de naissance

attribut multivalu : un attribut qui peut prendre plusieurs valeurs par occurrence (connectivit max>1)
Exemples : prnoms, tlphones

attribut obligatoire : un attribut qui doit prendre une valeur au moins par occurrence (connectivit
min=1)

Exemple : nom, prnoms
attribut facultatif : un attribut qui peut ne pas prendre de valeur dans une occurrence (connectivit
min=0)
Exemple : salaire, tlphone

CLES DES TE ET TA
Une cl, ou un identifiant, dun TE (TA) est un ensemble minimum dattributs tel quil nexiste pas deux
occurrences du TE (TA) qui ont la mme valeurs pour ces attributs.
Un TE (TA) peut avoir plusieurs cls.
Exemple : nemploy et (nom+prnoms) sont deux cls du TE Employ, si dans cette entreprise il
ny a jamais deux employs ayant les mmes noms et prnoms.

Une cl peut tre dsigne sur un diagramme en la soulignant.
Cl dun TA
Personne Mariage
Epoux
Epouse
date
Nom
Sexe
Etat-civil
....
0:1
0:1

Exemple : une occurrence du TA mariage est un triplet :
< un poux, une pouse, une date>
Si lon admet que lattribut nom est la cl de Personne, la cl de mariage est : poux.nom, ou
pouse.nom.
Cette dfinition nest valable que si la population du TA Mariage ne contient que les mariages en
cours (on ne garde pas lhistorique). si le TA mariage conservait lhistorique (les mariages passs),
les connectivits des deux rles seraient 0,n et la cl du TA serait :
poux.nom + date ou pouse.nom + date
car il nest pas exclu que les deux mmes personnes se remarient une deuxime fois aprs avoir
divorc.

Un TA dont tous les rles ont une connectivit maximum suprieure 1, a, en gnral, une cl
constitue de lensemble des cls des TE lis.
Exemple : soit un TA Contrle, avec une occurrence (donc une moyenne, et un ensemble de notes)
par tudiant et par matire suivie.

Etudiant Contrle Matire
Ncarte Notes Moyenne Coef NumMat
1,n 1,n

En supposant que les cls de TE soient comme indiqu sur le diagramme, la cl du TA Contrle
est :
Etudiant.Ncarte + Matire.NumMat
Nanmoins, il nest pas toujours vrai que la cl dun TA soit constitu de lensemble des cls des TE
lis. Si lun des rles du TA a une connectivit maximum gale 1, la cl du TE associ ce rle est
une cl du TA.
Exemple : soit le TA suivant :
Personne
Assure
Voiture
Cie Assurance NomA
NumV
NomP
0,n 1,1
1,n

La cl du TA Assure n'est pas
Personne.NomP + CieAssurance.NomA + Voiture.NumV
car ce triplet ne constitue pas un ensemble minimal. En effet, lattribut Voiture.NumV suffit lui
seul, pour identifier une occurrence dAssure. Ceci est d la connectivit 1,1 du rle de Voiture
dans le TA, qui garantit que pour une valeur de numV il ny aura jamais quune seule occurrence
dAssure avec cette valeur de NumV.

Rgle : si le TA a une connectivit maximum gale 1 pour un de TE lis, alors toute cl de ce TE est
une cl du TA
Une autre rgle peut tre tablie pour les cas o plusieurs occurrences du TA lient les mmes
occurrences de TE. Dans lexemple ci-dessous, plusieurs commandes peuvent tre passes par un
mme client pour un mme produit des dates diffrentes. Dans ce cas lidentifiant de TA contient
au moins un attribut du TA.
Produit
Commande
Client
Nproduit Ncommande
Date
Quantit
Nclient
0,n 0,n

Le TA Commande a ici deux cls :
Nproduit + Nclient + Date ou Ncommande

Cl dun TE faible
Un TE faible est un TE dont aucun sous-ensemble dattributs ne constitue une cl (il ny a pas de cl qui
lui soit interne), et qui est li par un TA binaire de connectivit (1,1) un autre TE dont il dpend.
Dans lexemple ci-dessous, Exemplaire (qui reprsente un exemplaire dun livre) est un TE faible
(N ex nest pas une cl) dpendant du TE Livre.

Livre Exemplaire
ISBN Titre
Nex Etat
est un
1:n 1:1

La cl dun TE faible (qui est la mme que celle du TA) est constitue de la cl du TE dont il dpend et
dun (ou plusieurs) attribut du TE faible.
La cl de Exemplaire (et de est un ) est : ISBN + Nex

Cl d'un TE sous-type
Soit E un TE sous-type d'un TE E', alors tout identifiant de E' est aussi cl de E. E n'a pas ncessairement
de cl qui lui soit propre. Dans l'exemple dj cit du supermarch, Article Alimentaire, Article Hi-Fi et
Article Habillement ont tous trois comme cl la cl de Article.
CONTRAI NTES D I NTEGRI TE
Les concepts dentit, dassociation, attribut et sous-type ne suffisent pas dcrire tout ce qui caractrise
les donnes dun schma EA.
Soit, par exemple, le diagramme suivant :
Personne Mariage
Epoux
Epouse
date
Nom
Sexe
Etat-civil
....
0:1
0:1

Une rgle connue mais non exprime par ce diagramme est : si une personne participe lassociation
Mariage, alors son tat civil doit tre mari .
En ltat actuel des SGBD, ces rgles ne peuvent tre vrifies que par des programmes ad hoc, tablis
lors de la programmation des applications.
Dautres rgles possibles sappliquant cet exemple sont :
- si une personne participe lassociation Mariage, dans le rle poux , alors son sexe doit tre
M;
- si une personne participe lassociation Mariage, dans le rle pouse , alors son sexe doit tre
F;

De telles rgles, dfinissant les tats possibles de la base de donnes et qui peuvent ne pas tre dcrites
avec les concepts du modle, sont appeles contraintes dintgrit. Si les valeurs de la base de donnes
ne les satisfont pas, il y a une erreur dans la base; on dit quelle est incohrente.

Contraintes d'intgrit sur les attributs
Les contraintes dintgrit les plus frquentes limitent les valeurs possibles dun attribut certaines
valeurs du domaine sous-jacent.
Dans le cas le plus simple, elles sont du type : agee[0,130].
Il sagit ici dune limitation dfinissant de faon fixe une fourchette pour toutes les valeurs de lattribut.
Ces contraintes disparaissent si le modle permet une dfinition prcise des domaines de valeurs.
Les limitations peuvent tre dfinies en fonction du contexte (valeur dun autre attribut, participation une
association,...)
Exemples :
si moise[4,6,9,11] alors joure[1,30], sinon si mois=2 alors joure[1,29] sinon joure[1,31]
tat-civil = mari si ....
une femme mari avant 1986 a pour premier nom, le nom de son mari, une femme marie aprs
1986 a pour premier nom son nom de jeune fille.
Contraintes d'intgrit sur les cardinalits
Dautres types de contraintes dintgrit limitent les cardinalits des TE, des TA, des rles des TA, ou
des valeurs des attributs.
Exemples : On suppose, dans le diagramme Parent-Enfant, que les attributs du type dentit
Parent sont les suivants : nom, prenoms, adresse, nombre-enfants. Il existe la contrainte
dintgrit :
nombre-enfants = nombre doccurrences du TA est parent de qui lient ce Parent.
Contraintes d'intgrit sur les gnralisations / spcialisations
Dans une hirarchie de gnralisation / spcialisation, il est frquent de trouver des contraintes
d'intgrit dcrivant le partage de population entre les diffrents sous-types d'un mme sur-type :
Contrainte de couverture pour spcifier que l'union des populations des TE spcifiques d'un mme TE
gnrique est gale la population du TE gnrique.
Contrainte de disjonction, pour spcifier que les populations des TE spcifiques d'un mme TE
gnrique n'ont aucune occurrence en commun.
Contrainte de partition, pour spcifier que la population d'un TE gnrique se subdivise compltement
et sans intersection entre certains de ses TE spcifiques.
CONCLUSI ON
Un schma conceptuel ENTITE / ASSOCIATION est un ensemble de descriptions de types d'entits et
de types d'associations, de leur attributs, des liens de spcialisation / gnralisation entre types d'entits
et des contraintes d'intgrit associes.
EA = ( {TE} , {TA} , {CI} )

27 Le modle Objet
3. Le modle Objet
CONCEPT DE BASE OBJ ET ET SCHEMAS UML
Objet :
Objet du monde rel (concret ou abstrait), propos duquel on veut enregistrer des informations et qui a
une existence propre. Un objet existe indpendamment du fait quil est lie dautres objets de la base
de donnes. Le modle objet est intressant en ce quil permet de dcrire simplement les objets du
monde rel et de les grer sous une forme naturelle dans laquelle les donnes et les procdures les
manipulant sont regroupes dans une mme unit smantique.
Lobjet se caractrise par sa structure (les valeurs portes par les attributs), son comportement (sa faon
dagir ou de ragir) et les liens quil partage avec dautres objets, grce son identifiant unique (OID).

MONDE REEL ABSTRACTION : MODELE
VENDEUR
:VOITURE
:BOITE
:MOTEUR
:VOITURE
CONSTRUCTEUR
Object
Entit
A
BS
T
RA
CT
IO
N
ABSTRACTION

Encapsulation
Lencapsulation est le fait de regrouper dans un seul lment des attributs (donnes) et des oprations
(fonctions, mthodes, comportements ).
Lencapsulation est un principe de lapproche objet grce auquel les donnes et les comportements
associs de lobjet sont cachs (partie prive) pour ne laisser visible que leur interface (partie publique).
Le fonctionnement interne de lobjet est ainsi cach des autres parties du programme qui utilisent cet
objet.

Prendre
de
l'essence
Rouler
Compteur
Niveau
essence
:VOITURE (V1.0)
Prendre
de
l'essence
Rouler
Compteur
Niveau
essence
:VOITURE (V1.1)
Niveau huile
:Conducteur
Implmentation :
Proprits masques,
accessibles seulement
par l'objet
Interface : Proprits
accessibles par
d'autres objets

- En sintressant plus aux interfaces quau fonctionnement interne de lobjet, lencapsulation
permet de raliser des modules indpendants les uns des autres.
- Le masquage des informations permet de protger lobjet contre des modifications indsirables.
- lencapsulation permet de modifier limplmentation de lobjet (son fonctionnement interne)
sans affecter les autres objets qui lutilisent.
Classes
Une classe est une reprsentation abstraite dun concept qui existe dans le domaine modlis.

VOITURE
+ / Compteur
+ / Niveau essence
+ / Niveau huile
...
Rouler
Prendre essence
Vendre
...
Monde rel Modle : classe
attributs
oprations
}
}

Les concepts dobjet et de classe sont indpendants. Un objet existe en tant quinstance (membre) dune
classe. La classe dcrit des objets qui partagent le mme comportement (oprations) et les mmes
attributs (donns).
La classe dcrit une liste de relations (associations) que les objets pourront partager avec dautres objets.
Les valeurs portes par les attributs de lobjet caractrisent ce dernier.
Diagramme des classes
La reprsentation graphique utilise avec la mthode objet pour mettre en vidence la structure des
classes et les diffrents liens dassociations entre les classes est le diagramme des classes UML. A la
diffrence dautres modlisations (entit-association, ou Merise), le diagramme des classes ne fait

29 Le modle Objet
aucune sparation entre la modlisation des donnes et des traitements ventuels qui pourront
sappliquer sur ces donnes.
Lobjet dune classe est une instance. Linstanciation est le mcanisme qui permet de crer les objets
dune classe. Le systme est constitu des classes et de leurs associations.
Les objets de base du modle sont la classe, lassociation et la classe dassociation.
Personne
+ / estMari : bool
+ / estEmploy : bool
+ / nom : chane
+ / prnom : chane
+ / sexe : numration(M,F)
age () : entier
revenu(Date) : entier
Banque
Classe
Association
1 0..1
Manager Compagnie manage
*
*
Employs Employeur
Compagnie
+ / nom : chane
+ / nombreEmploys: entier
+ prixAction : entier
Classe
d'association
0..1
Mari
0..1
Epouse
Emploi
+ titre : chane
+ dateDbut: date
+ salaire : entier Mariage
+ lieu : chane
+ date: date
Opration
Attribut
Rle

Modlisation des associations
Les liens de multiplicit indiquent combien dobjets de chaque classe peuvent tre lis un objet de
lautre classe. Les multiplicits les plus usuelles sont :
- 1..1 ou 1 : un et un seul
- 0..1 : de zro un
- 0..* ou * : de zro (aucun) n (plusieurs).
- 1..* : de 1 (obligatoire) n (plusieurs).
- X..Y : de X Y (cas rare )

La smantique dune association peut tre exprime le cas chant par le rle jou par chaque classe
dans lassociation :
Personne
...
...
Vhicule
...
Propritaire
0..1
Proprit
*

La navigation prcise le sens dans lequel une association peut tre parcourue. Par dfaut, la navigation
est possible dans les deux sens. Lorsquelle nest possible que dans un seul sens, celui ci est indiqu par
une flche.
Pays
...
...
Personne
...

Lagrgation est une forme particulire dassociation entre classes dans laquelle des objets complexes
(agrgats) sont construits partir dobjets lmentaires (composants). Chacun des composants pourrait
exister sans lagrgat.
Vhicule
...
Roue
...
Chassis
...
Moteur
...
0..1 0..1 0..4
0..1
Agrgat
Agrgation
Composant

La composition est une agrgation qui spcifie une forte relation de proprit. Le composant ne peut
appartenir qu un seul agrgat un instant donn. Le composant ne peut pas exister indpendamment
de lagrgat.
La composition impose des contraintes sur le cycle de vie des composants : les composants peuvent tre
cres et retirs avant la destruction de lagrgat, mais si lagrgat est dtruit, alors tous les composants le
sont aussi.
Personne
...
Tte
...
Jambes
...
Bras
...
0..2 0..2 1
1
Agrgat
Composition
Composant

On remarquera qualors que lagrgation (relation plutt faible entre classes) est symbolise par un
losange vide, la composition (relation forte ) est symbolise par un losange plein.

31 Le modle Objet
Lhritage permet au modle de factoriser des attributs et / ou des comportements communs
diffrentes classes. Une classe gnraliste agit alors comme anctre commun plusieurs classes, qui
sont des variations de la classe anctre. L hritage est essentiellement un moyen de grer la complexit
et la rutilisation de ce qui est dj crit. On verra quil pose un problme pour la modlisation des
donnes, le modle relationnel ne disposant daucun moyen simple de le grer.
La reprsentation commune de lhritage
dans un langage de programmation est
base sur des pointeurs ou ventuellement
des OID (Object ID : identifiant dobjet).
Chaque objet maintient une forme de lien
avec lequel il peut localiser, ou recrer si
ncessaire lobjet parent.
Insistons sur le fait que lhritage est une
notion bien plus complexe que cette
prsentation trop sommaire. Le lecteur se
reportera la bibliographie pour rflchir
aux diffrents cas de modlisation de
lhritage (hritage multiple, problmes lis la covariance, aux diffrents choix de placement possibles
des classes dans la hirarchie, ).

Personne
...
Enfant
...
Parent
...
une classe gnraliste
(Personne) de laquelle les
autres classes (Parent et
Enfant) sont drives.

4. Le Modle Relationnel
DEF I NI TI ON D UNE RELATI ON
Une relation est un sous ensemble du produit cartsien dune liste de domaines (ensembles de valeurs ou
encore, types au sens des langages de programmation).
Le nombre de domaines de la relation est son arit. Elle est reprsente sous la forme dune table, o les
lignes correspondent aux tuples, et les colonnes aux composantes.
Exemple :

136 Dupont Jean 19
253 Aubry Annie 20
101 Duval Andr 20
147 Dupont Marc 21

Cet exemple reprsente une relation (ou table) dcrivant des tudiants. La premire et la dernire
colonne ont pour domaine les entiers et les deux autres les chanes de caractres.
La population d'une relation est constitue de l'ensemble des tuples (lignes) de la relation.
Contrairement ce que la reprsentation sous forme de table pourrait induire, il n'y a pas d'ordre (les
nouveaux tuples sont rajouts la fin)
On donne un nom diffrent chaque colonne, pour les distinguer. On appelle attribut dune relation un
couple <nom, domaine>, et schma de la relation, le nom de la relation suivi de la liste de ses attributs.
Exemple : la relation ci-dessus a pour schma :
Etudiant ( NEtud : entier; Nom : Chane(30); Prnom : Chane(20); Age : entier(0..120);)

Pour simplifier, nous omettrons en gnral les domaines; ils sont dduits implicitement des noms des
attributs.
Il est usuel de souligner lattribut, ou les attributs, qui constitue(nt) la cl de la relation. Si un attribut est
une cl dune autre relation, il est appel cl externe.
Notion de domaine
Un domaine est un ensemble nomm de valeurs que peut prendre un attribut. C'est le domaine de
dfinition d'un ou plusieurs attributs.
Exemple :
Dnom : chanes de caractres de longueur 30.
Dnum : entiers entre 0 et 99999
Dcouleurs : "bleu", "vert", "jaune"

33 Le Modle Relationnel
Cette notion de domaine, proche de la notion de type de donnes en programmation, est importante
lorsquelle peut tre contrle par le SGBD utilis. Elle permet alors de renforcer les contraintes
d'intgrit respecter par la base de manire automatique. Le SGBD refusera ainsi automatiquement
l'entre d'une donne qui n'est pas "bien forme" pour le domaine, ce qui diminue d'autant les contrles
de cohrences raliser par le programmeur.
DES SCHEMAS EA AUX SCHEMAS RELATI ONNELS
Les attributs du modle relationnel sont tous simples et monovalus; toute valeur prise par un attribut
est atomique (non dcomposable par le SGBD) et unique. Les notions d'attributs complexes, multivalus
ou facultatifs n'existent pas dans ce modle.
Partant dun schma entit-association, on peut construire un ensemble de schmas de relations. Lide
consiste reprsenter les types dentits et leurs attributs par une relation, chaque tuple de la relation
tant associe une entit. Les types dassociations sont galement transforms en relations constitues,
en gnral, des cls des types dentits associs, complts par les attributs de lassociation, si elle en a.
Exemple :
Etudiant NEtud Nom Prnom Age
136 Dupont Jean 19
253 Aubry Annie 20
101 Duval Andr 20

Cours NomC Horaire Prof
Algo Lundi 10-12 Duval
Systme Mardi 16-18 Malin

Suit NEtud NomC Note
253 Algo 12
136 Systme 08
253 Systme 15

On remarque que la relation Suit (qui traduit un type dassociation) a pour attributs les cls des deux
prcdentes relations (qui traduisent des types dentits) et lattribut de lassociation.
Quelques rgles :
Constitution de la relation :
La relation associe un TA est constitue des cls des TE associs, et de ses propres attributs.
Si un TE est faible (sans cl) il faut y mettre lensemble de ses attributs.
La cl de la relation :
En gnral, elle est constitue par lensemble des cls des TE associs.
Lorsquil y a un TE faible, il faut ajouter un attribut du TE,
Lorsquil y a plusieurs jeux de valeurs possibles pour un mme ensemble de valeur sur les cls externes,
il faut ajouter un des attributs du TA.
Lorsque la connectivit dun des rles est 1:1, la cl est celle du TE (non faible) associ.

Attributs facultatifs du modle EA :
La plupart des SGBDR grent une valeur spciale, appele valeur nulle et note NULL. Cette valeur
peut tre prise par tout attribut (sauf si dans le schma on a spcifi le contraire). Elle signifie alors que
le tuple n'a pas de valeur pour cet attribut. Ainsi un tudiant dont on ne connat pas l'ge serait
reprsent par le tuple (123, DUMOND, NULL).
Cette valeur spciale implique souvent un traitement particulier dans les langages de manipulation de
donnes et dans les programmes.
Attributs complexes du modle EA :
L'exemple classique est l'attribut adresse : N rue, Nom Rue, Ville, Code Postal.
Solution 1 : On utilise l'attribut adresse avec pour domaine les chanes de caractres. Dans ce cas,
l'utilisateur devra lire l'adresse et chercher lui mme le nom de la ville dans celle ci. Il ne pourra pas
poser de question au SGBD concernant la ville.
Solution 2 : On scinde l'adresse en 4 attributs : N rue, Nom Rue, Ville, Code Postal Dans ce cas, le
SGBD est capable de recherche labores sur chacun des attributs, mais il ne connat pas la notion
d'adresse globale. Pour diter une tiquette par exemple, on est oblig de raliser des concatnations.
Attributs multivalus du modle EA :
L'exemple classique est la liste des prnoms
Solution 1 : Avoir dans la relation Etudiants plusieurs attributs : Prnom1, Prnom2, Mais combien
mettre d'attributs de prnom ? Et comment poser une question sur un prnom (on est oblig de poser
autant de questions que d'attributs dclars).
Solution 2 : On garde dans la relation tudiant uniquement le n d'tudiant, le nom et l'age et on cre une
relation supplmentaire (n tudiant, prnom).
(Reprendre les exemples du chapitre 2)
LA NOTI ON DE SCHEMA DE RELATI ON
Le schma dune relation donne la signification ou linterprtation de la relation. Elle est constitue dun
ensemble de tuples vrifiants une certaine smantique. Les valeurs dun tuple doivent en gnral
vrifier un certain nombre de contraintes.
Un schma de relation est dfini par :
- - son nom
- - la liste de ses attributs : couples (nom:domaine)
- - sa (ses) cl(s) et ses cls externes
- - sa dfinition (phrase en franais)
- - la liste des contraintes

Parmi les contraintes que peut imposer un schma relationnel, les dpendances fonctionnelles sont une
catgorie importante, car elles sont lies la notion intuitive de cl.
Dfinition : Soit R(A1, A2,...,An) un schma de relation, et X et Y deux sous ensembles de {A1, A2,...,An},
on dit quil a dpendance fonctionnelle de Y sur X, et on crit XY, si quel que soit un exemplaire
acceptable r de R, tous les tuples u et v de r qui ont les mmes composantes dans X, ont aussi les mmes
composantes dans Y.

Une dpendance fonctionnelle est une proprit impose priori, provenant du monde rel, et qui doit
tre dfinie partir de la signification des attributs. Il ne faut pas tenir compte des dpendances
constates sur un exemplaire particulier de la relation.
Exemple :
La relation Etudiant :
NEtud (Nom, Prnom, Age)
La relation Cours :
NomC(Horaire, Prof)
La relation Suit :
(NEtud, NomC) Note; un tudiant a une note par cours.

Il est vident que la notion de cl dune relation entrane la dpendance de tous les attributs de la
relation sur la cl. Inversement, la notion de dpendance permet de prciser cette notion de cl.
Dfinition : Soit R(A1, A2,...,An) un schma de relation, et X un sous ensemble de {A1, A2,...,An}. On dit
que X est une cl pour R si :
1- X A1A2...An;
2- YcX, si Y A1A2...An , alors X=Y.
Lorsquil y a plusieurs cls possibles pour une relation, on peut en choisir une, dite cl primaire, les
autres tant des cls candidates.
Une cl peut tre compose de un ou plusieurs attributs. Une relation peut avoir une ou plusieurs cls.
Une relation a ncessairement une cl. Par convention, l'attribut (ou les attributs) constituant la cl est
soulign sur les schmas graphiques.
Exemple :
Etudiant (N Etud, nom, prnom, age)
Il n'y a pas deux tudiants qui peuvent avoir le mme numro

On ne peut pas avoir de valeur inconnue pour une cl. En effet si on entrait deux tuples sans valeur
pour la cl, alors il existerait deux tuples ayant mme valeur (inconnue) pour la cl, ce qui est impossible
d'aprs la dfinition de la cl.
Si les dpendances lies aux cls sont naturelles, les autres conduisent quelques difficults. pour les
viter, il faut pouvoir transformer un ensemble de relations, tout en conservant les dpendances
fonctionnelles, puisquil sagit de contraintes vrifies par le monde rel.
On appellera schma relationnel, un ensemble de schmas de relations et son ensemble de contraintes
dintgrit.
CLE EXTERNE (OU CLE ETRANGERE)
Certains attributs rfrencent des tuples dune autre relation (ou parfois la mme); cest--dire que leur
valeur est ncessairement gale celle de la cl dun tuple existant dans lautre relation.
Par exemple, la relation Suit(NomC, NEtud, Note) possde une cl (NomC+NEtud), et deux cls
externes : NomC et NEtud. En effet, NomC rfrence un Cours, cest dire que si une valeur
NomC existe dans Suit, alors il doit ncessairement exister un cours de ce nom l dans la relation
Cours. de mme, Netud rfrence un Etudiant.

Le schma dune relation comprend donc, en plus de la dfinition du nom de la relation et de ses
attributs et domaines associs, la dfinition de de sa (ses) cl(s), et celle de ses cls externes, sil en existe.
Les cls externes sont dclares de la faon suivante :
Suit(Netud ; Dnum, NomC : Dnom)
Cls externes :
NEtud rfrence un Etudiant
NomC rfrence un Cours
Dfinition : Soient deux relations R1(X, Y) et R2(V, W), o X, Y, V, W, dsignent des attributs ou des
ensembles dattributs, et o X est la cl de R1, on dit que W est une cl externe sur R1 (ou que W
rfrence R1) si pour tout tuple de R2, la valeur prise par W est ncessairement la valeur de X pour un
tuple existant de R1.
Autrement dit, tout instant, lensemble des valeurs prises par W est compris dans lensemble des
valeurs prises par X.
Cette vrification est automatiquement assure par le SGBD : une fois dclare la cl externe W de R2
sur R1, le SGBD vrifie toutes les insertions dans R2 (il vrifie que la valeur de W existe dans R1); il
vrifie de la mme faon les modifications de W. Il vrifie toutes les suppressions de tuples de R1 (il
vrifie quil nexiste pas de tuple dans R2 rfrencant ce tuple supprimer). Le SGBD assure ainsi, lintgrit de
rfrence (ou intgrit rfrentielle) de la base de donnes.

EXEMPLE DE DECLARATI ON D UN SCHEMA RELATI ONNE L
Domaines :
Dnom : chane de caractres de longueur infrieure 30;
Dch100 : chanes de caractres de longueur infrieure 100;
Danne : [1970:1990];
Dnote : [0.0:20.0];
Ddate : [1:31]/[1:12]/[1920:2000];

Nous ne ferons apparatre que les DF non triviales.
Relation : Personne
Attributs :
NP : entier sans valeur nulle;
Nom : Dnom sans valeur nulle;
Prnom : Dnom sans valeur nulle;
Adr : Dch100 sans valeur nulle;

Cl : (NP)
Dfinition : Tout tudiant et tout enseignant de la composante.

Relation : Etudiant
Attributs :
NE : entier sans valeur nulle;
DateN : Ddate sans valeur nulle;

Cls : (NE), (NP);
Cls externe : NP rfrence une Personne;
Dfinition : Tout individu qui est actuellement inscrit dans la composante, ou qui a dj pass avec
succs un des cours de la comosante;

Relation : EtudiantEtudes
Attributs :
Anne : Danne sans valeur nulle;
Diplme : Dnom sans valeur nulle;

Cl : (NE+Anne);
Cl externe : NE rfrence un Etudiant;
Dfinition : tudes antrieures dun tudiant;

Relation : Enseignant
Attributs :
Statut : Dnom sans valeur nulle;
Dpartement : Dnom sans valeur nulle;
Cl : (NP)
Cl externe : NP rfrence une Personne;
Dfinition : tout individu assurant actuellement un ou plusieurs cours dans la composante;

Relation : Inscrit
Types dentits lis : Etudiant (0:n), Cours (1:n);
Attributs :
NomC : Dnom sans valeur nulle;
Note : Dnote;
Cl : (NE+NomC)
Cls externes :
NE rfrence un Etudiant
NomC rfrence un Cours;

Dfinition : actuellement, ltudiant NE est inscrit au cours NomC;

Relation : Prrequis
Types dentits lis : Cours : est-un (0:n), Cours : a-pour (0,n);
Attributs :
NomC : Dnom sans valeur nulle;
NomCprrequis : Dnom sans valeur nulle;
Cl : (NomC+NomCprrequis)
Cls externes :
NomC rfrence un Cours;
NomCprrequis rfrence un Cours;

Dfinition : le cours NomCprrequis est un prrequis pour le cours NomC.

39 Normalisation dun schma relationnel
5. Normalisation d un schma relationnel
FORMES NORMALES
PREMI ERE ET DEUXI EME FORMES NORMALES
Dfinition : Une relation est en premire forme normale (1FN) si tous ses attributs sont simples et
monovalus.
Dfinition : Une relation est en deuxime forme normale (2FN) si elle est en premire forme normale et
si chaque attribut qui ne fait pas partie dune cl dpend dune cl entire.
Pour une relation R munie de lensemble de df F, on a
ACl (AeCl (-Cl) ClAeF
+
)
Exemple : Soit une relation qui est en 1FN, mais pas en 2FN :
Fournisseur1 (NF, Adr, Tel, NomProduit, Prix)
Une telle relation pose des problmes :
- Redondances : sil existe 100 produits pour un fournisseur on va rpter 100 fois le nom,
ladresse et le tlphone du fournisseur.
- Problme de mise jour pour les insertions : quand on veut rajouter un produit, il faut
rentrer nouveau ladresse et le tlphone du fournisseur.
- Problme pour les suppressions : si on supprime (momentanment) la liste des produits
dun fournisseur, alors on supprime aussi le fournisseur.
- Problme de mise jour des tuples : si un fournisseur change dadresse ou de tlphone, il
faut faire cette mise jour sur tous les 100 tuples !
Cette relation nest pas en 2FN. Le graphe minimum des df de Fournisseur 1 est :
NomProduit
Prix
NF Adr
Tel
On dcompose Fournisseur1 en deux relations de la faon suivante : pour chaque source de DF, on
cre une relation ayant pour attributs la source et tous les attributs des dF directes de cette source,
en sassurant quune (au moins) des deux sources est entirement contenue dans les attributs
communs aux deux relations ainsi cres (cf thorme de Heath). On obtient ainsi :
Fournisseur(NF, Adr, Tel);
Catalogue(NF, NomProduit, Prix);
qui sont en 2FN (et mme plus).
Cette dcomposition est
- sans perte dinformation
- sans perte de dpendance fonctionnelle : les DF sont soit dans lune ou lautre des deux
relations.

TROI SI EME FORME NORMALE
Dfinition : Une relation est en troisime forme normale si elle est en premire forme normale et si
chaque attribut qui ne fait pas partie dune cl, dpend directement dune cl entire.
Pour une relation R muni de lensemble de df F, on a :
ACl (AeCl -Cl (ClAeF
+
directe )

Exemple : Considrons la relation suivante (en 2FN) :
Fournisseur2 (NF, Pays, Ville)
Elle possde les df : NFVille et VillePays.
On suppose quon na dans la base de donnes que des grandes villes sans homonynes. La df
NFPays est une df dduite.
Le graphe minimum de Fournisseur2 est
NF Ville Pays
Dans cette relation, il y a redondance : le pays dune ville est rpt, ce qui cause des problmes
de mise jour. On dcompose donc en :
Four (NF, Ville)
Go (Ville, Pays)
Cette dcomposition est sans perte dinformation (Ville est une cl pour Go), et sans perte de df
(les df non dduites sont soit dans Fourn, soit dans Go).

FORME NORMALE DE BOYCE-CODD
Dfinition : Une relation est en forme normale de Boyce-Codd (FNBC), si elle est en premire forme
normale et si tout membre gauche de df est une cl entire ou contient une cl entire.
Pour une relation R muni de lensemble de df F, on a :
XAeF
+
lmentaire, (-Cl) Cl_X

Exemple 1 : Considrons la relation (en 3FN; on suppose quil ny a pas dhomonyme chez les
fournisseurs) :
Catalogue3 (NF, NomF, NomProduit, Prix)
admettant plusieurs cls : (NF+NomProduit) ou (NomF+NomProduit)

Le graphe minimum des df est :

NF NomF

Prix
NomProduit

Dans la relation, il y a redondance entre NF et NomF, ce qui gnre des problmes lors des mises
jour. Par exemple, si un fournisseur change de nom, il faut mettre jour son nom dans tous les
tuples correspondants ces produits.
Elle nest pas en FNBC parce que lattribut NF est membre droit dune df (NFNomF) et nest pas
une cl entire. Il en est de mme pour NomF.

On dcompose donc Catalogue3 en deux relations FNBC :
Fournisseur (NF, NomF) de cl NF ou NomF
Catalogue (NF, Nomproduit, Prix)

On remarque quune relation en FNBC est en 3FN.

Exemple 2 : La relation Place (Netud, Matire, Rang), reprsente le rang obtenu par chaque
tudiant pour chaque matire. On suppose quil ny a pas dex-eaquo.
Il y a deux cls : (NEtud+Matire) ou (NEtud+Rang)

NEtud Matire

Rang
Est-on en 3FN ? oui, car il ny a pas dattribut qui ne fasse pas partie dune cl. On est aussi en
FNBC. On ne dcompose donc pas.

Exemple 3 : La relation Enseignement(NEtud, Matire, Prof)
On suppose que chaque professeur enseigne une seule matire, et que que pour chaque matire,
chaque tudiant suit les cours dun seul professeur.
NEtud Matire

Prof

La relation a deux cls (NEtud+Matire) et (NEtud+Prof). Elle est en 3FN puisque tout attribut fit
partie dune cl. Mais elle nest pas en FNBC puisque lattribut Prof est source de df et ne constitue
pas une cl.
Cette relation prsente des inconvnients (redondnaces, problmes de mise jour) ds au fait que
la df ProfMatire nest pas traduite par la relation (notamment, rien nempche dinsrer deux
tuples pour le mme professeur avec deux matires diffrentes). cependant on ne peut pas
dcomposer sans perdre de df. Par exemple la dcomposition (Prof,Matire) et (NEtud,Prof) perd la
df (NEtud,Matire)Prof.
Elle permet dinsrer le fait quun tudiant suit deux cours portant sur la mme matire avec deux
professeurs diffrents, ce quinterdisait la relation Enseignement.
Il ny a pas de solution idale dans ce cas. Pratiquement, on conserve la relation initiale et on
rajoute une contrainte dintgrit (si le SGBD les gre) spcifiant le fait quun professeur ne peut
enseigner quune seule matire.

Tableau rcapitulatif des Formes Normales :
Forme X XA A
Boyce-Codd contient lmentaire tous
3me une cl directe non dans
2me pas inclus strictement dans une cl lmentaire une cl

L ALGORI THME DE BERNSTEI N
Cet algorithme permet de dcomposer une relation en 3FN sans perte dinformation (SPI) ni de df
(SPD).
Entre :
R = (A1,A2,...,An) un schma de relation;
F un ensemble de df sur R;
Sortie :
Une dcomposition de R muni de F en schmas de relations en 3FN sans perte dinformation ni de df.
Algorithme :
Etape 1 : on remplace F par une couverture minimale de F.
On cherche les cls minimales de R et on teste si R est en 3FN. Si oui, on sarrte.
Etape 2 : on regroupe les df XAi (1sisp) ayant mme membre gauche X.
pour chaque membre gauche X on dfinit un schma de relation contenant tous les attributs intervenant
dans ces df, soit RX=(X,A1,A2,...,Ap). Le schma Rx est muni de lensemble des df XAi (1sisp).
Etape 3 : si aucun des schmas RX dfinis ltape 2 ne contient de cl de R, on ajoute un schma RK=(K), o K
est une cl minimale de R, muni daucune df.

Commentaires :
1- Chacun des schmas Ri, obtenu ltape 2 et muni des df XAi (1sisp), soit encore de la df
quivalente XA1A2...Ap, est bien en 3FN. De mme le schma RK.
2- Le schma RK sert assurer que la dcomposition est bien SPI.
3- La dcomposition est trivialement SPD puisque la runion des df des nouveaux schmas est F.
Exemple : Considrons le schma R=(C,E,P,N,J,H,S) (dj prsent), muni de lensemble des df
CEPN (1) EPC (3)
JHSPC (2) EPSC (4)

Etape 1 : On remplace F par sa couverture minimale, savoir
EPN (1) JHSP (2)
JHSC (2) EPC (3)

Toute cl minimale de R doit contenir les attributs EJHS qui ne figurent pas dans les membres droits
des df de F. on vrifie facilement que EJHS est une cl de R, par suite, cest la seule cl minimale de
R. A cause de la df (1), R nest pas en 3FN.

Etape 2 : on regroupe les df (1) et (3), puis (2) et (2), et on dfinit
R1=(E,P,N,C) muni de F1={(1), (3)}
R2=(J,H,S,P,C) muni de F2={(2), (2)}

R1 muni de F1 a une seule cl minimale EP et est en FNBC.
R2 muni de F2 a une seule cl minimale JHS et est en FNBC.

Etape 3 : ni R1, ni R2 ne contiennent EJHS la cl de R, par suite on ajoute le schma
R3=(E,J,H,S) muni daucune df.

NORMALI SATI ON D' UNE RELATI ON
INTRODUCTI ON
Lors de la dfinition dun schma conceptuel dans le modle relationnel, le choix des relations est
primordial. Ce choix doit tre guid par les dpendances entre les donnes qui existent dans la ralit, et
qui sont des contraintes que doivent vrifier les donnes effectivement prsentes dans la base.
Exemple : on veut dcrire les produits et leurs fournisseurs. On peut le faire avec un des schmas
suivants :
schma 1 (on suppose que chaque produit est dune couleur unique) :
Produit (NP, NomP, Couleur, Poids);
Fournisseur (NF, NomF, Adr, Tel);
Livraison (NP, NF, Qt, Date);

schma 2 (autre schma propos pour le mme sujet) :
Produit (NP, NomP, Couleur, Poids);
Fournisseur (NF, NomF, Adr);
Livraisonbis (NP, NF, TelF, Qt, Date);

Exemples de problmes rencontrs lors des mises jour de la base de donnes dcrite par le
schma 2 :
Sil ny a plus de livraisons pour un fournisseur, son numro de tlphone est perdu. Sil existe N
livraisons pour un fournisseur, le numro TelF est rpt N fois, il faut vrifier que cest le mme.
Pour insrer une nouvelle livraison, il faut enregistrer nouveau ce numro. Ces problmes
nexistent pas avec le schma 1 qui est meilleur que ce second schma.

Lorsquun schma relationnel prsente des problmes de redondance dinformation, danomalie de
mise jour ou danomalie dinsertion/suppression, il est ncessaire de transformer les schmas de
relation posant des problmes. Cette transformation est appele processus de normalisation.
On mesure la qualit dune relation (ou sa capacit reprsenter le monde rel sans gnrer les problmes
aperus ci-dessus) par son degr de normalisation. Une relation peut tre (de la moins bonne la meilleure)
en 1re forme normale, en 2me forme normale, en 3me forme normale, en forme normale de Boyce-
Codd, en 4me forme normale,... (chaque forme normale implique les prcdentes).
Notations : pour la suite, les lettres X, Y, Z, dsigneront soit des attributs, soit des ensembles
dattributs; les lettres A, B, C, dsigneront des attributs.

DEPENDANCES FONCTI ONNELLES
Les notions de dpendance fonctionnelle et de cl ont dj t dfinies au chapitre prcdent.

LA NOTI ON DE CLOTURE
Dfinition : Soit F un ensemble de dpendances fonctionnelles pour un schma de relation R, et XY
une dpendance fonctionnelle. On dit que XY est la consquence logique de F, et lon crit FXY, si
tout exemplaire de relation r de R qui satisfait les dpendances de F satisfait aussi XY.
La notion de clture permet de prendre en compte lensemble de toutes les dpendances fonctionnelles
consquence logique dun ensemble de dpendances donnes. Elle permet galement de dfinir
lquivalence entre deux ensembles de dpendances F et G comme lgalit de leurs cltures respectives.
Dfinition : On appelle clture de F, lensemble F+ = { XY | F XY}
Ces dfinitions mettent en avant le fait que certaines dpendances sont plus fondamentales que
dautres, puisque les autres peuvent sen dduire.
On peut dmontrer que la clture est obtenue en itrant les rgles suivantes, o R est lensemble des
attributs dune relation :
Rflexivit : Si XcYcR alors XY
Transitivit : {XY, YZ} XZ
Augmentation : {XY} XZYZ, pour tout ZcR;
Union : {XY, XZ} XYZ;
Pseudotransitivit : {XY, WYZ} XWZ;
Dcomposition : {XY} XZ, pour tout ZcY;

Notons que les trois dernires rgles se dduisent des trois premires.
Le calcul de F
+
peut cependant tre trs long. Mais il peut tre remplac par le calcul de X
+
= {A | AeR
et XA}, o X est lensemble des attributs des dpendances fonctionnelles de F, au moyen de litration
suivante :
X
(0)
=X;
X
(i+1)
=X {A | -YZeF tel que YcX
(i)
et AeZ};

Algorithme de calcul de X
+
:
X
+
X;
rpter
AUX X
+
;

pour chaque df YZeF faire
si Y cX
+
alors X
+
X
+
Z;
jusqu AUX= X
+
ou X
+
=R;

Exemple : Soit R=(A,B,C,D,E) et F={ABC, BD, CDE}. Calculons (AB)
+
.

Enfin, pour tout ensemble F de dpendances, il existe un ensemble quivalent F, (au sens F
+
=F
+
), qui
est minimal, cest--dire que :
1- XYeF, Y ne comporte quun seul attribut;
2- XAeF, lensemble F-{XA} nest pas quivalent F;
3- XAeF et ZcX, lensemble F-{XA}{ZA} nest pas quivalent F.
Algorithme de calcul de la couverture minimale dun ensemble de df :
Entre : R=(A1,A2,...,An) un schma de relation;
F un ensemble de DF sur R;
Sortie : G une couverture minimale de F, dfinie par
1- G
+
=F
+
;
2- Tout membre droit dune DF de G est rduit un seul attribut;
3- Pour aucune DF XAeG on na G-{XA}XA;
4- Pour aucune DF XAeG on na GYA avec YcX;
Algorithme :
On ordonne les df de F, supposons :F={X1Y1, X2Y2, ...., XmYm}
Etape 1 : on dcompose les membres droits Yi des df de F
Pour i1 m faire
si Yi=A1A2...As, avec s>1
alors FF-{XiYi}{XiA1, XiA2,...., XiAs}
Nous supposons par la suite que :F={X1A, X2A, ...., XpAp}
Etape 2 : on regarde si on peut enlever de dfde F sans modifier sa fermeture
Pour i1 p faire
si F-{XiAi}{XiAi} alors FF-{XiAi}
Quitte renumroter les df, nous supposons qu la fin de cette tape nous avons : F={X1A, X2A, ....,
XqAq} avec qsp.

Etape 3 : on cherche si on peut remplacer les membres gauches des df de F qui sont forms de plus dun attribut
par des membres gauches comprenant moins dattributs sans changer la fermeture de F.
Pour i1 q faire
si Xi=B1B2...Br, avec r>1
alors pour i1 r faire
si F{XiBj}Ai, alors XiXi-Bj}
Il ny a pas unicit de la couverture, elle dpend de lordre choisi.
Exemple : Considrons un schma de relation R contenant des cours C, des tudiants E, des
professeurs F, des notes N, des jours et horaires de cours J et H, et des salles S. Soit
R=(C,E,P,N,J,H,S) muni de lensemble des df :
CEPN, JHSPC, EPC, EPSC;
Lui appliquer lalgorithme.

PROPRI ETES DES DEPENDANCES FONCTI ONNELLES
Dfinition : On appelle dpendance fonctionnelle lmentaire une DF, XA, o A est un attribut
unique non inclus dans X, telle que
YcX, YA X=Y.
En dautres termes, A est atomique et X est minimal.
Exemples : Dans la relation Produit, les DF :
NP(Couleur,Poids) et (NP,NomP)Poids ne sont pas lmentaires.
Mais les DF :
NPCouleur, NPPoids, NPNomP,
NomPCouleur, NomPPoids, NomPNP;
sont lmentaires.
La DF (NP,NF,Date) Qt de la relation Livraison est lmentaire.

Dfinition : On appelle dpendance fonctionnelle transitive une DF de la forme XA, o A est un
attribut unique non inclus dans X, telle que
-Y.X, XY . YA . YX
Dfinition : On appelle dpendance fonctionnelle directe une dpendance fonctionnelle de la forme
XA, o A est un attribut unique non inclus dans X, telle que Y.X, XY . YA . YX
Une dpendance est directe si elle nest pas obtenue par transitivit partir dautres dpendances.

DECOMPOSI TI ON D UNE RELATI ON
Etant donn une relation non satisfaisante, en ce sens quelle implique des rptitions au niveau de sa
population et quelle pose des problmes lors des insertions/modifications/suppressions de tuples (voir
relation Livraisonbis ci-dessus), trouver un ensemble de relations satisfaisantes et qui dcrive les mmes
informations.

La mthode consiste essentiellement dcomposer la relation en deux ou plusieurs relations. Pour cela,
il est ncessaire de disposer de deux oprations qui permettent, l'une, de dcouper une relation en sous
relations (la projection), et l'autre de recomposer la relation partir de ses sous relations (la jointure).
Dfinition : La projection d'une relation R(A1,A2,,An) sur un sous ensemble de ses attributs
Ai1,Ai2,,Aip est la relation note I[Ai1,Ai2,,Aip]R dfinie par
T(Ai1,Ai2,,Aip)={t | -r (reR.r.Ai1=t.Ai1 . r.Ai2=t.Ai2 . . r.Aip=t.Aip)}
Exemple : Soit la base de donnes dcrivant les enseignants :
Enseignant NomE Dept Statut Age
Marie Info Prof 50
Claire Info Vacataire 25
Luc Phys Assistant 32

La projection de Enseignant sur Nom,Age donne :
I[Nom,Age]Enseignant NomE Age
Marie 50
Claire 25
Luc 32

La projection de Enseignant sur Dept donne
I[Dept]Enseignant Dept
Info
Phys

On remarque que les valeurs doubles (Info) ont t limines.

Dfinition : La jointure naturelle de deux relations R1(X,Y) et R2(Y,Z) est la relation, note R1*R2
dfinie par :
R(X,Y,Z)={t | -t1eR1,-t2eR2 (t.X=t1.X .t.Y=t1.Y . t.Z=t2.Z . t1.Y=t2.Y)}
La population de cette nouvelle relation est constitue de lensemble des tuples de R1 concatns ceux
de R2 qui ont la mme valeur pour Y.
Exemple : Soit la base de donnes dcrivant les enseignements et les cours de la faon suivante
(on suppose que chaque cours est assur par un seul enseignant) :
Enseignant NomE Dept Statut Age
Marie Info Prof 50
Claire Info Vacataire 25
Luc Phys Assistant 32

Cours NomC Diplme NomE
SGBD MInfo Claire
Systme LInfo Luc
Algo LInfo Claire
Pascal DEUG Marie

Si lon veut connatre pour chaque enseignant la liste des cours quil assure, on fait la jointure
dEnseignant et de Cours. La relation rsultat est la suivante.
NomE Dept Statut Age NomC Diplme
Marie Info Prof 50 Pascal DEUG
Claire Info Vacataire 25 SGBD MInfo

Claire Info Vacataire 25 Algo LInfo
Luc Phys Assistant 32 Systme LInfo

On peut dcomposer une relation R, si partir des relations rsultant de cette dcomposition, on peut
retrouver R en faisant la jointure de ces relations.
Dfinition : Une relation R(X,Y,Z) est dcomposable sans perte dinformation en deux relations R1(X,Y)
et R2(X,Z) o la population de R1 (respectivement R2) est constitue des tuples de R tronqus X, Y
(respectivement X, Z) si R=R1*R2.
Exemple :
Ens1 Nom Dept Statut * Ens2 Nom Age
Marie Info Prof Marie 50
Claire Info Vacataire Claire 25
Luc Phys Assistant Luc 32

Cest une bonne dcomposition en ce sens quon retrouve la relation initiale. Ce nest pas toujours
le cas. Par exemple :
Ens1 Nom Dept Statut * Ens2 Dept Age

Marie Info Prof Info 50
Marie Info Prof Info 25
Claire Info Vacataire Info 50
Claire Info Vacataire Info 25
Luc Phys Assistant Luc 32

Donnent des tuples nappartiennant pas la relation initiale
Lors de la jointure de nouveaux tuples sont crs : les tuples de Marie et de Luc donnent chacun
naissance deux tuples ! Cest une mauvaise dcomposition, on dit quil y a perte
dinformation .

Le thorme suivant permet de savoir quand une dcomposition est sans perte d'information :
Thorme de Heath (pour faire une bonne dcomposition) :
Toute relation R(X,Y,Z) est dcomposable sans perte dinformation en R1(X,Y) et R2(X,Z) sil y a dans R1
une df XY ou dans R2 une df . XZ.

49 Le langage de dfinition de donnes
6. Le langage de dfinition de donnes

Le LDD est la partie du langage qui permet la cration, la modification et la suppression des tables.
CREATI ON DE TABLE
La cration d'une table consiste lui attribuer un nom et lui dfinir ses caractristiques. Deux parties
sont dfinies dans la norme ANSI, et prsentes dans la majorit des systmes. Ce sont la dfinition de
colonnes et la dfinition de contraintes d'intgrit.
La plupart des SGBD implantent des commandes supplmentaires permettant par exemple la
spcification des paramtres de stockage, la dfinition de clusters, l'importation de donnes travers
une requte au moment de la cration
La commande de cration d'une table a pour syntaxe :
CREATE TABLE Nom_Table
( Dfinition d'une colonne
|Dfinition d'une contrainte
...)
[Spcification de stockage]
[dfinition de cluster]
[donnes provenant d'une requte]

Elle cre la dfinition d'une table. Celle ci est stocke dans les tables systme du dictionnaire des
donnes. Chaque SGBD a ses propres rgles concernant le nom de la table. En gnral, il est au
moins impossible de crer deux tables de mme nom dans la base de donnes.
"Crer la table factures"
CREATE TABLE Factures (
Date datetime ,
NumFacture varchar(15) ,
CodeClient varchar(30) ,
Commercial varchar(20)
)
DEFI NI TI ON D' UNE COLONNE
Pour dfinir une colonne dans une table, il faut lui attribuer obligatoirement un nom et un type de
donnes. Une valeur que peut prendre par dfaut une colonne et les contraintes d'intgrit la concernant
sont optionnelles dans sa dfinition.

Elment_de_colonne ::=
Nom_colonne Type_colonne
[DEFAULT expression] [Contrainte_de_colonne]...

Le nom de colonne est soumis la mme problmatique que le nom de table. Les contraintes
varient compltement d'un systme un autre. Il doit tre cependant possible de crer deux
attributs de mme nom dans des tables diffrentes. La distinction entre les attributs de mme nom
dans des tables diffrentes est permise grce au prfixage du nom de l'attribut par le nom de la
table (implicite ou explicite). Ainsi matable.monattr dsigne sans quivoque l'attribut monattr de
la table matable.
Les types de donnes
Les types de donnes varient eux aussi fortement d'un SGBD l'autre. On trouvera en annexe
quelques types selon les SGBD.
A titre dexemple, Oracle gre les types de donnes suivant :
CHAR(n) Donnes de type caractre de longueur fixe n, n est compris entre 1 et 255
VARCHAR2(n)
Ce type spcifie une chane de caractres de longueur variable n. n est la
taille maximale de la chane et est compris entre 1 et 2000
VARCHAR(n) Utilis actuellement comme un synonyme de VARCHAR2(n)
NUMBER(p, s)
Nombre de prcision p et d'chelles. La prcision est comprise entre 1 et 38
et l'chelle entre -84 et 127
LONG Donnes de type caractre de longueur variable allant jusqu' 2 Go
DATE Donnes de type date
RAW(n)
Donnes de type binaire de longueur fixe n. Contrairement au type CHAR,
n doit tre spcifi pour ce type et son maximum est de 255
LONGRAW Donnes de type binaire de longueur variable allant jusqu' 2 Go
ROWID
Chane hexadcimale reprsentant l'adresse unique d'une ligne de la table.
Sa valeur est retourne par la pseudo-colonne de mme nom.
Les valeurs nulles
Prenons l'exemple de l'insertion d'un nouveau client dans une table. Si l'on ne connat pas son numro
de tlphone, faut il rentrer une valeur quelconque, ou garder vide ce champ. Selon le type de colonne,
il n'est pas toujours facile d'avoir l'interprtation que l'on veut. C'est pourquoi les " valeurs nulles "
existent. Elle spcifie que le champ n'est pas valide, et ce indpendamment du type.
Par dfaut, l'utilisation de ces valeurs est possible dans toutes les colonnes. Pour ne pas autoriser la
saisie des valeurs nulles dans une colonne, il suffit de le spcifier dans avec une contrainte lors de la
dfinition de la colonne. C'est l'option NOT NULL.
Le mot cl DEFAULT spcifie qu'une expression peut tre affecte la colonne si la valeur de donnes
n'a pas t explicitement assigne lors de l'insertion de la ligne dans la table.

CREATE TABLE Clients (
Code varchar(30) NOT NULL ,
Nom varchar(40) NULL ,
Code_Postal varchar(10) NULL ,
Ville varchar(40) NULL ,
Pays varchar(40) NULL ,
Reprsentant varchar(20) NULL
)

CONTRAI NTES D' I NTEGRI TE
Une contrainte d'intgrit est une rgle qui permet de contrler au mieux la valeur d'une colonne. Elle
peut tre dfinie sous deux formes diffrentes dans les commandes de cration et de modification de
structure de tables.
La plupart des systmes doivent au moins implanter les contraintes NOT NULL et UNIQUE dfinies
dans la norme.
Dfinition de contrainte d'intgrit par contraintes de colonnes
Cette contrainte est dfinie en mme temps que la colonne qu'elle concerne. Elle est spcifie juste aprs
le type de donnes. L'utilisateur peut dfinir une ou plusieurs contraintes par colonne.
[CONSTRAINT nom de contrainte]
{ [NOT] NULL
| {UNIQUE | PRIMARY KEY}
| REFERENCES table [(colonne)]
[ON DELETE CASCADE]
| CHECK (condition)}

Le mot cl CONSTRAINT est optionnel et sert attribuer un nom la contrainte dfinir, qui sera
sauvegard dans le dictionnaire des donnes. Si lidentifiant est omis, Oracle gnre un identifiant sous
la forme SYS_Cn o n est un entier qui reprsente un nom unique dans la base.
NULL (NOT NULL)
Spcifie que la colonne peut (ne peut pas) contenir de valeur
nulle
UNIQUE
Interdit que deux lignes ait la mme valeur (les valeurs nulles ne
sont pas prises en compte
PRIMARY KEY
Spcifie que la colonne est dfinie comme une cl primaire.
Mme si l'effet est le mme que pour UNIQUE, aucune valeur
nulle n'est accepte.
REFERENCES
Dfinit une contrainte d'intgrit rfrentielle par rapport une
cl unique ou primaire
ON DELETE CASCADE
Permet de maintenir l'intgrit rfrentielle en supprimant
automatiquement les valeurs d'une cl trangre dpendant
d'une valeur d'une cl unique ou primaire si cette dernire est
supprime par l'utilisateur.
CHECK Oblige a vrifier la condition associe pour chaque valeur rentre

USING INDEX
Spcifie les paramtres pour l'index utilise pour forcer l'intgrit
de la cl primaire ou unique. Le nom de l'index est identique
celui de la contrainte.
EXCEPTIONS INTO
Identifie une table d'exception existante dans laquelle Oracle
place des informations sur le lignes qui violent une contrainte
d'intgrit active
DISABLE
Permet de dsactiver la contrainte. Par dfaut, Oracle active cette
contrainte.
Dfinition de contrainte d'intgrit par contraintes de tables
La seconde forme de contraintes d'intgrit concerne un ensemble de colonnes de la table et est appele
contrainte de table. En effet on ne peut pas, avec la premire forme, dfinir de cl unique, primaire ou
trangre compose. De plus le fait de dclarer une contrainte d'intgrit UNIQUE pour les deux
colonnes sparment ne signifie pas qu'il y a cration d'une cl UNIQUE compose des deux colonnes.
Cette remarque est aussi valable pour l'intgrit rfrentielle compose. Par contre la contrainte NOT
NULL reste associe seulement l'intgrit de colonne.
[CONSTRAINT nom de contrainte]
{ {UNIQUE | PRIMARY KEY} (colonne [,colonne]...)
| FOREIGN KEY (colonne [,colonne]...)
REFERENCES [schma.]table [(colonne,....)]
[ON DELETE CASCADE]
| CHECK (condition) }

Le mot cl FOREIGN KEY dsigne une ou plusieurs colonnes comme une cl trangre dans une
contrainte dintgrit rfrentielle.
Ni les cls primaires, ni les cls trangres, ni la plupart des contraintes sur les donnes ne sont dfinies
explicitement dans la norme SQL (un attribut NOT NULL UNIQUE est cependant une cl primaire).
Une manire lgante, bien qu'un peu lourde de contourner ces manques consiste utiliser des vues.
Une autre manire consiste utiliser des systmes utilisant des extensions de SQL 86. Ainsi, SQL-
SERVER ou ORACLE permettent l'utilisation de TRIGGERS (procdure se dclenchant en fonction
d'vnements sur les donnes), tandis que INGRES possde un ordre explicite CREATE INTEGRITY,
CREATI ON D' UNE TABLE A PARTI R D' UNE TABLE EXI STANTE
La clause AS de la commande CREATE TABLE permet de crer une nouvelle table partir d'une table
existante. La nouvelle table possde les caractristiques et les donnes de la table source. La dfinition
de colonnes, dans ce cas, se limite aux noms des colonnes et aux valeurs que doivent prendre ces
colonnes par dfaut. Le nombre de colonnes spcifi dans la dfinition de colonnes et celui de la requte
doit tre identique. Les types de donnes sont valus partir de la requte.
Si la dfinition de colonnes est omise, le SGBD hrite les noms de colonnes de la requte. Il est possible
de dfinir une table partir de plusieurs tables sources.
"Crer la table des clients de Paris en la remplissant partir des clients de Paris de la table client"

create table client_paris (nom, adresse, code)
as select nom, adresse, code
from clients
where ville = "Paris"

MODI F I CATI ON DE TABLE
Elle permet l'addition d'un attribut ou l'agrandissement de la longueur d'un attribut existant. Il n'est
possible de supprimer un attribut ou de rtrcir sa longueur qu'en crant une nouvelle table. Les valeurs
initiales existantes pour ces nouveaux attributs seront mises la valeur nulle. L'utilisateur peut attribuer
une contrainte NOT NULL au nouvel attribut seulement si la table est encore vide. La syntaxe complte
de la modification de table est la suivante :
ALTER TABLE table
[ADD { {colonne | contrainte}
| ( {colonne | contrainte}
[ , {colonne | contrainte }]...) } ]
[MODIFY { colonne
| (colonne [, colonne]...)}]
[DROP clause_drop]...
[ENABLE clause_enable | DISABLE clause_disable]

"Ajouter un attribut telephone dans la table fournisseurs"
alter table fournisseurs add telephone char(13)

"Agrandir l'attribut nom dans la table fournisseurs"
alter table fournisseurs modify nom char(30)

SUPPRESSI ON DE TABLE
Elle permet d'enlever une table (et plus gnralement un objet) de la base de donnes.
DROP TABLE Nom_table [CASCADE CONSTRAINTS]
Le mot cl CASCADE CONTRAINTS permet de supprimer toutes les contraintes d'intgrit rfrentielle
qui se rfrent aux cls uniques ou primaires de la table supprimer.
"Supprimer la table fournisseurs"
drop table fournisseurs

RENOMMAGE
Oracle offre la possibilit de renommer une table, une vue, une squence ou un synonyme avec la
syntaxe suivante :

RENAME Ancien_objet TO Nouvel_objet
Le nouveau nom ne doit pas dj exister dans l'espace des noms. Les vues, les synonymes et les
procdures qui se rfrent l'ancien nom de la table ne sont pas supprims, mais deviennent invalides.
Mme si Oracle n'a pas de commande pour renommer les colonnes, on peut combiner les commandes
pour raliser cette tache :
CREATE TABLE tmp_tab (article#, libelle, PV, PA)
AS SELECT code, libelle, PV, PA
FROM articles;
DROP TABLE articles;
RENAME tmp_tab TO articles;

55 Langage de contrle des donnes
7. Langage de contrle des donnes
PRI VI LEGES D' ACCES
Notion d'environnement : Dans DB2, INGRES ou INFORMIX, l'environnement est constitu de la base
de donnes choisie au dbut de la session. Dans ORACLE, la notion de base de donnes explicite est
absente. L'environnement de l'utilisateur est constitu de l'ensemble de ses tables et des tables
auxquelles les autres utilisateurs lui permettent d'accder.
Il s'agit de pouvoir grer les privilges d'accs la base des diffrents utilisateurs. Le principe
fondamental est qu'un utilisateur ne peut effectuer une opration quelconque sur un objet que s'il
dtient le privilge appropri pour cette opration.
Les objets auxquels les privilges sont attachs sont les tables de base et les vues (et, si elles existent, les
procdures). Les oprations sont select, insert, update et delete (resp. execute).
Le propritaire (crateur) d'un objet dtient tous les privilges attachs celui-ci. Il peut accorder
d'autres utilisateurs des privilges attachs cet objet en utilisant GRANT. Il peut galement accorder
un privilge "avec autorisation de transmission", via la clause WITH GRANT OPTION. Cela signifie que
le bnficiaire du privilge pourra son tour accorder le mme privilge (avec ou sans autorisation de
transmission) un autre utilisateur.
Celui qui possde un privilge sur un objet peut retirer ce privilge quelqu'un qui il l'avait accord.
Dans ce cas, le bnficiaire du privilge, ainsi que tous ceux qui il l'avait lui mme ventuellement
accord perdent le privilge. En cas de multiples autorisations, le privilge est retir lorsque le dernier
propritaire l'a retir.
GRANT
La commande grant permet de donner des privilges sur une table, une vue ou une procdure. Les
privilges peuvent en gnral tre un des suivants (d'autres peuvent s'y ajouter selon le SGBD) :
select
insert
delete
update ...
execute (pour les procdures)
"Permettre tous les utilisateurs d'insrer et de slectionner dans la table Client"
grant insert, select on client to public
REVOKE
La commande revoke permet de supprimer un privilge qui a t accord.
"Reprendre le privilge de cration dans la table client accord l'utilisateur JULIEN"

revoke create on client from julien

57 Le langage d'interrogation des donnes
8. Le langage d' interrogation des donnes

Il comprend en gros quatre commandes, SELECT, INSERT, UPDATE et DELETE.
CONSULTATI ON DES DONNEES .
La commande SELECT permet de raliser les oprations les plus courantes sur la base de donnes,
savoir la recherche d'informations, en slectionnant les donnes selon diffrents critres. Dans sa forme
la plus gnrale
2
, elle a pour syntaxe :
SELECT [ALL|DISTINCT] liste_de_colonnes
FROM liste_de_tables
[ WHERE condition ]
[ GROUP BY Liste_de_colonnes]
[ HAVING condition]
[ ORDER BY {expression | position} [ASC | DESC ], ]
[ { UNION | UNION ALL | INTERSECT | MINUS } commande SELECT ]

Les clauses SELECT et FROM sont obligatoires et permettent de spcifier respectivement la liste de
colonnes extraire et la liste des tables partir desquelles les donnes sont extraites. Toutes les autres
clauses ne servent qu' raffiner la slection et sont donc optionnelles.
CLAUSES SELECT, FROM
La forme la plus lmentaire comporte deux clauses indiquant dans quelle(s) tables(s) (clause FROM) et
quel(s) attribut(s) (clause SELECT) sont extraire.
Le rsultat d'une commande SELECT est toujours une table (ventuellement rduite une ligne et une
colonne). Cette proprit fondamentale, (consquence de la fermeture de la base de donne par l'algbre
relationnelle implante par la commande SELECT), permet en particulier de rutiliser le rsultat d'un
SELECT dans un autre SELECT.
Par dfaut, les attributs du rsultat portent le mme nom que les attributs de la table dorigine. Il est
possible de leur donner un nom diffrent en spcifiant ce nom comme tiquette , ct de lattribut
dorigine.
Certains systmes permettent dutiliser des attributs contenant des caractres spciaux (accents,
dlimiteurs, espace, ). Dans ce cas les noms des attributs seront encadrs dans le SELECT par des
guillemets ou des apostrophes . Cette pratique ne fait pas partie de la norme et est source de
confusion. Elle nuit galement la portabilit, chaque SGBD ayant un caractre dencadrement prfr,
voir plusieurs dans le mme SGBD selon le contexte (cest le cas de Access). Il est prfrable de
conserver des noms de colonnes simples et de ne pas se compliquer la vie

2
c'est dire telle qu'elle est reconnue par la majorit des SGBD. Des paragraphes traiteront des particularits lies telle ou telle
base commercialise.


"Afficher tous les attributs de tous les tuples de la table CLIENTS"
select *
from clients
"Afficher les attributs CODE et NOM des tuples de la table CLIENTS"
select code, nom
from clients
"Afficher les attributs CODE et NOM des tuples de la table CLIENTS ; avec renommage de la colonne code"
select code IDENTIFIANT , nom
from clients
"Afficher tous les attributs du tuple dont le nom est DUPOND"
select *
from clients
where nom="DUPONT"
Remarques :
- Il est toujours possible (et souvent indispensable) de prfixer le nom de l'attribut par le nom
de la table :
select clients.nom
from clients
- La notion d'alias est prise en compte (on verra que c'est indispensable pour raliser une auto
jointure). Un alias est un autre nom donn la table, synonyme de son nom rel.
select p.nom
from clients p
- Il est toujours possible, parfois ncessaire, de prfixer le nom de la table par le nom de son
propritaire. En fait, le systme le ralise implicitement.

IMPLEMENTATI ON DES OPERATEURS DE L' ALGEBRE RELATI ONNELLE PAR LA
COMMANDE SELECT
Projection
La projection est ralise en donnant explicitement les colonnes slectionnes cot du mot cl SELECT
"Afficher les noms des fournisseurs"
select nom
from fournisseurs
Par dfaut, SQL affiche le rsultat d'une requte sans liminer les rptitions. Cette limination est
possible en ajoutant la clause DISTINCT

"Afficher les localits des clients"
select distinct VILLE
from clients
Slection
La slection est ralise en utilisant la clause WHERE <condition>. Les seuls tuples affichs sont ceux
pour lesquels <condition> est ralise.
<condition> est une expression logique qui utilise les constituants des tables dclares par FROM. Dans
cette expression logique, on peut utiliser :
- Les prdicats de comparaison (>,>=,<,<=,=,<>,BETWEEN)
- Le prdicat de comparaison approche (LIKE)
- Le prdicat de non-existence NULL
- Un prdicat tout ou n'importe lequel (ANY ou ALL)
- Le prdicat d'appartenance ou la non appartenance un ensemble, souvent donn sous forme de
table unicolonne (IN)
- Le prdicat d'existence (EXIST)
- Le test dunicit (UNIQUE)
Chacun de ces prdicats, en nombre quelconque pouvant tre combins par les connecteurs logiques
(AND, OR, NOT). Ces connecteurs logiques possdent les priorits classiques, le SQL effectuant d'abord
les NOT, puis les AND et en dernier lieu les OR. Il est conseill d'employer les parenthses afin de
grouper les expressions.
Les prdicats de comparaison
Une condition de comparaison permet de comparer une colonne ou une expression une autre colonne,
expression ou liste de colonnes. Cette comparaison peut prendre une des formes suivantes :
exp oprateur_relationnel exp
exp (NOT] BETWEEN exp AND exp
exp [NOT] IN (liste_de_valeurs)
colonne IS [NOT] NULL
colonne [NOT] LIKE " chane"
exp dsigne une expression qui peut tre un nom de colonne, une constante numrique ou caractre,
une pseudo_colonne, une valeur nulle ou une combinaison de ces lments par des oprateurs logiques.
Les oprateurs relationnels sont classiques :
= : gal
!=, <>, ^= : diffrent de
3

> : suprieur
>= : suprieur ou gal
< : infrieur
<= : infrieur ou gal
"Afficher les code et noms des clients de PARIS"
select code,nom from clients
where ville="PARIS"

3
selon le SGBD

"Afficher les codes, les noms et les prix de vente des articles dont le prix de vente est suprieur 200"
select code, libelle, PV
from articles
where PV > 200
"Afficher les codes, les noms et les prix de vente des articles dont le prix de vente est suprieur ou gal
deux fois le prix d'achat"
select code, libell, PV
from articles
where pv >= pa*2
NB : Cette dernire forme permet de constater qu'il est possible d'introduire dans la comparaison des
expressions. Malheureusement, cette possibilit est relativement limite dans la plupart des SGBD.
"articles de la famille EMCOPDET dont le prix de vente est suprieur 200"
select code, libell, PV, famille from articles
where famille = "EMCOPDET" and PV > 200
" articles de la famille EMCOPDET et articles dont le prix de vente est suprieur 200"
select code, libell, PV, famille
from articles
where famille = "EMCOPDET"
or PV > 200
"articles qui ne sont pas de la famille EMCOPDET et dont le prix de vente est suprieur 200"
from articles
where not (famille = "EMCOPDET" or PV > 200)
"articles dont le prix de vente est compris entre 100 et 200"
from articles
where PV <= 100 and PV >= 200
Remarque : Ce type de requte ("entre x et y") dispose aussi d'un oprateur abrgeant la frappe :
BETWEEN. On pourra donc exprimer la mme requte avec :
from articles
where PV between 100 and 200
"articles des familles EMCOPDET, EMPCOCPET et EMCOCOPO
from articles
where famille in ("EMCOPDET", "EMPCOCPET", "EMCOCOPO")
Remarque : Il est ais de dmontrer que cet oprateur est facultatif. Il peut en effet tre exprim l'aide
de OR. Cependant son utilisation prend tout son intrt lorsque la liste de valeur est elle-mme
construite comme le rsultat d'une requte, comme dans l'exemple suivant :

"articles fabriqus par des fournisseurs habitant PARIS"
from articles
where fournisseur in
( select code from fournisseurs where ville = "PARIS" )
L'ensemble des requtes exprimes prcdemment ne renvoient jamais de tuples dont les valeurs
compares n'ont pas t initialises. Une valeur d'attribut non affecte est en effet une valeur spciale
NULL , qui ne peut tre compare avec aucune autre valeur. Il est donc ncessaire de disposer d'une
interrogation spciale pour ce type de valeur.
"articles dont on a nglig de saisir la famille"
select code, libell, PV
from articles
where famille IS NULL
L'interrogation inverse se fait avec IS NOT NULL
"clients dont le nom commence par J"
select code, nom
from clients
where nom LIKE "J%"
La fonction du prdicat LIKE est la reconnaissance d'une structure. Il teste l'adquation d'une chane de
caractres une structure donne. Les caractres composant cette structure sont interprts comme suit :
- Le caractre de soulignement _ remplace n'importe quel caractre.
- Le caractre pourcentage % remplace n'importe quelle squence de n caractres, le n pouvant tre
gal 0
- Tous les autres caractres ne reprsentent qu'eux mme
4
.
Le prdicat MATCH est synonyme de IN. Il rend la valeur VRAI si la valeur de lattribut se trouve dans
la liste qui suit. Il est gnralement employ avec les requtes imbriques. MATCH UNIQUE rend la
valeur VRAI lorsque la valeur de lattribut se trouve une fois et une seule dans la liste qui suit.

Ordre des lments extraits
L'ordre des attributs affichs dpend :
En cas d'utilisation de l'toile, de l'ordre de leur dfinition au moment de la dfinition de la table
(CREATE TABLE ...), sinon de l'ordre de leur apparition dans la commande SELECT
L'ordre des tuples affichs est absolument quelconque. Dans certains cas, il peut mme varier selon le
moment de l'excution de la commande select. Il est possible, grce la clause ORDER BY de demander
un ordre spcifique l'affichage. Cette clause ne ncessite aucune prparation de la table (tri ou
indexation). C'est SQL qui ralise si ncessaire les oprations ncessaires l'affichage dans l'ordre
demand.

4
Dans Microsoft Access, et de manire gnrale les produits SGBD d'origine Microsoft le _ est remplac par ? et le * remplace le %.
Sous Oracle, l'option ESCAPE permet d'identifier un caractre comme une squence escape. Ceci est surtout utilis pour permettre
l'utilisation des caractres gnriques comme des caractres littraux. Si la squence d'escape est dfinie par la caractre "\" alors
"\_" signifie que le soulign est une donne et non pas un caractre gnrique.

"articles dans l'ordre croissant de leur prix de vente"
from articles
order by PV
"articles de prix de vente infrieur 200, dans l'ordre croissant de prix de vente, et prix de vente gal
par prix d'achat dcroissant"
select code, libell, PV, famille from articles
where PV < 200
order by PV, PA desc
Remarques :
- Alors que pour raliser une slection, il n'est pas ncessaire que l'attribut de slection
apparaisse dans la liste des attributs du select, c'est au contraire indispensable dans les
oprations de mise en ordre.
- Il suffit de dire ORDER BY <n> pour obtenir le mme rsultat, <n> faisant rfrence au
nime attribut spcifi dans la commande. C'est un des rares moments en SQL o une
importance est attribue l'ordre des attributs
- La clause ORDER BY ne peut pas figurer dans une sous-requte. En rgle gnrale, on ne
permet qu'une clause ORDER BY par requte quelle que soit sa nature.

OPERATEURS ENSEMBLI STES
L'union existe dans la plupart des SGBD. L'intersection et la diffrence n'existent que dans de rares
SGBD. Le produit cartsien est ralis automatiquement dans les requtes impliquant plusieurs tables.
Union
SQL permet la fusion de donnes provenant de plusieurs requtes SELECT formules sur une ou
plusieurs tables. La condition essentielle de requtes avec l'oprateur UNION est la comptabilit des
listes de slection dans les clauses SELECT du point de vue du type de donnes et de l'ordre des
colonnes. On formule une requte d'union en composant plusieurs requtes SELECT spares par le mot
cl UNION comme le montre la syntaxe suivante :
requte_SELECT
UNION [ALL] requte_SELECT
[UNION [ALL] requte_SELECT... ]
L'oprateur UNION supprime toutes les donnes redondantes par dfaut sauf si l'option ALL est
explicite. Une requte SELECT avec l'oprateur UNION ne peut contenir qu'une seule clause ORDER
BY ( la fin).

articles de la famille EMCOPDET et articles de prix de vente suprieur 500
select code,libell
from articles
union
select code,libell
from articles
where PV > 500
order by code
Noter que :
- les attributs demands dans la clause SELECT doivent tre exactement identiques dans
les deux SELECT mis en jeu pour l'union.
- ORDER BY s'applique l'intgralit des tuples slectionns.
- UNION ALL permet de sortir les doublons.
Intersection
L'intersection de deux requtes permet d'obtenir comme rsultat les lignes appartenant la fois ces
deux requtes. Cette opration exige le mme nombre de colonnes dans les deux listes de slection et
une comptabilit entre leur type de donnes.
requte_SELECT
INTERSECT
requte_SELECT
Diffrence
La diffrence exprime par le verbe MINUS permet de lister les lignes du rsultat de la premire requte
SELECT, qui ne dont pas comprises dans le rsultat de la seconde requte.
requte_SELECT
MINUS
requte SELECT

JOI NTURES
Lorsque les tables possdent des attributs communs ou comparables, il est possible d'obtenir un rsultat
compos de donnes provenant de plusieurs tables "jointes" par cet attribut commun. C'est l'opration
de jointure. Cette opration n'a pas en elle mme d'intrt. Elle ralise en fait le produit cartsien de ces
tables. Elle ne devient intressante qu'en appliquant sur l'ensemble ainsi obtenu une slection base sur
la condition de jointure.
Produit cartsien
Le produit cartsien "pur" est exprim par l'utilisation de plusieurs tables dans le select. Il n'offre
strictement aucun intrt.
select * from articles,fournisseurs

Equijointure
La condition de jointure est exprime par une galit. Un tuple d'une table est concatn un tuple
d'une autre table si leur(s) attribut(s) commun(s) ont mme valeur

"liste des articles de la famille EMCOPDET avec leur nom, leur prix de vente et le nom du fournisseur"
select code, libell, PV, fournisseurs.nom
from articles, fournisseurs
where
articles.fournisseur = fournisseurs.code
and
famille = "EMCOPDET"

La syntaxe ci dessus est celle disponible depuis l'origine du SQL. La norme ANSI-92 a apport une autre
syntaxe dont le but est surtout de clarifier et d'tendre celle utilise pour les jointures externes (voir plus
bas). Elle permet aussi de mieux distinguer entre des conditions WHERE imposes par la jointure et
celles qui sont imposes par la requte :
select code, libell, PV, fournisseurs.nom
from articles
join fournisseurs on articles.fournisseur = fournisseurs.code
Thta-jointure (jointure par non galit)
Plus gnralement, l'opration de jointure peut utiliser n'importe lequel des oprateurs de comparaison
(<, >, BETWEEN, ...).
Lister les articles avec leur catgories de poids
select art_num, art_nom, art_poids, categ
from article, poids
where art_poids between poids_min and poids_max
Autojointure
Il est possible (et souvent indispensable) de pouvoir raliser la jointure d'une table avec elle-mme.
Cette technique, dite d'autojointure, ncessite de pouvoir utiliser des alias pour distinguer les rles de
chacune des tables.
"liste des articles dont le prix d'achat est suprieur au prix d'achat de l'article BIA420001"
select X.code, X.libell, X.PA
from articles X , articles Y
where Y.code = "BIA420001"
and X.PA > Y.PA

Remarque : En ralit, en SQL, il faut toujours formuler les requtes en termes de variables
accompagnes de leur alias. Si l'alias n'est pas prsent, SQL suppose l'existence d'alias implicites portant
le nom des tables. Ainsi "select T.Champ from T" est interprte par SQL comme si elle avait t crite
"select T.Champ from T T"
Jointure externe
Dans une jointure, si la condition n'est pas vrifie, le tuple n'apparat pas dans la table rsultat. On peut
souhaiter au contraire lister les tuples d'une table qui n'ont pas de "correspondants" pour la condition de
jointure dans l'autre table. Cela se nomme une jointure externe. Cette jointure externe s'exprime
diffremment selon les systmes et peut ne pas exister. Elle n'a d'ailleurs t normalise qu' partir de
SQL-92. Les diffrences entre les systmes sont ici particulirement importantes, nous donnerons trois
des principales syntaxes :

Jointure externe DB2 / SQL Server / ANSI:
On utilise la mme syntaxe que dans le JOIN, auquel on ajoute les mots cls LEFT OUTER, RIGHT
OUTER ou FULL OUTER selon la table dont on souhaite conserver les tuples.
Jointure externe Oracle :
La jointure externe est explicite par l'oprateur (+) qui est plac dans la clause WHERE aprs le nom de
la table et celui de la colonne subordonne :
Jointure externe droite : WHERE table1.colonne = table2.colonne(+)
Jointure externe gauche : WHERE table1.colonne(+) = table2.colonne
Jointure externe Access
On utilise galement la construction avec un JOIN en ajoutant LEFT ou RIGHT selon la table dont on
souhaite conserver les tuples. A noter que le JOIN doit obligatoirement galement scrire INNER JOIN
"liste des clients et ventuellement de leur dates d'achat. Si le client n'a rien achet, il doit cependant se trouver
dans la table, avec une date d'achat vide"
select distinct code, nom, date
from clients, lignesfactures
where clients.code = lignesfactures.client (+)

LES FONCTI ONS ET SQL
Fonctions arithmtiques
Elles oprent sur les valeurs de chaque tuple d'une table. Il est ainsi possible de combiner les diffrents
attributs par les oprateurs arithmtiques. L'expression obtenue peut se placer dans un SELECT, un
WHERE ou un ORDER.
"liste de la marge bnficiaire d'un produit dont le prix d'achat est suprieur 100"
select *, pv - pa
from article
where pa > 100

Chaque systme dispose de ses propres fonctions arithmtiques. Voir en annexe.
Fonctions sur les chanes
Elles oprent sur les valeurs de chaque tuple d'une table. L'expression obtenue peut se placer dans un
SELECT, un WHERE ou un ORDER.
Chaque systme dispose de ses propres fonctions. Voir en annexe.
Fonctions sur les dates
Elles oprent sur les valeurs de chaque tuple d'une table. L'expression obtenue peut se placer dans un
SELECT, un WHERE ou un ORDER.
Chaque systme dispose de ses propres fonctions. Voir en annexe.

Fonctions de groupe
Elles oprent sur les valeurs d'un attribut d'une table et produisent une seule valeur scalaire. Utilises
avec GROUP BY, elles permettent de produire plusieurs valeurs, une valeur par facteur de groupement.
5 fonctions sont prdtermines en SQL standard
5
:
COUNT compte le nombre d'occurrences d'un attribut.
SUM somme les valeurs d'un attribut.
AVG effectue la moyenne d'un attribut.
MAX donne la plus grande valeur d'un attribut.
MIN donne la plus petite valeur d'un attribut.
L'argument de la fonction est l'attribut sur lequel elle doit tre calcule. La clause DISTINCT permet
d'liminer les rptitions de valeurs. La clause ALL permet de prendre en compte les rptitions de
valeurs. Elle est implicite, sauf dans le cas de COUNT. Les valeurs indetermines (NULL) ne sont pas
prises en compte, sauf pour COUNT(*), avec laquelle les valeurs nulles sont galement prises en
compte. L'argument d'une fonction de groupe ne peut pas lui-mme faire rfrence une fonction de
groupe (les rfrences ne peuvent pas tre imbriques).
"Prix d'achat moyen des articles"
select avg(PA)
from articles

"Prix moyen, marge maximum, diffrence entre prix d'achat maximum et prix d'achat minimum des articles"
select avg(PV),
max(pv-pa), max(pv)-max(pa)
from articles

"Nombre de familles"
select count(all famille)
from articles
"Nombre de familles diffrentes"
select count(distinct famille)
from articles
Remarque : En gnral, il n'est pas possible de placer dans une clause SELECT une rfrence une
fonction avec un attribut, comme "select code, count(code)"

5
La plupart des systmes se font un plaisir d'ajouter leurs propres fonctions de groupe, plus ou moins obscures. Ainsi chez Oracle
:
GLB Le plus grand minuscule label
LUB Le plus petit majuscule label
STDDEV Ecart type de la colonne
VARIANCE Variance de la colonne

REGROUPEMENTS
La clause GROUP BY
Elle rarrange la table reprsente par la clause FROM (et WHERE) en un nombre minimum de
partitions ou groupes dont les lignes contiennent une valeur commune de(s) l'attribut(s) concern(s) par
GROUP BY. En gnral, il est indispensable de l'utiliser avec des fonctions de groupe. Hors cette
utilisation, les rsultats sont parfaitement imprvisibles. Lorsque la clause GROUP BY est spcifie, les
fonctions de groupe sont alors calcules pour chaque groupe.
Toute expression figurant dans le SELECT doit obligatoirement figurer galement dans le GROUP BY
sous peine de dclencher une erreur.
"Prix de vente moyen pour chaque famille"
select famille, avg(pv)
from article
group by famille

"Calculer, par article, la marge totale ralise pour les factures du 26/02/99 pour la semaine du 880107 au 880113"
SELECT CodeArticle, SUM(Montant - Quantit*PA)
FROM (FacturesLignes LEFT JOIN Factures
ON Factures.NumFacture = FacturesLignes.NumFacture)
LEFT JOIN Articles
ON FacturesLignes.CodeArticle = Articles.Code
WHERE Factures.Date=26/02/1999
GROUP BY FacturesLignes.CodeArticle;

La clause HAVING
C'est une "clause WHERE pour les groupes". La condition porte sur la valeur d'un attribut de groupe.
Ceci n'exclut pas naturellement qu'une slection de type WHERE ait dj t effectue.
"Rechercher les familles des articles dont le prix de vente moyen des articles de la famille est suprieur 100"
select famille, avg(pv)
from articles
group by famille
having avg(pv)>100

"Magasins qui, pour la semaine du 880107 au 880113, ont ralis plus de deux ventes et afficher le nombre de
ventes et le nombre d'articles vendus"
select vnt_mag,count(*), sum(vnt_qte)
from vente
where vnt_date between "880107" and "880113"
group by vnt_mag
having count(*)>2

IMBRI CATI ON DES REQUETES
Une proprit fondamentale de "l'ensemble des tables d'une base, muni des oprations implantes par
SELECT" est d'tre ferm. En effet, toute requte sur des tables retourne une table. Cette table est
ventuellement rduite un attribut et un tuple, donc une valeur unique, ou mme vide. On peut donc
imbriquer volont les requtes. Il n'y a pas de limites la profondeur de l'imbrication
6
.
Cas 1 : Le SELECT interne renvoie UNE valeur
La valeur retourne peut servir de comparaison dans le WHERE

"Liste des articles dont le prix est infrieur au prix de l'article numro BIA420001"
select code, pv
from articles
where pv <
(select pv
from articles where code = "BIA420001")

Remarque(s) :
- Dj vu ?
- Il y a erreur lorsque le SELECT interne retourne plus d'une valeur.

"Liste des articles de mme famille que l'article n BIA420001 et dont le prix de vente est suprieur au prix de
vente moyen de tous les articles"
select code, libelle
from articles
where famille =
(select famille
from articles
where code = "BIA420001")
and PV >
(select avg(PV)
from articles)
"Liste des clients dont la somme des achats est suprieure la moyenne de la somme des achats de tous les clients"
select codeClient, sum(montant)
FROM (FacturesLignes LEFT JOIN Factures
ON Factures.NumFacture = FacturesLignes.NumFacture)
group by codeClient
having sum(montant) >
(select avg(montant)
from FacturesLignes)

Cas 2 : Le SELECT interne retourne UN ENSEMBLE de valeurs
La condition peut alors utiliser les oprateurs :

6
Indisponible dans les versions de MySQL antrieures la version 4.1 (mais penser aussi que la plupart des sous requtes peuvent
tre en gnral remplaces par des jointures.

- d'appartenance : IN
- de non-appartenance : NOT IN
- "Pour tous" : ALL
- "Il existe" : ANY
- existence : EXISTS
Exemples avec IN
"Liste des fournisseurs qui vendent au moins un article de famille EMCOPDET "
select nom
from fournisseurs
where code in
(select fournisseur from articles where famille = "EMCOPDET")

"Nom des grants des magasins qui ont vendu au moins un article n 2"
select M.mag_ger
from magasin M
where 2 in
(select vnt_art from vente where vnt_mag=M.mag_num)

Remarque : On a ici un "attribut corrl". Le SELECT imbriqu utilise un attribut d'un SELECT d'un
niveau suprieur. Le rsultat du SELECT interne va donc dpendre de la valeur de l'attribut renvoy
par le SELECT suprieur. On est alors oblig de prciser, l'aide d'un alias, l'attribut suprieur utilis.
Le processus peut tre "vu" comme un parcours comportant une double itration. Le moteur SQL
examine le premier tuple du SELECT suprieur, celui ci lui fournit une valeur d'attribut, qui peut tre
utilis comme valeur de comparaison dans le SELECT de niveau infrieur, puis on itre
Exemples avec ANY ou ALL
Une comparaison quantifie peut aussi tre utilise. Il s'agit d'une comparaison ordinaire
(=,<>,>,<,<=,>=) suivi d'un des mots cls ANY ou ALL. Un tel prdicat prend la valeur VRAI si le
prdicat correspondant, ne contenant ni ALL, ni ANY, prend la valeur VRAI pour tous (dans le cas de
ALL) ou pour un quelconque (dans le cas de ANY) des valeurs de l'attribut (la colonne) retourne par la
requte imbrique.
"Liste des articles dont le prix de vente est suprieur au prix de vente de l'article de couleur blanche le moins cher"
select art_nom
from article
where art_pv > ANY
(select art_pv from article where art_coul="Blanc")

"Liste des articles dont le prix de vente est suprieur au prix de vente de l'article de couleur blanche le plus cher"
select art_nom
from article
where art_pv > ALL
(select art_pv from article where art_coul="Blanc")

Exercice : Ecrire ces requtes sous une forme plus claire

Remarque : L'emploi de ANY ou ALL ne contribue pas forcment claircir la comprhension d'une
requte. Prudence. De plus les prdicats utilisants ANY ou ALL sont compltement inutiles, puisque
toute requte les utilisant peut tre reformule en utilisant EXISTS :
x $ ANY (select y from T where (p))
<=> EXISTS (select * from T where (p) and x $ T.y )
x $ ALL (select y from T where (p))
<=> NOT EXISTS (select * from T where (p) and NOT x $ T.y)

Exemples avec EXISTS
Le test d'existence prend la valeur FAUX si la sous requte a comme rsultat l'ensemble vide. Sinon, il
prend la valeur VRAI.
"Liste des articles dont le prix de vente est suprieur au prix de vente de l'article de couleur blanche le moins cher"
select A.art_nom
from article A
where exists
(select * from article B
where art_coul="Blanc" and A.art_pv > B.art_pv)

Remarque : Dans ce contexte, il est commode d'utiliser SELECT *, puisque seule l'existence d'un tuple
est intressante et non plus sa valeur. L'optimiseur de requte fera son travail le cas chant afin de ne
pas ramener le tuple dans son entier.

I NSERTI ON DE DONNEES
La commande INSERT prsente deux formes, une forme ensembliste (agissant sur un ensemble de
donnes) et une forme non ensembliste (agissant sur un tuple unique). Les deux autres n'existent que
sous des formes ensemblistes, agissant sur des ensembles de tuples de la base slectionns par un
WHERE.
Ces commandes changent l'tat de la base. Elles sont donc contrles par les transactions. Elles
provoquent un blocage de la (des) table(s) concernes.
La table cible doit exister pralablement et les types de donnes doivent (selon le SGBD) correspondre
exactement ou du moins tre de mme type.
FORME NON ENSEMBLI STE : INSERT VALUES
La syntaxe de cette forme est :
INSERT INTO {table|vue}
[(liste_de_colonne)]
VALUES (liste_de_valeur)

Sous cette forme, INSERT permet d'insrer un seul tuple la fois. Si les attributs sont non prciss, le
systme suppose que l'insertion se ralise sur tous les attributs, dans l'ordre de lecture de gauche
droite (c'est un des rares cas en SQL o l'ordre des attributs a une importance). Si la liste des valeurs
donn dans VALUES comporte un manque, une erreur est dclenche et l'insertion n'est pas ralise.
L'existence d'une liste explicite d'attributs viss permet de se limiter un ou des attributs et/ou de

changer l'ordre des attributs. Les attributs non cits reoivent dans ce cas la valeur NULL, ce qui va
videmment tre rejet si ils ont t dfinis comme NOT NULL dans la commande CREATE.
"Insrer dans la table clients une personne bien prcise (sur lequel on possde toutes les informations)"
insert into clients
values (1,"PELFRENE","Marc",)

"Insrer dans la table clients un client dont on a oubli l'adresse"
insert into client(code, nom, ville)
values (1,"PELFRENE","AUBAGNE")

FORME ENSEMBLI STE : INSERTSELECT
INSERT INTO table [(liste_de_slection)]
<requte_SELECT>

La requte_SELECT doit ramener le mme nombre d'attributs que celui spcifi dans la
liste_de_slection si celle-ci est explicite ou le mme nombre d'attributs que celui spcifi lors de la
cration de la table si la liste_de_slection est omise. Dans les deux cas, les types de donnes doivent
correspondre.
Il s'agit d'un transfert de table table.
"Insrer dans la table client_paris les clients de la table client habitant Paris"
insert into clients_paris
select code, nom, adresse from clients where ville="Paris"

On remarquera que la clause SELECT n'est pas entre parenthses. Il ne s'agit pas ici d'une sous requte.
Remarque :
- La table cible de INSERT ne doit tre dclare dans aucune clause FROM de la
requte.

SUPPRESSI ON DE DONNEE S
La syntaxe gnrale de cette commande est :
DELETE FROM { table | vue }
[ WHERE condition ]

La formulation gnrale de la commande est multi-tuples (clause WHERE ncessaire). Pour supprimer
un seul tuple, il faut donc trouver un critre qui le caractrise entirement. En l'absence de la clause
WHERE, c'est l'intgralit des tuples qui seront dtruits.
"Supprimer tous les articles provenant du fournisseur de l'article SERVISPRAY "
delete from articles
where fournisseur =
(select distinct fournisseur
from article
where nom = "SERVISPRAY")

Remarques :
- La table cible de DELETE ne doit tre dclare dans aucune clause FROM de la
requte.
- ORACLE possde une commande permettant de dtruire l'intgralit des tuples
d'une table en rcuprant l'espace de stockage :
TRUNCATE
{TABLE Nom_table | CLUSTER Nom_cluster}
[{DROP | REUSE} STORAGE]

La clause DROP STORAGE permet de librer l'espace des lignes supprimes.
Cet espace peut tre utilis par d'autres objets de la tablespace.
La clause REUSE STORAGE permet de maintenir l'espace des lignes
supprimes pour le profit de la mme table ou du mme cluster.
Si l'utilisateur a omis de spcifier l'une des deux clauses, Oracle prend par
dfaut la clause DROP STORAGE.
Cette commande ne fait pas cependant partie stricto sensu du langage de
manipulation de donnes, car elle ne peut pas tre annule par un ROLLBACK.

MI SE A J OUR DE DONNEES
La syntaxe gnrale de la commande UPDATE est :
UPDATE { table | vue }
SET { ( colonne [,colonne ] ... ) = ( requte )
| colonne = {expr | requte ) } }
[, { ( colonne [,colonne ] ... ) = ( requte )
| colonne = {expr | requte ) } } ] ...
[ WHERE condition ]

Cette commande consiste en une clause UPDATE spcifiant le nom de la table concerne, suivie d'une
clause SET, dfinissant les valeurs mettre jour, et d'une clause WHERE prcisant les tuples
modifier.
La formulation gnrale de la commande est donc ici encore multi-tuple, et il faut soigneusement choisir
le critre pour mettre jour un seul tuple.
On remarquera que les valeurs utilises pour la mise jour sont de deux types :
- une constante ou une expression :
UPDATE { table | vue }
SET nom_de_colonne = exp, ...
[ WHERE condition ]

- une clause SELECT :
UPDATE {table | vue }
SET ( liste_de_colonnes ) = (requte SELECT )
[ WHERE condition ]

Dans ce dernier cas il faut bien entendu respecter un certain nombre de contraintes. La liste
d'attributs gauche du = doit correspondre en nombre et en type aux attributs ramens par
la requte SELECT. Par ailleurs celle ci doit retourner une seule ligne.
"Ajuster le prix de vente par rapport au prix d'achat pour les articles dont la devise est le DEUTCH MARK de
telle faon que le prix de vente soit le double du prix d'achat"
update articles
set pv=2*pa where devise < "DEUTCH MARK"
"Modifier le prix de vente des articles en fonction des prix rellement pratiqus. Le prix de vente doit tre rendu
gal au prix de vente rellement pratiqu"
update articles
set pv=
(select avg(Montant/Quantit)
from FacturesLignes
where FacturesLignes.CodeArticle = Articles.Code
group by CodeArticle)

Remarque :
- La table cible de UPDATE ne doit tre dclare dans aucune clause FROM de la
requte.

75 SQL - Programmation
9. SQL - Programmation
ORACLE
TRI GGERS , PROCEDURES , F ONCTI ONS ET PACKAGE S
Ce sont des objets pouvant tre utiliss dans tous les outils de dveloppement dOracle, SQL*forms,
SQL*Menu, SQL*Plus, et les interfaces de programmation PRO*C,..
Les procdures (fonctions) compiles, sont stockes dans la base. Elles peuvent tre groupes dans des
bibliothques (packages) personnalises ou publiques.
LES TRI GGERS
Les triggers sont des actions spciales dfinies par lAdministrateur de la base de donnes,
gnralement sous forme de procdures stockes, qui sont excutes automatiquement par le systme
lors dvnements dclencheurs comme la mise jour, la cration ou la suppression de donnes dans
une table.
Un trigger est stock dans la base et associ une table. Il est excut implicitement par le noyau du
SGBD chaque fois que lvnement quil reprsente se produit.
Les triggers, utilisant les procdures stockes, peuvent utiliser toute la puissance du langage procdural
associ celles ci. Ils compltent donc les mcanismes de contraintes , en permettant de grer des
actions plus complexes que la simple validation des donnes.
Lintrt des triggers est li la mise en oeuvre dun contrle des accs aux donnes centralis dans la
base de donnes elle mme, donc indpendant des diffrents programmes dapplication.
Un trigger pourra par exemple tre utilis pour calculer automatiquement la valeur de colonnes
drives, mettre en place des systme de scurit complexes, mettre en place des rgles de gestion
complexes, offrir des systmes daudit et de journalisation ou modifier les tables de base lorsque des
ordres de cration ou de suppression sont raliss sur des vues.
Il convient malgr tout dtre prudent avec les triggers. Dune part le langage utilis, le type
dvnement dclenchant, et les instructions autorises dans le corps du trigger ne sont actuellement pas
normaliss, ce qui gnre bien sr des problmes de portabilit
7
. Dautre part, un trigger peut
dclencher dautres triggers sur dautres tables (triggers en cascade), et le rsultat de ces dclenchements
successifs peut tre dune grande complexit, et donc assez difficile maintenir. Enfin, le SGBD na
souvent aucun moyen doptimiser le dclenchement dun trigger, ce qui dans certaines utilisations peut
poser un grave problme de performance. Ainsi si une procdure ajoute mille lignes dans une table, le
trigger dajout sur cette table peut se dclencher mille fois pour vrifier une cl trangre, mme si cette
cl est identique dans toutes les lignes
8
.

7
rflchir sur le fait quil existe 3 versions du mme chapitre .
8
Il existe cependant des moyens de dsactiver les triggers temporairement, par exemple pour faire face une situation dinsertion
massive de donnes.

Pour ces raisons, le dbat est vif entre les tenants de la mise en uvre de la logique mtier via les
triggers et les procdures dans une base de donnes et ceux qui prfrent rgler le problme via la
programmation objet, le SGBD ne grant plus que la persistance des donnes.
En rsum, on se limitera dans lutilisation des triggers aux cas suivants :
o Mise en place de rgles mtiers complexes (si absence de dveloppement 3-tiers).
o Impossibilit de traduire les contraintes dintgrit par des contraintes (CONSTRAINT).
La cration :
Les commandes SQL qui sont susceptibles de dclencher un trigger sont INSERT, DELETE et UPDATE.
CREATE TRIGGER [schma.]trigger
{BEFORE | AFTER}
{DELETE | INSERT | UPDATE [OF colonne [,colonne]...]}
OR {DELETE | INSERT | UPDATE [OF colonne [,colonne]...]}
ON [schma.]table
[ [REFERENCE {OLD [AS] ancien NEW [AS] nouveau]
| NEW [AS] nouveau OLD [AS] ancien] } ]
FOR EACH ROW]
[WHEN (condition)]
<bloc PL/SQL>

Laction accomplir par le trigger est le bloc PL/SQL. Une restriction peut tre apporte par la clause
WHEN. On peut croiser les niveaux dexcution des triggers. Dune part ceux qui sont dfinis au niveau
ligne (row) et ceux qui sont dfinis au niveau tables. Dautre part ceux qui sexcutent avant
lvnement (BEFORE) ou aprs lvnement (AFTER). Il existe un type spcial de triggers, nomm
INSTEAD OF qui, contrairement aux autres types de triggers ont pour vocation de se dclencher pour
chaque ligne dune vue, et qui sexcutent la place de la commande SQL.
option FOR EACH ROW
Option
BEFORE
Actions avant la commande vnement Actions avant chaque ligne mise jour.
option
AFTER
Actions aprs la commande vnement Actions aprs chaque ligne mise jour.

Pour mmoire, il existe un dernier type de trigger qui peut sexcuter sur les vnements systme et
utilisateur (logon et logoff, dmarrage et fermeture de la base, messages derreurs du serveur )

Il est possible de mettre en place autant de triggers que dsir pour la mme instruction pour la mme
table. Il faut alors prter la plus grande attention ce que fait chaque trigger pour viter les problmes
de concurrence et dincohrence.
Pour spcifier les nouvelles et les anciennes valeurs de la ligne courante, Oracle introduit deux noms
denregistrement dfinis implicitement et nomms respectivement OLD et NEW. Ils peuvent tre
redfinis par la clause REFERENCE OLD AS ancien et NEW AS nouveau.
Les triggers agissent partir de leur validation, donc sur les nouvelles donnes. En aucun cas ils ne
vrifient les anciennes donnes.

Exemple : Crer un trigger qui permet de mettre jour automatiquement le montant de la commande et la
quantit des articles commands pour chaque ligne de commande enregistre. Lutilisateur peut insrer des
nouvelles commandes, modifier la quantit commande ou supprimer une ligne de commande. Pour chaque cas
cit, le trigger doit assurer la cohrence de la base de faon transparente. Cette cohrence, qui tait assure par le
programme de lapplication, est dsormais ralise par le noyau.

CREATE TRIGGER modifcom
AFTER DELETE OR UPDATE OR INSERT
ON ligne_commande FOR EACH ROW
DECLARE
nouv_prix article.prix%TYPE DEFAULT 0;
anci_prix article.prix%TYPE DEFAULT 0
BEGIN
IF DELETING OR UPDATING THEN
/*Chercher le prix unitaire de larticle modifier ou supprimer*/
SELECT prixunit INTO anci_prix FROM article
WHERE idarticle = :OLD.idarticle;
/*Mettre jour la quantit stocke*/
UPDATE article a SET a.qtestock = a.qtestock+:OLD.qtestock
END IF;
IF INSERTING OR UPDATING THEN
SELECT prixunit INTO nouv_prix FROM article
WHERE idarticle = :NEW.idarticle;
/*Mettre jour la quantit stcoke*/
UPDATE article a SET a.qtestock = a.qtestock-:NEW.qtecom
END IF;
/*Mettre jour le montant de la table commande*/
UPDATE commande a SET a.montant = a.montant +
:NEW.qtecom*nouv_prix - :OLD.qtecom*anc_prix
WHERE a.numcom =
DECODE(:NEW.numcom, NULL, :OLD.numcom, :NEW.numcom);
END;

Modifier un trigger :
La modification consiste lactiver, le dsactiver ou le recompiler :
ALTER TRIGGER [schma.]trigger
{ENABLE | DISABLE | COMPILE}

La suppression :
DROP TRIGGER [schma.]trigger

LES PROCEDURES ET FONCTI ONS
Lorsqu'on cre une procdure de BD, plusieurs points importants sont prendre en compte :
- Toutes les rfrences des objets sont rsolues au moment de la cration de la procdure. Cela
signifie en particulier que si une table publique est utilise dans la procdure, ce sera cette table
qui sera accde au moment de l'excution de la procdure par un utilisateur, mme si cet
utilisateur possde une table prive de mme nom.
- Tous les objets utiliss dans la procdure doivent exister et tre semblables au moment o celle ci
est cre et au moment ou elle est utilise. Si un objet est modifi (par exemple un attribut
redclar avec un autre type), la dfinition de la procdure doit tre supprime et recre.

Le plan d'excution de l'interrogation est cre lorsque la procdure est cre. Si la procdure est modifie,
le plan d'interrogation est recre la prochaine utilisation de la procdure. Ce point permet surtout de
mettre la disposition des utilisateurs des moyens de recherche de donnes parfaitement tests et
optimiss.
Exemple de procdure : "procdure qui dplace un client de la table client vers une table des clients
supprims"
create procedure move_client (id integer not null) as
begin
insert into client_sav
select *
from client
where clt_num=:id;
delete from client
where clt_num=:id;
end;
Les deux tables peuvent tre inaccessibles aux utilisateurs sauf travers la procdure. Lorsque la
procdure est appele, l'application passe un entier comme paramtre la procdure, paramtre qui
donne le numro de client dplacer.

La cration :
CREATE [OR REPLACE] PROCEDURE
[schma.]nom_procdure [(<liste darguments>)]
{IS | AS}
bloc PL/SQL;

CREATE [OR REPLACE] FUNCTION
[schma.]nom_fonction [(<liste darguments>)]
RETURN type
{IS | AS}
bloc PL/SQL;

Loption OR REPLACE permet de spcifier au systme le remplacement de la procdure ou de la
fonction si elle existe dj.
Les arguments sont spars par des virgules et de la forme :
nom_dargument {IN | OUT | IN OUT} type

Lorsquune procdure est cre laide dun diteur, sa dernire ligne doit tre compose dun seul
caractre \ , pour spcifier au systme lexcution de sa cration.
Exemples :

une procdure qui permet de baisser le prix dun article.

CREATE OR REPLACE PROCEDURE baisse_prix
( id IN NUMBER, Taux IN NUMBER)
IS
BEGIN
UPDATE article a SET a.prixunit = a.prixunit*(1+Taux)
WHERE a.idarticle = Id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE_APPLICATION_ERROR(-20010, Article Invalide :
|| TO_CHAR(Id));
END;

une fonction qui retourne le numro du client ou celui dun article.

CREATE OR REPLACE FUNCTION numero
(Nature IN CHAR)
RETURN NUMBER
IS
valeur NUMBER;
BEGIN

IF Nature = C OR Nature = c THEN
SELECT seqcl.nextval INTO valeur FROM dual;
ELSEIF Nature = A OR Nature = a THEN
SELECT seqar.nextval INTO valeur FROM dual;
ELSE valeur := -1;
END IF;
RETURN(valeur);
END;

La modification :
ALTER {FUNCTION | PROCEDURE} [schma.]nom COMPILE;
Recompile uniquement les procdures catalogues standards (pas les packages). Il faut avoir les droits
ncessaires.
La suppression :
DROP {FUNCTION | PROCEDURE} [schma.]nom;

LES PACKAGES
Un package permet dencapsuler des procdures, des fonctions, des curseurs et des variables comme
une unit dans la base.
La cration se fait en deux tapes :
o La cration des spcifications
o La cration du corps
La cration :
CREATE [OR REPLACE] PACKAGE [schma.]nom_package
{IS | AS} <spcification PL/SQL>

spcification PL/SQL ::=
dclaration de variable |
dclaration denregistrement |
dclaration de curseur |
dclaration dexception |
dclaration de table PL/SQL |
dclaration de fonction |
dclaration de procdure ...

CREATE [OR REPLACE] PACKAGE BODY [schma.]nom_package
{IS | AS} <corps PL/SQL>

corps PL/SQL ::=
dclaration de variable | dclaration denregistrement |
dclaration de curseur | dclaration dexception |
dclaration de table PL/SQL | dclaration de fonction |
dclaration de procdure ...
Les deux noms de package doivent tre identiques. Les objets dclars dans la spcification sont rendus
publics et peuvent tre accds lextrieur du package. Pour les utiliser il faut avoir le privilge
EXECUTE sur le package.

Le corps du package peut se terminer par un bloc (BEGIN END) permettant dinitialiser certaines
variables ou certains curseurs, qui par dfaut sont initialiss avec la valeur nulle.
Il est possible de nommer plusieurs procdures de la mme faon. Cette possibilit permet de dfinir
une procdure plusieurs points dentre (nombre darguments et types de donnes diffrents).
Exemple : Crer un package compos de deux fonctions qui calculent le chiffre daffaires global et par client pour
un vendeur donn et une procdure daugmentation annuelle des salaires de vendeurs.

CREATE PACKAGE ges_vendeur IS
TYPE VenEnreg IS RECORD (idven vendeur.idvendeur%TYPE,
qual vendeur.qualification%TYPE,
salaire vendeur.salaire%TYPE);
TYPE LstVendeur IS TABLE OF vendeur.nom%TYPE
INDEX BY BINARY_INTEGER;
Inval_Vendeur EXCEPTION

FUNCTION chiffre_affaire (Idvendeur NUMBER)
RETURN NUMBER;
FUNCTION chiffre_affaire( Idvendeur NUMBER, Idclient NUMBER)
RETURN NUMBER;
PROCEDURE augmente_ANN;
END ges_vendeur;

CREATE PACKAGE BODY ges_vendeur IS

/* Fonction permettant de calculer le chiffre daffaire dun vendeur*/
FUNCTION chiffre-affaire (Idvendeur NUMBER)
RETURN NUMBER IS
ca NUMBER DEFAULT 0;
BEGIN
SELECT NVL(SUM(a.montant),0) INTO ca
FROM Commande a
WHERE a.idvendeur = Idvendeur;
RETURN(ca);
END chiffre-affaire;

/*Fonction permettant de calculer le chiffre daffaire dun vendeur pour un
client donn */
FUNCTION chiffre_affaire (Idvendeur NUMBER, Idclient NUMBER)
RETURN NUMBER IS
ca NUMBER DEFAULT 0;
BEGIN
SELECT NVL(SUM(a.montant),0) INTO ca
FROM Commande a
WHERE a.idvendeur = Idvendeur AND a.idclient = Idclient;
RETURN(ca);
END chiffre_affaire;

/*procdure permettant de raliser une augmentation annuelle de 6% pour tous les
employs */
/* Ensuite et en fonction du chiffre daffaire raliser une seconde augmentation
*/
PROCEDURE augmente_ann IS
CURSOR bonus IS
SELECT commission FROM vendeur WHERE qualification=002
FOR UPDATE OF salaire;
mntcom vendeur.commission%TYPE;
BEGIN
IF (TO_CHAR(SYSDATE, DDMM)=0501)
THEN UPDATE vendeur SET salaire=salaire*1.06;
OPEN bonus;
LOOP
FETCH bonus INTO mntcom;
EXIT WHEN bonus%NOTFOUND;
IF (mntcom>500000) THEN facteur := .05;
ELSEIF (mntcom>20000) THEN facteur := .03;
ELSE facteur := 0;

END IF;
UPDATE vendeur SET salaire=salaire*(1+facteur)
WHERE CURRENT OF bonus;
END LOOP;
CLOSE bonus;
END IF
END;
BEGIN
INSERT INTO audit_vendeur
VALUES (SYSDATE, USER, Gestion Vendeur);
nbr_engages := 0;
END ges_vendeur;

La modification
Elle concerne la version compile. La recompilation se fait de la manire suivante :
ALTER PACKAGE [schma.]package COMPILE [PACKAGE | BODY];
La suppression
DROP PACKAGE [schma.]package ;

ORACLE
PL/ SQL
PL/SQL est lextension procdurale de Oracle au langage SQL
9
. Il permet de grouper des commandes et
de les soumettre au noyau comme un bloc unique de traitement.
Il permet de manipuler des donnes en combinant des instructions SQL et des instructions de contrle
de flux de programme telle que les constructions IF-THEN-ELSE et les boucles LOOP. Il est galement
possible de dclarer et dutiliser des variables, des constantes, de dfinir des procdures et des fonctions
et mme dutiliser des objets et des collections.
Il est utilis pour concevoir des procdures et des fonctions stockes dans la base de donnes, des
packages et des triggers.
Les applications crites en utilisant une des interfaces de programmation permettant laccs ORACLE
peuvent appeler les procdures crites en PL/SQL et stockes dans la base de donnes et/ou envoyer au
serveur de base de donnes des blocs de code de PL/SQL et demander lexcution de ces instructions.

9
Soyez conscient que chaque SGBD dfinit sa propre extension procdurale SQL (Transact SQL pour SQL Server, Stored Procedure
Language pour Informix, ). Au lieu de conserver la sparation entre code et donnes qui tait un des fondements de la mise en
place de systme de base de donnes relationnelles, les diteurs ont de plus en plus tendance amener le code lintrieur de la
base, tel point quaujourdhui il devient parfois difficile de porter un exemple crit pour SQL Server sur Oracle. Le seul rconfort
dans ce marasme est que presque tous les diteurs supportent (ou supporteront) les procdures stockes base de Java.

Autre Client
Serveur
Oracle
Oracle Forms
Programme PL/SQL
Interprteur SQL
Runtime PL/SQL
Procdure
stocke
Appel procdure
stocke
Gnrateur SQL
instruction SQL
instruction SQL
appel PS
CLIENT
SERVEUR

Dans un contexte Oracle, une des seules alternatives lutilisation de PL/SQL est lutilisation de Java
sous forme dEJB (Enterprise Java Beans) ou de JSP (Java Stored Procedures). Sinon, il faut renoncer la
mise en uvre du contrle des donnes lintrieur de la base et utiliser une couche intermdiaire (par
exemple laide dun langage objet) entre le programme et les donnes.

PRESENTATI ON DE PL/ SQL
Un programme est constitu dun bloc compos de trois parties :
DECLARE
Dclarations
BEGIN
Commandes excutables
EXCEPTION
Gestion des erreurs
END

La partie Dclarations sert dfinir les variables et les constantes utilises dans le bloc.
Les parties Commandes et Exceptions constituent le corps du bloc PL/SQL. Ce corps commence par le
mot BEGIN et se termine par END.

Dclarations
Cette partie peut comporter trois types de dclarations :
- Dclaration de variables et de constantes
- Dclaration de curseurs
- Dclaration des exceptions
Les types de donnes
Les types scalaires peuvent tre de nimporte quel type de donnes SQL (CHAR, VARCHAR, DATE,
NUMBER, ) auxquels sajoutent des types spcifiques PL/SQL :

TYPES PL/SQL
Types Scalaires
BINARY_INTEGER
DEC
DECIMAL
DOUBLE_PRECISION
FLOAT
INT
INTEGER
NATURAL
NATURALN
NUMBER
NUMERIC
PLS_INTEGER
POSITIVE
POSITIVEN
REAL
SIGNTYPE
SMALLINT
CHAR
CHARACTER
LONG
LONG_RAW
NCHAR
NVARCHAR2
RAW
ROWID
STRING
UROWID
VARCHAR
VARCHAR2
BOOLEAN
DATE
Types Composs
RECORD
TABLE
VARRAY
Types Rfrence
REF CORSOR
REF <object_type>
Types LOB
BFILE
BLOB
CBLOB
NCBLOB

BINARY_INTEGER comprend les entiers allant de -2
31
2
31
-1. Il admet les sous-types NATURAL,
POSITIVE, NATURALN, POSITIVEN et SIGNTYPE
DEC, DECIMAL, DOUBLE PRECISION, FLOAT, INTEGER, INT, NUMERIC, REAL, SMALLINT
sont des sous types de NUMBER, qui comprend les nombres rels de 1
-130
10
125

CHAR reprsente une chane de caractres taille fixe allant jusqu 32767 caractres (Ce type est limit
255 caractres dans les colonnes de tables).
VARCHAR2 est une chane de longueur variable allant jusqu 32767 caractres (limit 2000 octets
dans les colonnes. Attention octet peut tre diffrent de caractre dans certains systmes).
LONG est quivalent VARCHAR2 (une colonne de ce type peut avoir une taille de 2 147 483 647
octets).
BOOLEAN peut valoir TRUE, FALSE ou NULL. Seules les variables peuvent avoir ce type.
Il existe deux types composs : RECORD et TABLE et quatre types permettant de stocker des blocs de
donnes non structures comme les images, les sons et les clips vidos.
Des rgles trs prcises permettent la conversion des types ( voir dans la documentation).

En cas de manque, le mot cl SUBTYPE permet de dfinit des sous types de donnes utilisateurs :
SUBTYPE BirthDate IS DATE NOT NULL; -- based on DATE type
SUBTYPE Counter IS NATURAL; -- based on NATURAL subtype
SUBTYPE NameList IS TABLE OF VARCHAR2(10);
SUBTYPE DutyRoster IS NameList; -- based on TABLE type
SUBTYPE TimeRec IS RECORD (minutes INTEGER, hours INTEGER);
SUBTYPE FinishTime IS TimeRec; -- based on RECORD type
SUBTYPE ID_Num IS emp.empno%TYPE; -- based on column type
CURSOR c1 IS SELECT * FROM dept;
SUBTYPE DeptFile IS c1%ROWTYPE; -- based on cursor rowtype

Variables et constantes
dclaration de variable ::=
nom de variable [CONSTANT]
{type | identifiant%TYPE | identifiant%ROWTYPE}
[NOT NULL] [{:= | DEFAULT}expression PL/SQL];

La variable peut recevoir une valeur par dfaut. Variable et constante peuvent avoir un statut NOT
NULL.
Lutilisateur peut utiliser le type dun identificateur existant (variable ou colonne) en suffixant
lidentificateur par %TYPE, ou par %ROWTYPE sil sagit de la dclaration dune structure (table).
Exemples :
ename VARCHAR2(10) := 'KING'
birthdate DATE
balance NUMBER(7,2);
minimum_balance balance%TYPE := 10.00;

test table1.colonne2%TYPE
essai propritaire5.table1.colonne2%TYPE
MonRecord table1%ROWTYPE

Quelques exemples dexpression numriques :
-155 +5.0 (prixunit*18.6)/100 :var_h + 12 {variable dun langage hte}
SQL%ROWCOUNT + 1 NULL (12 + LENGTH(var1) - var2)**2
Quelques exemples dexpressions de chanes de caractres :
bonjour || lecteur varc || UPPER(varc2) || NULL ||| .
Quelques exemples dexpressions de dates :
05-JAN-98 LAST_DAY(sysdate)
Les tables
Les index dune table PL/SQL sont de type BINARY_INTEGER (cl primaire), et les valeurs
uniquement de type scalaire.

La dclaration se fait en deux tapes, dclaration du type puis des variables, suivant la syntaxe :
TYPE nom_type IS TABLE OF
{type_colonne | table.colonne%TYPE} [NOT NULL]

Exemples :
TYPE TypeNomArt IS TABLE OF CHAR(20)
-- ou encore
TYPE TypeNomArt IS TABLE OF article.nom%TYPE
-- puis la variable
NomArt TypeNomArt;
-- et les affectations
NomArt(1) := CRAYON;
NomArt(2) := STYLO NOIR;

Les enregistrements
Comme pour les tables, il faut dclarer le type puis les variables.
TYPE nom_type IS RECORD
(champ {type_champ | table.colonne%TYPE} [NOT NULL], ....);

Exemple :
TYPE TypeComm IS RECORD
(NomCl client.nom%TYPE,
Numcom commande.numcom%TYPE,
DateCom DATE,
Montant NUMBER(7,2) );

-- puis la dclaration de variable
Macom TypeComm;

-- et laffectation
Macom.Montant := 0;

Il est possible de dclarer des types RECORD imbriqus.
Exemples :
TYPE Identite IS RECORD
(Nom CHAR(15),
Prenom CHAR(25),
DateNaiss DATE );

TYPE Adresse IS RECORD
(Numero SMALLINT,
Rue CHAR(35),
Codepost CHAR(8),

Ville CHAR(25),
Pays CHAR(18) );

TYPE Personne IS RECORD
(Numero SMALLINT,
Ident Identite,
Adr Adresse );

Les curseurs
Un curseur peut tre vu comme un pointeur permettant de traiter successivement toutes les lignes dune
table obtenue par une requte. Il doit tre dclar au pralable dans la section de dclarations, puis
ouvert et utilis grce une commande spciale (voir plus loin) dans le programme.
DECLARE CURSOR nom_curseur [(nom_param type [,nom_param type]...)]
IS SELECT requte .....;

Les paramtres peuvent tre uniquement utiliss dans la requte associe au curseur.
Exemple :
CURSOR cur_article (prixunit NUMBER) IS
SELECT idarticle, prixunit
FROM article
WHERE prixunit > cur_article.prixunit ;

Gestion des erreurs
Le mcanisme de gestion derreurs dans PL/SQL est appel gestionnaire des exceptions. Il permet au
dveloppeur de planifier sa gestion et dabandonner ou de continuer le traitement en prsence dune
erreur.
Comme dans tous les langages, il faut diffrencier les erreurs systmes (exceptions internes), des erreurs
utilisateurs (exceptions externes).
Les exceptions internes
Une exception interne est produite lorsquun bloc PL/SQL viole une rgle dOracle ou dpasse une
limite dpendant du systme dexploitation (division par zro, dpassement de mmoire,...).
Les erreurs Oracle gnres par le noyau sont numrotes, or le gestionnaire des exceptions PL/SQL ne
sait grer que des exceptions nommes. Pour cela , PL/SQL a redfini quelques erreurs Oracle comme
des exceptions. pour les autres lutilisateur doit utiliser le gestionnaire OTHERS ou EXCEPTION_INIT
pour nommer ces erreurs.
Quelques exceptions prdfinies :
Nom dexception Erreur Oracle Valeur SQLCODE
CURSOR_ALREADY_OPEN ORA-06511 -6511
DUP_VAL_ON_INDEX ORA-00001 -1
INVALID_CURSOR ORA-01001 -1001

INVALID_NUMBER ORA-01722 -1722
NO_DATA_FOUND ORA-01403 -1403

Il y en a ainsi 14 prdfinies.
La gestion des exceptions
Elle se fait dans la partie EXCEPTION du bloc de commandes.
EXCEPTION
WHEN err1 THEN
-- grer lerreur err1
WHEN err2 THEN
-- grer lerreur err2
WHEN OTHERS THEN
-- grer toutes les autres erreurs
END;

WHEN err1 OR err2 THEN
-- gestion commune des erreurs err1 et err2

Lutilisateur peut dfinir ses propres exceptions, qui seront dclenches par la commande RAISE (elle
transfre le contrle de lexcution au gestionnaire dexception).
Exemple :
DECLARE
stock__zro EXCEPTION
BEGIN
....
BEGIN
IF qtestock = 0 THEN
RAISE stock__zro
END IF;
...
EXCEPTION
WHEN stock__zro THEN
-- grer lerreur
RAISE stock__zro;
END;
EXCEPTION
WHEN stock__zro THEN
--grer lerreur diffremment
END;

Si lutilisateur produit une exception qui nexiste pas dans le gestionnaire du bloc courant, elle se
propage vers le bloc fermant le bloc courant, jusqu ce quil la trouve. Sil ne la trouve pas, lexcution
sarrte avec une erreur dexception non gre.
Le dveloppeur peut utiliser les fonction SQLCODE et SQLERRM pour coder les erreurs Oracle en
exceptions. La premire fonction retourne le numro de lerreur, qui est gnralement ngatif, sauf pour
le non trouv qui vaut 100. La seconde reoit en entre le numro de lerreur et retourne le message
associ cod sur 196 octets.
Il est possible dutiliser une directive compile (PRAGMA) nomme EXCEPTION_INIT pour affecter un
nom un code derreur Oracle et nutiliser ensuite que ce nom pour la rfrencer.
Exemple :
DECLARE
erreur1025 EXCEPTION;
PRAGMA EXCEPTION_INIT (erreur1025, -1025);

LES I NSTRUCTI ONS DE CONTROLE
Elles permettent de diriger le flux dun programme PL/SQL en fonction de la valeur de conditions. Une
condition est une variable ou une expression quelconque retournant une valeur de type BOOLEAN,
cest dire VRAI ou FAUX.
La conditionnelle
Sa forme la plus gnrale est :
IF condition1 THEN
sequence_of_statements1
ELSIF condition2 THEN
ELSE
END IF;

Les parties ELSIF et ELSE sont facultatives.
IF qtestock < 10 THEN
alertstock := 100 ;
ELSEIF qtestock > 50 THEN
alertstock := 0;
ELSE
alertstock := 50;
END IF;
Les boucles
La plus simple des boucles est une boucle infinie :

LOOP
commandes, dont intruction de sortie;
END LOOP;

Les instructions de sorties (obligatoires sous peine de bouclage jusqu la fin des temps ou dpassement
de capacit) sont au choix :
EXIT; -- sortie inconditionnelle
EXIT WHEN condition; -- sortie si la condition est VRAIE
GOTO label; -- trs laid comme programmation

LOOP
FETCH c1 INTO ...
EXIT WHEN c1%NOTFOUND; -- exit loop if condition is true
...
END LOOP;
CLOSE c1;

La boucle incrmente :
Le nombre de fois ou la squence dinstructions doit tre value est calcul par soustraction de la borne
infrieure la borne suprieure ds lentre dans la boucle. La boucle est ensuite excute autant de fois
que ncessaire. Noter la notation originale de loprateur dtendue ( .. ).
FOR compteur IN [REVERSE] borneinf .. bornesup LOOP
commandes;
END LOOP;

A lintrieur de la boucle, le compteur peut tre rfrenc comme une variable, mais il est interdit de
changer sa valeur.
FOR ctr IN 1..10 LOOP
IF NOT finished THEN
INSERT INTO ... VALUES (ctr, ...); -- autoris
factor := ctr * 2; -- autoris
ELSE
ctr := 10; -- pas bien du tout !!!!!!!!!!!
END IF;
END LOOP;

La boucle conditionnelle :
Avant chaque itration de la boucle, la condition dans le WHILE est value. La boucle ne s excute que
si la condition est VRAIE

WHILE condition LOOP
commandes;
END LOOP;

WHILE total <= 25000 LOOP

SELECT sal INTO salary FROM emp WHERE
total := total + salary;

END LOOP;

LA GESTI ON DES CURSEURS
Pour traiter une commande SQL, PL/SQL ouvre une zone de contexte pour excuter la commande et
stocker les informations. Le curseur permet de nommer cette zone, daccder aux informations et
ventuellement den contrler le traitement. PL/SQL utilise deux types de curseurs :
Les curseurs explicites pour traiter les requtes multilignes,
Les curseurs implicites utiliss pour les autres commandes SQL.
Les curseurs explicites
Pour traiter une requte qui retourne plusieurs lignes, lutilisateur doit dfinir un curseur qui lui permet
dextraire la totalit des lignes slectionnes.
Une requte SELECT simple renvoie uniquement le premier enregistrement rencontr. Pour dfiler la liste
complte des valeurs, il faut utiliser un curseur.
Pour utiliser un curseur, il faut le dclarer dans la partie dclarative du programme (CURSOR), louvrir
dans la partie commande (OPEN), ensuite dfiler lextraction de donnes par la commande FETCH, en
utilisant une boucle et une instruction conditionnelle pour quitter la boucle quand il ny a plus de
donne. Le curseur doit tre ferm si lon juge quil ne sera plus utilis dans le reste du programme
(CLOSE).
Nous avons dj vu la syntaxe de la dclaration dun curseur.
CURSOR cursor_name [(parameter[, parameter]...)]
[RETURN return_type] IS select_statement;

return_type doit reprsenter un enregistrement ou une range dans une table de base de donnes.
DECLARE
CURSOR c1 IS SELECT empno, ename, job, sal FROM emp WHERE sal > 2000;
CURSOR c2 RETURN dept%ROWTYPE IS SELECT * FROM dept WHERE deptno = 10;
CURSOR c3 (low INTEGER DEFAULT 0,
high INTEGER DEFAULT 99)
IS SELECT ...

Le curseur ayant t dclar doit tre ouvert avant dtre utilis :
OPEN nom_curseur [(param_entre [, param_entre]...)]

Param_entre est une expression PL/SQL jouant le rle de paramtre rel associ par position un
paramtre formel de la dfinition du curseur. Il est possible que lassociation soit par nom condition de
prciser le lien param_formel =>param_rel
OPEN c1 ;
OPEN c2 ;
OPEN c3 (15, 2000);
OPEN C3 (low => 15, high => salary);
OPEN C3 (high => salary, low => 15);

Enfin le FETCH permet davancer dune ligne la fois dans le curseur :
FETCH nom_curseur INTO { nom_var [, nom_var ].. |
nom_enregistrement};

Les variables servent stocker les donnes retournes par la requte. Elles doivent tre dclares et
types selon le type des colonnes correspondantes. Elles peuvent tre remplaces par une variable de
type enregistrement ayant la structure du rsultat de la requte.

FETCH c1 INTO my_empno, my_ename, my_deptno;

LOOP
FETCH c1 INTO my_record;
EXIT WHEN c1%NOTFOUND;
-- process data record
END LOOP;

En fin dutilisation, penser fermer le curseur :
CLOSE nom_curseur;
Attributs de curseurs
Chaque curseur explicite possde quatre attributs utiliss pour accder sa zone de contexte :
NOM DE LATTRIBUT UTILISATION
%NOTFOUND : Gnre un boolen VRAI lorsque FETCH choue cause de la non-disponibilit
de donnes.
%FOUND : Contraire du prcdent.
%ROWCOUNT : Retourne le nombre de lignes dfiles de lensemble actif de donnes.
%ISOPEN : Gnre un boolen VRAI si le curseur spcifi est ouvert.

Utilis de la faon suivante nom_curseur%ATTRIBUT (voir exemples).
Les curseurs implicites
Oracle ouvre une zone de contexte de traitement pour tout ordre SQL. Ainsi la commande passe au
moteur nest pas une requte de consultation, lutilisateur peut accder aux informations de la zone de
contexte dite galement implicite SQL%attribut
BEGIN
...
UPDATE parts SET quantity = quantity - 1 WHERE partno = part_id;
sql_notfound := SQL%NOTFOUND; -- assign value to Boolean variable
...
IF sql_notfound THEN
...
END;

Il convient cependant de manipuler ces attributs de curseurs implicite avec la plus extrme prcaution,
puisque dune part, ces attributs font rfrence au dernier curseur utilis et que en mme temps, Oracle
lve le cas chant des exceptions qui ont priorit sur le traitement des instructions. Ainsi dans
lexemple prcdent, si la commande avait t une commande SELECT et quelle nait pas renvoy de
donnes, Oracle aurait lev lexception NO_DATA_FOUND.
Quelques exemples dutilisation
Exemple 1
DECLARE
client_enrg client%ROWTYPE;
Nom_art CHAR(20);
Prix_art NUMBER;
BEGIN
SELECT designation, prixunit INTO Nom_art, Prix_art
FROM article
WHERE idarticle = 123;

SELECT * INTO client_engr
FROM client
WHERE idclient = 1331;
END;

Exemple 2
DECLARE
CURSOR cur1 IS
SELECT nom || prenom, adresse, codepost || , || ville
FROM client WHERE idclient BETWEEN 1 AND 1500;
lib1 CHAR(45);
lib2 CHAR(40);
lib3 CHAR(50);
BEGIN
OPEN cur1;
LOOP
FETCH cur1 INTO lib1, lib2, lib3;
EXIT WHEN cur1%NOTFOUND;
INSERT INTO mail_table VALUE (lib1, lib2, lib3);
END LOOP;
CLOSE cur1;
END;

Exemple 3 (Avec une version spciale de la boucle FOR)

DECLARE
CURSOR cur_cl (id NUMBER) IS
SELECT nom, prenom, adresse, ville, codepost
FROM client WHERE idclient < id;
BEGIN
FOR cl_enrg IN cur_cl(1500) LOOP
INSERT INTO mail_client VALUES
( cl_enrg.nom || cl_enrg.prenom,
cl_enrg.adresse, cl_enrg.codepost
|| , || cl_enrg.ville);
END LOOP;
END;

Exemple 4 (Pour la mise jour de donnes)
DECLARE cur1 IS
SELECT nom || prenom, adresse, codepost || , || ville
FROM client WHERE idclient BETWEEN 1 AND 1500;
lib1 CHAR(45);
lib2 CHAR(40);
lib3 CHAR(50);
BEGIN
OPEN cur1;
LOOP
FETCH cur1 INTO lib1, lib2, lib3;
EXIT WHEN cur1%NOTFOUND;
IF lib1 = NULL
DELETE FROM client WHERE CURRENT OF cur1;
ELSEIF lib2 = NULL
UPDATE client SET adresse = rue inconnue
WHERE CURRENT OF cur1;
ELSE
INSERT INTO mail_table VALUES (lib1, lib2, lib3);
ENDIF;
END LOOP;
CLOSE cur1;
END;

LA GESTI ON DES TRANSACTI ONS
Dans un bloc PL/SQL, lutilisateur peut utiliser les commandes standard de gestion des transactions
pour coordonner ses traitements.
En plus des commandes COMMIT et ROLLBACK, qui permettent respectivement de valider ou
dannuler une transaction, lutilisateur dispose dune commande qui lui permet de dcouper une
transaction en sous-transactions laide de la commande SAVEPOINT. Ainsi en cas derreur, il peut
annuler seulement une partie de la transaction.
SAVEPOINT nom_de_point;
ROLLBACK TO [SAVEPOINT] nom_de_point;

MYSQL
TRI GGERS , PROCEDURES , F ONCTI ONS
LES TRI GGERS
Le support rudimentaire des dclencheurs (triggers) est inclus dans les versions de MySQL partir de la
version 5.0.2. Un dclencheur est un objet de base de donnes nomm, qui est associ une table et qui
s'active lorsqu'un vnement particulier survient dans une table
La cration :
Les commandes SQL qui sont susceptibles de dclencher un trigger sont INSERT, DELETE et UPDATE.
CREATE TRIGGER [schma.]trigger
{BEFORE | AFTER}
{DELETE | INSERT | UPDATE}
ON [schma.]table
FOR EACH ROW]
<bloc>

Laction accomplir par le trigger est le bloc (dfini par une suite dinstructions encadres par BEGIN
END
10
. On peut croiser les niveaux dexcution des triggers entre ceux qui sexcutent avant
lvnement (BEFORE) ou aprs lvnement (AFTER).

option FOR EACH ROW
Option
BEFORE
Actions avant la commande vnement Actions avant chaque ligne mise jour.
option
AFTER
Actions aprs la commande vnement Actions aprs chaque ligne mise jour.

Il ne peut pas y avoir deux dclencheurs pour une mme table avec les mmes configurations de
moment et de commande. Par exemple, vous ne pouvez pas avoir deux dclencheurs BEFORE UPDATE
pour la mme table. Mais vous pouvez avoir un dclencheur BEFORE UPDATE et un dclencheur
BEFORE INSERT, ou un dclencheur BEFORE UPDATE et un dclencheur AFTER UPDATE.
Pour spcifier les nouvelles et les anciennes valeurs de la ligne courante, MySQL introduit deux noms
denregistrement dfinis implicitement et nomms respectivement OLD et NEW.
Le dclencheur ne peut pas utiliser de commande qui ouvre ou ferme une transaction avec START
TRANSACTION, COMMIT ou ROLLBACK.

10
Seulement partir de version 5.0.2. Auparavent ne pas mettre le bloc BEGIN END

Les triggers agissent partir de leur validation, donc sur les nouvelles donnes. En aucun cas ils ne
vrifient les anciennes donnes.

Exemple : Crer un trigger qui permet de mettre jour automatiquement le montant de la commande et la
quantit des articles commands pour chaque ligne de commande enregistre. Lutilisateur peut insrer des
nouvelles commandes, modifier la quantit commande ou supprimer une ligne de commande. Pour chaque cas
cit, le trigger doit assurer la cohrence de la base de faon transparente. Cette cohrence, qui tait assure par le
programme de lapplication, est dsormais ralise par le noyau.

CREATE TRIGGER modifcom
AFTER DELETE OR UPDATE OR INSERT
ON ligne_commande FOR EACH ROW
DECLARE
nouv_prix article.prix%TYPE DEFAULT 0;
anci_prix article.prix%TYPE DEFAULT 0
BEGIN
IF DELETING OR UPDATING THEN
SELECT prixunit INTO anci_prix FROM article
/*Mettre jour la quantit stocke*/
UPDATE article a SET a.qtestock = a.qtestock+:OLD.qtestock
END IF;
IF INSERTING OR UPDATING THEN
SELECT prixunit INTO nouv_prix FROM article
/*Mettre jour la quantit stcoke*/
UPDATE article a SET a.qtestock = a.qtestock-:NEW.qtecom
END IF;
/*Mettre jour le montant de la table commande*/
UPDATE commande a SET a.montant = a.montant +
:NEW.qtecom*nouv_prix - :OLD.qtecom*anc_prix
WHERE a.numcom =
DECODE(:NEW.numcom, NULL, :OLD.numcom, :NEW.numcom);
END;

Modifier un trigger :
Pas de possibilit de modification de dclencheur. Il faut supprimer, puis recrer le dclencheur.
La suppression :
DROP TRIGGER [schma.]trigger
Une restriction importante !
Il nest pas possible dappeler une procdure stocke depuis un dclencheur. Il faut rcrire chaque
commande

MYSQL
LES PROCEDURES ET F ONCTI ONS
Les procdures stockes et les fonctions sont cres avec les commandes CREATE PROCEDURE et
CREATE FUNCTION. Une procdure est appele avec la commande CALL, et ne peut retourner de
valeur que via les variables de retour. Les fonctions peuvent retourner une valeur scalaire, et tre
appele depuis une commande, tout comme toute autre fonction. Les procdures stockes peuvent
appeler une autre routine stocke. Une routine est une procdure stocke ou une fonction.
La cration :
CREATE PROCEDURE
[schma.]nom_procdure [(<liste darguments>)]
[LANGUAGE SQL | [NOT] DETERMINISTIC
| SQL SECURITY {DEFINER | INVOKER} | COMMENT string]

bloc instructions;

CREATE FUNCTION
[schma.]nom_fonction [(<liste darguments>)]
RETURNS type
[LANGUAGE SQL | [NOT] DETERMINISTIC
| SQL SECURITY {DEFINER | INVOKER} | COMMENT string]
bloc instructions;

Les arguments sont spars par des virgules et de la forme :
nom_dargument {IN | OUT | IN OUT} type
Un framework pour dvelopper des procdures stockes externes sera prochainement prsent. Il
permettra d'crire des procdures stockes dans d'autres langages que SQL. Il est probable que l'un des
premiers langages supports sera PHP, car le moteur PHP est compact, compatible avec les threads et
peut tre facilement intgr. Comme ce framework sera public, il est probable que bien d'autres
langages soient supports
Une fonction est considre comme ``dterministe'' si elle retourne toujours le mme rsultat pour les
mmes paramtres d'entre. Sinon, elle est considre comme ``non dterministe''. L'optimiseur peut
utiliser cette proprit. Actuellement, l'attribut DETERMINISTIC est accept, mais il n'est pas encore
utilis.
L'attribut SQL SECURITY peut tre utilis pour spcifier si la routine doit tre excute avec les droits
de l'utilisateur qui l'a cr (DEFINER) ou avec ceux de celui qui appelle la fonction (INVOKER). La valeur
par dfaut est DEFINER. Cette fonctionnalit est nouvelle en SQL:2003.

La clause COMMENT est une extension MySQL, et peut servir dcrire la procdure stocke. Cette
information est affiche par les commandes SHOW CREATE PROCEDURE et SHOW CREATE FUNCTION.

Exemples :
une procdure qui permet de baisser le prix dun article.

CREATE PROCEDURE baisse_prix
( id IN NUMBER, Taux IN NUMBER)
BEGIN
UPDATE article a SET a.prixunit = a.prixunit*(1+Taux)
WHERE a.idarticle = Id;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE_APPLICATION_ERROR(-20010, Article Invalide :
|| TO_CHAR(Id));
END;

une fonction qui retourne le numro du client ou celui dun article.

CREATE OR REPLACE FUNCTION numero
(Nature IN CHAR)
RETURN NUMBER
IS
valeur NUMBER;
BEGIN
IF Nature = C OR Nature = c THEN
SELECT seqcl.nextval INTO valeur FROM dual;
ELSEIF Nature = A OR Nature = a THEN
SELECT seqar.nextval INTO valeur FROM dual;
ELSE valeur := -1;
END IF;
RETURN(valeur);
END;

La modification :
ALTER PROCEDURE | FUNCTION sp_name [characteristic ...]

characteristic:
NAME newname
| SQL SECURITY {DEFINER | INVOKER}
| COMMENT string

La suppression :

DROP {FUNCTION | PROCEDURE} [schma.]nom;

MYSQL
LANGAGE DE PROGRAMMATI ON
PRESENTATI ON
Un programme est constitu dun bloc compos de 2 parties :
DECLARE
Dclarations
BEGIN
Commandes excutables
END

La partie Dclarations sert dfinir les variables et les constantes utilises dans le bloc.
La partie Commandes constitue le corps du bloc. Ce corps commence par le mot BEGIN et se termine par
END.
Dclarations
Cette partie peut comporter trois types de dclarations :
- Dclaration de variables et de constantes
- Dclaration de curseurs
- Dclaration des gestionnaires
Les types de donnes
Les types de donnes sont les types supports par MySQL.
Les curseurs
Un curseur peut tre vu comme un pointeur permettant de traiter successivement toutes les lignes dune
table obtenue par une requte. Il doit tre dclar au pralable dans la section de dclarations, puis
ouvert et utilis grce une commande spciale (voir plus loin) dans le programme.
DECLARE CURSOR nom_curseur FOR SELECT requte .....;
OPEN CURSOR nom_curseur
FETCH nom_curseur
CLOSE nom_curseur
Exemple :

LES I NSTRUCTI ONS DE CONTROLE
Elles permettent de diriger le flux dun programme en fonction de la valeur de conditions. Une
condition est une variable ou une expression quelconque retournant une valeur de type BOOLEAN,
cest dire VRAI ou FAUX.
Conditionnelle
IF search_condition THEN statement(s)
[ELSEIF search_condition THEN statement(s)]
...
[ELSE statement(s)]
END IF
Test
CASE case_value
WHEN when_value THEN statement
[WHEN when_value THEN statement ...]
[ELSE statement]
END CASE
Ou bien :
CASE
WHEN search_condition THEN statement
[WHEN search_condition THEN statement ...]
[ELSE statement]
END CASE
Boucle inconditionnelle
[begin_label:] LOOP
statement(s)
END LOOP [end_label]

LOOP implmente une boucle, permettant l'excution rpte d'un groupe de commande. Les
commandes l'intrieure de la boucle sont excute jusqu' ce que la boucle se termine, gnralement
lorsqu'elle atteint la commande LEAVE.

Boucle REPETER TANT QUE
[begin_label:] REPEAT
statement(s)
UNTIL search_condition
END REPEAT [end_label]
Boucle TANT QUE FAIRE
[begin_label:] WHILE search_condition DO
statement(s)
END WHILE [end_label]

SQL ET J AVA
PRESENTATI ON
Comment accder aux donnes SQL ? Une application peut elle accder de faon transparente aux bases
de donnes rparties / fdres ? Une application construite sur un SGBD donn peut elle fonctionner
sur un autre ?
Les rponses forment un ensemble flou de oui , non et peut-tre Il existe au moins deux
approches concurrentes pour supporter SQL au sein dun langage de programmation : ESQL
(Embedded SQL partie 10 de la norme, SQL/OLB) et CLI (partie 3 de la norme, SQL/CLI).
CLIENT
Appel SQL
incorpor
Appel CLI SQL
PRECOMPILATEUR
Run-time library Run-time library
PILOTE DE BASE DE DONNEES
SERVEUR
PILE RESEAU
PILE RESEAU
Procdures stockes
SQL compil
Tables
...

Figure 7: Les deux API : CLI et ESQL
SQLJ : SQL I NCORPORE JAVA
En 1998, SQLJ
11
est devenue la base des liaison en langage objet de SQL3 ISO (cest la partie 10 du
document SQL3). Comme tous les ESQL (Embedded SQL), SQLJ permet dincorporer directement des
instructions SQL dans les programmes Java. A la diffrence dautres SQLJ, il permet aussi dincorporer
des appels des procdures stockes et des types dfinis par lutilisateur.
Afin de faire fonctionner SQLJ, il est ncessaire de disposer :
o Dun driver JDBC incluant les classes standard java.sql
o Dune base de donnes accessible par le driver
o Des classes pour le pr-compilateur, le runtime et les classes de profils. Ces classes sont
normalement accessibles dans <Oracle Home>/sqlj/lib/translator.zip.
Le principe dutilisation consiste crire des classes Java parfaitement classiques et dajouter ces
classes un certain nombre de dclarations, de commandes, et dexpressions destines un
preprocesseur. Ce preprocesseur va enlever ces ajouts et les remplacer par les appels de classes
ncessaires lexcution des instructions et au retour des rsultats. En voici un exemple, la directive
#sql indique au preprocesseur de commencer son travail, linstruction SQL est enferme dans les

11
Initiative de Oracle, Tandem et IBM au dpart

accolades ouvrantes et fermantes {}, le prprocesseur reconnat les variables prfixes par les deux
points comme des variables du langage hte et les traite comme telles.
public static void writeSalesData (int[] itemNums, String[] itemNames)
throws SQLException
{
for (int i =0; i < itemNums.length; i++)
#sql { INSERT INTO sales VALUES(:(itemNums[i]), :(itemNames[i]), SYSDATE) };
}
La classe ainsi compose doit tre enregistre dans un fichier dextension .sqlj . Ce fichier est ensuite
prcompil et produit un fichier .java et un certain nombre de fichiers de profils sqlj. Lensemble est
compil par un compilateur java pour produire le .class .

Un exemple de classe SQLJ : On ouvre la connexion la base de donnes et on lit une table.
// Import SQLJ classes:
import sqlj.runtime.*;
import sqlj.runtime.ref.*;
import oracle.sqlj.runtime.*;
// Import standard java.sql package:
import java.sql.*;
// Declare a SQLJ iterator.
// Use object types (Integer, Float) for mgr, sal, And comm rather
// than primitive types to allow for possible null selection.
#sql iterator EmpRecs(
int empno, // This column cannot be null, so int is OK.
// (If null is possible, Integer is required.)
String ename,
String job,
Integer mgr,
Date hiredate,
Float sal,
Float comm,
int deptno);

// This is the application class.
public class EmpDemo1App {
public EmpDemo1App() throws SQLException {
/* If you are using a non-Oracle JDBC driver, add a call here to
DriverManager.registerDriver() to register your driver. */
// Set default connection (as defined in connect.properties).
Oracle.connect(getClass(), "connect.properties");
}
public static void main(String[] args) {
try {
EmpDemo1App app = new EmpDemo1App();
app.runExample();
}
catch( SQLException exception ) {
System.err.println( "Error running the example: " + exception
);
}
}
finally
{
try { Oracle.close(); } catch(SQLException ex) {...}
}
void runExample() throws SQLException {
System.out.println("\nRunning the example.\n" );
// The query creates a new instance of the iterator and stores it
in
// the variable employees of type EmpRecs. SQLJ translator
has
// automatically declared the iterator so that it has methods for
// accessing the rows and columns of the result set.
EmpRecs employees;
#sql employees = { SELECT empno, ename, job, mgr, hiredate,

sal, comm, deptno FROM emp };
// Print the result using the iterator.
// Note how the next row is accessed using method next(), and
how
// the columns can be accessed with methods that are named after
the
// actual database column names.
while (employees.next()) {
System.out.println( "Name: " + employees.ename() );
System.out.println( "EMPNO: " + employees.empno() );
System.out.println( "Job: " + employees.job() );
System.out.println( "Manager: " + employees.mgr() );
System.out.println( "Date hired: " + employees.hiredate()
);
System.out.println( "Salary: " + employees.sal() );
System.out.println( "Commission: " + employees.comm() );
System.out.println( "Department: " + employees.deptno()
);
System.out.println();
}
// You must close the iterator when its no longer needed.
employees.close() ;
}
}
JDBC
JDBC (Java Database Connection) est une interface SQL portable, entirement crite en Java. Elle permet
dcrire du code portable indpendant du SGBD vis. JDBC fournit deux jeux dinterfaces : une interface
dapplication qui permet laccs aux services SQL de manire indpendante de la base de donnes et une
interface de pilote que les diteurs de base de donnes doivent adapter leur base de donnes
particulire. Son concurrent le plus direct est OLE-DB de Microsoft.
CLIENT
Programme Java Programme Java
Gestionnaire de pilotes OJDBC
PILOTE
JDBC/ODBC
PILOTE DB2 PILOTE MySQL
PILOTE
ORACLE
SERVEUR PILE
RESEAU
DB2
SERVEUR PILE
RESEAU
SQL Server
SERVEUR PILE
RESEAU
MySQL
ODBC

Figure 8 : Couches de l'API JDBC

Chaque base de donnes utilise un pilote (driver) qui lui est propre et qui permet de convertir les
requtes JDBC dans le langage natif du SGBD. Ces drivers, dits JDBC, existent pour la plupart des
diteurs et des bases. Voir http://developers.sun.com/product/jdbc/drivers
Le driver peut tre un driver natif , crit en pur Java ou tre une mixture entre Java et des mthodes
JNI (Java Native Interface). Certains diteurs (Oracle) proposent plusieurs versions du driver utilisant
une ou lautre des technologies.

Il existe un pont JDBC-ODBC permettant JDBC dutiliser une source de donnes ODBC, donc un
driver ODBC pour lequel il nexisterait pas dquivalent JDBC
Pilote type 3
Pilote type 1
Pilote type 2
Pilote type 4
API Tierce
API C/C++ native
SGBD
Conversation directe via
les sockets Java
(fournissseur SGBD)
API rseau
gnriqueavec le
serveur
Conversation via API C/
C++ => logiciel client
SGBD
Conversation via
ODBC

Figure 9 : diffrents types de pilotes JDBC
interface
Driver
DriverManager
interface
Connection
interface
Statement
interface
ResultSet
interface
DatabaseMetaData
interface
PreparedStatement
interface
CallableStatement
interface
ResultSetMetaData
+fournit 1
1
1 +fournit 0..*
1
+enregistre
0..*
1
+cre
0..* 1
+ramne
0..*
1
+fournit 1

Figure 10 : Classes et interfaces de JDBC

Mise en uvre
- Importer le package java.sql
- Enregistrer le driver JDBC
- Etablir la connexion la base de donnes
- Crer la description de requte
- Excuter la requte
- Traiter les donnes retournes
- Fermer les diffrents espaces

Exemple
Un exemple complet des techniques de base pour travailler avec une base de donne depuis un
programme java :
/*
* Exemple simple d'accs une base de donnes
*
* On utilise le driver MySQL.
* Noter quil suffit de modifier deux lignes pour travailler avec Oracle
*/

import java.sql.*;
import java.util.*;
import java.text.*; // pour formater la date

public class Test1 {
public static void main(String[] args)
throws SQLException, ClassNotFoundException {
// Charge le driver
//Class.forName ("oracle.jdbc.driver.OracleDriver");
Class.forName("com.mysql.jdbc.Driver");
// Un exemple ne pas suivre : mettre le mot de passe en dur
Connection conn =
DriverManager.getConnection("jdbc:mysql://localhost/immobilier");
//DriverManager.getConnection ("jdbc:oracle:thin:@localhost:1521:BASE",
// "system", "manager");
Statement stmt = conn.createStatement();
ResultSet rset =
stmt.executeQuery("SELECT ROWID, NOM, DATENAISSANCE FROM TIERS");

// Rcupre les donnes
while (rset.next()) {
System.out.print(rset.getInt(1));
System.out.print(" - ");
System.out.print(rset.getString(2));

java.sql.Date Annee = rset.getDate(3);
if (!rset.wasNull()) {
// Un peu d'exercice sur les dates en franais ne fait pas de
mal...
String strAnnee =
DateFormat.getDateInstance(
DateFormat.DEFAULT,
Locale.FRANCE).format(
Annee);
SimpleDateFormat formateur =
(SimpleDateFormat) DateFormat.getDateInstance(
DateFormat.DEFAULT,
Locale.FRANCE);
formateur.applyPattern("MMMM");
// configure le formateur pour avoir
// le mois en lettres (avec plus de
// 3 lettres (car plus de 3 M)
String mois = formateur.format(Annee);
System.out.print(" : n(e) le " + strAnnee);
System.out.print(" (" + Annee + ")");
} else
}

// Modification d'un bien
rset =
stmt.executeQuery(
"SELECT TYPE,VILLE,PRIX from BIENS WHERE ROWID = 4");
rset.next();
System.out.println(
"Le prix de "

+ rset.getString(1)
+ " situ "
+ rset.getString(2)
+ " est de "
+ rset.getDouble(3));

int nbLignesModifiees =
stmt.executeUpdate(
"UPDATE BIENS " + "SET PRIX = 1.06*PRIX " + "WHERE ROWID =
4");
System.out.println(nbLignesModifiees + " lignes modifiees");

rset =
stmt.executeQuery(
"SELECT TYPE,VILLE,PRIX from BIENS WHERE ROWID = 4");
rset.next();
System.out.println(
"Le prix de "
+ rset.getString(1)
+ " situ "
+ rset.getString(2)
+ " est pass "
+ rset.getDouble(3));
}
}

Chargement du driver
La premire tape est de mettre le(s) Driver(s) adquat(s) la disposition des classes.
Class.forName("com.mysql.jdbc.Driver");

La partie la plus difficile est de connatre le nom et la localisation du Driver. Lorsque cest un driver
dorigine Sun, il est dans sun.jdbc(exemple sun.jdbc.odbc.JdbcOdbcDriver). Lorsque le Driver
est propritaire, il est en gnral fourni sous forme dun jar. Ne pas oublier que celui-ci doit se trouver
dans le CLASSPATH.
Connexion la base de donnes
Les accs ultrieurs aux donnes se ralisent par lintermdiaire dun objet Connection.
static public synchronized Connection getConnection (String url)
throws SQLException
Ou
static public synchronized Connection getConnection (String url,
String user, String password)
throws SQLException
Par exemple :

Connection conn =
DriverManager.getConnection("jdbc:mysql://localhost/immobilier");


Cette tape est aussi trs simple. En fonction de lurl demande, le DriverManager va choisir le Driver
appropripour raliser la connexion. La seule difficult ici est de connatre lurl fournir au
DriverManager pour tablir la connexion. Cette url est dcrite dans la documentation du driver et
dpend de la base de donne considre. Quelques exemples :
MySQL :
jdbc:mysql://<IP ou DNS du serveur>/<nom base>
Oracle :
jdbc:oracle:<type driver>:@<IP ou DNS du serveur>:<port>:<nom base>
SQL Serveur (avec driver propritaire) :

Description de la requte
Dans sa forme lmentaire, une requte est envoye au SGBD par lintermdiaire de lobjet
Statement. On cre lobjet puis on appelle la mthode adquate pour lenvoyer au SGBD. Pour des
requtes de type SELECT (qui retournent un rsultat), la mthode est executeQuery(), pour des
requtes de mise jour (qui ne retournent pas de rsultat), la mthode est executeUpdate().
public Statement createStatement()
throws SQLException
Par exemple :
Statement stmt = conn.createStatement();

Requtes sans rsultats
Une requte qui ne retourne aucun rsultat est simplement excute laide de executeUpdate(). Il
est aussi possible (mais peut utile) dutiliser execute(). La mthode retourne le nombre de lignes
affectes par la requte.
public int executeUpdate(String sql) throws SQLexception

par exemple :
int nbLignesModifiees =
stmt.executeUpdate(
"UPDATE BIENS SET PRIX = 1.06*PRIX WHERE ROWID = 4");
System.out.println(nbLignesModifiees + " lignes modifiees");

Cette mthode permet aussi dutiliser les langages de description et de contrle :
stmt.executeUpdate("CREATE TABLE COFFEES " +
"(COF_NAME VARCHAR(32), SUP_ID INTEGER, PRICE FLOAT, " +
"SALES INTEGER, TOTAL INTEGER)");

stmt.executeUpdate("INSERT INTO COFFEES " +

"VALUES ('Espresso', 150, 9.99, 0, 0)");

Requtes avec rsultat
On dispose de nombreuses possibilits pour utiliser lordre SELECT. La plus simple est dutiliser un
simple Statement, avec un ordre SQL crit en dur .
La mthode executeQuery envoie la chane dinterrogation SQL au SGBD et retourne un objet
ResultSet
public ResultSet executeQuery(String sql) throws SQLException

par exemple :
ResultSet rset =

Le ResultSet est un objet qui peut tre visuellement assimil un tableau . Les lignes du
tableau sont les tuples de la base retourns par le SELECT, les colonnes du tableau sont les attributs
retourns par le SELECT. Le parcours du tableau se fait par la mthode next(). Celle-ci renvoie
VRAI tant quil existe encore une ligne dans le tableau. Les mthodes getXXXX() (getString,
getInt, getDouble, ) permettent de rcuprer les valeurs des colonnes soit par nom ( partir des
attributs du SELECT), soit par position.
ResultSet rset =

}

qui aurait aussi pu scrire :

System.out.print(rset.getInt("ROWID"));
System.out.print(rset.getString("NOM"));
}

Lorsque on souhaite utiliser des variables internes au programme java, une premire solution consiste
bien entendu utiliser comme instruction SQL une chane construite lors de lexcution du programme,
mlant les instructions SQL et les valeurs des variables. Il faut tre particulirement soigneux sur la
syntaxe SQL (ne pas oublier quune chane est entoure de guillemets par exemple .

La deuxime solution consiste utiliser une instruction prpare PreparedStatement, qui permet de
dfinir une instruction SQL contenant des paramtres, que lon peut excuter plusieurs fois en
changeant la valeur des paramtres.

Parcours du ResultSet
Au moment de sa cration, un ResultSet est positionn avant la premire ligne. La mthode next()
fait avancer le pointeur sur la premire ligne relle de rsultat et la rend disponible au programme. Il
faut donc excuter next() au moins une fois pour avoir le premier rsultat. Les appels suivants font
avancer le pointeur dune ligne la fois. Cest la mthode la plus simple pour parcourir un ensemble
rsultat.
Si ncessaire, il est aussi possible de parcourir lensemble rsultat dans un ordre diffrent. Pour cela, il
faut pralablement avoir cr linstruction Statement de manire supporter le dfilement dans les
deux sens. Linstruction createStatement() existe aussi sous une forme avec deux paramtres qui
dfinissent comment on pourra utiliser le ResultSet :
public Statement createStatement(int type, int concur)
throws SQLException

Le premier paramtre dfinit le type de lensemble rsultat :
- TYPE_FORWARD_ONLY : Le curseur dfile seulement vers lavant
- TYPE_SCROLL_INSENSITIVE : Le curseur dfile dans les deux sens, mais est insensible aux
changements survenus par le fait dune autre transaction en cours.
- TYPE_SCROLL_SENSITIVE : Le curseur dfile dans les deux sens, et les donnes rcupres
sont affectes par les changements survenus par le fait dune autre transaction en cours.

Le deuxime paramtre dfinit le type de concurrence de lensemble rsultat. Il est utilis notamment
lorsque on souhaite mettre jour ultrieurement le ResultSet.
- CONCUR_READ_ONLY : Le ResultSet ne peut pas tre mis jour
- CONCUR_UPDATABLE : Le ResultSet peut tre mis jour (voir plus loin).

On pourrait penser quil est plus simple de toujours utiliser TYPE_SCROLL_SENSITIVE et
CONCUR_UPDATABLE. Mais bien videmment, cest la forme qui consomme le plus de ressources et qui
est la plus lente, le SGBD devant mettre en place tous les systmes de transaction et de verrouillage pour
assurer le bon fonctionnement de linstruction.
Exemple : Crer un RecordSet permettant un dfilement dans les deux sens
Statement stmt = conn.createStatement(TYPE_SCROLL_INSENSITIVE,
CONCUR_READ_ONLY);
ResultSet rset =

// Rcupre les donnes affichage vers lavant
}
// Puis repart en arrire
while (rset.previous()) {
}


Les mthodes suivantes sont disponibles dans un ResultSet dfilant :
- absolute()
- afterLast()
- beforeFirst()
- first()
- getRow()
- isAfterLast()
- isBeforeFirst()
- isFirst()
- isLast()
- last()
- moveToCurrentRow()(seulement si CONCUR_UPDATABLE).
- moveToInsertRow()(seulement si CONCUR_UPDATABLE).
- previous()
- relative()

La plupart des ces mthodes se comprennent delle-mme. Les mthodes absolute() et relative()
prennent un entier comme argument. absolute() positionne le pointeur (lorsque cest possible) la
ligne indique en argument. relative() dplace le pointeur (lorsque cest possible) du nombre de
lignes indiques en argument.
Correspondances entre type java et type SQL
JDBC permet de rcuprer les donnes sous la forme Java selon une correspondance dfinie par Java. Ce
nest pas sans poser problmes vis--vis du stockage de donnes Java, les types SQL tant souvent plus
pauvres que les types Java.
Cest un point surveiller attentivement
SQL Type Java Method
BIGINT getLong()
BINARY getBytes()
BIT getBoolean()
CHAR getString()
DATE getDate()
DECIMAL getBigDecimal()
DOUBLE getDouble()
FLOAT getDouble()
INTEGER getInt()
LONGVARBINARY getBytes()
LONGVARCHAR getString()
NUMERIC getBigDecimal()
OTHER getObject()
REAL getFloat()
SMALLINT getShort()

TIME getTime()
TIMESTAMP getTimestamp()
TINYINT getByte()
VARBINARY getBytes()
VARCHAR getString()
Tableau 1 : Correspondance entre type Java et SQL
Requtes prpares (PreparedStatement)
Un PreparedStatement est un hritage du Statement qui offre plusieurs bnfices :
- La gestion des quotes et plus gnralement des types de donnes est facilite.
- La requte est prcompile par loptimiseur de requtes du SGBD et stocke (pour la dure de
son existence) dans le cache du SGBD. Si la requte est excute plusieurs fois, ce nest que la
premire fois quelle est compile. Toutes les autres fois, le SGBD va rutiliser la version
compile. Au contraire, lorsque on utilise un Statement, celui-ci est recalcul chaque excution.
Il y a donc gain de temps lors de lexcution de requtes rptitives. Toutefois, il faut avoir que
ce point nest pas implment par tous les SGBD
- Enfin le PreparedStatement utilise des arguments IN, ce qui le fait ressembler une fonction.

Pour utiliser un PreparedStatement, il suffit de le crer partir dune connexion et dune chane de
spcification.
public PreparedStatement prepareStatement(java.lang.String sql,
int resultSetType,
int resultSetConcurrency)
throws SQLException

La chane sql peut comporter des instructions SQL et des points dinterrogations. Les points
dinterrogation jouent le rle de joker et seront remplacs lors de lexcution par les valeurs fournies
par les mthodes setXXX de lobjet preparedStatement. De mme que les getXXX pouvaient lire les
valeurs des colonnes daprs leur numro, les setXXX remplacent les points dinterrogations selon leur
position. Dans lexmple suivant, le paramtre 1 (une chane) est lie la valeur myString par
linstruction setString(1, ) ; le paramtre 2 (un entier), est li la valeur 1024 par linstruction
setInt(2, ).
Exemple :
pstmtU = con.prepareStatement(
"UPDATE myTable SET myStringColumn = ? " +
"WHERE myIntColumn = ?" );

pstmtQ = con.prepareStatement(
"SELECT myStringColumn FROM myTable " +
"WHERE myIntColumn = ? ");

pstmtU.setString( 1, "myString" );
pstmtU.setInt( 2, 1024 );
pstmtU.executeUpdate();

pstmtQ.setInt( 1, 1024 );

pstmtQ.executeQuery();

Pour la suite, et notamment le parcours du ResultSet, les requtes prpares se comportent exactement
de la mme manire que les requtes ordinaires.
Accs aux procdures stockes (CallableStatement)
Alors que les requtes prpares permettent daccder des requtes similaires, les appels de
procdures stockes poussent plus loin le concept de bote noire pour les accs au SGBD. Une
procdure stocke est construite dans la base de donnes avant toute excution de lapplication. Elle est
donc dj optimise et donc sexcute plus vite que du code SQL dynamique. Par ailleurs, les erreurs de
syntaxe dans la procdure stocke sont plus rares, puisque le code de celle-ci a t test dans le SGBD
avant le dveloppement du programme. Enfin la procdure stocke masque les dtails de son
implmentation, en fournissant une espce dappel de mthode invoque sur la base de donnes,
laquelle on na plus qu fournir les arguments et dont on reoit le rsultat.
La contrepartie de cette simplicit apparente est une plus faible portabilit. De part lexistence de
multiples dialectes SQL dans le domaine des procdures stockes, un programme faisant appel des
procdures stockes deviendra moins portable dun SGBD un autre. Il faudra souvent rcrire les
procdures stockes pour le nouveau SGBD. Parfois mme, certaines procdures stockes sont tellement
lies un SGBD donn que le portage devient impossible (cest souvent le cas pour Oracle vers
MySQL).
Pour utiliser un CallableStatement, il suffit de le crer partir dune connexion et dune chane de
spcification.
public interface CallableStatement
extends PreparedStatement
Linterface est fournie sous une forme pour attendre un rsultat renvoy par la procdure stocke et une
fourme qui nattend pas de rsultat. Les deux formes peuvent prendre des paramtres en entres, qui
sont enregistrs par des mthodes de type setXXX, hrites de PreparedStatement. Si ncessaire, la
valeur rsultat doit tre enregistre avec registerOutParameter().
JDBC fournit une syntaxe indpendante du SGBD :
CallableStatement cstmt =
con.prepareCall( "{ call sp_A( ? ) }" );
pour une procdure sp_A qui ne retourne pas de rsultat, et
CallableStatement cstmt =
con.prepareCall( "{ ? = call sp_B( ? ) }" );
pour une procdure sp_B qui retourne un rsultat.
Exemples :
une procdure qui affiche les clients parisiens et le montant de leurs achats
CREATE PROCEDURE ClientsParisiens AS
select nom,Articles.code,Magasin.loc,FacturesLignes.Montant
from clients,articles,magasins,FacturesLignes
where FacturesLignes.NumFacture = Factures.Numero -- conditions de jointure
and Factures.CodeClient = Clients.Code -- conditions de jointure
and FacturesLignes.CodeArticle = Articles.Code -- conditions de jointure
and Factures.Magasin = Magasins.Code -- conditions de jointure

and Magasins.Ville like "PARIS%"
Appel de cette procdure :
CallableStatement cs = con.prepareCall("{call ClientsParisiens }");
ResultSet rs = cs.executeQuery();

une procdure qui affiche les clients parisiens et le montant de leurs achats sur une anne donne
CREATE PROCEDURE ClientsParisiens
(Annee IN NUMBER)
AS
select nom,Articles.code,Magasin.loc,FacturesLignes.Montant
and YEAR(FacturesLignes.Date) = Annee
CallableStatement cs = con.prepareCall("{call ClientsParisiens ( ? )}");
Cs.setInt(1, 2006) ;

une procdure qui calcule le montant des achats des clients parisiens sur une anne donne.
CREATE PROCEDURE ClientsParisiens
(Annee IN NUMBER, val OUT NUMBER)
AS
select sum(FacturesLignes.Montant) INTO val
and YEAR(FacturesLignes.Date) = Annee

CallableStatement cs = con.prepareCall("{ ? = call ClientsParisiens ( ? )}");
cs.setInt(2, 2006) ;
cs.registerOutParameter(1, java.sql.Types.FLOAT) ;

Types de donnes avances (BLOB et autres )
JDBC supporte les types de donnes avancs de SQL3 : les BLOB (Bynary Large OBjects) et les CLOB
(Characters Large OBjects). Un CLOB est un type de donne qui peut contenir un grand nombre de
donnes caractres (un texte par exemple), alors quun BLOB peut contenir un grand nombre de
donnes binaires (une image, un film, un son, )
12
.
Un CLOB est obtenu par une des mthodes getClob() dun RecordSet ou dun
CallableStatement. Un CLOB possde des mthodes pour rcuprer une sous chane des donnes,
la longueur des donnes, la position dune sous chane ou dun autre CLOB dans le CLOB courant.

12
Nous ne discuterons pas ici de lutilit et des avantages/dsavantages du stockage de tels objets dans la base de donnes.
Lalternative est videmment de stocker les objets dans le systme de fichier et de nenregistrer dans la base quune rfrence
lobjet. Chacune des technique a ses partisans et ses adversaires acharns

Toutes ces mthodes travaillent sans matrialiser le flot de donnes. Pour matrialiser ce flot, il faut
utiliser getAsciiStream() (ou getCharacterStream() pour un stream Unicode) et construire
ensuite des objets utilisables.
Un BLOB possde des mthodes pour dterminer son nombre doctets ou la position dun tableau
doctets ou dun autre BLOB dans le BLOB courant. Toutes ces mthodes travaillent sans matrialiser le
flot de donnes. Pour matrialiser ce flot, il faut utiliser getBinaryStream() (ou getBytes()) et
construire ensuite des objets utilisables.
Le stockage des BLOB et des CLOB se ralise par les mthodes setBlob() et setClob() des classes
PreparedStatement et CallableStatement, ou en utilisant la mthode updateObject() dun
recordset modifiable.
La cration dun BLOB ou dun CLOB se ralise par les mthodes setAsciiStream() ou
setCharacterStream() (pour les CLOB) et setBinaryStream()ou setBytes() pour les CLOB
Exemples
lecture dune image et affichage
JLabel jlImage = new JLabel() ;
Blob blob ;

rs = pstmt.executeQuery();
if( rs.next() )
{
blob = rs.getBlob( 1 );
iLength = (int)(blob.length());
ii = new ImageIcon(blob.getBytes(1, iLength));
jlImage.setIcon( ii );
pack();
}

enregistrement dune image en base de donnes
File fImage;
InputStream isImage;

pstmt = con.prepareStatement("INSERT INTO test VALUES( ?, ? )" );

pstmt.setString( 1, LEGENDE IMAGE );
fImage = new File(FICHIER IMAGE.JPG );
isImage = new FileInputStream( fImage );
pstmt.setBinaryStream( 2, isImage, (int)( fImage.length() ) );
pstmt.executeUpdate();

Metadonnes
Le terme mta reprsente lensemble des informations sur les donnes. JDBC fournit deux classes
pour ces metadonnes : ResultSetMetaData, qui va donner les informations sur les donnes
contenues dans un ResultSet et DataBaseMetaData, qui va donner les informations gnrales sur la
base de donne.
Linterface DataBaseMetaData est une horreur (approximativement 150 mthodes !), qui permet
toutefois dobtenir assez facilement les informations essentielles comme le nom du driver, le nom de la
base, la version, le nombre de connexions disponibles, la conformit avec SQL,
Linterface ResultSetMetaData est plus abordable. Elle ne comporte que 25 mthodes, permettant par
exemple de connatre le nombre de colonnes rtournes, une suggestion pour la taille des colonnes, les
noms de colonnes, les type de colonnes,

Il faut en gnral prendre garde que certains SGBD ne rendent pas les rsultats demands (ou bien que
pour ce SGBD donn, ils ne sont pas pertinents). On prendra donc soin avant toute exploitation du
rsultat, de tester la NULLit ventuelle de celui-ci.

Exemple de lecture des mtadonnes dun RecordSet
//***************************************************************************
// Licensed Materials - Property of IBM
//
// Governed under the terms of the International
// License Agreement for Non-Warranted Sample Code.
//
// (C) COPYRIGHT International Business Machines Corp. 1997 - 2002
// All Rights Reserved.
//
// US Government Users Restricted Rights - Use, duplication or
// disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
//***************************************************************************
//
// SOURCE FILE NAME: DtInfo.java
//
// SAMPLE: How to get information about data types
//
// JAVA 2 CLASSES USED:
// Connection
// ResultSet
// ResultSetMetaData
//
// Classes used from Util.java are:
// Db
// Data
// JdbcException
//
// OUTPUT FILE: DtInfo.out (available in the online documentation)
// Output will vary depending on the JDBC driver connectivity used.
//***************************************************************************
//
// For more information on the sample programs, see the README file.
//
// For information on developing JDBC applications, see the Application
// Development Guide.
//
// For information on using SQL statements, see the SQL Reference.
//
// For the latest information on programming, compiling, and running DB2
// applications, visit the DB2 application development website at
// http://www.software.ibm.com/data/db2/udb/ad
//**************************************************************************/

import java.lang.*;
import java.sql.*;

class DtInfo
{
public static void main(String argv[])
{
try
{
Db db = new Db(argv);

System.out.println(
"THIS SAMPLE SHOWS HOW TO GET INFO ABOUT DATA TYPES.");

// connect to the 'sample' database
db.connect();

// Get information about the Data type
infoGet(db.con);

db.con.commit();

// disconnect from the 'sample' database
db.disconnect();
}
catch (Exception e)
{
JdbcException jdbcExc = new JdbcException(e);
jdbcExc.handle();
}
} // main

static void infoGet(Connection con)
{
try
{
System.out.println(
"----------------------------------------------------------\n" +
"USE THE JAVA APIs:\n" +
" Connection.getMetaData()\n" +
" ResultSet.getTypeInfo()\n" +
" ResultSetMetaData.getMetaData()\n" +
"TO GET INFO ABOUT DATA TYPES AND\n" +
"TO RETRIEVE THE AVAILABLE INFO IN THE RESULT SET.");

DatabaseMetaData dbMetaData = con.getMetaData();

// Get a description of all the standard SQL types supported by
// this database
ResultSet rs = dbMetaData.getTypeInfo();

// Retrieve the number, type and properties of the resultset's columns
ResultSetMetaData rsMetaData = rs.getMetaData();

// Get the number of columns in the ResultSet
int colCount = rsMetaData.getColumnCount();
System.out.println(
" Number of columns in the ResultSet = " + colCount);

// Retrieve and display the column's name along with its type
// and precision in the ResultSet
System.out.println(" A LIST OF ALL COLUMNS IN THE RESULT SET:\n" +
" Column Name Column Type\n" +
" ------------------- -----------");

String colName, colType;
for (int i = 1 ; i <= colCount ; i++)
{
colName = rsMetaData.getColumnName(i);
colType = rsMetaData.getColumnTypeName(i);
System.out.println(
" " + Data.format(colName, 19) +
" " + Data.format(colType, 13) + " ");
}

System.out.println(
" HERE ARE SOME OF THE COLUMNS' INFO IN THE TABLE ABOVE:\n"+
" TYPE_NAME DATA_ COLUMN NULL- CASE_\n"+
" TYPE _SIZE ABLE SENSITIVE\n"+
" (int) \n"+
" ------------------------- ----- ---------- ----- ---------");

String typeName;
int dataType;

Integer columnSize;
boolean nullable;
boolean caseSensitive;

// Retrieve and display the columns' information in the table
while (rs.next())
{
typeName = rs.getString(1);
dataType = rs.getInt(2);
if (rs.getInt(7) == 1)
{
nullable = true;
}
else
{
nullable = false;
}
if (rs.getInt(8) == 1)
{
caseSensitive = true;
}
else
{
caseSensitive = false;
}
if (rs.getString(3) != null)
{
columnSize = Integer.valueOf(rs.getString(3));
System.out.println(
" " + Data.format(typeName, 25) +
" " + Data.format(dataType, 5) +
" " + Data.format(columnSize, 10) +
" " + Data.format(String.valueOf(nullable), 5) +
" " + Data.format(String.valueOf(caseSensitive), 10));
}
else
// for the distinct data type, column size does not apply
{
System.out.println(
" " + Data.format(typeName, 25) +
" " + Data.format(dataType, 5) +
" n/a" +
" " + Data.format(String.valueOf(nullable), 5) +
" " + Data.format(String.valueOf(caseSensitive), 10));
}
}
// close the result set
rs.close();
}
catch (Exception e)
{
JdbcException jdbcExc = new JdbcException(e);
jdbcExc.handle();
}
}
} // DtInfo

Gestion des erreurs
La plupart des mthodes du package java.sql lancent une SQLException, qui ncessite un bloc try
catch comme les autres exceptions. Le but est de permettre de dcrire les erreurs lies au driver ou la
base de donnes, y compris les erreurs de syntaxe SQL. En plus de la mthode standard getMessage(),
lexception SQL dispose dautres mthodes permettant de traiter le contexte spcifique aux bases de
donnes :

- getSQLState() renvoi une valeur SQLState base sur la description des erreurs propose par le
consortium X/Open.
- getErrorCode() renvoie la description des erreurs spcifique au vendeur du SGBD.
- getNextException() renvoie la descritoion derreur suivante. Cette mthode permet de retrouver
la suite des erreurs ayant abouti un chec.
- setNextException() permet au programmeur dajouter une erreur la chane derreurs.

La gestion typique des erreurs en JDBC devrait ressembler au schma suivant :
try
{
// some DB work
} // end try
catch ( SQLException SQLe)
{
while( SQLe != null)
{
// do handling

SQLe = SQLe.getNextException();
}
} // end catch

SQLWarning

SQL ET L3G ( C)
Le gain d'instruction SQL/langage est en moyenne de 10. Par contre SQL n'est pas complet, c'est
seulement un langage de dfinition des donnes et d'accs. Il ne dit rien sur l'interface avec l'utilisateur.
Il est donc ncessaire de combiner SQL avec un langage traditionnel, habituellement C ou Cobol, ou
ventuellement un gnrateur de formulaires. On appelle cet autre langage un langage hte.
Les instructions SQL sont introduites au niveau du source du programme d'application (ncessite une
prcompilation). Il est cependant possible, dans certaines implmentations, de construire une
instruction SQL de manire dynamique.
EXEC SQL prcde toute instruction SQL
Toute instruction SQL est utilisable dans un programme, ventuellement avec de lgres variantes. Des
instructions complmentaires sont disponibles.
Une instruction SQL peut se placer partout o une instruction C peut l'tre.
Les instructions SQL peuvent faire rfrence aux variables du langage hte. Les rsultats produits par
une instruction SQL peuvent tre rcupres dans les variables htes.
SQL retourne une information complte sur le droulement de chaque instruction excute (code
d'erreur, nombre de lignes extraites ...).
Les curseurs tablissent les liens entre ensemble SQL et lment C
Exemple p1.c
DECLARATION DE VARIABLES HOTES
DECLARATION DES ZONES DE COMMUNICATION
DECLARATION DES DEROUTEMENTS D'ERREURS
CONNEXION A LA BASE
ACCES A LA BASE
TRAITEMENT DES ERREURS
SECTI ON DECLARE
Contient les dclarations des variables C utilises dans les instructions SQL, dites variables htes. Elles
seront prcdes par : (colon) dans les instructions SQL. Les variables peuvent avoir le mme nom qu'un
objet SQL (une colonne). C'est le "deux-points" qui fait la diffrence.
La dclaration est globale pour l'ensemble du programme. On peut introduire plusieurs sections de
dclaration dans un mme programme.
La section commence par EXEC SQL BEGIN DECLARE SECTION
La section se termine par EXEC SQL END DECLARE SECTION
Entre ces deux instructions, les variables sont dclares selon le mme format et avec la mme syntaxe
que le langage hte. Le type de la variable doit tre compatible avec le type du champ SQL rcupr
dans la variable.
Des variables structures peuvent tre utilises :

EXEC SQL SELECT *
into :nom, :salaire
from employes

EXEC SQL SELECT *
into :emprec
from employes

struct
{ char enom[20];
int esalaire;
} emprec;

Types utilisables (hors structures) :
Type SGBD Type C
integer
integer
integer1
integer2
smallint
integer
long
int
int
short
short
char
float
float4
date
money
double
float
char[26]
double
char(N)
char(N)
varchar(N)
char *[N+1]
char [N+1]
varchar
Nb: Un certain nombre de conversions sont faites automatiquement.
Cas spcial : le type varchar.
Le type SQL varchar nom(n) est quivallent
struct {
int longueur;
char contenu[n];
} nom;

Utilitaire dclgen (Ingres).
dclgen est un utilitaire qui gnre une structure partir de la table. On peut ensuite inclure cette
structure dans la section de dclaration des variables.
dclgen c <nom de base> <nom de table> <nom de fichier> <nom de structure>

SECTI ON DE DECLARATI ON DES ZONES DE COMMUNI CATI ON C<->SQL
La zone de communication SQL (SQLCA) permet de grer les erreurs et les warnings concernant
l'excution d'une instruction SQL. C'est une collection de variables prdfinies qui doivent tre inclues
dans le programme par
exec sql include sqlca;

UTI LI SATI ON DE SQLCA
Explicite : Le programme teste explicitement les variables aprs un accs la base.
Implicite : En utilisant l'instruction WHENEVER
exec sql whenever <condition> <action>
Condition
SQLERROR, active si erreur quelconque (sqlcode<0)
SQLWARNING, active si warning quelconque (sqlwarn[0]='W')
NOT FOUND, active si pas de ranges slectionnes (sqlcode=100)
SQLMESSAGE, active si une instruction message a t excute dans une procdure
(sqlcode=700).
Action
CONTINUE, condition ignore (sauf si elle est fatale, auquel cas le programme stoppe...)
STOP, arrt du programme et rollback
GOTO <tiquette>, branchement (en accord avec les rgles du langage hte),
CALL <procdure>, appel de procdure du langage hte. La procdure ne peut pas avoir de
paramtre et ne peut pas excuter des instructions sql.
Exemple
exec sql whenever sqlerror goto erreur;
exec sql whenever not found call pastrouve;
exec sql whenever sqlerror stop; /*brutal !*/
Note sur la porte d'un WHENEVER
La porte d'un whenever est physique. L'action spcifie est valable jusqu'au whenever suivant ayant la
mme condition. On peut dclarer autant de whenever que dsir dans un programme.
Attention aux boucles infinies !
Dans la mesure o le traitement d'erreur provoqu par le whenever reste actif mme dans la routine de
traitement d'erreur, il est facile de provoquer des boucles infinies. Il est donc recommand de placer un
whenever continue comme premire instruction du traitement d'erreur.
exec sql whenever sqlerror goto TraiteErreur;
...
TraiteErreur:
exec sql whenever sqlerror continue;
...

Informations remontes par SQLCA
struct {
char sqlaid[8]; /*dummy ...*/
long sqlabc; /*dummy ...*/
long sqlcode; /*0=russi, <0 erreur en n erreur, >0
struct {
short sqlerrml; /* longueur du message d'erreur */
char sqlerrmc[70]; /* 70 premiers car. du texte du
message d'erreur */
} sqlerrm;
char sqlerrp[8]; /* rfu */
long sqlerrd[6]; /* seul 3 utilis : indique le nombre de

ranges */
struct {
char sqlwarn0; /* 'W' si warning, dtail dans les autres
*/
char sqlwarn1;
char sqlwarn2;
char sqlwarn3;
char sqlwarn4;
char sqlwarn5;
char sqlwarn6;
char sqlwarn7;
} sqlwarn;
char sqlext[8];
}

SECTI ON D' ACCES A LA BASE
exec sql connect <nom de base> [identified by <nom d'utilisateur>]
exec sql disconnect

ACCES A LA BASE
Chaque instruction sql est ajoute une transaction. La transaction n'est pas confirme (et les verrous
sur les donnes ne sont pas levs) tant qu'un commit, un disconnect ou un end transaction n'est pas
rencontr. Les transactions sont annules en cas de rencontre d'un rollback, d'un stop de sqlca, d'un exit
anormal, ou d'un dpassement de la taille du journal.
Cas 1 : Traitement d'une seule ligne (un tuple)
Slection simple
exec sql select 'fruit', nom, prix*2
into :categorie, :item, :newprix
from produits
where nom='pomme';

La correspondance colonne/variable se fait position position
Insertions, destructions, etc ...
exec sql insert into produits(nom,prix)
values (:item, :prix);

exec sql update produits
set prix=:prix
where nom = :item;

exec sql delete from produits
where nom = :item;

Cas 2 : Traitement d'un tableau (un ensemble de tuples)
Dans certaines implmentations commerciales, il existe des formes modifies de exec sql qui permettent
la rptition de l'instruction. La forme gnrale se sert de tableaux de variables ou bien des curseurs.

SQL MODE DYNAMI QUE
Les commandes SQL ne sont plus statiques, figes, c'est dire connues la compilation. Il est possible
de faire excuter par un programme des requtes non prvues la compilation, introduites par
l'utilisateur. Cela permet de retrouver la souplesse du sql interactif, en bnficiant de la facilit de
traitement des erreurs de l'utilisateur du langage. C'est ce mode qui permet de crer des interfaces
d'accs volues aux bases de donnes (QBE d'IBM, SQL*FORMS d'Oracle, QBF d'Ingres, ...).
Sous Oracle, quatre modes dynamiques sont possibles :
Mode 1 : Toute commande sauf select introduite comme chane de caractres (exemple m1.c)
exec sql execute immediate :<var>
La commande est donne en totalit par l'utilisateur, ou bien complte. Elle est stocke dans la variable
hte, et excute par l'instruction.
Mode 2 : Toute instruction, sauf select, avec en plus des variables htes paramtrant la commande qui
peut ainsi tre excute plusieurs fois avec des valeurs diffrentes des variables htes (exemple m2.c)
La commande est d'abord prpare.
exec sql prepare <nom commande> from <chane de caractres>
La commande est initialement construite dans une chane de caractres. Les paramtres sont spcifis en
utilisant un point d'interrogation la place des variables.
ex :
buffer = 'insert into'+user_name+'(enfant,age) values (?,?)';
exec sql prepare Commande1 from :buffer
La commande est ensuite excute.
exec sql <nom commande> [using :<var hte>]
La clause using permet d'utiliser des variables htes comme paramtre de la commande.
ex :
exec sql Commande1 using :nom, :age;

Mode 3 : Les commandes select prprogrammes sont possibles, mais les clauses select et from sont
connues la compilation. Seules les clauses where et order by sont dfinies dynamiquement (exemple
m3.c)
Mode 4 : Tout est permis, mais ncessite un langage allocation dynamique de mmoire (ni COBOL, ni
FORTRAN) (exemple m4.c)
La structure du rsultat est inconnue ==> le programme doit grer dynamiquement l'espace ncessaire
pour les variables htes et les intituls de colonnes.
Le nombre, l'ordre et le type des paramtre ne sont pas connues avant l'excution ==> le systme doit
grer dynamiquement l'espace ncessaire aux paramtre.
Logique du programme :

buffer_instruction = '';
lecture au terminal de buffer_instruction;
exec sql prepare Cmd1 from :buffer_instruction;
exec sql describe Cmd1 into :descripteur;
si (descripteur indique une commande non select) alors
exec sql execute Cmd1;
sinon
/* c'est un select */
exec sql declare Curs1 cursor for Cmd1;
exec sql open Curs1;
allocation de variables rsultats en utilisant descripteur;
faire tant que il reste des ranges dans le curseur
exec sql fetch Curs1;
using descriptor :descripteur;
si (pas dernire range) alors
traitement;
fsi;
ftque;
desallouer les variables en utilisant descripteur;
exec sql close Curs1;

Zone SQLDA
C'est une structure alloue dynamiquement contenant les informations ncessaire au langage hte pour
effectuer son allocation de mmoire. (Cfs p107-110 du Pro*C user's guide d'Oracle ou p54-60 du ESQL
user's guide d'Ingres).
/* p1.c : Mettre jour une valeur unique. Cette valeur est d'abord recherche,
puis affiche, saisie et mise jour. - Pro-C sous Oracle*/

# include <stdio.h>

EXEC SQL BEGIN DECLARE SECTION;
varchar uid(20);
varchar pwd(50);
varchar nom(15);
int numero;
EXEC SQL END DECLARE SECTION;

/* Inclusion des variables de communication C/SQL */
EXEC INCLUDE sqla.h;

main()
{
connect();

printf("\n Numro de magasin ? ");
scanf("%\n",&numero);

EXEC SQL SELECT nom_gerant into :nom
FROM magasins
WHERE mag_num=:numero;

/*ajouter \0 en fin de chaine nom afin de l'afficher */
nom.arr[nom.len]='\0';
printf("\n Il s'appellait : %s", nom.arr)

/* Saisie du nouveau nom */
printf("\n Donner le nouveau nom :");
scanf("%s",&nom.arr);
nom.len=strlen(nom.arr)

/* Mise jour */
EXEC SQL UPDATE magasins
SET nom_gerant=:nom
WHERE mag_num=:numero

EXEC SQL COMMIT WORK RELEASE;

}

/* m1.c : "executer une commande autre que select et sans paramtres */

#include <stdio.h>

exec sql begin declare section;
varchar instruction[127];
exec sql end declare section;


main()
{
exec sql connect mabase;


printf("\n donner une instruction ");
gets(instruction.arr);
instruction.len=strlen(instruction.arr);

exec sql execute immediate :instruction;

exec sql commit work release;
exit(0);

erreur:
printf("\n %s",sqlca.sqlerrm.sqlerrmc);
exec sql rollback work release;
exit(1);
}

/* m2.c : "executer une commande autre que select et avec paramtres */

#include <stdio.h>

int argument;


main()
{


printf("\n donner une instruction ");
gets(instruction.arr);

exec sql prepare Command from :instruction;
do
{
printf("\n donner un argument");
scanf("%d",&argument);
if (argument !=0) {
exec sql execute Command using :argument;
exec sql commit work;

}
} while (argument != 0);

exit(0);

erreur:
exit(1);
}

/* m3.c : "executer une commande select */

#include <stdio.h>

varchar nom[15];
int numero, prix, newprix;


main()
{
char clause_where[80], final[25];



strcpy(instruction.arr,"select art_num, art_nom,art_pv
from article
where ");

printf("\n donner la condition de slection ");
gets(clause_where);
strcat(instruction.arr,clause_where);
strcpy(final,"for update of art_pv);
strcat(instruction.arr,final);

exec sql prepare Commande from :instruction;
exec sql declare Curseur cursor for Commande;
exec sql open Curseur;

exec sql whenever not found goto fin1;

for(;;) {
exec sql fetch Curseur into :numero, :nom, :prix;
nom.arr(nom.len)='\0';
printf("\n %d %s %d", numero, nom.arr, prix);
scanf("%d",&newprix);
exec sql update article
set prix = :newprix
where current of Curseur;
exec sql commit work;
}

fin1:
printf("\n Tarif modifi");
exec sql whenever not found goto fin2
for(;;) {
exec sql fetch Curseur into :numero, :nom, :prix;

nom.arr(nom.len)='\0';
printf("\n %d %s %d", numero, nom.arr, prix);
}

fin2:
exec sql close Curseur;
exit(0);

erreur:
exit(1);
}

* m4.c : "executer n'importe quelle instruction SQL */

#include <stdio.h>

varchar *pinstruction;

exec sql include sqlda;

SQLDA *psqlda;
int da_nbvar = 8; /*Nombre de variables dans sqlda*/
int da_largeur=80; /*largeur par dfaut de chaque attribut*/

extern char *malloc();
extern char *sqlald();

main()
{
char clause_where[80], final[25];



if (pinstruction = malloc(256)) {
printf("\n Problme malloc pinstruction ");
exit(1),
}
else {
if (psqlda=sqlald(da_nbvar,da_largeur,0)) {
printf("\n Problme sqlald pinstruction");
exit(2);
}
};

psqlda->N=da_nbvar;
printf("\n Entrer l'instruction : ");
gets(pinstruction);

exec sql prepare Commande from :pinstruction;
exec sql declare Curseur cursor for Commande;

declist();
if (psqlda->F != 0) {
dimensionner();
lecture();
}


exec sql close Curseur;
if (psqlda->N != 0) liberer();
sqlclu(psqlda);

fin:
exit(0);

erreur:
exit(1);
}

declist()
{
exec sql describe select list for Commande into psqlda;
if (psqlda->F != 0) {
da_nbvar = -psqlda->F;
sqlcu(psqlda);
if (psqlda=sqlald(da_nbvar,da_largeur,0)) {
printf("\n problme allocation sqlda");
exit(3);
}
exec sql describe select list for Commande into psqlda;
}
}

dimensionner()
{
int i;
unsigned char prec;
char scale;
for (i=0;i<psqlda->F;i++)
{
if (psqlda->T[I]==2) {
prec = (unsigned char)(psqlda->L[i]>8);
scale = (char)psqlda->L[i];
if (prec==0) prec = 26;
psqlda->L[i] = prec;
if (scale<0) psqlda->L[i] += -scale;
psqlda->L[i] += 2;
}
else {
if (psqlda->T[i]==12) psqlda->L[i]=9;
psqlda->T[i]=1;
if (psqlda->L[i] ? 240) psqlda-> =240;
psqlda->V[i]=malloc(psqlda->L[i]);
}
}

lecture()
{
int cnt,nblg;
char nomcol[100],val_attr[100];
int colnoml;

exec sql whenever not found goto fin1;
putchar('\n');

/* lecture des noms de colonnes*/
for (cnt=0;cnt<sqlda->F;cnt++)
{
colnoml=;
memcpy(colnom,psqlda->S[cnt],psqlda->L[cnt]);
colnom[psqlda->L[cnt]='\0';

printf(" %s ",colnom);
}

/* pour chaque range */
for (nblg=0;;nblg++);
{
/* lecture de la range */
exec sql fetch Commande using descriptor psqlda;
for (cnt=0;cnt<sqlda->F;cnt++)
{
colnoml=psqlda->L[cnt];
memcpy(val_attr,psqlda->V[cnt],psqlda->L[cnt]);
colnom[psqlda->L[cnt]='\0';
printf(" %s ",val_attr);
}
printf("\n");
}

fin1:
printf("\n %d lignes extraites \n",nblg);
exec sql whenever not found continue;
}

liberer()
{
int i;
for (i=0;i<psqlda->N;i++) free(psqlda->V[i];
psqlda->N=0;
}

Cours 2009

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cours 2009

Încărcat de

Drepturi de autor:

Formate disponibile

10/07/2009 [Tapez un texte]

S-ar putea să vă placă și