Cours2009

5/8/2018 Cours2009 - slidepdf.com

http://slidepdf.com/reader/full/cours2009 1/133

10/07/2009 [Tapez un texte]

1Introduction

2009

Jean Yves CHIESA

Université de Rouen

10/07/2009

Cours Bases de Données




2 Cours Bases de Données




3Introduction

1. Introduction .............................................................................................................. ..................................... 4

2. Le modèle Entité-Association ............................................................ ........................................................ 15

3. Le modèle UML ............................................................. ................................................................. ............. 27

4. Le Modèle Relationnel ............................................................. ................................................................. .. 32

5. Le langage de définition de données .......................................................... .............................................. 49 Création de table ......................................... ................................................................. ................................... 49

Modification de table ........................................................ ................................................................. ............. 53

Suppression de table ......................................................... ................................................................. ............. 53

Renommage ....................................................................................................... .............................................. 53

6. Langage de contrôle des données ................................................................................................ ............. 55

Priviléges d'accés ............................................................................................................................................ 55

7. Le langage d'interrogation des données .................................................................................................. 57

Consultation des données. .......................................................... .............................................................. ..... 57

Insertion de données .................................. ................................................................. ................................... 70

Suppression de données ....................................... ................................................................. ........................ 72

Mise à jour de données ................................................................ ................................................................ ... 73

8. SQL - Programmation ....................................... ................................................................. ........................ 75

ORACLE Triggers, procédures, fonctions et packages .............................................................................. 75

Oracle PL/SQL .................................................................................................. .............................................. 84

MySQL Triggers, procédures, 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

Création d'index .......................................................................... ............................................................... ... 146

Suppression d'index .............................................. ................................................................. ...................... 147

Quelques indications sur les stratégies de création d'index ........................................................ ........... 147

13. 12ConceptTraitementTransactions .............................................. ....................................................... 148

Position du problème. ................................ ................................................................. ................................. 148

Méthodes de sérialisation ................................................ .............................................................. .............. 150

Exclusion mutuelle. ............................................... ................................................................. ...................... 151

Propriétés ACID ..................................................................................... ....................................................... 151

Gestion des transactions ................. ................................................................. ............................................ 152

Les niveaux d’isolation................................................................ ................................................................ . 153 Les Verrous ........................................................................ .............................................................. .............. 154

14. 13BasesDistribuées ............................................................... ................................................................. 156





1. Introduction

C O N C E P T D E B A S E S D E D O N N E E S

Pourquoi des bases de données ?

Le concept de bases de données n'est pas apparu tout d'un coup par magie dans le monde del'informatique, mais il était "en l'air" depuis longtemps. Dès les premiers fichiers sur bande magnétique,on s'était rendu compte des difficultés qu'il y avait à utiliser des informations séparées, réparties, voire

même disséminées, sur plusieurs supports.

Dans une entreprise, chaque programme possède son propre ensemble de données sur lequel porte letraitement. Tant que ces ensembles ne se recouvrent pas, tout va bien. Mais ce n'est pratiquement jamaisle cas et une ou plusieurs informations sont fréquemment présentes sur plusieurs fichiers. On trouveraainsi habituellement des informations relatives à la clientèle à la fois dans la chaîne de traitement de lagestion commerciale (commandes, facturation, règlement), dans la chaîne de traitement de lacomptabilité (comptabilité, gestion de trésorerie, banque), voire dans la gestion des produits. Le"gaspillage" des ressources matérielles (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 aumême niveau d'actualité. Ainsi, une même information est souvent présente sur un site informatique

avec des valeurs différentes.




5Introduction

Ces problèmes dits de la cohérence de l'information et de la redondance de l'information n'avaient bienentendu pas échappés aux utilisateurs des débuts de l'informatique de gestion, et de nombreusestentatives d'homogénéisation des fichiers étaient mises en place dans la plupart des centresinformatiques. Vont dans ce sens la plupart des systèmes de pointeurs entre les fichiers ou lesmécanismes de mise à jour en mode "lot" (batch) voire les différentes routines d'extraction/intégrationsouvent présentes dans les logiciels de gestion.

Il paraît é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 nombreuxfichiers physiques mis en œuvre. Une des idées qui a présidé à l'émergence des bases de données est dechercher avant tout à privilégier la non redondance des informations. L'objectif est de réduire à UN lenombre de représentation physiques identiques d'une même donnée1.

Figure 2

1 La vérité oblige à préciser qu'il s'agit du nombre de représentations "vues" par les utilisateurs, et non du nombre réeld'occurrences en mémoire ou sur un support disque. En effet, les SGBD sont parfois amenés à dupliquer physiquement certaines

informations afin d'optimiser les moyens d'accès et donc les performances.

Ceci n'est cependant pas en contradiction avec le principe de base, car cette duplication est réalisée par le système lui-même, avectoutes les précautions nécessaires





Q U E L Q U E S D E F I N I T I O N S

Base de données (BD) et Système de gestion de bases de données (SGBD)

Une base de données (BD) représente l’ensemble (cohérent, intégré, partagé, sécurisé, structuré) des

informations nécessaires au fonctionnement d’une entreprise, ensemble dont la gestion est assurée parun logiciel appelé système de gestion de base de données(SGBD). (1)

On entend ici par entreprise toute collectivité d’individus travaillant en coordination à la réalisationd’un objectif commun.

Exemples de bases de données : celle qui permet la gestion des personnels, étudiants, cours,inscriptions,... d’une université ou école, celle du système de réservation de places d’avion descompagnies aériennes, celle qui permettent la gestion des comptes clients des sociétés bancaires,...

Banque de données

Une base de données est développée au sein d’une entreprise pour son propre fonctionnement.Inversement, une banque de données est un ensemble de données, propres à un domaine d’application,que des « producteurs » réunissent pour ensuite en commercialiser l’usage vers le public extérieur.Exemples : les banques de données juridiques, économiques, médicales, des brevets, des propriétés desmatériaux,...La constitution et l’exploitation des banques de données font appel à des techniquesspécifiques (télématique, par exemple), différentes des techniques bases de données.

On peut citer comme exemple des renseignements de bibliographie, de linguistique de justice, dechimie, d'architecture, de cinématographie, de biologie, d'astronomie, de géographie, de médecine ou de jeu. La banque de données est souvent équipée d'un moteur de recherche. Elle repose sur une ou desbases de données.

Fichier

Dans une entreprise, il convient de faire appel à l’approche base de données lorsque les données à gérersont de natures diverses (exemple : étudiants, cours, enseignants, salles,..) et possèdent de nombreuxliens entre elles (exemple : un étudiant suit un cours, un cours est assuré par un enseignant,..).

Il existe des cas où les données à gérer, bien qu’importantes en volume, sont homogènes : les abonnésd’une revue, le personnel d’une entreprise, les produits vendus par un magasin,... Dans ce cas, onparlera de fichier (le fichier des abonnés,...) et l’on utilisera un système de gestion de fichiers (SGF),moins complexe qu’un SGBD. Toutefois, le prix décroissant et la facilité d’utilisation croissante desSGBD sur micro-ordinateurs tendent à faire disparaître progressivement ces pratiques. Elles nesubsistent plus aujourd’hui que pour des application déjà existantes.

Tout système d’exploitation d’un ordinateur contient un SGF spécifique. Toutefois, pour lesapplications, on fait plutôt appel à des progiciels du commerce ( dBase, Filemaker,..), d’un usage plussimple et offrant des fonctionnalités plus élaborées.

Il est à noter que l’implantation physique d’une base de données sur les mémoires secondaires se fait viala notion de fichier. Le choix de ceux-ci, toutefois, reste de la compétence du SGBD et est invisible àl’utilisateur.




7Introduction

F O N C T I O N S D ’ U N S G B D

Persistance des données sur disque

Partage des données (gestion des conflits d’accès)

Intégrité (respect de contraintes de cohérence)

Sûreté de fonctionnement (reprises après panne)

Confidentialité (attribution de droits d’accès) Archivage sur support externes (back-up)

M O D E L E S D E D O N N E E S E T S C H E M A S

Au cours des différentes phases de la vie d'une base de données, plusieurs descriptions sontsuccessivement élaborées, chacune d'elle répondant à un objectif déterminé et complémentaire. Dansl'état actuel de l'art, ces descriptions ne peuvent être faites avec le langage naturel, celui-ci étant tropambigu et trop difficile à comprendre pour un ordinateur. On fait donc appel à des langages formels,

basés sur un petit nombre de concepts bien établis (les objets, les liens, les propriétés, …)

On appelle modèle de données l'ensemble des concepts qui permettent la description en langage formeld'une base et les règles d'utilisation de ces concepts (leur grammaire). On appelle schéma d'une base dedonnées l'expression de la description de la base obtenue en employant un modèle de donnée.

Lors de la conception d'une base de données, on passe en général par plusieurs étapes, chacune d'ellespouvant être plus ou moins informatisée. Dans le cas général d'un projet d'une certaine envergure, onpeu distinguer au moins les phases de conception, d'implantation, de chargement des données,d'utilisation. Dans le cas de petites bases de données simples, certaine de ces phases sont absentes voiredans certains cas imposées par le SGBD.

Conception d'une base de données.

C'est la phase d'analyse du réel qui conduit à déterminer le contenu futur de la base. Le premierproblème à résoudre est de déterminer les informations qu'il convient de stocker dans la base.

Dans cette phase, il s'avère nécessaire que les utilisateurs puissent échanger avec les informaticiens ducontenu 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 déterminer quelles sontles informations nécessaires à la vie de l'entreprise, indépendamment de la solution technique qui seraretenue. La description de ces informations s'appuie ne général sur un ensemble de concepts qui ne fontpas référence à l'informatique. Les modèles utilisés sont dits "conceptuels".

La description ainsi obtenue est dite modèle conceptuel des besoins. Un tel modèle comprend engénéral deux parties, le modèle statique, permettant de décrire la structure des données et le modèledynamique, description des opérations sur les données.

De plus, quelque soit le modèle conceptuel choisi, il n'est pas possible de décrire toute la connaissanceque l'on possède sur le fonctionnement de l'entreprise, notamment les règles de gestion. On complètedonc le modèle en énonçant des descriptions explicites de contraintes supplémentaires, dites contraintesd'intégrité.

Cette activité est peut être une des plus délicates qui puissent exister dans le domaine des bases dedonnées. C’est pourquoi de nombreuses méthodes d’analyse existent. Actuellement, celle dont on parlele plus (mais est elle réellement la plus utilisée ?) est la méthode UML, conçue au départ comme une

méthode d’analyse des applications en général, mais qui a très vite étendu son domaine aux bases dedonnées. En France, la méthode Merise continue à être très appliquée dans les projets d’une certaineenvergure.





Implantation d'une base de données.

La phase suivante, celle d'implantation, demande que les données du schéma conceptuel soienttraduites dans les concepts du modèle utilisé par le SGBD choisi. On appelle modèle logique (ou modèlemachinable) le modèle sur lequel est construit un SGBD actuel.

Il existe aujourd'hui plusieurs modèles logiques, certains étant massivement prédominants

(hiérarchique, réseau, relationnel, objet). Le schéma obtenu en traduisant le modèle conceptuel desdonnées sera appelé le schéma logique des données.

Quelques SGBD prennent en compte la totalité de la notion de schéma.

Chargement de la base

Le chargement de la base de données avec la version initiale nécessite que soient fixés les choix enmatière de structuration des données sur le disque (quels type(s) de fichier(s), quels index ?). Ces choixne sont pas faits par les utilisateurs, mais par les administrateurs de base de données qui, en fonction deleur analyse des traitements qui seront effectués sur la base, fixent les paramètres effectifs pourl'implantation de la base de données dans le SGBD.

L'ensemble de ces choix sera consigné dans ce qu'on appelle le schéma interne de la base. Cettedescription fait appel à un nouveau modèle, appelé modèle interne, où les concepts clés seront ceux defichier, organisation, index, chemin d'accès, clé, …

Seuls les SGBD de haut de gamme permettent la mise en place de tels schémas. La plupart des SGBD surmicro-ordinateur sont eux totalement pré-configurés.

Utilisation de la base

Au cours de la phase d'utilisation de la base de données, d'autres schémas sont élaborés pour répondreaux besoins spécifiques des utilisateurs. La plupart de ceux ci n'ont pas besoin de connaître l'ensemble

du contenu de la base. Chaque utilisateur n'a que des exigences limitées (il n'est intéressé que parcertaines informations) et particulières (il souhaite une représentation qui lui convienne desinformations).

A ces utilisateurs, on peut associer un schéma, dit schéma externe, qui définit le sous ensemble de labase auquel il a accès.

Figure 3




9Introduction

Ce choix d’architecture a pour objectif d’accroître le niveau d’indépendance entre les données et lestraitements, a savoir :

l’indépendance physique,

l’indépendance logique,

l’indépendance vis-à-vis des stratégies d’accès.

L’indépendance physique consiste à rendre l’utilisation des données indépendante de leur organisationphysique (support de stockage et méthodes d’accès). La modification de l’organisation physique desdonnées ne doit pas entraîner, par exemple, la réécriture de programmes accédant à ces données.

L’indépendance logique consiste à rendre l’utilisation des données indépendante de la structure logiqueglobale. La modification du schéma conceptuel ne doit pas entraîner la modification des programmesd’application. Une modification des schémas externes est cependant nécessaire dans ce cas.

L’indépendance vis-à-vis des stratégies d’accès n’intervient qu’au moment de la manipulation desdonnées. Un programme d’application n’a pas à préciser comment accéder à telle ou telle donnée maisuniquement ce qu’il désire (le « quoi » et non pas le « comment »). C’est le SGBD qui doit déduire lemeilleur chemin d’accès aux données.

S T R U C T U R E T Y P E S D E D O N N E E S

Nous allons présenter dans cette section quelques représentations de l’organisation et de l’accès auxdonnées utilisés en base de données. Certaines n’ont plus qu’un intérêt historique ou sontéventuellement utilisées dans des applications spécialisées (hiérarchique, réseau). D’autres sont enconcurrence difficile avec le modèle relationnel, qui a envahi l’ensemble de l’espace et ne rencontreaujourd’hui plus aucune résistance.

Historique sommaire

Recherche Concepts Produits

1950 Structure hiérarchique : les données sont représentées sous formed’une arborescence

1960

1960 Structure réseau : les données sont représentées sous forme d’ungraphe quelconque

1970

1970 Structure relationnelle : les données sont représentées sous formede tables

1980

1980 Modèle objet : représentation sous forme d’objet et relationnel

objet : représentation relationnelle et extensions afin de stockerles méthodes.

1990

Structure hiérarchique

Ce modèle est capable de créer et de gérer des bases de données dont les relations entre les diverséléments logiques sont du type communément appelé "un à n".

Prenons l'exemple des cartes grises des automobiles.

Pour décrire une carte grise, il faut un fichier contenant le nom de la personne, la marque du véhicule, lenuméro d'immatriculation. Une personne pouvant posséder plus d'un véhicule, on admettra que lapartie relative à celui ci, marque et numéro d'immatriculation, est présente de "une" à "n" fois. On voitdonc qu'il existe dans ce fichier deux types de relations entre les données : d'une part des relations "1 à





n" entre une personne et les véhicules qui lui appartiennent et d'autre part une relation "1 à 1" entre unvéhicule et son propriétaire.

La décomposition hiérarchique de ce fichier est illustrée par la figure qui met en évidence les diversensembles et sous ensembles de données.

A partir de cette décomposition, il est possible de représenter schématiquement l'arborescence de la base

de données (figure ) : un nom d'individu "pointe" sur un sous-ensemble d'informations relatives à unvéhicule, ce sous ensemble étant présent "n" fois, c'est-à-dire autant de fois que l'individu possède devéhicules. On peut constater que cette décomposition en ensembles et sous ensembles n'est pas réservéeà une approche du problème par les bases de données ; une solution classique de fichier aurait eurecours à la même structure de données. Cependant, dans ce cas, tout choix d'organisation était définitif,à cause de la dépendance entre l'organisation physique des données et les techniques deprogrammation.

Une réalisation sous forme de base de données permettra en partie de s'affranchir de cette contrainte,mais en partie seulement. En effet, il est obligatoire de définir, au moment de la création de la base,l'ensemble des liens logiques à créer (figure).

Un des principaux inconvénients d'un tel système réside dans sa relative rigidité. Il faudra veiller àorganiser la base selon un schéma correspondant aux accès les plus courants. En effet, dans un telmodèle, les éléments terminaux ne peuvent être atteints que par les éléments racines. Un problèmemajeur intervient lorsque les questions posées sont du type : "Donne moi tous les éléments pèrespossédant des racines de tel type".

Un parcours intégral de la base sera alors nécessaire et, si ces parcours sont nombreux, l'utilisation de labase sera alors aussi onéreuse que celle d'un bête fichier séquentiel.

De plus, le parcours obligé de la structure d’arbre pour accéder aux données provoque forcément uneredondance des données. Or la redondance créant l’incohérence …

Structure en réseau

Dans les années 1970 commence la définition d’un nouveau type de gestionnaire de bases de données,destiné à pallier toutes les faiblesses citées du modèle hiérarchique. C’est en 1971 que sort le rapportd’un groupe de travail réunissant fabricants d’ordinateurs et utilisateurs, connu sous le nom de« Codasyl Data Base Task Group Report ». Ce rapport reprenait, en les développant, les idées quivenaient d’être mises en œuvre par C. Bachman dans la conception du SGBD IDS. Ce rapport eut unretentissement suffisant pour que très rapidement se répandent des SGBD de type réseau, « aux normesCodasyl ».

Fournisseur

......

Article

...

...Type Article

Figure 4

Une des idées de base est de permettre l’accès aux informations par différents liens, de s’affranchir de larelation parents/enfants qui est contenue dans une structure hiérarchique. Considérons l’exemplesuivant : une entreprise a un certain nombre de fournisseurs. Chaque fournisseur propose des articlesregroupés suivant différents « type articles » (chaudronnerie, électricité, gros-œuvre, charpente, …).




11Introduction

Chaque article est caractérisé par une référence chez le fournisseur et un prix. Cette réalité est facilementmise en œuvre par le diagramme hiérarchique de la Figure 4. Cependant il arrive fréquemment queplusieurs fournisseurs proposent le même article. Si alors on souhaite effectuer une recherche sur lesdifférents prix des articles similaires, on imagine facilement que le parcours de la base hiérarchique vadevenir d’une complexité importante. Le principe d’une base réseau est de permettre de créer des liensentre des éléments sans dépendance de type parents/enfants entre eux, comme les articles dans notrecas.

Fournisseur

......

Article

...

...Type Article

Fournisseur

......

Article

...

...Type Article

Figure 5

Bien entendu, la complexité d’une telle base va croître très vite en fonction du nombre de lienssupplémentaires que l’on va vouloir mettre en œuvre. Partant, les temps d’accès vont aussi croître et ilfaudra souvent étudier sérieusement les coûts comparés d’un accroissement du nombre de liens parrapport à des redondances (nous retrouverons d’ailleurs ces mêmes problématiques sous une formelégèrement différente dans le modèle relationnel). Il faut également noter que dans les deux modèles debases de données hiérarchique et réseau, la souplesse apparente liée à la possibilité de faire créer par lesystème tous les pointeurs désirés est en pratique limitée par la nécessité de définir, au moment de la

création de la base, l’ensemble des pointeurs et des chemins d’accès voulus. Toute modificationultérieure implique souvent une refonte de la base et (et des programmes d’exploitation).

Structure relationnelle

Face à cet ensemble de difficultés se sont progressivement imposées sur le marché les bases de donnéesrelationnelles, dans lesquelles ces contraintes de navigation par des pointeurs prédéterminés n’existentplus. Ces dernières fonctionnent sur le principe selon lequel « c’est le contenu de la question qui vadéterminer les chemins d’accès à établir ». Les liens ne sont plus fixés une fois pour toutes dans leSGBD, c’est le système qui les fabriquent dynamiquement selon les besoins. Le système agit par« déduction » à partir de la question. Lorsque celle ci implique la consultation des fichiers W et X, lesliens entre ces fichiers seront réalisés entre ceux ci en fonction des noms de zones communs à ces

fichiers. Il sera possible à tout moment d’ajouter ou de supprimer des fichiers dans la base de données.

PAIE

Matricule DateMontant...

EMPLOYES

Matricule Date entréeNombre enfants...

HISTORIQUE

Matricule Date d'entréeAncienneté...

Figure 6

La Figure 6 montre le principe du regroupement en tables des données appartenant à des fichiersdifférents d’une base relationnelle. Lors d’une interrogation portant sur le montant de la paie etl’ancienneté de l’employé, les deux tables PAIE et HISTORIQUE seront chaînés pour trouver la réponse.Si la donnée nombre d’enfants est aussi mentionnée, la table EMPLOYES sera aussi connectée





logiquement et physiquement pour participer à la recherche. Il va de soit que la donnée communematricule doit figurer dans chacune des tables, sinon tout chaînage serait impossible.

Bases d e données objet

La technologie orientée objet est un domaine à la situation un peu floue dans le domaine de la gestiondes données. L’augmentation du niveau d’abstraction introduit par les concepts d’objet, de classes, de

méthodes, de messages entre les objets a prouvé sa valeur dans le domaine de la programmation. Il étaitdonc naturel que la communauté des bases de données tente d’appliquer ces concepts. De plus, à partirdu moment ou les informaticiens manipulaient des objets, il était naturel que se pose la question de lapersistance des données, autrement dit du stockage de ces données. Et là, les bases de donnéesrelationnelles, avec la pauvreté de leur structure, apparaissaient nettement défavorisées.

Après un moment de confusion, ou certains ont pu prédire la fin du modèle relationnel, la situation estactuellement relativement claire.

D’un côté, de nouveaux concepts de bases de données, purement objet, permettent de développer desproduits dont l’objectif essentiel est de prolonger les développements objets dans le doma ine dustockage. C’est le cas de J2EE qui propose depuis longtemps un modèle de composants prédéfinis (les

EJB Entities) conçu pour faciliter la mise au point de cette couche de persistance. Certaines sociétés ontégalement tenté l’aventure de produits commerciaux, avec plus ou moins de bonheur. Il semble que leproblème des performances soit difficile à régler.

D’autre part, les grands éditeurs de bases de données relationnelles prolongent maintenant leursproduits avec des extensions orientées objet, permettant de continuer l’utilisation des conceptsrelationnels, en les étendant si nécessaire. C’est le cas d’Oracle ou de Postgres par exemple.

S G B D : L E S A C T E U R S D U M A R C H E

La théorie est une chose, la réalité commerciale en est une autre. Il existe des centaines de bases dedonnées (sans parler des prototypes universitaires ou autres). Cependant il faut avoir conscience que,dans la réalité des entreprises, le marché se partage entre quelques grands acteurs. Essayons d’endonner un rapide panorama. Je ne dirai rien des SGBD de type bureautique comme Access, FoxPro,FileMaker, 4D, Omnis. Non pas qu’ils ne soient pas intéressants, mais la plupart, pour des raisonsdiverses, sont trop loin des concepts qui caractérisent un SGBD.

Les bases de données relationnelles commerciales

Editeur Version et OS Remarques

Oracle

www.oracle.com

Tous OS Acteur historique du marché. Faible marketing, mais

sans cesse à l’affût de compléments et de nouveautés.Peu facile à utiliser …

IBMwww.ibm.com

DB2Tous OS

L’éléphant a du mal à danser face à Microsoft. Maisreste un acteur incontournable et mène un combatimpitoyable, en se défendant pied à pied face à sonchallenger.

Microsoftwww.microsoft.com

SQL ServeurUniquement Windows

Ultra facile à utiliser et administrer. Nombreusesextensions intéressantes (data mining, replication, …).

Sybasewww.sybase.com

Quasiment tous OS

Informixwww.informix.com

Unix Like et Windows Un acteur historique, récemment racheté par IBM. Lafin d’une histoire ?

http://www.oracle.com/


http://www.ibm.com/

http://www.ibm.com/

http://www.microsoft.com/


http://www.sybase.com/


http://www.informix.com/





http://www.ibm.com/





13Introduction

Les bases de données relationnelles Open Source


MySQLwww.mysql.com

Linux, Windows,Mac OS X

Optimisé pour la vitesse, pèche encore par denombreux manques sur des concepts relationnels

comme les transactions ou l’intégrité référentielle (quidevraient être introduites dans la version 5)

PostgreSQLwww.postgresql.org

Linux, Unix, MacOS X etWindows

C’est l’antithèse de MySQL. Implémentation de laplupart des concepts relationnels, au détriment de lavitesse disent certains…

SAPwww.sapdb.org

Linux, Unix, MacOS X etWindows

A ne pas confondre avec l’ERP du même nom. Sembleactuellement (Février 2003) en processus de fusionavec MySQL …

Borlandwww.borland.com

Linux, Windows, Solaris Le produit s’appelle Interbase. Il est surtoutcommercialisé avec les outils de développement del’éditeur (Delphi, C++, Kilyx, …)

Four Thoughtwww.4suite.org

Windows, Linux

Sleepycat Softwarewww.sleepycat.com

Windows , Linux, Solaris Le produit s’appelle Berkeley DB …

www.ozone-db.org Tous systèmes(développement en Java)

Les bases de données « objet »


Matissewww.matisse.com

Windows, Unix Stockage direct d’objets provenant de Java, C#, VB,Delphi, Eiffel, Smalltalk, Perl, Python, PHP

Objectivitywww.objectivity.com

Windows, Unix

Versantwww.versant.com

Solaris, Windows Stockage direct des objets de J2EE

Les bases de données « XML »

Avec la généralisation de l’engouement pour XML, il était fatal que les SGBD s’y collent. Deuxapproches existent actuellement. Chez Oracle ou IBM, le principe est de fournir une surchouche deprocédures permettant de stocker et de retrouver de manière transparente des données XML dans unebase de données relationnelle. Une autre approche consiste à stocker directement les données sousforme XML. C’est un peu celle de Microsoft dans le projet « Yukon », future version de SQL Server.Certains éditeurs tentent aussi le pari. Peu de commentaires, j’avoue peu connaître ce domaine.


Wolfgang Meyerexist.sourceforge.net

eXist 0.9.2sous Java

Apachexml.apache.org/xindice

Apache Xindice 1.0Windows, Linux

Software AGwww.softwareag.com

Tamino 4.1.4Windows, Solaris, Unix

Ipedo

www.ipedo.com

Windows, Unix

IxiaSoftwww.ixiasoft.com

Windows, Unix

http://www.mysql.com/


http://www.postgresql.org/


http://www.sapdb.org/


http://www.borland.com/


http://www.4suite.org/


http://www.sleepycat.com/


http://www.ozone-db.org/


http://www.matisse.com/


http://www.objectivity.com/


http://www.versant.com/


http://exist.sourceforge.net/


http://xml.apache.org/xindice


http://www.softwareag.com/


http://www.ipedo.com/


http://www.ixiasoft.com/





















Répartition du marché

Les chiffres suivants concernent l’année 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 très diversifiée sur plusieurs gammes de machines, duposte individuel au serveur départemental, avec différents types de bases de données), on constate quela lutte se situe essentiellement entre Oracle, créateur historique de la base de données relationnelle, et

Microsoft, challenger encore handicapé par son approche mono plate forme (Windows exclusivement).Les parts de marché d’Oracle décroissent continuellement au profit de Microsoft, en raisonessentiellement d’une politique de prix extrêmement agressive de la part de Microsoft, mais aussi de lamontée en puissance de Windows Server, avec lequel SQL Server est de plus en plus proposé commeproduit de « Back Office ». Microsoft essaye avec ce produit de rejouer « le coup de l’intégration » quiavait tellement bien réussi avec Internet Explorer. Ces chiffres ne font cependant pas apparaître que, enproduction, Oracle reste le support de bases de données nettement plus volumineuses et complexes queSQL Server.

Dans le monde de l’Open Source, MySQL se taille la part du lion …

Parts de marché des SGBD Open Source parmi les développeurs de bases de données qui enutilisent au moins un

Région 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

http://www.journaldunet.com/







15Le modèle Entité-Association

2. Le modèle Entité-Association

C O N C E P T S D E B A S E E T D I A G R A M M E S E A

Le modèle entité-association (EA, appelé aussi entité-relation) est un modèle de données de typeconceptuel. Il est actuellement utilisé par la plupart des méthodes et outils d’aide à la conception(MERISE,...). C'est un modèle limité à la description statique : son but est de permettre la description desstructures de données exclusivement, sans préjuger des traitements qui s'effectueraient sur cesstructures.

L’idée fondamentale de ce modèle est de retenir comme concepts de base les concepts génériques(objets, liens, propriétés) utilisés dans le processus d’abstraction qui conduit de l’observation d’uneréalité à sa description. On suppose que la perception d'une situation observée se fait naturellement surla base de l'identification des objets présents (concrets ou abstraits), des liens entre ces objets et despropriétés observables de ces objets.

Afin de distinguer le discours sur la réalité (fait en termes d'objets, de liens et de propriétés) du discourssur la représentation de la réalité, le modèle EA renomme ces mêmes trois concepts avec uneterminologie particulière :

OBJET ENTITE

LIEN ASSOCIATIONPROPRIETE ATTRIBUT

Entité objet du monde réel (concret ou abstrait), à propos duquel on veutenregistrer des informations et qui a une existence propre. Uneentité existe indépendamment du fait qu’elle est liée à d’autresobjets de la base de données.

Exemples : Mme Dupont, Mr. Durand, la cafetière X32,l’atelier de fabrication A22, le service Comptabilité,...

Type d’entité (TE) représentation d’une classe d’entités perçues comme similaires etayant les mêmes caractéristiques.

Exemples : employés (représentation de la classe desemployés), produit, atelier de fabrication, service,...





Association lien entre plusieurs entités où chacune d’elles joue un certain rôle.Si l’association lie deux (ou plus) entités du même type, elle estdite « cyclique » et, dans ce cas, la spécification du rôle de chaqueentité est indispensable pour supprimer les ambiguïtés possibles.

Exemples : l’atelier de fabrication A22 fabrique la cafetière X32; l’employé Durand travaille dans le serviceComptabilité; Mr Durand, époux, est marié avec MmeDupont, son épouse,...

Type d’association (TA) représentation d’un ensemble d’associations similaires ayant lesmêmes caractéristiques (liant des entités de même type avec lesmêmes rôles, et possédant les mêmes propriétés).

Exemples : fabrique lie un atelier de fabrication à un produit; travaille lie un employé à un service; est mariéavec lie une personne, l’époux à une personne, l’épouse,..

Attribut propriété associée à un TE, ou à un TA, ou participant à lacomposition d’un autre attribut.

Exemples : nom, prénoms, salaire sont des attributs du TE employé; quantité-en-fabrication est un attribut du TAfabrique; date-de-mariage est un attribut du TA est mariéavec; jour, mois, année sont des attributs composant unattribut date,...

On appelle occurrence d’un TE (TA) la représentation dans la base de données d’une entité (association)appartenant à la classe décrite par le TE (TA). On appelle population d’un TE (TA) l’ensemble desoccurrences du TE (TA). La base de données décrite par le schéma EA est l'ensemble des populations

des TE et TA apparaissant dans le schéma

Une occurrence de TE est constituée d’un ensemble de valeurs : une valeur pour chaque attribut du TE(NB : il est possible que la valeur d’un attribut soit en fait une absence de valeur ou un ensemble de valeurs ).

Une occurrence de TA est constituée d’un ensemble de valeurs (éventuellement vide) et d’un ensembled’occurrences de TE : une valeur pour chaque attribut du TA, (s’il en existe), et, pour chaque rôle du TA,une occurrence du TE qui joue ce rôle.

Il faut remarquer que les termes type, population, occurrence sont génériques (ne sont pas propres aumodèle EA).

Le modèle EA permet une représentation graphique assez lisible d’un schéma d’une base de données.Dans cette représentation, appelée diagramme EA, les types d’entités sont représentés par desrectangles; les types d’associations sont représentés par des losanges ou autre symbole similaire (ellipse,hexagone, rectangle arrondi,...). Les attributs sont soit rattachés au TE (TA) par des traits, soit listés àl’intérieur du rectangle TE (losange TA), au dessous du nom du TE (TA) et séparés de celui-ci par unebarre (voir diagrammes MERISE, par exemple).





Par exemple, le diagramme EA suivant illustre un schéma 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

AR

AR

E

R

Dans ce diagramme, sont représentés quatre types d’entités :

Employé, d’attributs nom et sal,

Rayon, d’attributs nomR et étage,

Article, d’attributs nomA et type,

Fournisseur, d’attributs nomF et adresse.

Ces types d’entité sont reliés par les types d’association suivants :

Livraison, d’attribut quantité, liant Fournisseur (avec le rôle F), Article (avec le rôle A) et Rayon(avec le rôle R),

Vente, d’attribut quantité, liant Rayon (avec le rôle R) et Article (avec le rôle A),

Emploi, liant Employé (avec le rôle E) et rayon (avec le rôle R),

Chef, cyclique, liant Employé (avec le rôle Inf) et Employé (avec le rôle Sup).

G E N E R A L I S A T I O N / S P E C I A L I S A T I O N

Un type entité représente une classe d’objets du monde réel perçus comme similaires et ayant les mêmescaractéristiques. Or, il arrive parfois qu’un même ensemble d’objets soit perçu d’un certain point de vuecomme une seule classe, mais en même temps perçu d’un autre point de vue, comme plusieurs classes,différentes malgré l’existence de caractéristiques communes.

Exemple : dans le diagramme du paragraphe précédent, le TE Article regroupe tous les articlesvendus, quels qu’ils soient; certains traitements doivent pouvoir accéder de façon uniforme à tousles articles : inventaire, recherche des caractéristiques d’un article dont on connaît le code,...

Pour d’autres usages, on peut néanmoins vouloir séparer les articles en plusieurs classes(alimentation, habillement, Hi-Fi, hygiène,..). Par exemple, la gestion des ventes promotionnellesn’aura pas les mêmes critères suivant la catégorie, les articles d’alimentation doivent être retirésdes rayons lorsque la date limite de vente est dépassée. Chaque classe peut avoir descaractéristiques qui lui sont propres, par exemple : date limite de vente (alimentation), taille et couleur (habillement),...

On sera donc amené à décrire, en plus du TE générique Article, des TE plus spécialisés, représentant lesclasses « intéressantes » (celles sur lesquelles on a effectivement quelque chose de particulier à faire). Parexemple, un TE « Article alimentaire », un TE « Article d’habillement » et un TE « Article Hi-Fi ».

Ceci, toutefois, introduit une situation atypique : celle où les mêmes objets sont représentés par deux TE(le TE générique et l’un des TE spécialisés), alors que normalement les populations de deux TEreprésentent des classes d’objets disjointes.





Pour décrire une telle situation, les modèles de données récents incluent le concept degénéralisation/spécialisation : un lien, orienté, d’un TE spécialisé (ou spécifique) vers un TE générique.La sémantique de ce lien est que toute occurrence du TE spécifique est également occurrence du TEgénérique. Graphiquement, ce lien est représenté par une flèche orientée du TE spécifique vers le TEgénérique.

Pour l’exemple de l’hypermarché, cela donne le diagramme suivant pour la représentation des

articles :

Article

Art. Alimentaire Art. Habillement Art Hi-Fi

Les liens de généralisation/spécialisation sont souvent appelés liens « est-un »; on dit que « Article

alimentaire est-un Article ». On dit généralement que le TE spécifique est un sous-type du TE génériquequi lui est un sur-type du TE spécifique.

Par convention, les attributs communs au TE générique et aux TE spécialisés ne sont décrits, dans leschéma, que comme attributs du TE générique. Néanmoins, ils sont implicitement inclus dans lesattributs des TE spécifiques : on dit que ces derniers « héritent » des attributs du TE générique. En plusdes attributs hérités, les TE spécifiques peuvent avoir des attributs propres.

Ce qui a été dit pour les attributs s’applique également aux TA (description, héritage). Par exemple, leTE « Article Hi-Fi », comme les autres TE spécifiques, est implicitement lié par les TA Vente etLivraison, hérités du TE Article. Il pourrait, en plus être lié par un TA Réparation à un TE Service après-vente (tel type d’article est réparé par tel service après-vente). Ce dernier TA n’est défini alors que pour

les articles du TE Article Hi-Fi.

Un diagramme plus complet pour l’exemple hypermarché est donc :

Service

Après-Vente

Réparation

ArticleHi-Fi

ArticleHabillement

Article

Alimentaire

ArticleVente

Livraison

MarqueNomATypeN°codeQuantité en stock

Puissance

limite venteTailles Couleurs





Il n’est pas nécessaire que les TE spécifiques représentent, dans leur ensemble, tous les objetsreprésentés par le TE générique. Ainsi, dans l’exemple, les articles d’hygiène, de bricolage,.. neconstituent pas d’autres classes spécifiques et sont donc uniquement représentés par le TE Article.

Un TE générique peut à son tour être sous-type d’un autre TE : on dit alors que l’on a une hiérarchie de

généralisations.

On parle de généralisation multiple lorsqu'un TE est sous-type de plusieurs autres TE. C'est le cas danscet exemple du chargé de cours, qui est à la fois thésard et vacataire. La généralisation multiple pose desproblèmes liés à l'héritage : éviter d'hériter deux fois d'un ancêtre commun, éviter d'avoir des conflitsd'héritage (par exemple sur des problèmes d'attributs de même nom).

Personne

Etudiant Employé

Thésard Enseignant Technicien Administratif

Vacataire Professeur

Laboratoire

Sujet

Classe deTraitement

Section

N°matricule NomPrénom

D E S C R I P T I O N D ’ U N S C H E M A E A

Un TE est décrit par les spécifications suivantes :

le nom du type d’entité;

le nom du sur-type d’entité, s’il existe; une définition libre (commentaire) précisant la population exacte du type d’entité,

la description des attributs du TE

Exemple : description du TE « Employé »

nom : Employé

définition : « toute personne salariée par l’entreprise en ce moment »

attributs : nom, salaire (avec leurs description)

Remarques :

- deux TE différents ne peuvent avoir le même nom;





- la définition libre est une partie très importante de la description d’un TE. C’est elle qui permet dedéfinir exactement, de façon non ambiguë, la population du TE. Elle inclut notamment la spécificationtemporelle (soulignée dans l’exemple), qui permet de savoir si le contexte modélisé couvre uniquementla situation actuelle ou aussi l’historique (les situations antérieures) et/ou la prospective (situation àvenir).

Un TA est décrit par les spécifications suivantes :

le nom du type d’association;

une définition libre (commentaire) précisant la population exacte du type d’association;

les noms des TE participant au TA, avec leur rôle;

pour chaque rôle, ses connectivités (souvent appelées cardinalités) : c’est une informationsupplémentaire exprimant la règle de participation des entités dans les associations (au niveaudes occurrences). Les connectivités consistent en deux nombres, min et max, spécifiant le nombreminimal et le nombre maximal d’occurrences du TA qui peuvent, à un instant donné, lier par cerôle une occurrence déterminée du TE en question. min et max sont deux entiers tels que

maxmin, min0, max1;

- la description des attributs du TA, s’il en existe.

Exemple : description du TA « Emploi »

nom : Emploi

définition : « lie un employé au rayon dans lequel cet employé travaille aujourd’hui »

TE participants : <Employé, E>, <Rayon, R>

connectivités : E: min=0, max=1 R: min=0, max=n;

attributs : ---

Les connectivités possibles pour un rôle (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 d’un rayon

max=n : un employé peut travailler dans plusieurs rayons

Conventions graphiques :

min=0, max=1 sont représentés par un trait unique discontinu

min=1, max=1 sont représentés par un trait unique continu

min=0, max=n sont représentés par deux traits discontinus

min=1, max=n sont représentés par deux traits l’un continu et l’autre discontinu.

Une autre façon de faire est de représenter les connectivités par deux chiffres (min,max ou min:max) auvoisinage du trait continu représentant le lien correspondant :

Parent est parent de Enfant

est parent de0,n 2,2

Signification des connectivités dans ce diagramme : un parent peut avoir de 0 à n enfants; un enfant a toujours

(dans cette base de données) deux parents.





Cas particuliers des TA cycliques : un TA est dit cyclique s’il lie plusieurs fois le même type d’entité(avec des rôles différents). Dans ce cas , le nom des rôles est essentiel et il faut, dans un diagramme, lesnoter sur les pattes de TA.

Exemples : les produits sont composés d’autres produits

Produit Composition

est composé de

est composant de

quantité

Si l’on enregistre dans la base de données la composition du produit 10001 : 5 unités de produit 512 et 3unités 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 apparaître dans le TA composition avec le rôle « est composé de », si cene sont pas des produits de type matière première.

Un attribut est décrit par les spécifications suivantes :

nom de l’attribut

définition libre (libellé en clair)

connectivités : min et max, spécifiant combien de valeurs de cet attribut sont autorisées (auminimum, au maximum) dans une occurrence du TE (TA), si l’attribut est directement rattachéau TE (TA), dans une valeur de l’attribut dont il est composant sinon (voir ci-dessous);

si l’attribut n’est pas composé d’autres attributs : domaine de valeurs associé, spécifiant quelensemble des valeurs est autorisé pour l’attribut;

si l’attribut est composé d’autres attributs : description des attributs composants.

Exemple 1 : description de l’at tribut « nom » du TE Employé

nom : nom

définition : « nom de l’employé, nom de jeune fille pour une femme »

connectivités : min=1, max=1 (tout employé a un nom et un seul)

domaine de valeurs : l'ensemble des chaînes de caractères de longueur inférieure à 15.





Exemple 2 : description d’un attribut « date de naissance » d’un TE Personne

nom : date de naissance

définition : « date de naissance de la personne »

connectivités : nim=1, max=1

composition :

nom : jour

définition : « jour de naissance de la personne »


domaine de valeurs : les entiers de l’intervalle [1,31]

nom : mois

définition : « mois de naissance de la personne »



nom : année

définition : « année de naissance de la personne »



T E R M I N O L O G I E

On appelle

attribut simple : un attribut qui n’est pas décomposé en d’autres attributs. Ses valeurs sont atomiques.Un domaine lui est associé.

Exemple : salaire, téléphone

attribut complexe : un attribut qui est décomposé en d’autres attributs. Ses valeurs sont des valeurscomposées.

Exemple : adresse composée de rue, ville, code postal.

attribut monovalué : un attribut qui ne peut prendre qu’une 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 : prénoms, téléphones

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





Exemple : nom, prénoms

attribut facultatif : un attribut qui peut ne pas prendre de valeur dans une occurrence (connectivitémin=0)

Exemple : salaire, téléphone

C L E S D E S T E E T T A

Une clé, ou un identifiant, d’un TE (TA) est un ensemble minimum d’attributs tel qu’il n’existe pas deuxoccurrences du TE (TA) qui ont la même valeurs pour ces attributs.

Un TE (TA) peut avoir plusieurs clés.

Exemple : n°employé et (nom+prénoms) sont deux clés du TE Employé, si dans cette entreprise il n’y a jamais deux employés ayant les mêmes noms et prénoms.

Une clé peut être désignée sur un diagramme en la soulignant.

Clé d’un 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 l’on admet que l’attribut nom est la clé de Personne, la clé de mariage est : époux.nom, ouépouse.nom.

Cette définition n’est valable que si la population du TA Mariage ne contient que les mariages en

cours (on ne garde pas l’historique). si le TA mariage conservait l’historique (les mariages passés),les connectivités des deux rôles seraient 0,n et la clé du TA serait :

époux.nom + date ou épouse.nom + date

car il n’est pas exclu que les deux mêmes personnes se remarient une deuxième fois après avoir divorcé.

Un TA dont tous les rôles ont une connectivité maximum supérieure à 1, a, en général, une cléconstituée de l’ensemble des clés des TE liés.

Exemple : soit un TA Contrôle, avec une occurrence (donc une moyenne, et un ensemble de notes) par étudiant et par matière suivie.





Etudiant Contrôle Matière

N°carte Notes M oyenne Coef NumMat

1,n 1,n

En supposant que les clés de TE soient comme indiqué sur le diagramme, la clé du TA Contrôleest :

Etudiant.N°carte + Matière.NumMat

Néanmoins, il n’est pas toujours vrai que la clé d’un TA soit constitué de l’ensemble des clés des TE liés. Si l’un des rôles du TA a une connectivité maximum égale à 1, la clé du TE associé à ce rôle 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, l’attribut Voiture.NumV suffit à lui seul, pour identifier une occurrence d’Assure. Ceci est dû à la connectivité 1,1 du rôle de Voituredans le TA, qui garantit que pour une valeur de numV il n’y aura jamais qu’une seule occurrenced’Assure avec cette valeur de NumV.

Règle : si le TA a une connectivité maximum égale à 1 pour un de TE liés, alors toute clé de ce TE estune clé du TA

Une autre règle peut être établie pour les cas où plusieurs occurrences du TA lient les mêmesoccurrences de TE. Dans l’exemple ci -dessous, plusieurs commandes peuvent être passées par unmême client pour un même prod uit à des dates différentes. Dans ce cas l’identifiant de TA contient au moins un attribut du TA.

Produit Commande Client

N°produit N°commandeDate

Quantité

N°client

0,n 0,n

Le TA Commande a ici deux clés :

N°produit + N°client + Date ou N°commande

Clé d’un TE faible

Un TE faible est un TE dont aucun sous-ensemble d’attributs ne constitue une clé (il n’y a pas de clé quilui soit interne), et qui est lié par un TA binaire de connectivité (1,1) à un autre TE dont il dépend.

Dans l’exemple ci -dessous, Exemplaire (qui représente un e xemplaire d’un livre) est un TE faible(N° ex n’est pas une clé) dépendant du TE Livre.





Livre Exemplaire

ISBN Titre N°ex Etat

est un1:n 1:1

La clé d’un TE faible (qui est la même que celle du TA) est constituée de la clé du TE dont il dépend etd’un (ou plusieurs) attribut du TE faible.

La clé de Exemplaire (et de « est un ») est : ISBN + N°ex

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 nécessairementde clé qui lui soit propre. Dans l'exemple déjà cité du supermarché, Article Alimentaire, Article Hi-Fi etArticle Habillement ont tous trois comme clé la clé de Article.

C O N T R A I N T E S D ’ I N T E G R I T E

Les concepts d’entité, d’association, attribut et sous-type ne suffisent pas à décrire tout ce qui caractériseles données d’un schéma EA.

Soit, par exemple, le diagramme suivant :

Personne Mariage

Epoux

Epouse

date Nom

Sexe

Etat-civil

....

0:1

0:1

Une règle connue mais non exprimée par ce diagramme est : si une personne participe à l’associationMariage, alors son état civil doit être « marié ».

En l’état actuel des SGBD, ces règles ne peuvent être vérifiées que par des programmes ad hoc, établislors de la programmation des applications.

D’autres règles possibles s’appliquant à cet exemple sont :

si une personne participe à l’association Mariage, dans le rôle « époux », alors son sexe doit être‘M’;

si une personne participe à l’association Mariage, dans le rôle « épouse », alors son sexe doit être‘F’;

De telles règles, définissant les états possibles de la base de données et qui peuvent ne pas être décritesavec les concepts du modèle, sont appelées contraintes d’intégrité. Si les valeurs de la base de données

ne les satisfont pas, il y a une « erreur » dans la base; on dit qu’elle est incohérente.





Contraintes d'intégrité sur les attributs

Les contraintes d’intégrité les plus fréquentes limitent les valeurs possibles d’un attribut à certainesvaleurs du domaine sous-jacent.

Dans le cas le plus simple, elles sont du type : age[0,130].

Il s’agit ici d’une limitation définissant de façon fixe une fourchette pour toutes les valeurs de l’attribut.Ces contraintes disparaissent si le modèle permet une définition précise des domaines de valeurs.

Les limitations peuvent être définies en fonction du contexte (valeur d’un autre attribut, participation à uneassociation,...)

Exemples :

si mois [4,6,9,11] alors jour [1,30], sinon si mois=2 alors jour [1,29] sinon jour [1,31]

état-civil = « marié » si ....

une femme marié avant 1986 a pour premier nom, le nom de son mari, une femme mariée après1986 a pour premier nom son nom de jeune fille.

Contraintes d'intégrité sur les cardinalités

D’autres types de contraintes d’intégrité limitent les cardinalités des TE, des TA, des rôles des TA, oudes valeurs des attributs.

Exemples : On suppose, dans le diagramme Parent-Enfant, que les attributs du type d’entitéParent sont les suivants : nom, prenoms, adresse, nombre-enfants. Il existe la contrainted’intégrité :

nombre-enfants = nombre d’occurrences du TA « est parent de » qui lient ce Parent.

Contraintes d'intégrité sur les généralisations / spécialisations

Dans une hiérarchie de généralisation / spécialisation, il est fréquent de trouver des contraintesd'intégrité décrivant le partage de population entre les différents sous-types d'un même sur-type :

Contrainte de couverture pour spécifier que l'union des populations des TE spécifiques d'un même TEgénérique est égale à la population du TE générique.

Contrainte de disjonction, pour spécifier que les populations des TE spécifiques d'un même TEgénérique n'ont aucune occurrence en commun.

Contrainte de partition, pour spécifier que la population d'un TE générique se subdivise complètementet sans intersection entre certains de ses TE spécifiques.

C O N C L U S I O N

Un schéma conceptuel ENTITE / ASSOCIATION est un ensemble de descriptions de types d'entités etde types d'associations, de leur attributs, des liens de spécialisation / généralisation entre types d'entitéset des contraintes d'intégrité associées.

EA = ( {TE} , {TA} , {CI} )




27Le modèle Objet

3. Le modèle Objet

C O N C E P T D E B A S E O B J E T E T S C H E M A S U M L

Objet :

Objet du monde réel (concret ou abstrait), à propos duquel on veut enregistrer des informations et qui aune existence propre. Un objet existe indépendamment du fait qu’il est liée à d’autres objets de la basede données. Le modèle objet est intéressant en ce qu’il permet de décrire simplement les objets du

monde réel et de les gérer sous une forme « naturelle » dans laquelle les données et les procédures lesmanipulant sont regroupées dans une même unité sémantique.

L’objet se caractérise par sa structure (les valeurs portées par les attributs), son comportement (sa façond’agir ou de réagir) et les liens qu’il partage avec d’autres objets, grâce à son identifiant unique (OID).

MONDE REEL ABSTRACTION : MODELE

VENDEUR

:VOITURE

:BOITE

:MOTEUR

:VOITURE

CONSTRUCTEUR

ObjectEntité

A BS T RA C T I O

N

ABSTRACTION

Encapsulation

L’encapsulation est le fait de regrouper dans un seul élément des attributs (données) et des opérations(fonctions, méthodes, comportements …).

L’encapsulation est un principe de l’approche objet grâce auquel les données et les comportementsassociés de l’objet sont cachés (partie privée) pour ne laisser visible que leur interface (parti e publique).Le fonctionnement interne de l’objet est ainsi caché des autres parties du programme qui utilisent cetobjet.





Prendrede

l'essenceRouler

CompteurNiveauessence

:VOITURE (V1.0)

Prendrede

l'essenceRouler

CompteurNiveauessence

:VOITURE (V1.1)

Niveau huile

:Conducteur

Implémentation :

Propriétés masquées,accessibles seulement

par l'objet

Interface : Propriétésaccessibles pard'autres objets

En s’intéressant plus aux interfaces qu’au fonctionnement interne de l’objet, l’encapsulationpermet de réaliser des modules indépendants les uns des autres.

Le masquage des informations permet de protéger l’objet contre des modifications indésirab les.

l’encapsulation permet de modifier l’implémentation de l’objet (son fonctionnement interne)sans affecter les autres objets qui l’utilisent.

Classes

Une classe est une représentation abstraite d’un concept qui existe dans le domaine modélisé.

VOITURE

+ / Compteur+ / Niveau essence+ / Niveau huile...

RoulerPrendre essence

Vendre...

Monde réel Modèle : classe

attributs

opérations

}

}

Les concepts d’objet et de classe sont indépendants. Un objet existe en tant qu’instance (membre) d’uneclasse. La classe décrit des objets qui partagent le même comportement (opérations) et les mêmesattributs (donnés).

La classe décrit une liste de relations (associations) que les objets pourront partager avec d’autres objets.

Les valeurs portées par les attributs de l’objet caractérisent ce dernier.

Diagramme des classes

La représentation graphique utilisée avec la méthode objet pour mettre en évidence la structure desclasses et les différents liens d’associations entre les classes est le diagramme des classes UML. A ladifférence d’autres modélisations (entité-association, ou Merise), le diagramme des classes ne fait




29Le modèle Objet

aucune séparation entre la modélisation des données et des traitements éventuels qui pourronts’appliquer sur ces données.

L’objet d’une classe est une instance. L’instanciation est le mécanisme qui permet de créer les objetsd’une classe. Le système est constitué des classes et de leurs associations.

Les objets de base du modèle sont la classe, l’association et la classe d’association.

Personne

+ / estMarié : bool

+ / estEmployé : bool

+ / nom : chaîne

+ / prénom : chaîne

+ / sexe : énumération(M,F)

age () : entier

revenu(Date) : entier

BanqueClasse

Association

1 0..1

Manager Compagnie managée

**

Employés Employeur

Compagnie

+ / nom : chaîne

+ / nombreEmployés: entier

+ prixAction : entier

Classed'association

0..1

Mari

0..1

Epouse Emploi

+ titre : chaîne

+ dateDébut: date

+ salaire : entier Mariage

+ lieu : chaîne

+ date: date

Opération

Attribut

Rôle

Modélisation des associations

Les liens de multiplicité indiquent combien d’objets de chaque classe peuvent être l iés à un objet del’autre classe. Les multiplicités les plus usuelles sont :

1..1 ou 1 : un et un seul

0..1 : de zéro à un

0..* ou * : de zéro (aucun) à n (plusieurs).

1..* : de 1 (obligatoire) à n (plusieurs).

X..Y : de X à Y (cas rare …)

La sémantique d’une association peut être exprimée le cas échéant par le rôle joué par chaque classedans l’association :

Personne

...

...

Véhicule

...

Propriétaire

0..1

Propriété

*





La navigation précise le sens dans lequel une association peut être parcourue. Par défaut, la navigationest possible dans les deux sens. Lorsqu’elle n’est possible que dans un seul sens, celui ci est indiqué parune flèche.

Pays

...

...

Personne

...

L’agrégation est une forme particulière d’association entre classes dans laquelle des objets complexes(agrégats) sont construits à partir d’objets élémentaires (composants). Chacun des composants pourraitexister sans l’agrégat.

Véhicule

...

Roue

...

Chassis

...

Moteur

...

0..1 0..1 0..4

0..1

Agrégat

Agrégation

Composant

La composition est une agrégation qui spécifie une forte relation de propriété. Le composant ne peutappartenir qu’à un seul agrégat à un instant donné. Le composant ne peut pas exister indépendammentde l’agrégat.

La composition impose des contraintes sur le cycle de vie des composants : les composants peuvent êtrecrées et retirés avant la destruction de l’agrégat, mais si l’agrégat est détruit, alors tous les composants lesont aussi.

Personne

...

Tête

...

Jambes

...

Bras

...

0..2 0..2 1

1

Agrégat

Composition

Composant

On remarquera qu’alors que l’agrégation (relation plutôt « faible » entre classes) est symbolisée par unlosange vide, la composition (relation « forte ») est symbolisée par un losange plein.




31Le modèle Objet

L’héritage permet au modèle de « factoriser » des attributs et / ou des comportements communs àdifférentes classes. Une classe « généraliste » agit alors comme ancêtre commun à plusieurs classes, quisont des variations de la classe ancêtre. L ‘héritage est essentiellement un moyen de gérer la complexitéet la réutilisation de ce qui est déjà écrit. On verra qu’il pose un problème pour la modélisation desdonnées, le modèle relationnel ne disposant d’aucun moyen simple de le gérer.

La représentation commune de l’héritage

dans un langage de programmation estbasée sur des pointeurs ou éventuellementdes OID (Object ID : identifiant d’objet).

Chaque objet maintient une forme de lienavec lequel il peut localiser, ou recréer sinécessaire l’objet parent.

Insistons sur le fait que l’héritage est unenotion bien plus complexe que cetteprésentation trop sommaire. Le lecteur sereportera à la bibliographie pour réfléchir

aux différents cas de modélisation del’héritage (héritage multiple, problèmes liés à la covariance, aux différents choix de placement possiblesdes classes dans la hiérarchie, …).

Personne

...

Enfant

...

Parent

...

une classe généraliste

(Personne) de laquelle les autres classes (Parent et Enfant) sont dérivées.





4. Le Modèle Relationnel

D E F I N I T I O N D ’ U N E R E L A T I O N

Une relation est un sous ensemble du produit cartésien d’une liste de domaines (ensembles de valeurs ouencore, types au sens des langages de programmation).

Le nombre de domaines de la relation est son arité. Elle est représentée sous la forme d’une table, où leslignes correspondent aux tuples, et les colonnes aux composantes.

Exemple :

136 Dupont Jean 19253 Aubry Annie 20101 Duval André 20147 Dupont Marc 21

Cet exemple représente une relation (ou table) décrivant des étudiants. La première et la dernièrecolonne ont pour domaine les entiers et les deux autres les chaînes de caractères.

La population d'une relation est constituée de l'ensemble des tuples (lignes) de la relation.Contrairement à ce que la représentation sous forme de table pourrait induire, il n'y a pas d'ordre (lesnouveaux tuples sont rajoutés à la fin)

On donne un nom différent à chaque colonne, pour les distinguer. On appelle attribut d’une relation uncouple <nom, domaine>, et schéma de la relation, le nom de la relation suivi de la liste de ses attributs.

Exemple : la relation ci-dessus a pour schéma :

Etudiant ( N°Etud : entier; Nom : Chaîne(30); Prénom : Chaîne(20); Age : entier(0..120);)

Pour simplifier, nous omettrons en général les domaines; ils sont déduits implicitement des noms desattributs.

Il est usuel de souligner l’attribut, ou les attributs, qui constitue(nt) la clé de la relation. Si un attribut estune clé d’une 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 dedéfinition d'un ou plusieurs attributs.

Exemple :

Dnom : chaînes de caractères de longueur 30.

Dnum : entiers entre 0 et 99999

Dcouleurs : "bleu", "vert", "jaune"




33Le Modèle Relationnel

Cette notion de domaine, proche de la notion de type de données en programmation, est importantelorsqu’elle peut être contrôlée par le SGBD utilisé. Elle permet alors de renforcer les contraintesd'intégrité à respecter par la base de manière automatique. Le SGBD refusera ainsi automatiquementl'entrée d'une donnée qui n'est pas "bien formée" pour le domaine, ce qui diminue d'autant les contrôlesde cohérences à réaliser par le programmeur.

D E S S C H E M A S E A A U X S C H E M A S R E L A T I O N N E L S

Les attributs du modèle relationnel sont tous simples et monovalués; toute valeur prise par un attributest atomique (non décomposable par le SGBD) et unique. Les notions d'attributs complexes, multivaluésou facultatifs n'existent pas dans ce modèle.

Partant d’un schéma entité-association, on peut construire un ensemble de schémas de relations. L’idéeconsiste à représenter les types d’entités et leurs attributs par une relation, chaque tuple de la relationétant associée à une entité. Les types d’associations sont également transformés en relations constituées,en général, des clés des types d’entités associés, complétés par les attributs de l’association, si elle en a.

Exemple :

Etudiant N°Etud Nom Prénom Age136 Dupont Jean 19253 Aubry Annie 20101 Duval André 20

Cours NomC Horaire Prof

Algo Lundi 10-12 DuvalSystème Mardi 16-18 Malin

Suit N°Etud NomC Note253 Algo 12136 Système 08253 Système 15

On remarque que la relation « Suit » (qui traduit un type d’association) a pour attributs les clés des deuxprécédentes relations (qui traduisent des types d’entités) et l’attribut de l’association.

Quelques règles :

Constitution de la relation :

La relation associée à un TA est constituée des clés des TE associés, et de ses propres attributs.

Si un TE est faible (sans clé) il faut y mettre l’ensemble de ses attributs.

La clé de la relation :

En général, elle est constituée par l’ensemble des clés des TE associés.

Lorsqu’il y a un TE faible, il faut ajouter un attribut du TE,

Lorsqu’il y a plusieurs jeux de valeurs possibles pour un même ensemble de valeur sur les clés externes,

il faut ajouter un des attributs du TA.

Lorsque la connectivité d’un des rôles est 1:1, la clé est celle du TE (non faible) associé.





Attributs facultatifs du modèle EA :

La plupart des SGBDR gèrent une valeur spéciale, appelée valeur nulle et notée NULL. Cette valeurpeut être prise par tout attribut (sauf si dans le schéma on a spécifié le contraire). Elle signifie alors quele tuple n'a pas de valeur pour cet attribut. Ainsi un étudiant dont on ne connaît pas l'âge seraitreprésenté par le tuple (123, DUMOND, NULL).

Cette valeur spéciale implique souvent un traitement particulier dans les langages de manipulation dedonnées et dans les programmes.

Attributs complexes du modèle 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 chaînes de caractères. Dans ce cas,l'utilisateur devra lire l'adresse et chercher lui même le nom de la ville dans celle ci. Il ne pourra pasposer 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 élaborées sur chacun des attributs, mais il ne connaît pas la notiond'adresse globale. Pour éditer une étiquette par exemple, on est obligé de réaliser des concaténations.

Attributs multivalués du modèle EA :

L'exemple classique est la liste des prénoms

Solution 1 : Avoir dans la relation Etudiants plusieurs attributs : Prénom1, Prénom2, … Mais combienmettre d'attributs de prénom ? Et comment poser une question sur un prénom (on est obligé de poserautant de questions que d'attributs déclarés).

Solution 2 : On garde dans la relation étudiant uniquement le n° d'étudiant, le nom et l'age et on crée une

relation supplémentaire (n° étudiant, prénom).

(Reprendre les exemples du chapitre 2)

L A N O T I O N D E S C H E M A D E R E L A T I O N

Le schéma d’une relation donne la signification ou l’interprétation de la relation. Elle est constituée d’unensemble de tuples vérifiants une certaine sémantique. Les valeurs d’un tuple doivent en généralvérifier un certain nombre de contraintes.

Un schéma de relation est défini par :

- son nom

- la liste de ses attributs : couples (nom:domaine)

- sa (ses) clé(s) et ses clés externes

- sa définition (phrase en français)

- la liste des contraintes

Parmi les contraintes que peut imposer un schéma relationnel, les dépendances fonctionnelles sont unecatégorie importante, car elles sont liées à la notion intuitive de clé.

Définition : Soit R(A1, A2,...,An) un schéma de relation, et X et Y deux sous ensembles de {A 1, A2,...,An},

on dit qu’il a dépendance fonctionnelle de Y sur X, et on écrit XY, si quel que soit un exemplaireacceptable r de R, tous les tuples u et v de r qui ont les mêmes composantes dans X, ont aussi les mêmescomposantes dans Y.





Une dépendance fonctionnelle est une propriété imposée à priori, provenant du monde réel, et qui doitêtre définie à partir de la signification des attributs. Il ne faut pas tenir compte des dépendancesconstatées sur un exemplaire particulier de la relation.

Exemple :

La relation Etudiant :

N°Etud (Nom, Prénom, Age)

La relation Cours :

NomC (Horaire, Prof)

La relation Suit :

(N°Etud, NomC) Note; un étudiant a une note par cours.

Il est évident que la notion de clé d’une relation entraîne la dépendance de tous les attributs de larelation sur la clé. Inversement, la notion de dépendance permet de préciser cette notion de clé.

Définition : Soit R(A1, A2,...,An) un schéma 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- YX, si Y A1A2...An , alors X=Y.

Lorsqu’il y a plusieurs clés possibles pour une relation, on peut en choisir une, dite clé primaire, lesautres étant des clés candidates.

Une clé peut être composée de un ou plusieurs attributs. Une relation peut avoir une ou plusieurs clés.Une relation a nécessairement une clé. Par convention, l'attribut (ou les attributs) constituant la clé estsouligné sur les schémas graphiques.

Exemple :

Etudiant (N° Etud, nom, prénom, age)

Il n'y a pas deux étudiants qui peuvent avoir le même numéro

On ne peut pas avoir de valeur inconnue pour une clé. En effet si on entrait deux tuples sans valeurpour la clé, alors il existerait deux tuples ayant même valeur (inconnue) pour la clé, ce qui est impossibled'après la définition de la clé.

Si les dépendances liées aux clés sont naturelles, les autres conduisent à quelques difficultés. pour les

éviter, il faut pouvoir transformer un ensemble de relations, tout en conservant les dépendancesfonctionnelles, puisqu’il s’agit de contraintes vérifiées par le monde réel.

On appellera schéma relationnel, un ensemble de schémas de relations et son ensemble de contraintesd’intégrité.

CLE EXTERNE (OU CLE ETRANGERE )

Certains attributs référencent des tuples d’une autre relation (ou parfois la même); c’est-à-dire que leurvaleur est nécessairement égale à celle de la clé d’un tuple existant dans l’autre relation.

Par exemple, la relation Suit(NomC, N°Etud, Note) possède une clé (NomC+N°Etud), et deux clésexternes : NomC et N°Etud. En effet, NomC ‘référence’ un Cours, c’est à dire que si une valeur NomC existe dans Suit, alors il doit nécessairement exister un cours de ce nom là dans la relationCours. de même, N°etud ‘référence’ un Etudi ant.





Le schéma d’une relation comprend donc, en plus de la définition du nom de la relation et de sesattributs et domaines associés, la définition de de sa (ses) clé(s), et celle de ses clés externes, s’il en existe.

Les clés externes sont déclarées de la façon suivante :

Suit(N°etud ; Dnum, NomC : Dnom)

Clés externes :

N°Etud référence un Etudiant

NomC référence un Cours

Définition : Soient deux relations R1(X, Y) et R2(V, W), où X, Y, V, W, désignent des attributs ou desensembles d’attributs, et où X est la clé de R1, on dit que W est une clé externe sur R1 (ou que Wréférence R1) si pour tout tuple de R2, la valeur prise par W est nécessairement la valeur de X pour untuple existant de R1.

Autrement dit, à tout instant, l’ensemble des valeurs prises par W est compris dans l’ensemble des

valeurs prises par X.

Cette vérification est automatiquement assurée par le SGBD : une fois déclarée la clé externe W de R2sur R1, le SGBD vérifie toutes les insertions dans R2 (il vérifie que la valeur de W existe dans R1); ilvérifie de la même façon les modifications de W. Il vérifie toutes les suppressions de tuples de R1 ( ilvérifie qu’il n’existe pas de tuple dans R2 ré férencant ce tuple à supprimer ). Le SGBD assure ainsi, l’intégrité deréférence (ou intégrité référentielle) de la base de données.

E X E M P L E D E D E C L A R A T I O N D ’ U N S C H E M A R E L A T I O N N E L

Domaines :

Dnom : chaîne de caractères de longueur inférieure à 30;Dch100 : chaînes de caractères de longueur inférieure à 100;Dannée : [1970:1990];Dnote : [0.0:20.0];Ddate : [1:31]/[1:12]/[1920:2000];

Nous ne ferons apparaître que les DF non triviales.

Relation : Personne

Attributs :

N°P : entier sans valeur nulle;Nom : Dnom sans valeur nulle;Prénom : Dnom sans valeur nulle;

Adr : Dch100 sans valeur nulle;

Clé : (N°P)

Définition : Tout étudiant et tout enseignant de la composante.





Relation : Etudiant

Attributs :

N°P : entier sans valeur nulle;N°E : entier sans valeur nulle;DateN : Ddate sans valeur nulle;

Clés : (N°E), (N°P);

Clés externe : N°P référence une Personne;

Définition : Tout individu qui est actuellement inscrit dans la composante, ou qui a déjà passé avec

succès un des cours de la comosante;

Relation : EtudiantEtudes

Attributs :

N°E : entier sans valeur nulle; Année : Dannée sans valeur nulle;Diplôme : Dnom sans valeur nulle;

Clé : (N°E+ Année);

Clé externe : N°E référence un Etudiant;

Définition : études antérieures d’un étudiant;

Relation : Enseignant

Attributs :

N°P : entier sans valeur nulle;Statut : Dnom sans valeur nulle;Département : Dnom sans valeur nulle;Clé : (N°P)

Clé externe : N°P référence une Personne;

Définition : tout individu assurant actuellement un ou plusieurs cours dans la composante;





Relation : Inscrit

Types d’entités liés : Etudiant (0:n), Cours (1:n);

Attributs :

N°E : entier sans valeur nulle;

NomC : Dnom sans valeur nulle;Note : Dnote;Clé : (N°E+NomC )

Clés externes :

N°E référence un Etudiant NomC référence un Cours;

Définition : actuellement, l’étudiant N°E est inscrit au cours NomC;

Relation : Prérequis

Types d’entités liés : Cours : est-un (0:n), Cours : a-pour (0,n);

Attributs :

NomC : Dnom sans valeur nulle;NomCprérequis : Dnom sans valeur nulle;Clé : (NomC +NomCprérequis)

Clés externes :

NomC référence un Cours;NomCprérequis référence un Cours;

Définition : le cours NomCprérequis est un prérequis pour le cours NomC .




39Normalisation d’un schéma relationnel

5. Normalisation d ’un schéma relationnel

F O R M E S N O R M A L E S

PREMIERE ET DEUXIEME FORMES NORMALES

Définition : Une relation est en première forme normale (1FN) si tous ses attributs sont simples etmonovalués.

Définition : Une relation est en deuxième forme normale (2FN) si elle est en première forme normale etsi chaque attribut qui ne fait pas partie d’une clé dépend d’une clé entière.

Pour une relation R munie de l’ensemble de df F, on a

AClé (AClé (Clé) CléAF+)

Exemple : Soit une relation qui est en 1FN, mais pas en 2FN :

Fournisseur1 (NF

, Adr, Tel, NomProduit, Prix)

Une telle relation pose des problèmes :

Redondances : s’il existe 100 produits pour un fournisseur on va répéter 100 fois le nom,l’adresse et le téléphone du fournisseur.

Problème de mise à jour pour les insertions : quand on veut rajouter un produit, il faut rentrer à nouveau l’adresse et le téléphone du fournisseur.

Problème pour les suppressions : si on supprime (momentanément) la liste des produitsd’un fournisseur, alors on suppri me aussi le fournisseur.

Problème de mise à jour des tuples : si un fournisseur change d’adresse ou de téléphone, il faut faire cette mise à jour sur tous les 100 tuples !

Cette relation n’est pas en 2FN. Le graphe minimum des df de Fournisseur 1 est :

NomProduit

Prix

NF Adr

Tel

On décompose Fournisseur1 en deux relations de la façon suivante : pour chaque source de DF, oncrée une relation ayant pour attributs la source et tous les attributs des dF directes de cette source,en s’assurant qu’une (au moins) des deux sources est entièrement contenue dans les attributscommuns aux deux relations ainsi créées (cf théorème de Heath). On obtient ainsi :

Fournisseur(NF, Adr, Tel);

Catalogue(NF, NomProduit, Prix);

qui sont en 2FN (et même plus).

Cette décomposition est

sans perte d’information

sans perte de dépendance fonctionnelle : les DF sont soit dans l’une ou l’autre des deux relations.





TROISIEME FORME NORMALE

Définition : Une relation est en troisième forme normale si elle est en première forme normale et sichaque attribut qui ne fait pas partie d’une clé, dépend directement d’une clé entière.

Pour une relation R muni de l’ensemble de df F, on a :

AClé (AClé Clé (CléAF+ directe )

Exemple : Considérons la relation suivante (en 2FN) :

Fournisseur2 (NF

, Pays, Ville)

Elle possède les df : NF Ville et Ville Pays.

On suppose qu’on n’a dans la base de données que des grandes villes sans homonynes. La df NF Pays est une df déduite.

Le graphe minimum de Fournisseur2 est

NF Ville Pays

Dans cette relation, il y a redondance : le pays d’une ville est répété, ce qui cause des problèmesde mise à jour. On décompose donc en :

Four (NF, Ville)

Géo (Ville, Pays)

Cette décomposition est sans perte d’information (Ville est une clé pour Géo), et sans per te de df (les df non déduites sont soit dans Fourn, soit dans Géo).

FORME NORMALE DE BOYCE-CODD

Définition : Une relation est en forme normale de Boyce-Codd (FNBC), si elle est en première formenormale et si tout membre gauche de df est une clé entière ou contient une clé entière.

Pour une relation R muni de l’ensemble de df F, on a :

XAF+ élémentaire, (Clé) CléX

Exemple 1 : Considérons la relation (en 3FN; on suppose qu’il n’y a pas d’homonyme chez lesfournisseurs) :

Catalogue3 (NF, NomF, NomProduit, Prix)

admettant plusieurs clés : (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 génère des problèmes lors des mises à

jour. Par exemple, si un fournisseur change de nom, il faut mettre à jour son nom dans tous lestuples correspondants à ces produits.

Elle n’est pas en FNBC parce que l’attribut NF est membre droit d’une df (NF NomF) et n’est pasune clé entière. Il en est de même pour NomF.





On décompose donc Catalogue3 en deux relations FNBC :

Fournisseur (NF, NomF) de clé NF ou NomF

Catalogue (NF, Nomproduit

, Prix)

On remarque qu’une relation en FNBC est en 3FN.

Exemple 2 : La relation Place (Netud, Matière, Rang), représente le rang obtenu par chaqueétudiant pour chaque matière. On suppose qu’il n’y a pas d’ex -eaquo.

Il y a deux clés : (NEtud+Matière) ou (NEtud+Rang)


NEtud Matière

RangEst-on en 3FN ? oui, car il n’y a pas d’attribut qui ne fasse pas partie d’une clé. On est aussi enFNBC. On ne décompose donc pas.

Exemple 3 : La relation Enseignement(NEtud, Matière, Prof)

On suppose que chaque professeur enseigne une seule matière, et que que pour chaque matière,chaque étudiant suit les cours d’un seul professeur.


NEtud Matière

Prof

La relation a deux clés (NEtud+Matière) et (NEtud+Prof). Elle est en 3FN puisque tout attribut fit partie d’une clé. Mais elle n’est pas en FNBC puisque l’attribut P rof est source de df et ne constitue pas une clé.

Cette relation présente des inconvénients (redondnaces, problèmes de mise à jour) dûs au fait quela df Prof Matière n’est pas traduite par la relation (notamment, rien n’empêche d’insérer deux tuples pour le même professeur avec deux matières différentes). cependant on ne peut pasdécomposer sans perdre de df. Par exemple la décomposition (Prof,Matière) et (NEtud,Prof) perd ladf (NEtud,Matière) Prof.

Elle permet d’insérer le fait qu’un étudiant suit deux c ours portant sur la même matière avec deux professeurs différents, ce qu’interdisait la relation Enseignement.

Il n’y a pas de solution idéale dans ce cas. Pratiquement, on conserve la relation initiale et onrajoute une contrainte d’intégrité (si le SGBD les gère) spécifiant le fait qu’un professeur ne peut enseigner qu’une seule matière.

Tableau récapitulatif des Formes Normales :

Forme X XA A

Boyce-Codd contient élémentaire tous

3ème une clé directe non dans

2ème pas inclus strictement dans une clé élémentaire une clé





L’ALGORITHME DE BERNSTEIN

Cet algorithme permet de décomposer une relation en 3FN sans perte d’information (SPI) ni de df(SPD).

Entrée :

R = (A1,A2,...,An) un schéma de relation;F un ensemble de df sur R;

Sortie :

Une décomposition de R muni de F en schémas de relations en 3FN sans perte d’information ni de df.

Algorithme :

Etape 1 : on remplace F par une couverture minimale de F .

On cherche les clés minimales de R et on teste si R est en 3FN. Si oui, on s’arrête.

Etape 2 : on regroupe les df X Ai (1i p) ayant même membre gauche X .

pour chaque membre gauche X on définit un schéma de relation contenant tous les attributs intervenant

dans ces df, soit RX=(X,A1,A2,...,Ap). Le schéma Rx est muni de l’ensemble des df XAi (1ip).

Etape 3 : si aucun des schémas RX définis à l’étape 2 ne contient de clé de R, on ajoute un schéma RK=(K), où Kest une clé minimale de R, muni d’aucune df.

Commentaires :

1- Chacun des schémas Ri, obtenu à l’étape 2 et muni des df XAi (1ip), soit encore de la df

équivalente XA1A2...Ap, est bien en 3FN. De même le schéma RK.

2- Le schéma RK sert à assurer que la décomposition est bien SPI.

3- La décomposition est trivialement SPD puisque la réunion des df des nouveaux schémas est F.

Exemple : Considérons le schéma R=(C,E,P,N,J,H,S) (déjà présenté), muni de l’ensemble des df

CEP N (1) EP C (3)

JHS PC (2) EPS C (4)

Etape 1 : On remplace F par sa couverture minimale, à savoir

EP N (1’) JHS P (2’)

JHS C (2’’) EP C (3)

Toute clé minimale de R doit contenir les attributs EJHS qui ne figurent pas dans les membres droitsdes df de F. on vérifie facilement que EJHS est une clé de R, par suite, c’est la seule clé minimale deR. A cause de la df (1’), R n’est pas en 3FN.

Etape 2 : on regroupe les d f (1’) et (3), puis (2’) et (2’’), et on définit

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 schéma

R3=(E,J,H,S) muni d’aucune df.

N O R M A L I S A T I O N D ' U N E R E L A T I O N

INTRODUCTION

Lors de la définition d’un schéma conceptuel dans le modèle relationnel, le choix des relations estprimordial. Ce choix doit être guidé par les dépendances entre les données qui existent dans la réalité, etqui sont des contraintes que doivent vérifier les données effectivement présentes dans la base.

Exemple : on veut décrire les produits et leurs fournisseurs. On peut le faire avec un des schémassuivants :

schéma 1 ( on suppose que chaque produit est d’une couleur unique ) :

Produit (NP

, NomP, Couleur, Poids);

Fournisseur (NF, NomF, Adr, Tel);

Livraison (NP, NF, Qté, Date);

schéma 2 ( autre schéma proposé pour le même sujet ) :

Produit (NP, NomP, Couleur, Poids);

Fournisseur (NF, NomF, Adr);

Livraisonbis (NP, NF, TelF, Qté, Date);

Exemples de problèmes rencontrés lors des mises à jour de la base de données décrite par leschéma 2 :

S’il n’y a plus de livraisons pour un fournisseur, son numéro de téléphone est perdu. S’il existe N livraisons pour un fournisseur, le numéro TelF est répété N fois, il faut vérifier que c’est le même.Pour insérer une nouvelle livraison, il faut enregistrer à nouveau ce numéro. Ces problèmesn’existent pas avec le schéma 1 qui est meilleur que ce second schéma.

Lorsqu’un schéma relationnel présente des problèmes de redondance d’information, d’anomalie de

mise à jour ou d’anomalie d’insertion/suppression, il est nécessaire de transformer les schémas derelation posant des problèmes. Cette transformation est appelée processus de normalisation.

On mesure la qualité d’une relation (ou sa capacité à représenter le monde réel sans générer les problèmes

aperçus ci-dessus) par son degré de normalisation. Une relation peut être (de la moins bonne à la meilleure)en 1ère forme normale, en 2ème forme normale, en 3ème forme normale, en forme normale de Boyce-Codd, en 4ème forme normale,... (chaque forme normale implique les précédentes).

Notations : pour la suite, les lettres X, Y, Z, … désigneront soit des attributs, soit des ensemblesd’attributs; les lettres A, B, C, … désigneront des attributs.





DEPENDANCES FONCTIONNELLES

Les notions de dépendance fonctionnelle et de clé ont déjà été définies au chapitre précédent.

LA NOTION DE CLOTURE

Définition : Soit F un ensemble de dépendances fonctionnelles pour un schéma de relation R, et XY

une dépendance fonctionnelle. On dit que XY est la conséquence logique de F, et l’on écrit FXY, si

tout exemplaire de relation r de R qui satisfait les dépendances de F satisfait aussi XY.

La notion de clôture permet de prendre en compte l’ensemble de toutes les dépendances fonctionnellesconséquence logique d’un ensemble de dépendances données. Elle permet également de définirl’équivalence entre deux ensembles de dépendances F et G comme l’égalité de leurs clôtures respectives.

Définition : On appelle clôture de F, l’ensemble F+ = { XY | F XY}

Ces définitions mettent en avant le fait que certaines dépendances sont « plus fondamentales» qued’autres, puisque les autres peuvent s’en déduire.

On peut démontrer que la clôture est obtenue en itérant les règles suivantes, où R est l’ensemble desattributs d’une relation :

Réflexivité : Si XYR alors XY

Transitivité : {XY, YZ} XZ

Augmentation : {XY} XZYZ, pour tout ZR;

Union: {X

Y, X

Z}

X

YZ;

Pseudotransitivité : {XY, WYZ} XWZ;

Décomposition : {XY} XZ, pour tout ZY;

Notons que les trois dernières règles se déduisent des trois premières.

Le calcul de F+ peut cependant être très long. Mais il peut être remplacé par le calcul de X + = {A | AR

et XA}, où X est l’ensemble des attributs des dépendances fonctionnelles de F, au moyen de l’itération

suivante :

X(0) =X;

X(i+1) =X {A | YZF tel que YX(i) et AZ};

Algorithme de calcul de X+ :

X+ X;

répéter

AUX X+ ;





pour chaque df YZF faire

si Y X+ alors X+X+ Z;

jusqu’à AUX= X+ ou X+ =R;

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

Enfin, pour tout ensemble F de dépendances, il existe un ensemble équivalent F’, (au sens F+=F’+), quiest minimal, c’est-à-dire que :

1- XYF, Y ne comporte qu’un seul attribut;

2- XAF, l’ensemble F-{XA} n’est pas équivalent à F;

3- XAF et ZX, l’ensemble F-{XA}{ZA} n’est pas équivalent à F.

Algorithme de calcul de la couverture minimale d’un ensemble de df :

Entrée : R=(A1,A2,...,An) un schéma de relation;

F un ensemble de DF sur R;

Sortie : G une couverture minimale de F, définie par

1- G+=F+;

2- Tout membre droit d’une DF de G est réduit à un seul attribut;

3- Pour aucune DF XAG on n’a G-{XA}XA;

4- Pour aucune DF XAG on n’a GYA avec YX;

Algorithme :

On ordonne les df de F, supposons :F={X1Y1, X2Y2, ...., XmYm}

Etape 1 : on décompose les membres droits Y i 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 à renuméroter les df, nous supposons qu’à la fin de cette étape nous avons : F={X1A, X2A, ....,

XqAq} avec qp.





Etape 3 : on cherche si on peut remplacer les membres gauches des df de F qui sont formés de plus d’un attribut par des membres gauches comprenant moins d’attributs sans changer la fermeture de F.

Pour i1 à q faire

si Xi=B1B2...Br, avec r>1

alors pour i1 à r faire

si F{XiB j}Ai, alors XiXi-B j}

Il n’y a pas unicité de la couverture, elle dépend de l’ordre choisi.

Exemple : Considérons un schéma 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 l’ensemble des df :

CEP N, JHS PC, EP C, EPS C;

Lui appliquer l’algorithme.

PROPRIETES DES DEPENDANCES FONCTIONNELLES

Définition : On appelle dépendance fonctionnelle élémentaire une DF, XA, où A est un attributunique non inclus dans X, telle que

YX, YA X=Y.

En d’autres 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 élémentaires.

Mais les DF :

NP Couleur, NP Poids, NP NomP,

NomP Couleur, NomP Poids, NomP NP;

sont élémentaires.

La DF (NP,NF,Date) Qté de la relation Livraison est élémentaire.

Définition : On appelle dépendance fonctionnelle transitive une DF de la forme XA, où A est unattribut unique non inclus dans X, telle que

YX, XY YA YX

Définition : On appelle dépendance fonctionnelle directe une dépendance fonctionnelle de la forme

XA, où A est un attribut unique non inclus dans X, telle que YX, XY YA YX

Une dépendance est directe si elle n’est pas obtenue par transitivité à partir d’autres dépendances.

DECOMPOSITION D ’UNE RELATION

Etant donné une relation non satisfaisante, en ce sens qu’elle implique des répétitions au niveau de sapopulation et qu’elle pose des problèmes lors des insertions/modifications/suppressions de tuples (voir

relation Livraisonbis ci-dessus), trouver un ensemble de relations satisfaisantes et qui décrive les mêmesinformations.





La méthode consiste essentiellement à décomposer la relation en deux ou plusieurs relations. Pour cela,il est nécessaire de disposer de deux opérations qui permettent, l'une, de découper une relation en sousrelations (la projection), et l'autre de recomposer la relation à partir de ses sous relations (la jointure).

Définition : La projection d'une relation R(A1,A2,…,An) sur un sous ensemble de ses attributs

Ai1,Ai2,…,Aip est la relation notée [Ai1,Ai2,…,Aip]R définie par

T(Ai1,Ai2,…,Aip)={t | r (rRr.Ai1=t.Ai1 r.Ai2=t.Ai2 … r.Aip=t.Aip)}

Exemple : Soit la base de données décrivant 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 :

[Nom,Age]Enseignant NomE Age

Marie 50

Claire 25Luc 32

La projection de Enseignant sur Dept donne

[Dept]Enseignant Dept

Info

Phys

On remarque que les valeurs doubles (Info) ont été éliminées.

Définition : La jointure naturelle de deux relations R1(X,Y) et R2(Y,Z) est la relation, notée R1*R2définie par :

R(X,Y,Z)={t | t1R1,t2R2 (t.X=t1.X t.Y=t1.Y t.Z=t2.Z t1.Y=t2.Y)}

La population de cette nouvelle relation est constituée de l’ensemble des tuples de R1 concaténés à ceuxde R2 qui ont la même valeur pour Y.

Exemple : Soit la base de données décrivant les enseignements et les cours de la façon suivante(on suppose que chaque cours est assuré par un seul enseignant) :

Enseignant NomE Dept Statut Age

Marie Info Prof 50

Claire Info Vacataire 25Luc Phys Assistant 32

Cours NomC Diplôme NomE

SGBD MInfo Claire

Système LInfo Luc

Algo LInfo Claire

Pascal DEUG Marie

Si l’on veut connaître pour chaque enseignant la liste des cours qu’il assure, on fait la jointured’Enseignant et de Cours. La relation résultat est la suivante.

NomE Dept Statut Age NomC DiplômeMarie Info Prof 50 Pascal DEUG

Claire Info Vacataire 25 SGBD MInfo





Claire Info Vacataire 25 Algo LInfo

Luc Phys Assistant 32 Système LInfo

On peut décomposer une relation R, si à partir des relations résultant de cette décomposition, on peutretrouver R en faisant la jointure de ces relations.

Définition : Une relation R(X,Y,Z) est décomposable sans perte d’information en deux relations R1(X,Y)et R2(X,Z) où la population de R1 (respectivement R2) est constituée des tuples de R tronqués à 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

C’est une bonne décomposition en ce sens qu’on retrouve la relation initiale. Ce n’est 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 n’appartiennant pas à la relation initiale

Lors de la jointure de nouveaux tuples sont créés : les tuples de Marie et de Luc donnent chacun

naissance à deux tuples ! C’est une mauvaise décomposition, on dit qu’il y a « perted’information ».

Le théorème suivant permet de savoir quand une décomposition est sans perte d'information :

Théorème de Heath ( pour faire une bonne décomposition) :

Toute relation R(X,Y,Z) est décomposable sans perte d’information en R1(X,Y) et R2(X,Z) s’il y a dans R1

une df XY ou dans R2 une df . XZ.




49Le langage de définition de données

6. Le langage de définition de données

Le LDD est la partie du langage qui permet la création, la modification et la suppression des tables.

C R E A T I O N D E T A B L E

La création d'une table consiste à lui attribuer un nom et à lui définir ses caractéristiques. Deux partiessont définies dans la norme ANSI, et présentes dans la majorité des systèmes. Ce sont la définition de

colonnes et la définition de contraintes d'intégrité.

La plupart des SGBD implantent des commandes supplémentaires permettant par exemple laspécification des paramètres de stockage, la définition de clusters, l'importation de données à traversune requête au moment de la création

La commande de création d'une table a pour syntaxe :

CREATE TABLE Nom_Table( Définition d'une colonne

|Définition d'une contrainte...)

[Spécification de stockage][définition de cluster][données provenant d'une requête]

Elle crée la définition d'une table. Celle ci est stockée dans les tables système du dictionnaire desdonnées. Chaque SGBD a ses propres règles concernant le nom de la table. En général, il est aumoins impossible de créer deux tables de même nom dans la base de données.

"Créer la table factures"

CREATE TABLE Factures (

Date datetime , NumFacture varchar(15) ,CodeClient varchar(30) ,Commercial varchar(20)

)

DEFINITION D 'UNE COLONNE

Pour définir une colonne dans une table, il faut lui attribuer obligatoirement un nom et un type dedonnées. Une valeur que peut prendre par défaut une colonne et les contraintes d'intégrité la concernantsont optionnelles dans sa définition.





Elément_de_colonne ::= Nom_colonne Type_colonne[DEFAULT expression] [Contrainte_de_colonne]...

Le nom de colonne est soumis à la même problématique que le nom de table. Les contraintesvarient complètement d'un système à un autre. Il doit être cependant possible de créer deux

attributs de même nom dans des tables différentes. La distinction entre les attributs de même nomdans des tables différentes est permise grâce au préfixage du nom de l'attribut par le nom de latable (implicite ou explicite). Ainsi matable.monattr désigne sans équivoque l'attribut monattr dela table matable.

Les types de données

Les types de données varient eux aussi fortement d'un SGBD à l'autre. On trouvera en annexequelques types selon les SGBD.

A titre d’exemple, Oracle gère les types de données suivant :

CHAR(n) Données de type caractère de longueur fixe n, n est compris entre 1 et 255

VARCHAR2(n)Ce type spécifie une chaîne de caractères de longueur variable n. n est lataille maximale de la chaîne et est compris entre 1 et 2000

VARCHAR(n) Utilisé actuellement comme un synonyme de VARCHAR2(n)

NUMBER(p, s)Nombre de précision p et d'échelles. La précision est comprise entre 1 et 38et l'échelle entre -84 et 127

LONG Données de type caractère de longueur variable allant jusqu'à 2 Go

DATE Données de type date

RAW(n)Données de type binaire de longueur fixe n. Contrairement au type CHAR,n doit être spécifié pour ce type et son maximum est de 255

LONGRAW Données de type binaire de longueur variable allant jusqu'à 2 Go

ROWIDChaîne hexadécimale représentant l'adresse unique d'une ligne de la table.Sa valeur est retournée par la pseudo-colonne de même nom.

Les valeurs nulles

Prenons l'exemple de l'insertion d'un nouveau client dans une table. Si l'on ne connaît pas son numérode téléphone, 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'interprétation que l'on veut. C'est pourquoi les " valeurs nulles "existent. Elle spécifie que le champ n'est pas valide, et ce indépendamment du type.

Par défaut, l'utilisation de ces valeurs est possible dans toutes les colonnes. Pour ne pas autoriser lasaisie des valeurs nulles dans une colonne, il suffit de le spécifier dans avec une contrainte lors de ladéfinition de la colonne. C'est l'option NOT NULL.

Le mot clé DEFAULT spécifie qu'une expression peut être affectée à la colonne si la valeur de donnéesn'a pas été explicitement assignée 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 ,Représentant varchar(20) NULL

)

CONTRAINTES D ' INTEGRITE

Une contrainte d'intégrité est une règle qui permet de contrôler au mieux la valeur d'une colonne. Ellepeut être définie sous deux formes différentes dans les commandes de création et de modification destructure de tables.

La plupart des systèmes doivent au moins implanter les contraintes NOT NULL et UNIQUE définiesdans la norme.

Définition de contrainte d'intégrité par contraintes de colonnes

Cette contrainte est définie en même temps que la colonne qu'elle concerne. Elle est spécifiée juste aprèsle type de données. L'utilisateur peut définir 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 à définir, qui serasauvegardé dans le dictionnaire des données. Si l’identifiant est omis, Oracle génère un identifiant sousla forme SYS_Cn où n est un entier qui représente un nom unique dans la base.

NULL (NOT NULL)Spécifie que la colonne peut (ne peut pas) contenir de valeurnulle

UNIQUEInterdit que deux lignes ait la même valeur (les valeurs nulles nesont pas prises en compte

PRIMARY KEYSpécifie que la colonne est définie comme une clé primaire.Même si l'effet est le même que pour UNIQUE, aucune valeurnulle n'est acceptée.

REFERENCESDéfinit une contrainte d'intégrité référentielle par rapport à uneclé unique ou primaire

ON DELETE CASCADE

Permet de maintenir l'intégrité référentielle en supprimantautomatiquement les valeurs d'une clé étrangère dépendantd'une valeur d'une clé unique ou primaire si cette dernière estsupprimée par l'utilisateur.

CHECK Oblige a vérifier la condition associée pour chaque valeur rentrée





USING INDEXSpécifie les paramètres pour l'index utilisée pour forcer l'intégritéde la clé primaire ou unique. Le nom de l'index est identique àcelui de la contrainte.

EXCEPTIONS INTOIdentifie une table d'exception existante dans laquelle Oracleplace des informations sur le lignes qui violent une contrainted'intégrité activée

DISABLEPermet de désactiver la contrainte. Par défaut, Oracle active cettecontrainte.

Définition de contrainte d'intégrité par contraintes de tables

La seconde forme de contraintes d'intégrité concerne un ensemble de colonnes de la table et est appeléecontrainte de table. En effet on ne peut pas, avec la première forme, définir de clé unique, primaire ouétrangère composée. De plus le fait de déclarer une contrainte d'intégrité UNIQUE pour les deuxcolonnes séparément ne signifie pas qu'il y a création d'une clé UNIQUE composée des deux colonnes.

Cette remarque est aussi valable pour l'intégrité référentielle composée. Par contre la contrainte NOTNULL reste associée seulement à l'intégrité de colonne.

[CONSTRAINT nom de contrainte]{ {UNIQUE | PRIMARY KEY} (colonne [,colonne]...)

| FOREIGN KEY (colonne [,colonne]...)REFERENCES [schéma.]table [(colonne,....)][ON DELETE CASCADE]

| CHECK (condition) }

Le mot clé FOREIGN KEY désigne une ou plusieurs colonnes comme une clé étrangère dans unecontrainte d’intégrité référentielle.

Ni les clés primaires, ni les clés étrangères, ni la plupart des contraintes sur les données ne sont définiesexplicitement dans la norme SQL (un attribut NOT NULL UNIQUE est cependant une clé primaire).Une manière élégante, bien qu'un peu lourde de contourner ces manques consiste à utiliser des vues.Une autre manière consiste à utiliser des systèmes utilisant des extensions de SQL 86. Ainsi, SQL-SERVER ou ORACLE permettent l'utilisation de TRIGGERS (procédure se déclenchant en fonctiond'événements sur les données), tandis que INGRES possède un ordre explicite CREATE INTEGRITY,

CREATION D 'UNE TABLE A PARTIR D 'UNE TABLE EXISTANTE

La clause AS de la commande CREATE TABLE permet de créer une nouvelle table à partir d'une tableexistante. La nouvelle table possède les caractéristiques et les données de la table source. La définitionde colonnes, dans ce cas, se limite aux noms des colonnes et aux valeurs que doivent prendre cescolonnes par défaut. Le nombre de colonnes spécifié dans la définition de colonnes et celui de la requêtedoit être identique. Les types de données sont évalués à partir de la requête.

Si la définition de colonnes est omise, le SGBD hérite les noms de colonnes de la requête. Il est possiblede définir une table à partir de plusieurs tables sources.

"Créer 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, codefrom clientswhere ville = "Paris"

M O D I F I C A T I O N D E T A B L E

Elle permet l'addition d'un attribut ou l'agrandissement de la longueur d'un attribut existant. Il n'estpossible de supprimer un attribut ou de rétrécir sa longueur qu'en créant une nouvelle table. Les valeursinitiales existantes pour ces nouveaux attributs seront mises à la valeur nulle. L'utilisateur peut attribuerune contrainte NOT NULL au nouvel attribut seulement si la table est encore vide. La syntaxe complètede 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)

S U P P R E S S I O N D E T A B L E

Elle permet d'enlever une table (et plus généralement un objet) de la base de données.

DROP TABLE Nom_table [CASCADE CONSTRAINTS]

Le mot clé CASCADE CONTRAINTS permet de supprimer toutes les contraintes d'intégrité référentiellequi se réfèrent aux clés uniques ou primaires de la table à supprimer.

"Supprimer la table fournisseurs"

drop table fournisseurs

R E N O M M A G E

Oracle offre la possibilité de renommer une table, une vue, une séquence ou un synonyme avec lasyntaxe suivante :





RENAME Ancien_objet TO Nouvel_objet

Le nouveau nom ne doit pas déjà exister dans l'espace des noms. Les vues, les synonymes et lesprocédures qui se réfèrent à l'ancien nom de la table ne sont pas supprimés, mais deviennent invalides.

Même si Oracle n'a pas de commande pour renommer les colonnes, on peut combiner les commandespour réaliser 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;




55Langage de contrôle des données

7. Langage de contrôle des données

P R I V I L E G E S D ' A C C E S

Notion d'environnement : Dans DB2, INGRES ou INFORMIX, l'environnement est constitué de la basede données choisie au début de la session. Dans ORACLE, la notion de base de données explicite estabsente. L'environnement de l'utilisateur est constitué de l'ensemble de ses tables et des tablesauxquelles les autres utilisateurs lui permettent d'accéder.

Il s'agit de pouvoir gérer les privilèges d'accès à la base des différents utilisateurs. Le principefondamental est qu'un utilisateur ne peut effectuer une opération quelconque sur un objet que s'ildétient le privilège approprié pour cette opération.

Les objets auxquels les privilèges sont attachés sont les tables de base et les vues (et, si elles existent, lesprocédures). Les opérations sont select, insert, update et delete (resp. execute).

Le propriétaire (créateur) d'un objet détient tous les privilèges attachés à celui-ci. Il peut accorder àd'autres utilisateurs des privilèges attachés à cet objet en utilisant GRANT. Il peut également accorderun privilège "avec autorisation de transmission", via la clause WITH GRANT OPTION. Cela signifie quele bénéficiaire du privilège pourra à son tour accorder le même privilège (avec ou sans autorisation detransmission) à un autre utilisateur.

Celui qui possède un privilège sur un objet peut retirer ce privilège à quelqu'un à qui il l'avait accordé.Dans ce cas, le bénéficiaire du privilège, ainsi que tous ceux à qui il l'avait lui même éventuellementaccordé perdent le privilège. En cas de multiples autorisations, le privilège est retiré lorsque le dernierpropriétaire l'a retiré.

GRANT

La commande grant permet de donner des privilèges sur une table, une vue ou une procédure. Lesprivilèges peuvent en général être un des suivants (d'autres peuvent s'y ajouter selon le SGBD) :

select

insertdeleteupdate ...execute (pour les procédures)

"Permettre à tous les utilisateurs d'insérer et de sélectionner dans la table Client "

grant insert, select on client to public

REVOKE

La commande revoke permet de supprimer un privilège qui a été accordé.

"Reprendre le privilège de création dans la table client accordé à l'utilisateur JULIEN "





revoke create on client from julien




57Le langage d'interrogation des données

8. Le langage d'interrogation des données

Il comprend en gros quatre commandes, SELECT, INSERT, UPDATE et DELETE.

C O N S U L T A T I O N D E S D O N N E E S .

La commande SELECT permet de réaliser les opérations les plus courantes sur la base de données, àsavoir la recherche d'informations, en sélectionnant les données selon différents critères. Dans sa forme

la plus générale2, 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 spécifier respectivement la liste de

colonnes à extraire et la liste des tables à partir desquelles les données sont extraites. Toutes les autresclauses ne servent qu'à raffiner la sélection et sont donc optionnelles.

CLAUSES SELECT, FROM

La forme la plus élémentaire comporte deux clauses indiquant dans quelle(s) tables(s) (clause FROM) etquel(s) attribut(s) (clause SELECT) sont à extraire.

Le résultat d'une commande SELECT est toujours une table (éventuellement réduite à une ligne et unecolonne). Cette propriété fondamentale, (conséquence de la fermeture de la base de donnée par l'algèbrerelationnelle implantée par la commande SELECT), permet en particulier de réutiliser le résultat d'unSELECT dans un autre SELECT.

Par défaut, les attributs du résultat portent le même nom que les attributs de la table d’origine. Il estpossible de leur donner un nom différent en spécifiant ce nom comme « étiquette », à côté de l’attributd’origine.

Certains systèmes permettent d’utiliser des attributs contenant des caractères spéciaux (accents,délimiteurs, espace, …). Dans ce cas les noms des attributs seront encadrés dans le SELECT par des« guillemets » ou des « apostrophes ». Cette pratique ne fait pas partie de la norme et est source deconfusion. Elle nuit également à la portabilité, chaque SGBD ayant un caractère d’encadrement p référé,voir plusieurs dans le même SGBD selon le contexte (c’est le cas de ™Access). Il est préférable deconserver 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 particularités liées à telle ou tellebase commercialisée.





" 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 clientswhere nom="DUPONT"

Remarques :

Il est toujours possible (et souvent indispensable) de préfixer le nom de l'attribut par le nomde la table :

select clients.nom from clients

La notion d'alias est prise en compte (on verra que c'est indispensable pour réaliser une auto jointure). Un alias est un autre nom donné à la table, synonyme de son nom réel.

select p.nom from clients p

Il est toujours possible, parfois nécessaire, de préfixer le nom de la table par le nom de sonpropriétaire. En fait, le système le réalise implicitement.

IMPLEMENTATION DES OPERATEURS DE L 'ALGEBRE RELATIONNELLE PAR LA

COMMANDE SELECT

Projection

La projection est réalisée en donnant explicitement les colonnes sélectionnées à coté du mot clé SELECT

"Afficher les noms des fournisseurs"

select nom from fournisseurs

Par défaut, SQL affiche le résultat d'une requête sans éliminer les répétitions. Cette élimination estpossible en ajoutant la clause DISTINCT





"Afficher les localités des clients"

select distinct VILLEfrom clients

Sélection

La sélection est réalisée en utilisant la clause WHERE <condition>. Les seuls tuples affichés sont ceuxpour lesquels <condition> est réalisée.

<condition> est une expression logique qui utilise les constituants des tables déclarées par FROM. Danscette expression logique, on peut utiliser :

Les prédicats de comparaison (>,>=,<,<=,=,<>,BETWEEN)

Le prédicat de comparaison approchée (LIKE)

Le prédicat de non-existence NULL

Un prédicat « tout ou n'importe lequel » (ANY ou ALL)

Le prédicat d'appartenance ou la non appartenance à un ensemble, souvent donné sous forme detable unicolonne (IN)

Le prédicat d'existence (EXIST)

Le test d’unicité (UNIQUE)

Chacun de ces prédicats, en nombre quelconque pouvant être combinés par les connecteurs logiques(AND, OR, NOT). Ces connecteurs logiques possèdent les priorités classiques, le SQL effectuant d'abordles NOT, puis les AND et en dernier lieu les OR. Il est conseillé d'employer les parenthèses afin degrouper les expressions.

Les prédicats 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 opérateur_relationnel expexp (NOT] BETWEEN exp AND expexp [NOT] IN (liste_de_valeurs)colonne IS [NOT] NULLcolonne [NOT] LIKE " chaîne"

exp désigne une expression qui peut être un nom de colonne, une constante numérique ou caractère,une pseudo_colonne, une valeur nulle ou une combinaison de ces éléments par des opérateurs logiques.

Les opérateurs relationnels sont classiques :

= : égal!=, <>, ^= : différent de 3 > : supérieur à>= : supérieur ou égal à < : inférieur à <= : inférieur ou égal à

"Afficher les code et noms des clients de PARIS"

select code,nom from clientswhere ville="PARIS"

3 selon le SGBD …





"Afficher les codes, les noms et les prix de vente des articles dont le prix de vente est supérieur à 200"

select code, libelle, PV from articleswhere PV > 200

"Afficher les codes, les noms et les prix de vente des articles dont le prix de vente est supérieur ou égal à

deux fois le prix d'achat"

select code, libellé, PV from articleswhere pv >= pa*2

NB : Cette dernière forme permet de constater qu'il est possible d'introduire dans la comparaison desexpressions. Malheureusement, cette possibilité est relativement limitée dans la plupart des SGBD.

"articles de la famille EMCOPDET dont le prix de vente est supérieur à 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 supérieur à 200"

select code, libellé, PV, famillefrom articleswhere famille = "EMCOPDET"or PV > 200

"articles qui ne sont pas de la famille EMCOPDET et dont le prix de vente est supérieur à 200"

select code, libellé, PV, famille

from articleswhere not (famille = "EMCOPDET" or PV > 200)

"articles dont le prix de vente est compris entre 100 et 200"

select code, libellé, PV, famillefrom articleswhere PV <= 100 and PV >= 200

Remarque : Ce type de requête ("entre x et y") dispose aussi d'un opérateur abrégeant la frappe :BETWEEN. On pourra donc exprimer la même requête avec :

select code, libellé, PV, famillefrom articleswhere PV between 100 and 200

"articles des familles EMCOPDET, EMPCOCPET et EMCOCOPO

select code, libellé, PV, famillefrom articleswhere famille in ("EMCOPDET", "EMPCOCPET", "EMCOCOPO")

Remarque : Il est aisé de démontrer que cet opérateur est facultatif. Il peut en effet être exprimé à l'aidede OR. Cependant son utilisation prend tout son intérêt lorsque la liste de valeur est elle-mêmeconstruite comme le résultat d'une requête, comme dans l'exemple suivant :





"articles fabriqués par des fournisseurs habitant PARIS"

select code, libellé, PV, famillefrom articleswhere fournisseur in( select code from fournisseurs where ville = "PARIS" )

L'ensemble des requêtes exprimées précédemment ne renvoient jamais de tuples dont les valeurscomparées n'ont pas été initialisées. Une valeur d'attribut non affectée est en effet une valeur spécialeNULL , qui ne peut être comparée avec aucune autre valeur. Il est donc nécessaire de disposer d'uneinterrogation spéciale pour ce type de valeur.

"articles dont on a négligé de saisir la famille"

select code, libellé, PV from articleswhere famille IS NULL

L'interrogation inverse se fait avec IS NOT NULL

"clients dont le nom commence par J"

select code, nom from clientswhere nom LIKE "J%"

La fonction du prédicat LIKE est la reconnaissance d'une structure. Il teste l'adéquation d'une chaîne decaractères à une structure donnée. Les caractères composant cette structure sont interprétés comme suit :

Le caractère de soulignement _ remplace n'importe quel caractère.

Le caractère pourcentage % remplace n'importe quelle séquence de n caractères, le n pouvant être

égal à 0 Tous les autres caractères ne représentent qu'eux même4.

Le prédicat MATCH est synonyme de IN. Il rend la valeur VRAI si la valeur de l’attribut se trouve dansla liste qui suit. Il est généralement employé avec les requêtes imbriquées. MATCH UNIQUE rend lavaleur VRAI lorsque la valeur de l’attribut se trouve une fois et une seule dans la liste qui suit.

Ordre des éléments extraits

L'ordre des attributs affichés dépend :

En cas d'utilisation de l'étoile, de l'ordre de leur définition au moment de la définition de la table(CREATE TABLE ...), sinon de l'ordre de leur apparition dans la commande SELECT

L'ordre des tuples affichés est absolument quelconque. Dans certains cas, il peut même varier selon lemoment de l'exécution de la commande select. Il est possible, grâce à la clause ORDER BY de demanderun ordre spécifique à l'affichage. Cette clause ne nécessite aucune préparation de la table (tri ouindexation). C'est SQL qui réalise si nécessaire les opérations nécessaires à l'affichage dans l'ordredemandé.

4 Dans Microsoft Access, et de manière générale les produits SGBD d'origine Microsoft le _ est remplacé par ? et le * remplace le %.

Sous Oracle, l'option ESCAPE permet d'identifier un caractère comme une séquence escape. Ceci est surtout utilisé pour permettrel'utilisation des caractères génériques comme des caractères littéraux. Si la séquence d'escape est définie par la caractère "\" alors"\_" signifie que le souligné est une donnée et non pas un caractère générique.





"articles dans l'ordre croissant de leur prix de vente"

select code, libellé, PV, famillefrom articlesorder by PV

"articles de prix de vente inférieur à 200, dans l'ordre croissant de prix de vente, et à prix de vente égal

par prix d'achat décroissant"

select code, libellé, PV, famille from articleswhere PV < 200order by PV, PA desc

Remarques :

Alors que pour réaliser une sélection, il n'est pas nécessaire que l'attribut de sélectionapparaisse dans la liste des attributs du select, c'est au contraire indispensable dans lesopérations de mise en ordre.

Il suffit de dire ORDER BY <n> pour obtenir le même résultat, <n> faisant référence au

nième attribut spécifié dans la commande. C'est un des rares moments en SQL où uneimportance est attribuée à l'ordre des attributs

La clause ORDER BY ne peut pas figurer dans une sous-requête. En règle générale, on nepermet qu'une clause ORDER BY par requête quelle que soit sa nature.

OPERATEURS ENSEMBLISTES

L'union existe dans la plupart des SGBD. L'intersection et la différence n'existent que dans de rares

SGBD. Le produit cartésien est réalisé automatiquement dans les requêtes impliquant plusieurs tables.

Union

SQL permet la fusion de données provenant de plusieurs requêtes SELECT formulées sur une ouplusieurs tables. La condition essentielle de requêtes avec l'opérateur UNION est la comptabilité deslistes de sélection dans les clauses SELECT du point de vue du type de données et de l'ordre descolonnes. On formule une requête d'union en composant plusieurs requêtes SELECT séparées par le motclé UNION comme le montre la syntaxe suivante :

requête_SELECTUNION [ALL] requête_SELECT

[UNION [ALL] requête_SELECT... ]

L'opérateur UNION supprime toutes les données redondantes par défaut sauf si l'option ALL estexplicitée. Une requête SELECT avec l'opérateur UNION ne peut contenir qu'une seule clause ORDERBY ( à la fin).





« articles de la famille EMCOPDET et articles de prix de vente supérieur à 500 »

select code,libelléfrom articleswhere famille = "EMCOPDET"unionselect code,libellé

from articleswhere PV > 500order by code

Noter que :

- les attributs demandés dans la clause SELECT doivent être exactement identiques dansles deux SELECT mis en jeu pour l'union.

- ORDER BY s'applique à l'intégralité des tuples sélectionnés.- UNION ALL permet de sortir les doublons.

Intersection

L'intersection de deux requêtes permet d'obtenir comme résultat les lignes appartenant à la fois à cesdeux requêtes. Cette opération exige le même nombre de colonnes dans les deux listes de sélection etune comptabilité entre leur type de données.

requête_SELECTINTERSECTrequête_SELECT

Différence

La différence exprimée par le verbe MINUS permet de lister les lignes du résultat de la première requête

SELECT, qui ne dont pas comprises dans le résultat de la seconde requête.

requête_SELECT MINUSrequête SELECT

JOINTURES

Lorsque les tables possèdent des attributs communs ou comparables, il est possible d'obtenir un résultatcomposé de données provenant de plusieurs tables "jointes" par cet attribut commun. C'est l'opération

de jointure. Cette opération n'a pas en elle même d'intérêt. Elle réalise en fait le produit cartésien de cestables. Elle ne devient intéressante qu'en appliquant sur l'ensemble ainsi obtenu une sélection basée surla condition de jointure.

Produit cartésien

Le produit cartésien "pur" est exprimé par l'utilisation de plusieurs tables dans le select. Il n'offrestrictement aucun intérêt.

select * from articles,fournisseurs

Equijointure

La condition de jointure est exprimée par une égalité. Un tuple d'une table est concaténé à un tupled'une autre table si leur(s) attribut(s) commun(s) ont même 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, fournisseurswherearticles.fournisseur = fournisseurs.codeand

famille = "EMCOPDET"

La syntaxe ci dessus est celle disponible depuis l'origine du SQL. La norme ANSI-92 a apporté une autresyntaxe dont le but est surtout de clarifier et d'étendre celle utilisée pour les jointures externes (voir plusbas). Elle permet aussi de mieux distinguer entre des conditions WHERE imposées par la jointure etcelles qui sont imposées par la requête :

select code, libellé, PV, fournisseurs.nom from articlesjoin fournisseurs on articles.fournisseur = fournisseurs.codewhere famille = "EMCOPDET"

Théta-jointure (jointure par non égalité)

Plus généralement, l'opération de jointure peut utiliser n'importe lequel des opérateurs de comparaison(<, >, BETWEEN, ...).

« Lister les articles avec leur catégories de poids »

select art_num, art_nom, art_poids, categfrom article, poidswhere art_poids between poids_min and poids_max

Autojointure

Il est possible (et souvent indispensable) de pouvoir réaliser la jointure d'une table avec elle-même.Cette technique, dite d'autojointure, nécessite de pouvoir utiliser des alias pour distinguer les rôles dechacune des tables.

"liste des articles dont le prix d'achat est supérieur au prix d'achat de l'article BIA420001"

select X.code, X.libellé, X.PA from articles X , articles Ywhere Y.code = "BIA420001"and X.PA > Y.PA

Remarque : En réalité, en SQL, il faut toujours formuler les requêtes en termes de variablesaccompagnées de leur alias. Si l'alias n'est pas présent, SQL suppose l'existence d'alias implicites portantle nom des tables. Ainsi "select T.Champ from T…" est interprétée 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 vérifiée, le tuple n'apparaît pas dans la table résultat. On peutsouhaiter 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'exprimedifféremment selon les systèmes et peut ne pas exister. Elle n'a d'ailleurs été normalisée qu'à partir deSQL-92. Les différences entre les systèmes sont ici particulièrement importantes, nous donnerons troisdes principales syntaxes :





Jointure externe DB2 / SQL Server / ANSI:

On utilise la même syntaxe que dans le JOIN, auquel on ajoute les mots clés LEFT OUTER, RIGHTOUTER ou FULL OUTER selon la table dont on souhaite conserver les tuples.

Jointure externe Oracle :

La jointure externe est explicitée par l'opérateur (+) qui est placé dans la clause WHERE après le nom dela table et celui de la colonne subordonnée :

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 onsouhaite conserver les tuples. A noter que le JOIN doit obligatoirement également s’écrire 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, datefrom clients, lignesfactureswhere clients.code = lignesfactures.client (+)

LES FONCTIONS ET SQL

Fonctions arithmétiques

Elles opèrent sur les valeurs de chaque tuple d'une table. Il est ainsi possible de combiner les différentsattributs par les opérateurs arithmétiques. L'expression obtenue peut se placer dans un SELECT, unWHERE ou un ORDER.

"liste de la marge bénéficiaire d'un produit dont le prix d'achat est supérieur à 100"

select *, pv - pafrom articlewhere pa > 100

Chaque système dispose de ses propres fonctions arithmétiques. Voir en annexe.

Fonctions sur les chaînes

Elles opèrent sur les valeurs de chaque tuple d'une table. L'expression obtenue peut se placer dans unSELECT, un WHERE ou un ORDER.

Chaque système dispose de ses propres fonctions. Voir en annexe.

Fonctions sur les dates

Elles opèrent sur les valeurs de chaque tuple d'une table. L'expression obtenue peut se placer dans unSELECT, un WHERE ou un ORDER.

Chaque système dispose de ses propres fonctions. Voir en annexe.





Fonctions de groupe

Elles opèrent sur les valeurs d'un attribut d'une table et produisent une seule valeur scalaire. Utiliséesavec GROUP BY, elles permettent de produire plusieurs valeurs, une valeur par facteur de groupement.5 fonctions sont prédéterminées 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 calculée. La clause DISTINCT permetd'éliminer les répétitions de valeurs. La clause ALL permet de prendre en compte les répétitions devaleurs. Elle est implicite, sauf dans le cas de COUNT. Les valeurs indeterminées (NULL) ne sont pas

prises en compte, sauf pour COUNT(*), avec laquelle les valeurs nulles sont également prises encompte. L'argument d'une fonction de groupe ne peut pas lui-même faire référence à une fonction degroupe (les références ne peuvent pas être imbriquées).

"Prix d'achat moyen des articles"

select avg(PA)from articles

"Prix moyen, marge maximum, différence 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 différentes"

select count(distinct famille)from articles

Remarque : En général, il n'est pas possible de placer dans une clause SELECT une référence à unefonction avec un attribut, comme "select code, count(code)"

5 La plupart des systèmes 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 colonneVARIANCE Variance de la colonne





REGROUPEMENTS

La clause GROUP BY

Elle réarrange la table représentée par la clause FROM (et WHERE) en un nombre minimum departitions ou groupes dont les lignes contiennent une valeur commune de(s) l'attribut(s) concerné(s) parGROUP BY. En général, il est indispensable de l'utiliser avec des fonctions de groupe. Hors cette

utilisation, les résultats sont parfaitement imprévisibles. Lorsque la clause GROUP BY est spécifiée, lesfonctions de groupe sont alors calculées pour chaque groupe.

Toute expression figurant dans le SELECT doit obligatoirement figurer également dans le GROUP BYsous peine de déclencher une erreur.

"Prix de vente moyen pour chaque famille"

select famille, avg(pv)from articlegroup by famille

"Calculer, par article, la marge totale réalisée pour les factures du 26/02/99 pour la semaine du 880107 au 880113"

SELECT CodeArticle, SUM(Montant - Quantité*PA)FROM (FacturesLignes LEFT JOIN FacturesON Factures.NumFacture = FacturesLignes.NumFacture)LEFT JOIN ArticlesON FacturesLignes.CodeArticle = Articles.Code WHERE Factures.Date=26/02/1999GROUP 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 sélection de type WHERE ait déjà été effectuée.

"Rechercher les familles des articles dont le prix de vente moyen des articles de la famille est supérieur à 100 "

select famille, avg(pv)from articlesgroup by famillehaving avg(pv)>100

" Magasins qui, pour la semaine du 880107 au 880113, ont réalisé plus de deux ventes et afficher le nombre deventes et le nombre d'articles vendus"

select vnt_mag,count(*), sum(vnt_qte)from ventewhere vnt_date between "880107" and "880113"group by vnt_maghaving count(*)>2





IMBRICATION DES REQUETES

Une propriété fondamentale de "l'ensemble des tables d'une base, muni des opérations implantées parSELECT" est d'être fermé. En effet, toute requête sur des tables retourne une table. Cette table estéventuellement réduite à un attribut et un tuple, donc une valeur unique, ou même vide. On peut doncimbriquer à volonté les requêtes. Il n'y a pas de limites à la profondeur de l'imbrication6.

Cas 1 : Le SELECT interne renvoie UNE valeur

La valeur retournée peut servir de comparaison dans le WHERE

"Liste des articles dont le prix est inférieur au prix de l'article numéro BIA420001 "

select code, pv from articleswhere pv <(select pv

from articles where code = "BIA420001")

Remarque(s) :

Déjà vu ? Il y a erreur lorsque le SELECT interne retourne plus d'une valeur.

"Liste des articles de même famille que l'article n° BIA420001 et dont le prix de vente est supérieur au prix devente moyen de tous les articles"

select code, libellefrom articleswhere famille =(select famillefrom articleswhere code = "BIA420001")and PV > (select avg(PV)from articles)

"Liste des clients dont la somme des achats est supérieure à la moyenne de la somme des achats de tous les clients "

select codeClient, sum(montant)FROM (FacturesLignes LEFT JOIN FacturesON Factures.NumFacture = FacturesLignes.NumFacture)group by codeClienthaving sum(montant) > (select avg(montant)from FacturesLignes)

Cas 2 : Le SELECT interne retourne UN ENSEMBLE de valeurs

La condition peut alors utiliser les opérateurs :

6 Indisponible dans les versions de MySQL antérieures à la version 4.1 (mais penser aussi que la plupart des sous requêtes peuventêtre en général remplacées 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 fournisseurswhere code in(select fournisseur from articles where famille = "EMCOPDET")

"Nom des gérants des magasins qui ont vendu au moins un article n° 2"

select M.mag_gerfrom magasin M where 2 in(select vnt_art from vente where vnt_mag=M.mag_num)

Remarque : On a ici un "attribut corrélé". Le SELECT imbriqué utilise un attribut d'un SELECT d'unniveau supérieur. Le résultat du SELECT interne va donc dépendre de la valeur de l'attribut renvoyépar le SELECT supérieur. On est alors obligé de préciser, à l'aide d'un alias, l'attribut supérieur utilisé.Le processus peut être "vu" comme un parcours comportant une double itération. Le moteur SQLexamine le premier tuple du SELECT supérieur, celui ci lui fournit une valeur d'attribut, qui peut êtreutilisé comme valeur de comparaison dans le SELECT de niveau inférieur, puis on itére

Exemples avec ANY ou ALL

Une comparaison quantifiée peut aussi être utilisée. Il s'agit d'une comparaison ordinaire(=,<>,>,<,<=,>=) suivi d'un des mots clés ANY ou ALL. Un tel prédicat prend la valeur VRAI si leprédicat correspondant, ne contenant ni ALL, ni ANY, prend la valeur VRAI pour tous (dans le cas deALL) ou pour un quelconque (dans le cas de ANY) des valeurs de l'attribut (la colonne) retournée par larequête imbriquée.

"Liste des articles dont le prix de vente est supérieur 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 supérieur au prix de vente de l'article de couleur blanche le plus cher "

select art_nom from articlewhere art_pv > ALL(select art_pv from article where art_coul="Blanc")

Exercice : Ecrire ces requêtes sous une forme plus claire





Remarque : L'emploi de ANY ou ALL ne contribue pas forcément à éclaircir la compréhension d'unerequête. Prudence. De plus les prédicats utilisants ANY ou ALL sont complètement inutiles, puisquetoute requête les utilisant peut être reformulée 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 requête a comme résultat l'ensemble vide. Sinon, ilprend la valeur VRAI.

"Liste des articles dont le prix de vente est supérieur 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 Bwhere 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 tupleest intéressante et non plus sa valeur. L'optimiseur de requête fera son travail le cas échéant afin de nepas ramener le tuple dans son entier.

I N S E R T I O N D E D O N N E E S

La commande INSERT présente deux formes, une forme ensembliste (agissant sur un ensemble dedonnées) et une forme non ensembliste (agissant sur un tuple unique). Les deux autres n'existent quesous des formes ensemblistes, agissant sur des ensembles de tuples de la base sélectionnés par unWHERE.

Ces commandes changent l'état de la base. Elles sont donc contrôlées par les transactions. Ellesprovoquent un blocage de la (des) table(s) concernées.

La table cible doit exister préalablement et les types de données doivent (selon le SGBD) correspondreexactement ou du moins être de même type.

FORME NON ENSEMBLISTE : 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'insérer un seul tuple à la fois. Si les attributs sont non précisés, lesystème suppose que l'insertion se réalise 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 valeursdonné dans VALUES comporte un manque, une erreur est déclenchée et l'insertion n'est pas réalisée.L'existence d'une liste explicite d'attributs visés permet de se limiter à un ou des attributs et/ou de





changer l'ordre des attributs. Les attributs non cités reçoivent dans ce cas la valeur NULL, ce qui vaévidemment être rejeté si ils ont été définis comme NOT NULL dans la commande CREATE.

"Insérer dans la table clients une personne bien précise (sur lequel on possède toutes les informations)"

insert into clients values (1,"PELFRENE","Marc",)

"Insérer dans la table clients un client dont on a oublié l'adresse"

insert into client(code, nom, ville) values (1,"PELFRENE","AUBAGNE")

FORME ENSEMBLISTE : INSERT…SELECT…

INSERT INTO table [(liste_de_sélection)] <requête_SELECT>

La requête_SELECT doit ramener le même nombre d'attributs que celui spécifié dans laliste_de_sélection si celle-ci est explicitée ou le même nombre d'attributs que celui spécifié lors de lacréation de la table si la liste_de_sélection est omise. Dans les deux cas, les types de données doiventcorrespondre.

Il s'agit d'un transfert de table à table.

"Insérer dans la table client_paris les clients de la table client habitant Paris"

insert into clients_parisselect code, nom, adresse from clients where ville="Paris"

On remarquera que la clause SELECT n'est pas entre parenthèses. Il ne s'agit pas ici d'une sous requête.

Remarque :

La table cible de INSERT ne doit être déclarée dans aucune clause FROM de larequête.





S U P P R E S S I O N D E D O N N E E S

La syntaxe générale de cette commande est :

DELETE FROM { table | vue }[ WHERE condition ]

La formulation générale de la commande est multi-tuples (clause WHERE nécessaire). Pour supprimerun seul tuple, il faut donc trouver un critère qui le caractérise entièrement. En l'absence de la clauseWHERE, c'est l'intégralité des tuples qui seront détruits.

"Supprimer tous les articles provenant du fournisseur de l'article SERVISPRAY "

delete from articleswhere fournisseur =(select distinct fournisseurfrom article

where nom = "SERVISPRAY")

Remarques :

La table cible de DELETE ne doit être déclarée dans aucune clause FROM de larequête.

ORACLE possède une commande permettant de détruire l'intégralité des tuplesd'une table en récupérant l'espace de stockage :

TRUNCATE{TABLE Nom_table | CLUSTER Nom_cluster}

[{DROP | REUSE} STORAGE]

La clause DROP STORAGE permet de libérer l'espace des lignes supprimées.Cet espace peut être utilisé par d'autres objets de la tablespace.

La clause REUSE STORAGE permet de maintenir l'espace des lignessupprimées pour le profit de la même table ou du même cluster.

Si l'utilisateur a omis de spécifier l'une des deux clauses, Oracle prend pardéfaut la clause DROP STORAGE.

Cette commande ne fait pas cependant partie stricto sensu du langage demanipulation de données, car elle ne peut pas être annulée par un ROLLBACK.





M I S E A J O U R D E D O N N E E S

La syntaxe générale de la commande UPDATE est :

UPDATE { table | vue }SET { ( colonne [,colonne ] ... ) = ( requête )

| colonne = {expr | requête ) } }[, { ( colonne [,colonne ] ... ) = ( requête )| colonne = {expr | requête ) } } ] ...[ WHERE condition ]

Cette commande consiste en une clause UPDATE spécifiant le nom de la table concernée, suivie d'uneclause SET, définissant les valeurs à mettre à jour, et d'une clause WHERE précisant les tuples àmodifier.

La formulation générale de la commande est donc ici encore multi-tuple, et il faut soigneusement choisir

le critère pour mettre à jour un seul tuple.

On remarquera que les valeurs utilisées 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 ) = (requête SELECT )[ WHERE condition ]

Dans ce dernier cas il faut bien entendu respecter un certain nombre de contraintes. La listed'attributs à gauche du = doit correspondre en nombre et en type aux attributs ramenés parla requête 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 façon que le prix de vente soit le double du prix d'achat"

update articlesset pv=2*pa where devise < "DEUTCH MARK"

" Modifier le prix de vente des articles en fonction des prix réellement pratiqués. Le prix de vente doit être renduégal au prix de vente réellement pratiqué "

update articlesset pv=(select avg(Montant/Quantité)from FacturesLigneswhere FacturesLignes.CodeArticle = Articles.Codegroup by CodeArticle)





Remarque :

La table cible de UPDATE ne doit être déclarée dans aucune clause FROM de larequête.




75SQL - Programmation

9. SQL - Programmation

O R A C L ET R I G G E R S , P R O C E D U R E S , F O N C T I O N S E T P A C K A G E S

Ce sont des objets pouvant être utilisés dans tous les outils de développement d’Oracle, SQL*forms,SQL*Menu, SQL*Plus, et les interfaces de programmation PRO*C,..

Les procédures (fonctions) compilées, sont stockées dans la base. Elles peuvent être groupées dans des

bibliothèques (packages) personnalisées ou publiques.

LES TRIGGERS

Les triggers sont des actions spéciales définies par l’Administrateur de la base de données,généralement sous forme de procédures stockées, qui sont exécutées automatiquement par le systèmelors d’événements déclencheurs comme la mise à jour, la création ou la suppression de données dansune table.

Un trigger est stocké dans la base et associé à une table. Il est exécuté implicitement par le noyau duSGBD à chaque fois que l’événement qu’il représente se produit.

Les triggers, utilisant les procédures stockées, peuvent utiliser toute la puissance du langage procéduralassocié à celles ci. Ils complètent donc les mécanismes de « contraintes », en permettant de gérer desactions plus complexes que la simple validation des données.

L’intérêt des triggers est lié à la mise en oeuvre d’un contrôle des accès aux données centralisé dans labase de données elle même, donc indépendant des différents programmes d’application.

Un trigger pourra par exemple être utilisé pour calculer automatiquement la valeur de colonnesdérivées, mettre en place des système de sécurité complexes, mettre en place des règles de gestioncomplexes, offrir des systèmes d’audit et de journalisation ou modifier les tables de base lorsque desordres de création ou de suppression sont réalisés sur des vues.

Il convient malgré tout d’être prudent avec les triggers. D’une part le langage utilisé , le typed’événement déclenchant, et les instructions autorisées dans le corps du trigger ne sont actuellement pasnormalisés, ce qui génère bien sûr des problèmes de portabilité7. D’autre part, un trigger peutdéclencher d’autres triggers sur d’autres tables (triggers en cascade), et le résultat de ces déclenchementssuccessifs peut être d’une grande complexité, et donc assez difficile à maintenir. Enfin, le SGBD n’asouvent aucun moyen d’optimiser le déclenchement d’un trigger, ce qui dans certaines ut ilisations peutposer un grave problème de performance. Ainsi si une procédure ajoute mille lignes dans une table, letrigger d’ajout sur cette table peut se déclencher mille fois pour vérifier une clé étrangère, même si cetteclé est identique dans toutes les lignes8.

7

réfléchir sur le fait qu’il existe 3 versions du même chapitre ….

8 Il existe cependant des moyens de désactiver les triggers temporairement, par exemple pour faire face à une situation d’insertionmassive de données.





Pour ces raisons, le débat est vif entre les tenants de la mise en œuvre de la logique métier via lestriggers et les procédures dans une base de données et ceux qui préfèrent régler le problème via laprogrammation objet, le SGBD ne gérant plus que la persistance des données.

En résumé, on se limitera dans l’utilisation des triggers aux cas suivants :

o Mise en place de règles métiers complexes (si absence de développement 3-tiers).

o Impossibilité de traduire les contraintes d’intégrité par des contraintes (CONSTRAINT).

La création :

Les commandes SQL qui sont susceptibles de déclencher un trigger sont INSERT, DELETE et UPDATE.

CREATE TRIGGER [schéma.]trigger

{BEFORE | AFTER}

{DELETE | INSERT | UPDATE [OF colonne [,colonne]...]}

OR {DELETE | INSERT | UPDATE [OF colonne [,colonne]...]}

ON [schéma.]table

[ [REFERENCE {OLD [AS] ancien NEW [AS] nouveau]

| NEW [AS] nouveau OLD [AS] ancien] } ]

FOR EACH ROW]

[WHEN (condition)]

<bloc PL/SQL>

L’action à accomplir par le trigger est le bloc PL/SQL. Une restriction peut être apportée par la clauseWHEN. On peut croiser les niveaux d’exécution des triggers. D’une part ceux qui sont définis au niveauligne (row) et ceux qui sont définis au niveau tables. D’autre part ceux qui s’exécutent avantl’événement (BEFORE) ou après l’événement (AFTER). Il existe un type spécial de triggers, nomméINSTEAD OF qui, contrairement aux autres types de triggers ont pour vocation de se déclencher pourchaque ligne d’une vue, et qui s’exécutent « à la place » de la commande SQL.

option FOR EACH ROW

OptionBEFORE

Actions avant la commande événement Actions avant chaque ligne mise à jour.

optionAFTER

Actions après la commande événement Actions après chaque ligne mise à jour.

Pour mémoire, il existe un dernier type de trigger qui peut s’exécuter sur les événements système et

utilisateur (logon et logoff, démarrage et fermeture de la base, messages d’erreurs du serveur …)





Il est possible de mettre en place autant de triggers que désiré pour la même instruction pour la mêmetable. Il faut alors prêter la plus grande attention à ce que fait chaque trigger pour éviter les problèmesde concurrence et d’incohérence.

Pour spécifier les nouvelles et les anciennes valeurs de la ligne courante, Oracle introduit deux nomsd’enregistrement définis implicitement et nommés respectivement OLD et NEW. Ils peuvent êtreredéfinis par la clause REFERENCE OLD AS ancien et NEW AS nouveau.

Les triggers agissent à partir de leur validation, donc sur les nouvelles données. En aucun cas ils nevérifient les anciennes données.

Exemple : Créer un trigger qui permet de mettre à jour automatiquement le montant de la commande et laquantité des articles commandés pour chaque ligne de commande enregistrée. L’utilisateur peut insérer des

nouvelles commandes, modifier la quantité commandée ou supprimer une ligne de commande. Pour chaque cascité, le trigger doit assurer la cohérence de la base de façon transparente. Cette cohérence, qui était assurée par le programme de l’application, est désormais réalisée par le noyau.

CREATE TRIGGER modifcom AFTER DELETE OR UPDATE OR INSERTON ligne_commande FOR EACH ROWDECLAREnouv_prix article.prix%TYPE DEFAULT 0;anci_prix article.prix%TYPE DEFAULT 0

BEGINIF DELETING OR UPDATING THEN/*Chercher le prix unitaire de l’article à modifier ou à supprimer*/ SELECT prixunit INTO anci_ prix FROM article WHERE idarticle = :OLD.idarticle;/*Mettre à jour la quantité stockée*/UPDATE article a SET a.qtestock = a.qtestock+:OLD.qtestock WHERE idarticle = :OLD.idarticle;

END IF;

IF INSERTING OR UPDATING THEN/*Chercher le prix unitaire de l’article à modifier ou à supprimer*/ SELECT prixunit INTO nouv _ prix FROM article WHERE idarticle = :NEW.idarticle;

/*Mettre à jour la quantité stcokée*/UPDATE article a SET a.qtestock = a.qtestock-:NEW.qtecom WHERE idarticle = :NEW.idarticle;

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 à l’activer, le désactiver ou le recompiler :

ALTER TRIGGER [schéma.]trigger

{ENABLE | DISABLE | COMPILE}





La suppression :

DROP TRIGGER [schéma.]trigger





LES PROCEDURES ET FONCTIONS

Lorsqu'on crée une procédure de BD, plusieurs points importants sont à prendre en compte :

Toutes les références des objets sont résolues au moment de la création de la procédure. Celasignifie en particulier que si une table publique est utilisée dans la procédure, ce sera cette tablequi sera accédée au moment de l'exécution de la procédure par un utilisateur, même si cet

utilisateur possède une table privée de même nom. Tous les objets utilisés dans la procédure doivent exister et être semblables au moment où celle ci

est crée et au moment ou elle est utilisée. Si un objet est modifié (par exemple un attributredéclaré avec un autre type), la définition de la procédure doit être supprimée et recrée.

Le plan d'exécution de l'interrogation est crée lorsque la procédure est crée. Si la procédure est modifiée,le plan d'interrogation est recrée à la prochaine utilisation de la procédure. Ce point permet surtout demettre à la disposition des utilisateurs des moyens de recherche de données parfaitement testés etoptimisés.

Exemple de procédure : "procédure qui déplace un client de la table client vers une table des clientssupprimés"

create procedure move_client (id integer not null) as

begin

insert into client_sav select *from clientwhere clt_num=:id;

delete from client

where clt_num=:id;

end;

Les deux tables peuvent être inaccessibles aux utilisateurs sauf à travers la procédure. Lorsque laprocédure est appelée, l'application passe un entier comme paramètre à la procédure, paramètre quidonne le numéro de client à déplacer.





La création :

CREATE [OR REPLACE] PROCEDURE

[schéma.]nom_procédure [(<liste d’arguments>)]

{IS | AS}

bloc PL/SQL;

CREATE [OR REPLACE] FUNCTION

[schéma.]nom_fonction [(<liste d’arguments>)]

RETURN type

{IS | AS}

bloc PL/SQL;

L’option OR REPLACE permet de spécifier au système le remplacement de la procédure ou de lafonction si elle existe déjà.

Les arguments sont séparés par des virgules et de la forme :nom_d’argument {IN | OUT | IN OUT} type

Lorsqu’une procédure est créée à l’aide d’un éditeur, sa dernière ligne doit être composée d’un seulcaractère « \ », pour spécifier au système l’exécution de sa création.

Exemples :

une procédure qui permet de baisser le prix d’un article.

CREATE OR REPLACE PROCEDURE baisse_prix ( id IN NUMBER, Taux IN NUMBER)

ISBEGINUPDATE article a SET a.prixunit = a.prixunit*(1+Taux)

WHERE a.idarticle = Id ;EXCEPTIONWHEN NO_DATA_FOUND THENRAISE_APPLICATION_ERROR(-20010, ‘Article Invalide : ’

|| TO_CHAR(Id ));END;

une fonction qui retourne le numéro du client ou celui d’un article.

CREATE OR REPLACE FUNCTION numero

(Nature IN CHAR)RETURN NUMBERISvaleur 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} [schéma.]nom COMPILE;

Recompile uniquement les procédures cataloguées standards (pas les packages). Il faut avoir les droitsnécessaires.

La suppression :

DROP {FUNCTION | PROCEDURE} [schéma.]nom ;





LES PACKAGES

Un package permet d’encapsuler des procédures, des fonctions, des curseurs et des variables commeune unité dans la base.

La création se fait en deux étapes :

o La création des spécifications

o La création du corps

La création :

CREATE [OR REPLACE] PACKAGE [schéma.]nom _ package

{IS | AS} <spécification PL/SQL>

spécification PL/SQL ::=

déclaration de variable |

déclaration d’enregistrement |

déclaration de curseur |

déclaration d’exception |

déclaration de table PL/SQL |

déclaration de fonction |

déclaration de procédure ...

CREATE [OR REPLACE] PACKAGE BODY [schéma.]nom _ package

{IS | AS} <corps PL/SQL>

corps PL/SQL ::=

déclaration de variable | déclaration d’enregistrement |

déclaration de curseur | déclaration d’exception |

déclaration de table PL/SQL | déclaration de fonction |

déclaration de procédure ...

Les deux noms de package doivent être identiques. Les objets déclarés dans la spécification sont rendus

publics et peuvent être accédés à l’extérieur du package. Pour les utiliser il faut avoir le privilègeEXECUTE sur le package.





Le corps du package peut se terminer par un bloc (BEGIN END) permettant d’initialiser certainesvariables ou certains curseurs, qui par défaut sont initialisés avec la valeur nulle.

Il est possible de nommer plusieurs procédures de la même façon. Cette possibilité permet de définirune procédure à plusieurs points d’entrée (nombre d’arguments et types de données différents).

Exemple : Créer un package composé de deux fonctions qui calculent le chiffre d’affaires global et par client pour

un vendeur donné et une procédure d’augmentation annuelle des salaires de vendeurs.

CREATE PACKAGE ges_vendeur ISTYPE VenEnreg IS RECORD (idven vendeur.idvendeur%TYPE,

qual vendeur.qualification%TYPE,salaire vendeur.salaire%TYPE);

TYPE LstVendeur IS TABLE OF vendeur.nom%TYPEINDEX 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 d’affaire d’un vendeur*/ FUNCTION chiffre-affaire (Idvendeur NUMBER)RETURN NUMBER IS

ca NUMBER DEFAULT 0;BEGINSELECT 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 d’affaire d’un vendeur pour unclient donné */FUNCTION chiffre_affaire (Idvendeur NUMBER, Idclient NUMBER)RETURN NUMBER IS

ca NUMBER DEFAULT 0;BEGINSELECT NVL(SUM(a.montant),0) INTO ca FROM Commande aWHERE a.idvendeur = Idvendeur AND a.idclient = Idclient;RETURN(ca);

END chiffre_affaire;

/*procédure permettant de réaliser une augmentation annuelle de 6% pour tous lesemployés *//* Ensuite et en fonction du chiffre d’affaire réaliser une seconde augmentation*/PROCEDURE augmente_ann ISCURSOR bonus ISSELECT commission FROM vendeur WHERE qualification=‘002’ FOR UPDATE OF salaire;

mntcom vendeur.commission%TYPE;BEGINIF (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 IFEND;BEGININSERT INTO

audit_vendeur

VALUES (SYSDATE, USER, ‘Gestion Vendeur’);nbr_engages := 0;

END ges_vendeur;

La modification

Elle concerne la version compilée. La recompilation se fait de la manière suivante :

ALTER PACKAGE [schéma.] package COMPILE [PACKAGE | BODY];

La suppression

DROP PACKAGE [schéma.]package ;

O R A C L E P L / S Q L

PL/SQL est l’extension procédurale de Oracle au langage SQL9. Il permet de grouper des commandes etde les soumettre au noyau comme un bloc unique de traitement.

Il permet de manipuler des données en combinant des instructions SQL et des instructions de contrôlede flux de programme telle que les constructions IF-THEN-ELSE et les boucles LOOP. Il est égalementpossible de déclarer et d’utiliser des variables, des constantes, de définir des procédures et des fonctionset même d’utiliser des objets et des collections.

Il est utilisé pour concevoir des procédures et des fonctions stockées dans la base de données, despackages et des triggers.

Les applications écrites en utilisant une des interfaces de programmation permettant l’accès à ORACLEpeuvent appeler les procédures écrites en PL/SQL et stockées dans la base de données et/ou envoyer auserveur de base de données des blocs de code de PL/SQL et demander l’exécution de ces instructions.

9 Soyez conscient que chaque SGBD définit sa propre extension procédurale à SQL (Transact SQL pour SQL Server, Stored Procedure

Language pour Informix, …). Au lieu de conserver la séparation entre code et données qui était un des fondements de la mise enplace de système de base de données relationnelles, les éditeurs ont de plus en plus tendance à amener le code à l’intérieur de labase, à tel point qu’aujourd’hui il devient parfois difficile de porter un exemple écrit pour SQL Server sur Oracle. Le seul réconfortdans ce marasme est que presque tous les éditeurs supportent (ou supporteront) les procédures stockées à base de Java.





Autre Client

Serveur

Oracle

Oracle Forms

Programme PL/SQL

Interpréteur SQLRuntime PL/SQL

Procédure

stockée

Appel à procédure

stockéeGénérateur SQL

instruction SQL

instruction SQL

appel à PS

CLIENT

SERVEUR

Dans un contexte Oracle, une des seules alternatives à l’utilisation de PL/SQL est l’utilisation de Javasous forme d’EJB (Enterprise Java Beans) ou de JSP ( Java Stored Procedures). Sinon, il faut renoncer à lamise en œuvre du contrôle des données à l’intérieur de la base et utiliser une couche intermédiaire (parexemple à l’aide d’un langage objet) entre le programme et les données.

PRESENTATION DE PL/SQL

Un programme est constitué d’un bloc composé de trois parties :

DECLARE

Déclarations

BEGIN

Commandes exécutables

EXCEPTION

Gestion des erreurs

END

La partie Déclarations sert à définir les variables et les constantes utilisées dans le bloc.

Les parties Commandes et Exceptions constituent le corps du bloc PL/SQL. Ce corps commence par lemot BEGIN et se termine par END.





Déclarations

Cette partie peut comporter trois types de déclarations :

- Déclaration de variables et de constantes

- Déclaration de curseurs

- Déclaration des exceptions


Les types scalaires peuvent être de n’importe quel type de données SQL (CHAR, VARCHAR, DATE,NUMBER, …) auxquels s’ajoutent des types spécifiques à PL/SQL :

TYPES PL/SQL

Types Scalaires

BINARY_INTEGERDEC

DECIMAL

DOUBLE_PRECISION

FLOATINT

INTEGER

NATURAL

NATURALN

NUMBERNUMERIC

PLS_INTEGER

POSITIVE

POSITIVENREAL

SIGNTYPE

SMALLINT

CHARCHARACTER

LONG

LONG_RAW

NCHARNVARCHAR2

RAW

ROWID

STRING

UROWIDVARCHAR

VARCHAR2

BOOLEAN

DATE

Types Composés

RECORD

TABLE

VARRAY

Types Référence

REF CORSORREF <object_type>

Types LOB

BFILE

BLOB

CBLOBNCBLOB

BINARY_INTEGER comprend les entiers allant de -231 à 231-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 réels de 1-130 à 10125

CHAR représente une chaîne de caractères à taille fixe allant jusqu’à 32767 caractères (Ce type est limitéà 255 caractères dans les colonnes de tables).

VARCHAR2 est une chaîne de longueur variable allant jusqu’à 32767 caractères (limité à 2000 octetsdans les colonnes. Attention octet peut être différent de caractère dans certains systèmes).

LONG est équivalent à VARCHAR2 (une colonne de ce type peut avoir une taille de 2 147 483 647octets).

BOOLEAN peut valoir TRUE, FALSE ou NULL. Seules les variables peuvent avoir ce type.

Il existe deux types composés : RECORD et TABLE et quatre types permettant de stocker des blocs dedonnées non structurées comme les images, les sons et les clips vidéos.

Des règles très précises permettent la conversion des types (à voir dans la documentation).





En cas de manque, le mot clé SUBTYPE permet de définit des sous types de données utilisateurs :

SUBTYPE BirthDate IS DATE NOT NULL; -- based on DATE typeSUBTYPE Counter IS NATURAL; -- based on NATURAL subtypeSUBTYPE NameList IS TABLE OF VARCHAR2(10);SUBTYPE DutyRoster IS NameList; -- based on TABLE typeSUBTYPE 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 typeCURSOR c1 IS SELECT * FROM dept;SUBTYPE DeptFile IS c1%ROWTYPE; -- based on cursor rowtype

Variables et constantes

déclaration de variable ::=

nom de variable [CONSTANT]

{type | identifiant%TYPE | identifiant%ROWTYPE}

[NOT NULL] [{:= | DEFAULT}expression PL/SQL];

La variable peut recevoir une valeur par défaut. Variable et constante peuvent avoir un statut NOTNULL.

L’utilisateur peut utiliser le type d’un identificateur existant (variable ou colonne) en suffixantl’identificateur par %TYPE, ou par %ROWTYPE s’il s’agit de la déclaration d’une structure (table).

Exemples :

ename VARCHAR2(10) := 'KING' birthdate DATE balance NUMBER(7,2); minimum_balance balance%TYPE := 10.00;

test table1.colonne2%TYPEessai propriétaire5.table1.colonne2%TYPE MonRecord table1%ROWTYPE

Quelques exemples d’expression numériques :

-155 +5.0 ( prixunit*18.6)/100 :var_h + 12 {variable d’un langage hôte}

SQL%ROWCOUNT + 1 NULL (12 + LENGTH(var1) - var2)**2

Quelques exemples d’expressions de chaînes de caractères :

‘bonjour’ || ‘lecteur’ varc || UPPER(varc2) || NULL ||| ‘.’

Quelques exemples d’expressions de dates :

‘05-JAN-98’ LAST_DAY(sysdate)

Les tables

Les index d’une table PL/SQL sont de type BINARY_INTEGER (clé primaire), et les valeursuniquement de type scalaire.





La déclaration se fait en deux étapes, déclaration du type puis des variables, suivant la syntaxe :

TYPE nom_type IS TABLE OF

{type_colonne | table.colonne%TYPE} [NOT NULL]

INDEX BY BINARY_INTEGER;

Exemples :

TYPE TypeNomArt IS TABLE OF CHAR(20)INDEX BY BINARY_INTEGER;

-- ou encoreTYPE TypeNomArt IS TABLE OF article.nom %TYPEINDEX BY BINARY_INTEGER;

-- puis la variable NomArt TypeNomArt;-- et les affectations

NomArt(1) := ‘CRAYON’; NomArt(2) := ‘STYLO NOIR’;

Les enregistrements

Comme pour les tables, il faut déclarer 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 déclaration de variable Macom TypeComm;

-- et l’affectation Macom.Montant := 0;

Il est possible de déclarer des types RECORD imbriqués.

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 d’unetable obtenue par une requête. Il doit être déclaré au préalable dans la section de déclarations, puisouvert et utilisé grâce à une commande spéciale (voir plus loin) dans le programme.

DECLARE CURSOR nom_curseur [(nom_param type [,nom_param type]...)]

IS SELECT requête .....;

Les paramètres peuvent être uniquement utilisés dans la requête associée au curseur.

Exemple :

CURSOR cur_article ( prixunit NUMBER) ISSELECT idarticle, prixunit FROM article WHERE prixunit > cur _ article. prixunit ;

Gestion des erreurs

Le mécanisme de gestion d’erreurs dans PL/SQL est appelé gestionnaire des exceptions. Il permet audéveloppeur de planifier sa gestion et d’abandonner ou de continuer le traitement en présence d’uneerreur.

Comme dans tous les langages, il faut différencier les erreurs systèmes ( exceptions internes), des erreursutilisateurs (exceptions externes).

Les exceptions internes

Une exception interne est produite lorsqu’un bloc PL/SQL viole une règle d’Oracle ou dépasse unelimite dépendant du système d’exploitation (division par zéro, dépassement de mémoire,...).

Les erreurs Oracle générées par le noyau sont numérotées, or le gestionnaire des exceptions PL/SQL nesait gérer que des exceptions nommées. Pour cela , PL/SQL a redéfini quelques erreurs Oracle commedes exceptions. pour les autres l’utilisateur doit utiliser le gestionnaire OTHERS ou EXCEPTION_INITpour nommer ces erreurs.

Quelques exceptions prédéfinies :

Nom d’exception 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 prédéfinies.

La gestion des exceptions

Elle se fait dans la partie EXCEPTION du bloc de commandes.

EXCEPTION

WHEN err1 THEN

-- gérer l’erreur err1

WHEN err2 THEN

-- gérer l’erreur err2

WHEN OTHERS THEN

-- gérer toutes les autres erreurs

END;

WHEN err1 OR err2 THEN

-- gestion commune des erreurs err1 et err2

L’utilisateur peut définir ses propres exceptions, qui seront déclenchées par la commande RAISE (elletransfère le contrôle de l’exécution au gestionnaire d’exception).

Exemple :

DECLAREstock_à_zéro EXCEPTION

BEGIN....BEGINIF qtestock = 0 THEN

RAISE stock_à_zéro END IF;...EXCEPTION

WHEN stock_à_zéro THEN-- gérer l’erreur RAISE stock_à_zéro ;

END;EXCEPTIONWHEN stock_à_zéro THEN

--gérer l’erreur différemment END;





Si l’utilisateur produit une exception qui n’existe pas dans le gestionnaire du bloc courant, elle sepropage vers le bloc fermant le bloc courant, jusqu’à ce qu’il la trouve. S’il ne la trouve pas, l’exécutions’arrête avec une erreur d’exception non gérée.

Le développeur peut utiliser les fonction SQLCODE et SQLERRM pour coder les erreurs Oracle enexceptions. La première fonction retourne le numéro de l’erreur, qui est généralement négatif, sauf pourle non trouvé qui vaut 100. La seconde reçoit en entrée le numéro de l’erreur et retourne le message

associé codé sur 196 octets.

Il est possible d’utiliser une directive compilée (PRAGMA) nommée EXCEPTION_INIT pour affecter unnom à un code d’erreur Oracle et n’utiliser ensuite que ce nom pour la référencer.

Exemple :

DECLAREerreur1025 EXCEPTION;

PRAGMA EXCEPTION_INIT (erreur1025, -1025);

LES INSTRUCTIONS DE CONTROLE

Elles permettent de diriger le flux d’un programme PL/SQL en fonction de la valeur de conditions. Unecondition est une variable ou une expression quelconque retournant une valeur de type BOOLEAN,c’est à dire VRAI ou FAUX.

La conditionnelle

Sa forme la plus générale est :

IF condition1 THEN

sequence_of_statements1

ELSIF condition2 THEN


ELSE


END IF;

Les parties ELSIF et ELSE sont facultatives.

IF qtestock < 10 THENalertstock := 100 ;

ELSEIF qtestock > 50 THENalertstock := 0;

ELSEalertstock := 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 dépassementde capacité) sont au choix :

EXIT; -- sortie inconditionnelle

EXIT WHEN condition; -- sortie si la condition est VRAIE

GOTO label; -- très laid comme programmation …

LOOPFETCH c1 INTO ...EXIT WHEN c1%NOTFOUND; -- exit loop if condition is true...

END LOOP;CLOSE c1;

La boucle incrémentée :

Le nombre de fois ou la séquence d’instructions doit être évaluée est calculé par soustraction de la borneinférieure à la borne supérieure dès l’entrée dans la boucle. La boucle est ensuite exécutée autant de foisque nécessaire. Noter la notation originale de l’opérateur d’étendue ( .. ).

FOR compteur IN [REVERSE] borneinf .. bornesup LOOP

commandes;

END LOOP;

A l’intérieur de la boucle, le compteur peut être référencé comme une variable, mais il est interdit dechanger sa valeur.

FOR ctr IN 1..10 LOOPIF NOT finished THEN

INSERT INTO ... VALUES (ctr, ...); -- autorisé … factor := ctr * 2; -- autorisé …

ELSEctr := 10; -- pas bien du tout !!!!!!!!!!!

END IF;END LOOP;

La boucle conditionnelle :

Avant chaque itération de la boucle, la condition dans le WHILE est évaluée. La boucle ne s ‘exécute quesi 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 GESTION DES CURSEURS

Pour traiter une commande SQL, PL/SQL ouvre une zone de contexte pour exécuter la commande etstocker les informations. Le curseur permet de nommer cette zone, d’accéder aux informations etéventuellement d’en contrôler le traitement. PL/SQL utilise deux types de curseurs :

Les curseurs explicites pour traiter les requêtes multilignes,

Les curseurs implicites utilisés pour les autres commandes SQL.

Les curseurs explicites

Pour traiter une requête qui retourne plusieurs lignes, l’utilisateur doit définir un curseur qui lui permet

d’extraire la totalité des lignes sélectionnées.

Une requête SELECT simple renvoie uniquement le premier enregistrement rencontré. Pour défiler la listecomplète des valeurs, il faut utiliser un curseur.

Pour utiliser un curseur, il faut le déclarer dans la partie déclarative du programme (CURSOR), l’ouvrirdans la partie commande (OPEN), ensuite défiler l’extraction de données par la commande FETCH , enutilisant une boucle et une instruction conditionnelle pour quitter la boucle quand il n’y a plus dedonnée. Le curseur doit être fermé si l’on juge qu’il ne sera plus utilisé dans le reste du programme(CLOSE).

Nous avons déjà vu la syntaxe de la déclaration d’un curseur.

CURSOR cursor_name [(parameter[, parameter]...)]

[RETURN return_type] IS select_statement;

return_type doit représenter un enregistrement ou une rangée dans une table de base de données.

DECLARECURSOR 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é déclaré doit être ouvert avant d’être utilisé :

OPEN nom_curseur [(param_entrée [, param_entrée]...)]

Param_entrée est une expression PL/SQL jouant le rôle de paramètre réel associé par position à un

paramètre formel de la définition du curseur. Il est possible que l’association soit par nom à condition depréciser le lien param_formel =>param_réel

OPEN c1 ;OPEN c2 ;OPEN c3 (15, 2000);OPEN C3 (low => 15, high => salary);OPEN C3 (high => salary, low => 15);

Enfin le FETCH permet d’avancer d’une ligne à la fois dans le curseur :

FETCH nom_curseur INTO { nom_var [, nom_var ].. |nom_enregistrement};

Les variables servent à stocker les données retournées par la requête. Elles doivent être déclarées ettypées selon le type des colonnes correspondantes. Elles peuvent être remplacées par une variable detype enregistrement ayant la structure du résultat de la requête.

… FETCH c1 INTO my_empno, my_ename, my_deptno;

… LOOPFETCH c1 INTO my_record ;EXIT WHEN c1%NOTFOUND;-- process data record

END LOOP;

En fin d’utilisation, penser à fermer le curseur :

CLOSE nom_curseur;

Attributs de curseurs

Chaque curseur explicite possède quatre attributs utilisés pour accéder à sa zone de contexte :

NOM DE L’ATTRIBUT UTILISATION

%NOTFOUND : Génère un booléen VRAI lorsque FETCH échoue à cause de la non-disponibilitéde données.

%FOUND : Contraire du précédent.

%ROWCOUNT : Retourne le nombre de lignes défilées de l’ensemble actif de données.

%ISOPEN : Génère un booléen VRAI si le curseur spécifié est ouvert.





Utilisé de la façon suivante nom_curseur% ATTRIBUT (voir exemples).

Les curseurs implicites

Oracle ouvre une zone de contexte de traitement pour tout ordre SQL. Ainsi la commande passée aumoteur n’est pas une requête de consultation, l’utilisateur peut accéder aux informations de la zone decontexte 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 extrême précaution,puisque d’une part, ces attributs font référence au dernier curseur utilisé et que en même temps, Oracle

lève le cas échéant des exceptions qui ont priorité sur le traitement des instructions. Ainsi dansl’exemple précédent, si la commande avait été une commande SELECT et qu’elle n’ait pas renvoyé dedonnées, Oracle aurait levé l’exception NO_DATA_FOUND.

Quelques exemples d’utilisation

Exemple 1

DECLAREclient_enrg client%ROWTYPE;Nom_art CHAR(20);Prix_art NUMBER;

BEGINSELECT designation, prixunit INTO Nom_art, Prix_art FROM article WHERE idarticle = 123;

SELECT * INTO client_engr FROM client WHERE idclient = 1331;

END;

Exemple 2

DECLARECURSOR 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);

BEGINOPEN 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 spéciale de la boucle FOR)





DECLARECURSOR cur_cl (id NUMBER) IS

SELECT nom, prenom, adresse, ville, codepost FROM client WHERE idclient < id ;

BEGINFOR 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 données)

DECLARE cur1 ISSELECT nom || prenom, adresse, codepost || ‘,’ || ville FROM client WHERE idclient BETWEEN 1 AND 1500;lib1 CHAR(45);lib2 CHAR(40);lib3 CHAR(50);

BEGINOPEN 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;

ELSEINSERT INTO mail_table VALUES (lib1, lib2, lib3);

ENDIF;END LOOP;CLOSE cur1;

END;

LA GESTION DES TRANSACTIONS

Dans un bloc PL/SQL, l’utilisateur peut utiliser les commandes standard de gestion des transactionspour coordonner ses traitements.

En plus des commandes COMMIT et ROLLBACK, qui permettent respectivement de valider oud’annuler une transaction, l’utilisateur dispose d’une commande qui lui permet de découper unetransaction en sous-transactions à l’aide de la commande SAVEPOINT. Ainsi en cas d’erreur, il peutannuler seulement une partie de la transaction.

SAVEPOINT nom_de_point;

ROLLBACK TO [SAVEPOINT] nom_de_point;





M Y S Q LT R I G G E R S , P R O C E D U R E S , F O N C T I O N S

LES TRIGGERS

Le support rudimentaire des déclencheurs (triggers) est inclus dans les versions de MySQL à partir de laversion 5.0.2. Un déclencheur est un objet de base de données nommé, qui est associé à une table et quis'active lorsqu'un événement particulier survient dans une table

La création :

Les commandes SQL qui sont susceptibles de déclencher un trigger sont INSERT, DELETE et UPDATE.

CREATE TRIGGER [schéma.]trigger

{BEFORE | AFTER}

{DELETE | INSERT | UPDATE}

ON [schéma.]table

FOR EACH ROW]

<bloc>

L’action à accomplir par le trigger est le bloc (défini par une suite d’instructions encadrées par BEGIN …END10. On peut croiser les niveaux d’exécution des triggers entre ceux qui s’exécutent avant

l’événement (BEFORE) ou après l’événement (AFTER).

option FOR EACH ROW

OptionBEFORE

Actions avant la commande événement Actions avant chaque ligne mise à jour.

optionAFTER

Actions après la commande événement Actions après chaque ligne mise à jour.

Il ne peut pas y avoir deux déclencheurs pour une même table avec les mêmes configurations demoment et de commande. Par exemple, vous ne pouvez pas avoir deux déclencheurs BEFORE UPDATE pour la même table. Mais vous pouvez avoir un déclencheur BEFORE UPDATE et un déclencheurBEFORE INSERT, ou un déclencheur BEFORE UPDATE et un déclencheur AFTER UPDATE.

Pour spécifier les nouvelles et les anciennes valeurs de la ligne courante, MySQL introduit deux nomsd’enregistrement définis implicitement et nommés respectivement OLD et NEW.

Le déclencheur ne peut pas utiliser de commande qui ouvre ou ferme une transaction avec STARTTRANSACTION, 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 données. En aucun cas ils nevérifient les anciennes données.

Exemple : Créer un trigger qui permet de mettre à jour automatiquement le montant de la commande et la

quantité des articles commandés pour chaque ligne de commande enregistrée. L’utilisateur peut insérer desnouvelles commandes, modifier la quantité commandée ou supprimer une ligne de commande. Pour chaque cascité, le trigger doit assurer la cohérence de la base de façon transparente. Cette cohérence, qui était assurée par le programme de l’application, est désormais réalisée par le noyau .

CREATE TRIGGER modifcom AFTER DELETE OR UPDATE OR INSERTON ligne_commande FOR EACH ROWDECLAREnouv_prix article.prix%TYPE DEFAULT 0;anci_prix article.prix%TYPE DEFAULT 0

BEGINIF DELETING OR UPDATING THEN/*Chercher le prix unitaire de l’article à modifier ou à supprimer*/

SELECT prixunit INTO anci_ prix FROM article WHERE idarticle = :OLD.idarticle;/*Mettre à jour la quantité stockée*/UPDATE article a SET a.qtestock = a.qtestock+:OLD.qtestock WHERE idarticle = :OLD.idarticle;

END IF;IF INSERTING OR UPDATING THEN/*Chercher le prix unitaire de l’article à modifier ou à supprimer*/ SELECT prixunit INTO nouv _ prix FROM article WHERE idarticle = :NEW.idarticle;

/*Mettre à jour la quantité stcokée*/UPDATE article a SET a.qtestock = a.qtestock-:NEW.qtecom WHERE idarticle = :NEW.idarticle;

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 déclencheur. Il faut supprimer, puis recréer le déclencheur.

La suppression :

DROP TRIGGER [schéma.]trigger

Une restriction importante !

Il n’est pas possible d’appeler une procédure stockée depuis un déclencheur. Il faut réécrire chaquecommande …





M Y S Q LL E S P R O C E D U R E S E T F O N C T I O N S

Les procédures stockées et les fonctions sont créées avec les commandes CREATE PROCEDURE etCREATE FUNCTION. Une procédure est appelée avec la commande CALL, et ne peut retourner devaleur que via les variables de retour. Les fonctions peuvent retourner une valeur scalaire, et êtreappelée depuis une commande, tout comme toute autre fonction. Les procédures stockées peuventappeler une autre routine stockée. Une routine est une procédure stockée ou une fonction.

La création :

CREATE PROCEDURE

[schéma.]nom_procédure [(<liste d’arguments>)]

[LANGUAGE SQL | [NOT] DETERMINISTIC| SQL SECURITY {DEFINER | INVOKER} | COMMENT string]

bloc instructions;

CREATE FUNCTION

[schéma.]nom_fonction [(<liste d’arguments>)]

RETURNS type

[LANGUAGE SQL | [NOT] DETERMINISTIC| SQL SECURITY {DEFINER | INVOKER} | COMMENT string]

bloc instructions;

Les arguments sont séparés par des virgules et de la forme :

nom_d’argument {IN | OUT | IN OUT} type

Un framework pour développer des procédures stockées externes sera prochainement présenté. Ilpermettra d'écrire des procédures stockées dans d'autres langages que SQL. Il est probable que l'un despremiers langages supportés sera PHP, car le moteur PHP est compact, compatible avec les threads etpeut être facilement intégré. Comme ce framework sera public, il est probable que bien d'autreslangages soient supportés

Une fonction est considérée comme ``déterministe'' si elle retourne toujours le même résultat pour lesmêmes paramètres d'entrée. Sinon, elle est considérée comme ``non déterministe''. L'optimiseur peututiliser cette propriété. Actuellement, l'attribut DETERMINISTIC est accepté, mais il n'est pas encoreutilisé.

L'attribut SQL SECURITY peut être utilisé pour spécifier si la routine doit être exécutée avec les droits

de l'utilisateur qui l'a créé (DEFINER ) ou avec ceux de celui qui appelle la fonction (INVOKER ). La valeurpar défaut est DEFINER . Cette fonctionnalité est nouvelle en SQL:2003.





La clause COMMENT est une extension MySQL, et peut servir à décrire la procédure stockée. Cette

information est affichée par les commandes SHOW CREATE PROCEDURE et SHOW CREATE FUNCTION.

Exemples :

une procédure qui permet de baisser le prix d’un article.

CREATE PROCEDURE baisse_prix ( id IN NUMBER, Taux IN NUMBER)

BEGINUPDATE article a SET a.prixunit = a.prixunit*(1+Taux)

WHERE a.idarticle = Id ;EXCEPTIONWHEN NO_DATA_FOUND THENRAISE_APPLICATION_ERROR(-20010, ‘Article Invalide : ’

|| TO_CHAR(Id ));END;

une fonction qui retourne le numéro du client ou celui d’un article.

CREATE OR REPLACE FUNCTION numero (Nature IN CHAR)

RETURN NUMBERIS

valeur NUMBER;BEGINIF 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} [schéma.]nom;





M Y S Q LL A N G A G E D E P R O G R A M M A T I O N

PRESENTATION

Un programme est constitué d’un bloc composé de 2 parties :

DECLARE

Déclarations

BEGIN

Commandes exécutables

END

La partie Déclarations sert à définir les variables et les constantes utilisées dans le bloc.

La partie Commandes constitue le corps du bloc. Ce corps commence par le mot BEGIN et se termine parEND.

Déclarations

Cette partie peut comporter trois types de déclarations :

- Déclaration de variables et de constantes

- Déclaration de curseurs

- Déclaration des gestionnaires


Les types de données sont les types supportés par MySQL.

Les curseurs

Un curseur peut être vu comme un pointeur permettant de traiter successivement toutes les lignes d’une

table obtenue par une requête. Il doit être déclaré au préalable dans la section de déclarations, puisouvert et utilisé grâce à une commande spéciale (voir plus loin) dans le programme.

DECLARE CURSOR nom_curseur FOR SELECT requête .....;OPEN CURSOR nom_curseur

FETCH nom_curseur

CLOSE nom_curseur

Exemple :





LES INSTRUCTIONS DE CONTROLE

Elles permettent de diriger le flux d’un programme en fonction de la valeur de conditions. Unecondition est une variable ou une expression quelconque retournant une valeur de type BOOLEAN,c’est à 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 implémente une boucle, permettant l'exécution répétée d'un groupe de commande. Lescommandes à l'intérieure de la boucle sont exécutée jusqu'à ce que la boucle se termine, généralement

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]





S Q L E T JAVA

PRESENTATION

Comment accéder aux données SQL ? Une application peut elle accéder de façon transparente aux basesde données réparties / fédérées ? Une application construite sur un SGBD donné peut elle fonctionner

sur un autre ?

Les réponses forment un ensemble flou de « oui », « non » et « peut-être » … Il existe au moins deuxapproches concurrentes pour supporter SQL au sein d’un langage de programmation : ESQL(Embedded SQL – partie 10 de la norme, SQL/OLB) et CLI (partie 3 de la norme, SQL/CLI).

CLIENTAppel à SQL

incorporéAppel à CLI SQL

PRECOMPILATEUR

Run-time library Run-time library

PILOTE DE BASE DE DONNEES

SERVEUR

PILE RESEAU

PILE RESEAU

Procédures stockées SQL compilé Tables ...

Figure 7: Les deux API : CLI et ESQL

SQLJ : SQL INCORPORE JA VA

En 1998, SQLJ11 est devenue la base des liaison en langage objet de SQL3 ISO (c’est la partie 10 dudocument SQL3). Comme tous les ESQL (Embedded SQL), SQLJ permet d’incorporer directement desinstructions SQL dans les programmes Java. A la différence d’autres SQLJ, il permet aussi d’incorporerdes appels à des procédures stockées et à des types définis par l’utilisateur.

Afin de faire fonctionner SQLJ, il est nécessaire de disposer :

o D’un driver JDBC incluant les classes standard java.sql

o D’une base de données accessible par le driver

o Des classes pour le pré-compilateur, le runtime et les classes de profils. Ces classes sontnormalement accessibles dans <Oracle Home>/sqlj/lib/translator.zip.

Le principe d’utilisation consiste à écrire des classes Java parfaitement classiques et d’ajouter à cesclasses un certain nombre de déclarations, de commandes, et d’expressions destinées à unpreprocesseur. Ce preprocesseur va enlever ces ajouts et les remplacer par les appels de classesnécessaires à l’exécution des instructions et au retour des résultats. En voici un exemple, la directive#sql indique au preprocesseur de commencer son travail, l’instruction SQL est enfermée dans les

11 Initiative de Oracle, Tandem et IBM au départ





accolades ouvrantes et fermantes {}, le préprocesseur reconnaît les variables préfixées par les deuxpoints comme des variables du langage hôte 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 composée doit être enregistrée dans un fichier d’extension .sqlj . Ce fichier est ensuiteprécompilé et produit un fichier .java et un certain nombre de fichiers de profils sqlj. L’ensem ble estcompilé par un compilateur java pour produire le .class .

Un exemple de classe SQLJ : On ouvre la connexion à la base de données 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 it’s no longer needed. employees.close() ;

}

}

JDBC

JDBC (Java Database Connection) est une interface SQL portable, entièrement écrite en Java. Elle permetd’écrire du code portable indépendant du SGBD visé. JDBC fournit deux jeux d’interfaces : une interfaced’application qui permet l’accès aux services SQL de manière indépendante de la base de données et uneinterface de pilote que les éditeurs de base de données doivent adapter à leur base de donnéesparticulière. 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 MySQLPILOTE

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 données utilise un pilote (driver) qui lui est propre et qui permet de convertir lesrequêtes 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 méthodes JNI (Java Native Interface). Certains éditeurs (Oracle) proposent plusieurs versions du driver utilisantune ou l’autre des technologies.

http://developers.sun.com/product/jdbc/drivers









Il existe un « pont » JDBC-ODBC permettant à JDBC d’utiliser une source de données ODBC, donc undriver ODBC pour lequel il n’existerait pas d’équivalent 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 réseau génériqueavec le

serveur

Conversation via API C/ C++ => logiciel client

SGBD

Conversation via

ODBC

Figure 9 : différents types de pilotes JDBC

«interface»

Driver

DriverManager

«interface»

Connection

«interface»

Statement

«interface»

ResultSet

«interface»

DatabaseMetaData

«interface»

PreparedStatement

«interface»

CallableStatement

«interface»

ResultSetMetaData

+fournit1

1

1+fournit0..*

1

+enregistre

0..*

1

+crée

0..* 1

+ramène

0..*

1+fournit1

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 données

Créer la description de requête

Exécuter la requête Traiter les données retournées

Fermer les différents espaces





Exemple

Un exemple complet des techniques de base pour travailler avec une base de donnée depuis unprogramme java :

/** Exemple simple d'accès à une base de données** On utilise le driver MySQL.* Noter qu’il 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 durConnection 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");

// Récupère les donnéeswhile (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 français 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 + ")");System.out.println();

} elseSystem.out.println();

}

// Modification d'un bienSystem.out.println();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));

System.out.println();int nbLignesModifiees =

stmt.executeUpdate("UPDATE BIENS " + "SET PRIX = 1.06*PRIX " + "WHERE ROWID =4");

System.out.println(nbLignesModifiees + " lignes modifiees");

System.out.println();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 première étape est de mettre le(s) Driver(s) adéquat(s) à la disposition des classes.

Class.forName("com.mysql.jdbc.Driver");

La partie la plus difficile est de connaître le nom et la localisation du Driver. Lorsque c’est un driverd’origine Sun, il est dans sun.jdbc…(exemple sun.jdbc.odbc.JdbcOdbcDriver ). Lorsque le Driverest propriétaire, il est en général fourni sous forme d’un jar. Ne pas oublier que celui-ci doit se trouverdans le CLASSPATH.

Connexion à la base de données

Les accès ultérieurs aux données se réalisent par l’intermédiaire d’un 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 très simple. En fonction de l’url demandée, le DriverManager va choisir le Driverappropriépour réaliser la connexion. La seule difficulté ici est de connaître l’url à fournir auDriverManager pour établir la connexion. Cette url est décrite dans la documentation du driver etdépend de la base de donnée considérée. 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 propriétaire) :

Description de la requête

Dans sa forme élémentaire, une requête est envoyée au SGBD par l’intermédiaire de l’objetStatement. On crée l’objet puis on appelle la méthode adéquate pour l’envoyer au SGBD. Pour desrequêtes de type SELECT (qui retournent un résultat), la méthode est executeQuery(), pour desrequêtes de mise à jour (qui ne retournent pas de résultat), la méthode est executeUpdate().

public Statement createStatement()

throws SQLException

Par exemple :

Statement stmt = conn.createStatement();

Requêtes sans résultats

Une requête qui ne retourne aucun résultat est simplement exécutée à l’aide de executeUpdate(). Ilest aussi possible (mais peut utile) d’utiliser execute(). La méthode retourne le nombre de lignesaffectées par la requête.

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 méthode permet aussi d’utiliser les langages de description et de contrôle :

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)");

Requêtes avec résultat

On dispose de nombreuses possibilités pour utiliser l’ordre SELECT. La plus simple est d’utiliser unsimple Statement, avec un ordre SQL écrit « en dur ».

La méthode executeQuery envoie la cha îne d’interrogation SQL au SGBD et retourne un objetResultSet

public ResultSet executeQuery(String sql) throws SQLException

par exemple :

ResultSet rset =stmt.executeQuery("SELECT ROWID, NOM, DATENAISSANCE FROM TIERS");

Le ResultSet est un objet qui peut être « visuellement » assimilé à un « tableau ». Les lignes dutableau sont les tuples de la base retournés par le SELECT, les colonnes du tableau sont les attributsretournés par le SELECT. Le parcours du tableau se fait par la méthode next(). Celle-ci renvoie« VRAI » tant qu’il existe encore une ligne dans le tableau. Les méthodes getXXXX() (getString,getInt, getDouble, …) permettent de récupérer les valeurs des colonnes soit par nom (à partir desattributs du SELECT), soit par position.

ResultSet rset =stmt.executeQuery("SELECT ROWID, NOM, DATENAISSANCE FROM TIERS");

// Récupère les données

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

}

qui aurait aussi pu s’écrire :

// Récupère les donnéeswhile (rset.next()) {

System.out.print(rset.getInt("ROWID"));System.out.print(" - ");

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

Lorsque on souhaite utiliser des variables internes au programme java, une première solution consistebien entendu à utiliser comme instruction SQL une chaîne construite lors de l’exécution du programme,mêlant les instructions SQL et les valeurs des variables. Il faut être particulièrement soigneux sur lasyntaxe SQL (ne pas oublier qu’une chaîne est entourée de guillemets par exemple ….

La deuxième solution consiste à utiliser une instruction préparée PreparedStatement, qui permet de

définir une instruction SQL contenant des paramètres, que l’on peut exécuter plusieurs fois enchangeant la valeur des paramètres.





Parcours du ResultSet

Au moment de sa création, un ResultSet est positionné avant la première ligne. La méthode next() fait avancer le pointeur sur la première ligne réelle de résultat et la rend disponible au programme. Ilfaut donc exécuter next() au moins une fois pour avoir le premier résultat. Les appels suivants fontavancer le pointeur d’une ligne à la fois. C’est la méthode la plus simple pour parcourir un ensemblerésultat.

Si nécessaire, il est aussi possible de parcourir l’ensemble résultat dans un ordre différent. Pour cela, ilfaut préalablement avoir créé l’instruction Statement de manière à supporter le défilement dans lesdeux sens. L’instruction createStatement() existe aussi sous une forme avec deux paramètres quidéfinissent comment on pourra utiliser le ResultSet :

public Statement createStatement(int type, int concur)

throws SQLException

Le premier paramètre définit le type de l’ensemble résultat :

TYPE_FORWARD_ONLY : Le curseur défile seulement vers l’avant

TYPE_SCROLL_INSENSITIVE : Le curseur défile dans les deux sens, mais est insensible auxchangements survenus par le fait d’une autre transaction en cours.

TYPE_SCROLL_SENSITIVE : Le curseur défile dans les deux sens, et les données récupéréessont affectées par les changements survenus par le fait d’une autre transaction en cours.

Le deuxième paramètre définit le type de concurrence de l’ensemble résultat. Il est utilisé notammentlorsque on souhaite mettre à jour ultérieurement 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 qu’il est plus simple de toujours utiliser TYPE_SCROLL_SENSITIVE et

CONCUR_UPDATABLE . Mais bien évidemment, c’est la forme qui consomme le plus de ressources et quiest la plus lente, le SGBD devant mettre en place tous les systèmes de transaction et de verrouillage pourassurer le bon fonctionnement de l’instruction.

Exemple : « Créer un RecordSet permettant un défilement dans les deux sens »

Statement stmt = conn.createStatement(TYPE_SCROLL_INSENSITIVE,CONCUR_READ_ONLY);ResultSet rset =

stmt.executeQuery("SELECT ROWID, NOM, DATENAISSANCE FROM TIERS");

// Récupère les données affichage vers l’avant while (rset.next()) {

System.out.print(rset.getInt(1));System.out.print(" - ");System.out.print(rset.getString(2));

}// Puis repart en arrièrewhile (rset.previous()) {

System.out.print(rset.getInt(1));System.out.print(" - ");

System.out.print(rset.getString(2));}





Les méthodes suivantes sont disponibles dans un ResultSet défilant :

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 méthodes se comprennent d’elle-même. Les méthodes absolute() et relative() prennent un entier comme argument. absolute() positionne le pointeur (lorsque c’est possible) à laligne indiquée en argument. relative() déplace le pointeur (lorsque c’est possible) du nombre delignes indiquées en argument.

Correspondances entre type java et type SQL

JDBC permet de récupérer les données sous la forme Java selon une correspondance définie par Java. Cen’est pas sans poser problèmes vis-à-vis du stockage de données Java, les types SQL étant souvent plus

« pauvres » que les types Java.

C’est 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

Requêtes préparées (PreparedStatement)

Un PreparedStatement est un héritage du Statement qui offre plusieurs bénéfices :

La gestion des « quotes » et plus généralement des types de données est facilitée.

La requête est précompilée par l’optimiseur de requêtes du SGBD et stockée (pour la durée deson existence) dans le cache du SGBD. Si la requête est exécutée plusieurs fois, ce n’est que lapremière fois qu’elle est compilée. Toutes les autres fois, le SGBD va réutiliser la versioncompilée. Au contraire, lorsque on utilise un Statement, celui-ci est recalculé à chaque exécution.

Il y a donc gain de temps lors de l’exécution de requêtes répétitives. Toutefois, il faut avoir quece point n’est pas implémenté 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 créer à partir d’une connexion et d’une chaîne despécification.

public PreparedStatement prepareStatement(java.lang.String sql,

int resultSetType,

int resultSetConcurrency)

throws SQLException

La chaîne sql peut comporter des instructions SQL et des points d’interrogations. Les pointsd’interrogation jouent le rôle de « joker » et seront remplacés lors de l’exécution par les valeurs fournie spar les méthodes setXXX de l’objet preparedStatement. De même que les getXXX pouvaient lire lesvaleurs des colonnes d’après leur numéro, les setXXX remplacent les points d’interrogations selon leurposition. Dans l’exmple suivant, le paramètre 1 (une chaîne) est liée à la valeur « myString » par

l’instruction setString(1, …) ; le paramètre 2 (un entier), est lié à la valeur « 1024 » par l’instructionsetInt(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 requêtes préparées se comportent exactementde la même manière que les requêtes ordinaires.

Accès aux procédures stockées (CallableStatement)

Alors que les requêtes préparées permettent d’accéder à des requêtes similaires, les appels deprocédures stockées poussent plus loin le concept de « boîte noire » pour les accès au SGBD. Uneprocédure stockée est construite dans la base de données avant toute exécution de l’application. Elle es tdonc déjà optimisée et donc s’exécute plus vite que du code SQL dynamique. Par ailleurs, les erreurs desyntaxe dans la procédure stockée sont plus rares, puisque le code de celle-ci a été testé dans le SGBDavant le développement du programme. Enfin la procédure stockée masque les détails de sonimplémentation, en fournissant une espèce d’appel de méthode invoquée sur la base de données, àlaquelle on n’a plus qu’à fournir les arguments et dont on reçoit le résultat.

La contrepartie de cette simplicité apparente est une plus faible portabilité. De part l’existence demultiples dialectes SQL dans le domaine des procédures stockées, un programme faisant appel à desprocédures stockées deviendra moins « portable » d’un SGBD à un autre. Il faudra souvent réécrire les

procédures stockées pour le nouveau SGBD. Parfois même, certaines procédures stockées sont tellementliées à un SGBD donné que le portage devient impossible (c’est souvent le cas pour Oracle versMySQL…).

Pour utiliser un CallableStatement, il suffit de le créer à partir d’une connexion et d’une chaîne despécification.

public interface CallableStatement

extends PreparedStatement

L’interface est fournie sous une forme pour attendre un résultat renvoyé par la procédure stockée et une

fourme qui n’attend pas de résultat. Les deux formes peuvent prendre des paramètres en entrées, quisont enregistrés par des méthodes de type setXXX, héritées de PreparedStatement. Si nécessaire, lavaleur résultat doit être enregistrée avec registerOutParameter() .

JDBC fournit une syntaxe indépendante du SGBD :

CallableStatement cstmt =

con.prepareCall( "{ call sp_A( ? ) }" );

pour une procédure sp_A qui ne retourne pas de résultat, et

CallableStatement cstmt =

con.prepareCall( "{ ? = call sp_B( ? ) }" );

pour une procédure sp_B qui retourne un résultat.

Exemples :

« une procédure qui affiche les clients parisiens et le montant de leurs achats »

CREATE PROCEDURE ClientsParisiens ASselect nom,Articles.code,Magasin.loc,FacturesLignes.Montant

from clients,articles, magasins,FacturesLignes where FacturesLignes.NumFacture = Factures.Numero -- conditions de jointureand Factures.CodeClient = Clients.Code -- conditions de jointureand FacturesLignes.CodeArticle = Articles.Code -- conditions de jointureand Factures.Magasin = Magasins.Code -- conditions de jointure

http://c/DOCUME~1/Jean/LOCALS~1/Temp/Rar$EX00.500/javadoc-spec/java/sql/PreparedStatement.html

http://c/DOCUME~1/Jean/LOCALS~1/Temp/Rar$EX00.500/javadoc-spec/java/sql/PreparedStatement.html





and Magasins.Ville like "PARIS%"

Appel de cette procédure :

CallableStatement cs = con.prepareCall("{call ClientsParisiens }");ResultSet rs = cs.executeQuery();

« une procédure qui affiche les clients parisiens et le montant de leurs achats sur une année donnée »

CREATE PROCEDURE ClientsParisiens(Annee IN NUMBER)

ASselect nom,Articles.code,Magasin.loc,FacturesLignes.Montant

from clients,articles, magasins,FacturesLignes where FacturesLignes.NumFacture = Factures.Numero -- conditions de jointureand Factures.CodeClient = Clients.Code -- conditions de jointureand FacturesLignes.CodeArticle = Articles.Code -- conditions de jointureand Factures.Magasin = Magasins.Code -- conditions de jointureand Magasins.Ville like "PARIS%"and YEAR(FacturesLignes.Date) = Annee


CallableStatement cs = con.prepareCall("{call ClientsParisiens ( ? )}");Cs.setInt(1, 2006) ;ResultSet rs = cs.executeQuery();

« une procédure qui calcule le montant des achats des clients parisiens sur une année donnée. »

CREATE PROCEDURE ClientsParisiens(Annee IN NUMBER, val OUT NUMBER)

ASselect sum(FacturesLignes.Montant) INTO val

from clients,articles, magasins,FacturesLignes where FacturesLignes.NumFacture = Factures.Numero -- conditions de jointure

and Factures.CodeClient = Clients.Code -- conditions de jointureand FacturesLignes.CodeArticle = Articles.Code -- conditions de jointureand Factures.Magasin = Magasins.Code -- conditions de jointureand Magasins.Ville like "PARIS%"and YEAR(FacturesLignes.Date) = Annee


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

Types de données avancées (BLOB et autres …)

JDBC supporte les types de données avancés de SQL3 : les BLOB (Bynary Large OBjects) et les CLOB(Characters Large OBjects). Un CLOB est un type de donnée qui peut contenir un grand nombre dedonnées caractères (un texte par exemple), alors qu’un BLOB peut contenir un grand nombre dedonnées binaires (une image, un film, un son, …)12.

Un CLOB est obtenu par une des méthodes getClob() d’un RecordSet ou d’unCallableStatement . Un CLOB possède des méthodes pour récupérer une sous chaîne des données,la longueur des données, la position d’une sous chaîne ou d’un autre CLOB dans le CLOB courant.

12 Nous ne discuterons pas ici de l’utilité et des avantages/désavantages du stockage de tels objets dans la base de données.L’alternative est évidemment de stocker les objets dans le système de fichier et de n’enregistrer dans la base qu’une référence àl’objet. Chacune des technique a ses partisans et ses adversaires acharnés …





Toutes ces méthodes travaillent sans matérialiser le flot de données. Pour matérialiser ce flot, il faututiliser getAsciiStream() (ou getCharacterStream() pour un stream Unicode) et construireensuite des objets utilisables.

Un BLOB possède des méthodes pour déterminer son nombre d’octets ou la position d’un tableaud’octets ou d’un autre BLOB dans le BLOB courant. Toutes ces méthodes travaillent sans matérialiser leflot de données. Pour matérialiser ce flot, il faut utiliser getBinaryStream() (ou getBytes()) et

construire ensuite des objets utilisables.

Le stockage des BLOB et des CLOB se réalise par les méthodes setBlob() et setClob() des classesPreparedStatement et CallableStatement , ou en utilisant la méthode updateObject() d’unrecordset modifiable.

La création d’un BLOB ou d’un CLOB se réalise par les méthodes setAsciiStream() ousetCharacterStream() (pour les CLOB) et setBinaryStream()ou setBytes() pour les CLOB

Exemples

« lecture d’une 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 d’une image en base de données »

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();

Metadonnées

Le terme « méta » représente l’ensemble des informations sur les données. JDBC fournit deux classespour ces metadonnées : ResultSetMetaData , qui va donner les informations sur les donnéescontenues dans un ResultSet et DataBaseMetaData , qui va donner les informations générales sur labase de donnée.

L’interface DataBaseMetaData est une horreur (approximativement 150 méthodes !), qui permettoutefois d’obtenir assez facilement les informations essentielles comme le nom du driver, le nom de labase, la version, le nombre de connexions disponibles, la conformité avec SQL, …

L’interface ResultSetMetaData est plus abordable. Elle ne comporte que 25 méthodes, permettant parexemple de connaître le nombre de colonnes rtournées, une suggestion pour la taille des colonnes, lesnoms de colonnes, les type de colonnes, …





Il faut en général prendre garde que certains SGBD ne rendent pas les résultats demandés (ou bien quepour ce SGBD donné, ils ne sont pas pertinents). On prendra donc soin avant toute exploitation durésultat, de tester la NULLité éventuelle de celui-ci.

« Exemple de lecture des métadonnées d’un 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();System.out.println("THIS SAMPLE SHOWS HOW TO GET INFO ABOUT DATA TYPES.");

// connect to the 'sample' databasedb.connect();

http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/s-DtInfo-java.htm

http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/s-Util-java.htm


http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/s-DtInfo-out.htm

http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/readme_jdbc.htm


http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/develop_jdbc.htm



http://www.software.ibm.com/data/db2/udb/ad





http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/s-DtInfo-out.htm


http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/ad/samples/jdbc/s-DtInfo-java.htm





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

db.con.commit();

// disconnect from the 'sample' databasedb.disconnect();

}

catch (Exception e){JdbcException jdbcExc = new JdbcException(e);jdbcExc.handle();

}} // main

static void infoGet(Connection con){try{System.out.println();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 databaseResultSet rs = dbMetaData.getTypeInfo();

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

// Get the number of columns in the ResultSetint colCount = rsMetaData.getColumnCount();System.out.println();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 ResultSetSystem.out.println();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();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;

http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/admin/r0000865.htm

http://publib.boulder.ibm.com/infocenter/db2luw/v8/topic/com.ibm.db2.udb.doc/admin/r0000865.htm





Integer columnSize;boolean nullable;boolean caseSensitive;

// Retrieve and display the columns' information in the tablewhile (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 setrs.close();

}catch (Exception e){JdbcException jdbcExc = new JdbcException(e);

jdbcExc.handle();}

}} // DtInfo

Gestion des erreurs

La plupart des méthodes du package java.sql lancent une SQLException, qui nécessite un bloc try …catch comme les autres exceptions. Le but est de permettre de décrire les erreurs liées au driver ou à labase de données, y compris les erreurs de syntaxe SQL. En plus de la méthode standard getMessage(),l’exception SQL dispose d’autres méthodes permettant de tra iter le contexte spécifique aux bases de

données :





getSQLState() renvoi une valeur SQLState basée sur la description des erreurs proposée par leconsortium X/Open.

getErrorCode() renvoie la description des erreurs spécifique au vendeur du SGBD.

getNextException() renvoie la descritoion d’erreur suivante. Cette méthode permet de retrouverla suite des erreurs ayant abouti à un échec.

setNextException() permet au programmeur d’ajouter une erreur à la chaîne d’erreurs.

La gestion typique des erreurs en JDBC devrait ressembler au schéma suivant :

try{

// some DB work} // end trycatch ( SQLException SQLe){while( SQLe != null){// do handling

SQLe = SQLe.getNextException();}

} // end catch

SQLWarning





S Q L E T L 3 G ( C )

Le gain d'instruction SQL/langage est en moyenne de 10. Par contre SQL n'est pas complet, c'estseulement un langage de définition des données et d'accès. Il ne dit rien sur l'interface avec l'utilisateur.Il est donc nécessaire de combiner SQL avec un langage traditionnel, habituellement C ou Cobol, ouéventuellement un générateur de formulaires. On appelle cet autre langage un langage hôte.

Les instructions SQL sont introduites au niveau du source du programme d'application (nécessite uneprécompilation). Il est cependant possible, dans certaines implémentations, de construire uneinstruction SQL de manière dynamique.

EXEC SQL précède toute instruction SQL

Toute instruction SQL est utilisable dans un programme, éventuellement avec de légères variantes. Desinstructions complémentaires sont disponibles.

Une instruction SQL peut se placer partout où une instruction C peut l'être.

Les instructions SQL peuvent faire référence aux variables du langage hôte. Les résultats produits parune instruction SQL peuvent être récupérées dans les variables hôtes.

SQL retourne une information complète sur le déroulement de chaque instruction exécutée (coded'erreur, nombre de lignes extraites ...).

Les curseurs établissent les liens entre ensemble SQL et élément 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

SECTION DECLARE

Contient les déclarations des variables C utilisées dans les instructions SQL, dites variables hôtes. Ellesseront précédées par : (colon) dans les instructions SQL. Les variables peuvent avoir le même nom qu'unobjet SQL (une colonne). C'est le "deux-points" qui fait la différence.

La déclaration est globale pour l'ensemble du programme. On peut introduire plusieurs sections dedéclaration dans un même 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 déclarées selon le même format et avec la même syntaxe

que le langage hôte. Le type de la variable doit être compatible avec le type du champ SQL récupérédans la variable.

Des variables structurées peuvent être utilisées :





EXEC SQL SELECT *into :nom, :salairefrom employes

EXEC SQL SELECT *into :emprecfrom employes

struct{ char enom[20];

int esalaire;} emprec;

Types utilisables (hors structures) :

Type SGBD Type C

integerintegerinteger1integer2smallintinteger

longintintshortshortchar

floatfloat4datemoney

doublefloatchar[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 spécial : 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 génére une structure à partir de la table. On peut ensuite inclure cettestructure dans la section de déclaration des variables.

dclgen c <nom de base> <nom de table> <nom de fichier> <nom de structure>

SECTION DE DECLARATION DES ZONES DE COMMUNICATION C<->SQL

La zone de communication SQL (SQLCA) permet de gérer les erreurs et les warnings concernantl'exécution d'une instruction SQL. C'est une collection de variables prédéfinies qui doivent être incluesdans le programme par

exec sql include sqlca;





UTILISATION DE SQLCA

Explicite : Le programme teste explicitement les variables après un accès à la base.

Implicite : En utilisant l'instruction WHENEVER

exec sql whenever <condition> <action>

Condition

SQLERROR , activée si erreur quelconque (sqlcode<0)SQLWARNING, activée si warning quelconque (sqlwarn[0]='W') NOT FOUND, activée si pas de rangées sélectionnées (sqlcode=100)SQLMESSAGE, activée si une instruction message a été exécutée dans une procédure

(sqlcode=700).

Action

CONTINUE, condition ignorée (sauf si elle est fatale, auquel cas le programme stoppe...)

STOP, arrêt du programme et rollbackGOTO <étiquette>, branchement (en accord avec les règles du langage hôte),CALL <procédure>, appel de procédure du langage hôte. La procédure ne peut pas avoir de

paramètre et ne peut pas exécuter 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 portée d'un WHENEVER

La portée d'un whenever est physique. L'action spécifiée est valable jusqu'au whenever suivant ayant lamême condition. On peut déclarer autant de whenever que désiré dans un programme.

Attention aux boucles infinies !

Dans la mesure où le traitement d'erreur provoqué par le whenever reste actif même dans la routine detraitement d'erreur, il est facile de provoquer des boucles infinies. Il est donc recommandé de placer unwhenever continue comme première instruction du traitement d'erreur.

exec sql whenever sqlerror goto TraiteErreur;...

TraiteErreur:exec sql whenever sqlerror continue;...

Informations remontées par SQLCA

struct {char sqlaid[8]; /*dummy ...*/long sqlabc; /*dummy ...*/long sqlcode; /*0=réussi, <0 erreur en n° erreur, >0struct {

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





rangées */struct {

char sqlwarn0; /* 'W' si warning, détail dans les autres*/

char sqlwarn1;char sqlwarn2;char sqlwarn3;char sqlwarn4;char sqlwarn5;char sqlwarn6;char sqlwarn7;} sqlwarn;

char sqlext[8];}

SECTION 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 ajoutée à une transaction. La transaction n'est pas confirmée (et les verroussur les données ne sont pas levés) tant qu'un commit, un disconnect ou un end transaction n'est pasrencontré. Les transactions sont annulées en cas de rencontre d'un rollback, d'un stop de sqlca, d'un exitanormal, ou d'un dépassement de la taille du journal.

Cas 1 : Traitement d'une seule ligne (un tuple)

Sélection simple

exec sql select 'fruit', nom, prix*2into :categorie, :item, :newprixfrom produitswhere 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 produitsset prix=:prixwhere nom = :item;

exec sql delete from produitswhere nom = :item;

Cas 2 : Traitement d'un tableau (un ensemble de tuples)

Dans certaines implémentations commerciales, il existe des formes modifiées de exec sql qui permettentla répétition de l'instruction. La forme générale se sert de tableaux de variables ou bien des curseurs.





SQL MODE DYNAMIQUE

Les commandes SQL ne sont plus statiques, figées, c'est à dire connues à la compilation. Il est possiblede faire exécuter par un programme des requêtes non prévues à la compilation, introduites parl'utilisateur. Cela permet de retrouver la souplesse du sql interactif, en bénéficiant de la facilité detraitement des erreurs de l'utilisateur du langage. C'est ce mode qui permet de créer des interfacesd'accès évoluées aux bases de données (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 chaîne de caractères (exemple m1.c)

exec sql execute immediate :<var>

La commande est donnée en totalité par l'utilisateur, ou bien complétée. Elle est stockée dans la variablehôte, et exécutée par l'instruction.

Mode 2 : Toute instruction, sauf select, avec en plus des variables hôtes paramétrant la commande quipeut ainsi être exécutée plusieurs fois avec des valeurs différentes des variables hôtes (exemple m2.c)

La commande est d'abord préparée.

exec sql prepare <nom commande> from <chaîne de caractères>

La commande est initialement construite dans une chaîne de caractères. Les paramètres sont spécifiés enutilisant 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 exécutée.

exec sql <nom commande> [using :<var hôte>]

La clause using permet d'utiliser des variables hôtes comme paramètre de la commande.

ex :

exec sql Commande1 using :nom, :age;

Mode 3 : Les commandes select préprogrammées sont possibles, mais les clauses select et from sont

connues à la compilation. Seules les clauses where et order by sont définies dynamiquement (exemplem3.c)

Mode 4 : Tout est permis, mais nécessite un langage à allocation dynamique de mémoire (ni COBOL, niFORTRAN) (exemple m4.c)

La structure du résultat est inconnue ==> le programme doit gérer dynamiquement l'espace nécessairepour les variables hôtes et les intitulés de colonnes.

Le nombre, l'ordre et le type des paramètre ne sont pas connues avant l'exécution ==> le système doitgérer dynamiquement l'espace nécessaire aux paramètre.

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) alorsexec sql execute Cmd1;

sinon/* c'est un select */

exec sql declare Curs1 cursor for Cmd1;exec sql open Curs1;allocation de variables résultats en utilisant descripteur; faire tant que il reste des rangées dans le curseur exec sql fetch Curs1;

using descriptor :descripteur;si ( pas dernière rangée) alors

traitement; fsi;

ftque;desallouer les variables en utilisant descripteur; exec sql close Curs1;

Zone SQLDA

C'est une structure allouée dynamiquement contenant les informations nécessaire au langage hôte poureffectuer son allocation de mémoire. (Cfs p107-110 du Pro*C user's guide d'Oracle ou p54-60 du ESQLuser's guide d'Ingres).

/* p1.c : Mettre à jour une valeur unique. Cette valeur est d'abord recherchée,puis affichée, 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 Numéro de magasin ? ");scanf("%\n",&numero);

EXEC SQL SELECT nom_gerant into :nomFROM magasinsWHERE 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=:nomWHERE mag_num=:numero

EXEC SQL COMMIT WORK RELEASE;





}

/* m1.c : "executer une commande autre que select et sans paramétres */

#include <stdio.h>

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

exec sql end declare section;


main(){

exec sql connect mabase;

exec sql whenever sqlerror goto erreur;

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 whenever sqlerror continue;exec sql rollback work release;exit(1);

}

/* m2.c : "executer une commande autre que select et avec paramétres */

#include <stdio.h>

exec sql begin declare section;varchar instruction[127];int argument;



main(){



printf("\n donner une instruction ");gets(instruction.arr);instruction.len=strlen(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);

exec sql commit work release;exit(0);

erreur:printf("\n %s",sqlca.sqlerrm.sqlerrmc);

exec sql whenever sqlerror continue;exec sql rollback work release;exit(1);

}

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

#include <stdio.h>

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

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 articlewhere ");

printf("\n donner la condition de sélection ");gets(clause_where);strcat(instruction.arr,clause_where);strcpy(final,"for update of art_pv);strcat(instruction.arr,final);instruction.len=strlen(instruction.arr);

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 = :newprixwhere current of Curseur;

exec sql commit work;}

fin1:exec sql open Curseur;

printf("\n Tarif modifié");exec sql whenever not found goto fin2for(;;) {

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;exec sql commit work release;exit(0);


}

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

#include <stdio.h>

exec sql begin declare section;varchar *pinstruction;


exec sql include sqlca;exec sql include sqlda;

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

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

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



if (pinstruction = malloc(256)) {printf("\n Problème malloc pinstruction ");exit(1),}

else {if (psqlda=sqlald(da_nbvar,da_largeur,0)) {

printf("\n Problème 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;exec sql open Curseur;

declist();

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





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

fin:exec sql commit work release;exit(0);


}

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 problème 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 rangée */for (nblg=0;;nblg++);{

/* lecture de la rangée */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;

}

Cours2009

Documents

Transcript of Cours2009