Module 215

Bases de Donnes Avances

SGBD Objet-Relationnel

1 - Gnralits 2 - SQL3 3 - Oracle

Bibliographie

Grard-Michel Cochard cochard@u-picardie.fr

Gnralits
1. Introduction Contenu : 2. Types abstraits de donnes 3. Les objets 4. Modlisation des associations

1. Introduction
Il y a deux limites principales au modle relationnel :
q q

l'approche oriente objet n'est pas prvue : les concepts d'objet, d'hritage, d'encapsulation, .... lui sont trangers. Le modle relationnel ne manipule que des donnes classiques. Il n'existe pas de structures de donnes complexes comme des donnes multimdias ou des tables par exemple.

A partir de ce constat, on peut envisager deux types de solutions : 1re possibilit : abandonner le modle relationnel et construire un nouveau modle "objet" de bases de donnes qui devraient obir aux 13 rgles nonces prcdemment. De tels modles existent mais leur commercialisation sous forme de SGBD est lente et ils ne sont vraiment utiliss que dans des crneaux trs spcialiss. Il faut dire que les diteurs de SGBD relationnels ne sont enclins passer brutalement des modles objets pour des raisons conomiques trs comprhensibles. 2me possibilit : tendre le modle relationnel vers un modle objet-relationnel (il serait plus exact de dire "relationnel-objet"). Il s'agit de rendre le modle relationnel compatible avec les "rgles" objet. De fait, il y a trois extensions essentielles par rapport au modle relationnel standard :
q q q

l'incorporation de structures de donnes complexes : les types abstraits de donnes (TAD en franais, ADT en anglais). l'introduction des objets, notamment via leur identifiant (appel oid : object identifier) la modlisation des associations

Les SGBD commerciaux, bass sur le modle Objet-relationnel sont en gnral issus du modle Relationnel. Citons, parmi les plus connus :

Oracle 8i, 9i

Sybase

DB2

UNISQL

UNISYS

2 - Les types abstraits de donnes

Dans le modle relationnel, les types de donnes sont prdfinis (nombre, caractres, date, ...). Dans le modle objet-relationnel, les types abstraits de donnes (TAD) sont des types d'attributs dfinis par l'utilisateur, incluant des attributs mais aussi des mthodes (fonctions, procdures). Les TAD peuvent aussi tre dfinis partir d'autres TAD. Dans ce qui suit, on utilisera une syntaxe de type SQL pour la description, la manipulation et l'interrogation de donnes. exemple :
q

cration du type Tadresse :

CREATE TYPE Tadresse ( num NUMBER, voie CHAR(30), ville(30), cp (CHAR(10));

q

cration du type Tpersonne :

CREATE TYPE Tpersonne (nom CHAR(30), pnom CHAR(30), adr Tadresse);

q

cration d'une table ANNUAIRE :

CREATE TABLE ANNUAIRE OF Tpersonne

Sur cet exemple, on voit que l'on a incorpor dans une table un objet complexe adr. On peut incorporer ainsi des objets nouveaux comme des images que l'on peut insrer sous forme de BLOB qui est un type prdfini pour des objets de grande dimension. exemple : cration d'une table avec des images stockes dans la base de donnes CREATE TABLE TROMBINOSCOPE (personne Tpersonne, photo BLOB);

Un autre nouveau type est le pointeur qui comme son nom l'indique, dsigne l'adresse d'un tuple. exemple : CREATE TYPE Tadresse (num NUMBER, voie CHAR(30), ville CHAR(30), cp CHAR(10); CREATE TYPE Tpersonne(nom CHAR(30), pnom CHAR(30), adr REF Tadresse); CREATE TABLE ADRESSE OF Tadresse; CREATE TABLE PERSONNE OF Tpersonne;

On peut aussi dfinir des ensembles de donnes que l'on appelle collection. Un tuple peut donc ainsi contenir des attributs non atomiques en violation avec la premire forme normale du modle relationnel. On dit que cette possibilit est NF2 (Non-First Normal Form). exemple : CREATE TYPE Ttelephone (tel CHAR(20)); CREATE TYPE Tpersonne(nom CHAR(40), pnom CHAR(20), listel SET(Ttelephone)); CREATE TABLE PERSONNE OF Tpersonne;

3 - L'objet
En reprenant l'exemple prcdent, on peut imaginer qu'une collection ne comporte pas un nombre fix d'lments et on peut aussi bien en ajouter qu'en supprimer. exemple : dans le TAD prcdent, on peut dfinir les mthodes ajouter_tel() et supprimer_tel() : CREATE TYPE Tpersonne( nom CHAR(30), pnom CHAR530), listel SET(Ttelephone), METHOD ajouter_tel(nouveau_tel Ttelephone), METHOD supprimer_tel(tel Ttelephone)); Cet exemple monter que l'encapsulation des objets est bien mise en oeuvre. Il en est de mme que l'hritage : exemple : supposons que l'on ait dfini le type Tpersonne et que l'on ait deux autres types, Tclient et Tfournisseur, chacun de ces deux types hritant des attributs et des mthodes de Tpersonne.

On dfinira les deux types Tclient et Tfournisseur comme suit : CREATE TYPE Tclient UNDER Tpersonne(numclient NUMBER); CREATE TYPE Tfournisseur UNDER Tpersonne(numfour NUMBER, article CHAR(80)); Les nouveaux types hritent des attributs et mthodes de Tpersonne mais possdent des attributs spcifiques supplmentaires.

Un objet de la base est reprsent par son identifiant oid. L'utilisateur n'a pas s'en soucier. En revanche c'est le SGBD qui l'utilise, de manire transparente, pour rechercher et trouver les objets via leur oid. Pour montrer la diffrence avec le modle relationnel examinons quelques exemples de requtes.

exemple : une cuisine pour collectivits est organise en quipes de cuisiniers ; chaque quipe est dirige par un chef d'quipe. Dans le modle relationnel, on peut reprsenter la situation par une table CUISINIER ( numero, nom, prenom, chef)

Considrons les deux requtes suivantes : R2 : Quels sont les cuisiniers de l'quipe dirige par Alain DUBOIS ?

R1 : Quel est le chef du cuisinier 26 ? La solution, avec SQL2, peut tre : SELECT numero, nom, prenom FROM CUISINIER WHERE numero = (SELECT chef FROM CUISINIER WHERE numero=26);

SELECT numero, nom, prenom FROM CUISINIER WHERE chef = (SELECT numero FROM CUISINIER WHERE nom='DUBOIS' AND prenom = 'Alain');

Dans le modle objet-relationnel, une occurrence de CUISINIER peut tre considre comme un objet (qui sera repr par son oid). Il y a toutefois plusieurs manires de reprsenter la table CUISINIER. 1re reprsentation : utilisation de pointeurs

2me reprsentation : utilisation de tableaux de pointeurs

Passons aux requtes ci-dessus : SELECT c.chef.numero, c.chef.nom, c.chef.prenom FROM CUISINIER c WHERE c.numero=26; SELECT c.numero, c.nom, c.prenom FROM CUISINIER c WHERE c.chef.nom = "DUBOIS' AND c.chef.prenom = 'Alain';

On notera l'criture qui fait usage d'un alias. Un objet point s'crit ainsi alias.pointeur.objet_point.

exemple : Considrons maintenant des requtes sur deux tables. En reprenant l'exemple prcdent, considrons que dans le modle relationnel, la situation est dcrite par deux tables EQUIPE et CUISINIER EQUIPE(numeq, nomeq) CUISINIER(numero, nom, prenom, numeq)

Exprimons les requtes suivantes en SQL2 : R1 : Quels sont le numro et le nom de l'quipe des cuisiniers de prnom "Jean" ? SELECT numero, nom FROM EQUIPE WHERE numeq IN (SELECT numeq FROM CUISINIER WHERE prenom = 'Jean'); ou bien SELECT numero, nom FROM EQUIPE, CUISINIER WHERE prenom = 'Jean' AND EQUIPE.numeq = CUISINIER.numeq ; R2 : Quels sont les numros, les noms et les prnoms des cuisiniers de l'quipe "miammiam" ? SELECT numero, nom, prenom FROM CUISINIER WHERE numeq IN (SELECT numeq FROM EQUIPE WHERE nomeq = 'miammiam'); ou bien SELECT numero, nom, prenom FROM CUISINIER, EQUIPE WHERE nomeq = 'miammiam' AND CUISINIER.numeq = EQUIPE.numeq;

Dans le modle objet-relationnel, on peut envisager 4 solutions

q

pointeurs fils --> pre

SELECT c.equ.numeq, c.equ.nomeq FROM CUISINIER c WHERE c.prenom = 'Jean'; pointeurs pre --> fils

SELECT c.numero, c.nom, c.prenom FROM CUISINIER c WHERE c.equ.nomeq = 'miammiam';

SELECT e1.numeq, e1.nomeq FROM EQUIPE e1 WHERE EXISTS (SELECT REF(c) FROM CUISINIER c WHERE c.prenom = 'Jean') INTERSECT (SELECT e.cui FROM THE(SELECT e2.cui FROM EQUIPE e2 WHERE e2.numeq = e1.numeq) e2)); A noter que THE dsigne la table imbrique.
q

SELECT e1.cui.numero, e1.cui.nom, e1.cui.prenom FROM THE (SELECT e2.cui FROM EQUIPE e2 WHERE e2.nomeq = 'miammiam') e1;

double pointage

SELECT e.numeq, e.nomeq FROM EQUIPE e WHERE e.cui.numero IN (SELECT c.numero FROM CUISINIER c WHERE c.prenom = 'Jean';

SELECT c.numero, c.nom, c.prenom FROM CUISINIER c WHERE c.numero IN (SELECT e.cui.numero FROM EQUIPE e WHERE e.nomeq = 'miamiam');

solution universelle : table de connexion

SELECT co.equ.numeq, co.cui.nomeq FROM CONNEXION co WHERE co.cui.prenom='Jean';

SELECT co.cui.numero, co.cui.nom, co.cui.prenom FROM CONNEXION co WHERE co.equ.nomeq='miammiam';

4 - Modlisation des associations

Dans le modle relationnel, les associations peuvent donner lieu l'introduction de cls trangres ou de nouvelles tables. Examinons comment se prsente la situation pour un modle objet-relationnel. Nous avons, en effet, des possibilits supplmentaires :
q q

utilisation de structures de donnes complexes (tables imbriques notamment) utilisation de pointeurs

Nous avons considrer plusieurs types d'associations : les associations binaires : 1:1, 1:N, M:N et les associations n-aires. associations binaires 1:1

Dans le modle relationnel, le schma correspond usuellement 2 tables ou 3 tables ; il y a en effet 4 possibilits:

Dans le modle objet-relationnel, on peut envisager jusqu' 12 possibilits dont certaines figurent ci-dessous :

associations binaires 1:N

Le modle relationnel offre deux possibilits de reprsentations : une avec 2 tables et une avec 3 tables :

Dans le modle objet-relationnel, on peut envisager jusqu' 12 possibilits dont certaines figurent ci-dessous :

On notera notamment la possibilit de tables imbriques. associations binaires M:N

Le modle relationnel ne fournit qu'une seule possibilit :

Le modle objet-relationnel, par contre, offre 16 + 4p possibilits o p est le nombre de proprits de l'association. Parmi celles-ci :

associations n-aires Nous ne traiterons pas compltement ce cas que l'on peut aisment imaginer la lumire des cas prcdents. On dmontre que le nombre

de possibilits de reprsentations dans le modle objet-relationnel est de (3n + 2 + 2p)2n-1 o n est le nombre de tables du modle entitassociation impliques et p le nombre de proprits de l'association. exemple : considrons le modle relationnel suivant issu du modle E-R :

Voici quelques solutions offertes par le modle objet-relationnel :

SQL3
1. Introduction 2. Les types de donnes dfinis par les utilisateurs 3. Les tables Contenu : 4. Les constructeurs de type 5. Mthodes 6. Hritage 7. Triggers

1. Introduction
La normalisation du langage de requte SQL est pilote par le groupe ISO/IEC JTC1/SC 21/WG3 DBL. Les travaux de ce groupe sont rsums ci-dessous : SQL2 : 1 document de rfrence SQL3 : 9 composants : SQL/Framework : cadre gnral SQL/Foundation : fondements essentiels SQL/CLI : interface client SQL/PSM : procdures stockes SQL/Bindings : intgration dans les langages classiques SQL/Transaction : gestion des transactions SQL/Temporal : gestion du temps SQL/MED : accs aux donnes externes SQL/OBJ : intgration aux langages objet Cette normalisation est issue d'une riche historique rappele ici pour mmoire : SEQUEL 1 (1974) de System R (IBM) SEQUEL 2 (1977) SQL1 (ANSI : 1986 ; ISO : 1987 ; rvision en 1989 ; tests de validation effectus par le NIST - National Institute of Standards and Technology) SQL2 (ou SQL92, 1992) : 600 pages de spcification SQL3 (SQL99, 1999) : 1500 pages de spcification SQL4 : travaux dmarrs en 2001 Les SGBD qui suivent les prescriptions de SQL3 sont appels SGBD "Objet-Relationnel". Nous n'avons pas d'autres dfinition, en effet, de ce qu'est un SGBD Objet-Relationnel. Il faut toutefois remarquer que si l'on s'en tient strictement cette dfinition, il n'existe pratiquement pas de SGBD Objet-Relationnel !. Mais il existe des SGBD s'en rapprochant : Oracle8-9+, Informix9+ notamment. Les principes gnraux de SQL3 sont les suivants :
q

SQL3 veut incorporer l'objet tout en gardant les acquis du modle relationnel (et de SQL2). Notamment le concept de relation (table) reste central. SQL3 s'appuie sur des donnes fortement types (type = attributs + mthodes). Le processus de cration d'lments

d'une base de donnes comporte 3 tapes : cration des types ncessaires ; cration d'lments conformment ces types ; insertion de ces lments dans des tables existantes (si ces lments sont des objets, ils deviennent alors automatiquement persistants). SQL3 reprend tous les acquis de SQL2 et notamment les types prdfinis (considrs comme atomiques) : DECIMAL, FLOAT, INT, ....... et aussi les types des objets "grands" comme LOB (Long OBject) comportant CLOB (LOB de type caractre), BLOB (LOB de type binaire : une image par exemple), BFILE (fichier). SQL3 permet (nouveaut !) la cration de types par les utilisateurs. Il en existe 2 catgories : le type DISTINCT, et le TAD (Type Abstrait de Donnes, en anglais ADT) de nature complexe.

On suppose dans tout ce qui suit que le lecteur a une bonne connaissance de SQL2.

2 - Les types de donnes dfinis par les utilisateurs

Dans SQL2, pour le modle relationnel, les types de donnes sont prdfinis : CHAR, VARCHAR, NUMBER, DATE, .... Dans SQL3, pour le modle objet-relationnel, des types nouveaux peuvent tre dfinis par les utilisateurs : le type DISTINCT et les TAD. Les TAD se subdivisent en TAD littral et TAD objet. Type DISTINCT Ce type permet une personnalisation des donnes. Ainsi, un prix d'achat et un prix de vente peuvent s'exprimer par le type prdfini DOUBLE PRECISION. Mais si l'on veut caractriser ces deux entits (et les "distinguer") , on peut "redfinir" DOUBLE PRECISION en crant deux "sous-types" : CREATE DISTINCT TYPE pachat_t AS DOUBLE PRECISION; CREATE DISTINCT TYPE pvente_t AS DOUBLE PRECSION; CREATE TABLE Produit1 ( numP VARCHAR(10), pa pachat_t, pv pvente_t ); Dans l'criture prcdente, des conventions sont implicitement respectes : les noms des tables dbute par une lettre majuscule et un type est dclar avec un suffixe "_t" et son nom dbute avec une lettre minuscule. Un tuple, de mme que son schma, est dfini entre parenthses.

TAD littral Les TAD littraux portent sur les colonnes des tables relationnelles. On peut regrouper par exemple deux colonnes (dont les champs correspondent des types diffrents) en dfinissant un type pour ce regroupement. exemple : En reprenant l'exemple prcdent, o la table Produit1 possde 3 champs (3 colonnes), on peut regrouper les deux champs pa et pv en dfinissant un nouveau type : CREATE TYPE deuxPrix_t ( achat pachat_t, vente pvente_t ); CREATE TABLE Produit2 ( numP VARCHAR(10), prix deuxPrix_t ); SELECT p.numP, p.prix.achat FROM Produit2 p WHERE p.prix.vente > 100;

TAD objet Contrairement aux TAD prcdents, les TAD objet concernent les lignes des tables, c'est dire les tuples. Le mot cl correspondant est ROW. exemple : CREATE TYPE adresse_t ( num VARCHAR(6), voie VARCHAR(40), ville VARCHAR(30), codepostal INT); CREATE ROW TYPE personne_t( numSS INT, nom VARCHAR(30), prenom VARCHAR(30), adresse adresse_t); CREATE TABLE Personne OF personne_t(PRIMARY KEY numSS); SELECT p.nom, p.prenom, p.adresse FROM Personne p WHERE p.adresse.codepostal=80170; Cette sorte de TAD est appele "objet" dans la mesure o les lignes d'une table peuvent tre considres comme des objets et peuvent (voir plus loin) tre rfrences comme une entit indpendante, la rfrence jouant, en quelque sorte le rle d'un identifiant d'objet mais n'est toutefois pas identique un oid. Le type ROW explicit plus loin peut aussi tre considr comme reprsentant un objet.

3 - Les tables
Les tables restent centrales dans SQL3. Tout ce qui concerne les tables en SQL2 est valable en SQL3 (c'est la moindre des choses !). On peut toujours crer des tables relationnelles classiques ou des tables relationnelles en NF2 ou encore des tables d'objets.
q

tables relationnelles classiques

exemple : CREATE TABLE Personne ( nom VARCHAR(30), prenom VARCHAR(30), telephone NUMBER) ;
q

tables relationnelles en NF2

Elles peuvent tre cres en utilisant des constructeurs de type comme ROW() ou LIST() exemple : CREATE TYPE adresse_t(num VARCHAR(5), voie VARCHAR(30), ville VARCHAR(30), codepostal INT); CREATE TABLE Personne ( numero INT, adresse adresse_t, identit ROW(nom VARCHAR(30), prenom VARCHAR(30)), postes LIST(ROW(bureau INT, tel VARCHAR(10))) PRIMARY KEY numero);

tables d'objets

Bien que le mot objet n'existe pas dans la syntaxe SQL3, il est implicitement prsent dans le modle lorsque l'on utilise le mot cl OF. exemple : CREATE ROW TYPE personne_t ( nom VARCHAR(30), prenom VARCHAR(30), telephone NUMBER) ; CREATE TABLE Personne OF personne_t (PRIMARY KEY nom) ; Dans ce cas, toute instance de la table possde un oid connu du systme.

4 - Les constructeurs de type

Comme leur nom l'indiquent, ils servent construire des types donns. Nous en avons vu un exemple prcdemment avec ROW() et LIST(). Il existe trois catgories de constructeurs de types :
q

q q

le constructeur ROW qui permet de regrouper un nombre fixe de champs de types diffrents : le type obtenu est donc un tuple. les constructeurs de collection : SET, LIST, MULTISET qui permettent de regrouper plusieurs lments de mme type le constructeur REF qui permet de dfinir des rfrence (pointeurs) vers des objets.

constructeur ROW Il est assez naturel d'emploi et est quivalent la dclaration ROW TYPE sauf que ROW() s'utilise l'intrieur de la cration d'une table : exemple : CREATE ROW TYPE adresse_t ( num VARCHAR(5), voie VARCHAR(30), ville VARCHAR(30), codepostal INT); CREATE ROW TYPE identite_t( nom VARCHAR(30), prenom VARCHAR(30)); CREATE TYPE Personne ( numero INT, identite identite_t, adresse adress_t); est quivalent CREATE TYPE personne_t ( numero INT, identite ROW( nom VARCHAR(30), prenom VARCHAR(30)),

adresse

);

ROW( num VARCHAR(5), voie VARCHAR(30), ville VARCHAR(30), codepostal INT)

Le constructeur peut s'utiliser lors d'une instanciation. exemple : reprenons l'exemple prcdent CREATE TABLE Personne OF personne_t; INSERT INTO Personne VALUES ( '1234', ROW( 'DUPONT', 'Aristide'), ROW( '13', 'bd Saint-Michel', 'PARIS', '75005') ); Dans les requtes, il faudra utiliser la notation "." pour slectionner des champs particuliers : SELECT p.identite.nom, p.adresse.codepostal FROM Personne p WHERE p.adresse.ville = "PARIS';

constructeurs de collections Une collection contient des lments de mme type (contrairement au ROW). SQL3 dfinit 3 constructeurs de collection :

L'utilisation des constructeurs est trs naturelle. exemple : CREATE ROW TYPE adresse_t ( num VARCHAR(5), voie VARCHAR(30), codepostal INTEGER ville VARCHAR(30), ); CREATE TABLE Annuaire ( identite ROW(nom VARCHAR(30), prenom VARCHAR(30)) NOT NULL, domiciles LIST(adresse_t), hobbies SET(VARCHAR(50)) ); INSERT INTO Annuaire VALUES ( ROW ('DUPONT', 'Aristide'), LIST( ROW( '14', 'bd Saint-Michel', '75005', 'PARIS')::adresse_t, ROW( '13', 'rue Andr Chnier', '80000', 'AMIENS')::adresse_t),

);

SET('Tennis','Guitare','Sudoku')

Il existe aussi une criture plus simple pour la clause INSERT : INSERT INTO Annuaire VALUES (('DUPONT', 'Aristide'),(ROW( '14', 'bd Saint-Michel', '75005', 'PARIS'), ROW( '13', 'rue Andr Chnier', '80000', 'AMIENS')), ('Tennis','Guitare','Sudoku')); Quelques oprateurs sont utiliss pour les collections : IN, NOT IN, CARDINALITY. IN et NOT IN permettent de savoir si un lments figure dans une collection. CARDINALITY donne simplement le nombre d'lments d'une collection. exemple : SELECT p.identite.nom, p.identite.prenom FROM Annuaire p WHERE 'Sudoku' IN p.hobbies; SELECT p.identite.nom, p.identite.prenom, CARDINALITY(p.hobbies) FROM Annuaire p WHERE 'Sudoku' IN p.hobbies;

Constructeur de rfrence Rappelons qu'un lment est considr comme un objet ds qu'il est plac dans une table avec OF. Un objet possde un oid (identifiant) unique qui est gnr automatiquement par le systme. Rappelons aussi qu'il est immuable, non rutilisable aprs disparition de l'objet correspondant. Dans SQL3, l'oid d'un objet de type T est rfrenc par REF(T). Contrairement au modle O-O, une rfrence un objet peut tre affiche dans le modle O-R. Une rfrence peut tre dclare dans un type ou dans une table. exemple : supposons deux types dfinis a priori, un type personne et un type equipe_t (on suppose qu'une personne du type personne_t correspond une seule quipe du type equipe_t. On dsire relier ces deux types par une rfrence :

CREATE OR REPLACE BODY TYPE personne_t ( nom VARCHAR(30), prenom VARCHAR(30), affectation REF(equipe_t)); On peut aussi utiliser le constructeur REF() directement dans la cration d'une table. exemple : CREATE TABLE binome ( personne1 personne2

REF(personne_t), REF(personne_t));

Considrons maintenant les deux requtes suivantes : SELECT p.affectation FROM Personne p WHERE p.nom = 'Dupont'; SELECT p.affectation->nomeq FROM Personne p WHERE p.nom = "Dupont';

La premire requte fournira seulement l'adresse de l'quipe correspondant la personne 'Dupont' ce qui n'est pas en gnral trs utile. La seconde requte fournira le nom de l'quipe laquelle est affect la personne 'Dupont'. Elle est quivalente : SELECT e.nomeq FROM Personne p, Equipe e WHERE p.nom = 'Dupont' AND REF(e) = p.affectation;

5 - Mthodes
Nous avons signal que SQL3 est bas sur un typage fort, c'est dire que le type inclut les attributs mais aussi les mthodes. Comment SQL3 dfinit-il les mthodes ? Il faut distinguer la dclaration de la dfinition. La dfinition s'effectue la cration du type selon la syntaxe vidente : CREATE TYPE nomtype_t ( attributs dclaration ou dfinition des mthodes); La dfinition des mthodes peut se faire lors de la cration du type (CREATE) comme la syntaxe prcdente le montre ou lorsque l'on modifie le type (REPLACE). La dfinition d'une mthode ncessite un langage de programmation qui peut tre interne( c'est le cas de PL/SQL dans Oracle) ou externe (C ou C++ pu Java). exemple : le type personne_t contient la mthode personne_t() qui ajoute une personne (c'est un constructeur de type !). CREATE TYPE personne_t ( nom VARCHAR(30), prenom VARCHAR(30), FUNCTION personne_t( :nom VARCHAR(30), :prenom VARCHAR(30)) RETURNS personne_t; :p personne_t; /* dclaration locale */ BEGIN :p := personne_t(); /* constructeur */ :p.nom := :nom; :p.prenom := :prenom; RETURN :p; END;); La mthode personne_t() est ici dfinie compltement dans le type. On pourrait seulement la dclarer : CREATE TYPE personne_t ( nom VARCHAR(30), prenom VARCHAR(30), FUNCTION personne_t( :nom VARCHAR(30), :prenom VARCHAR(30) RETURNS personne_t); ); Evidemment il faudra dfinir, dans ce dernier cas la fonction personne_t() ailleurs, c'est dire hors du type personne_t. SQL3 fournit aussi un certain nombre de fonctions utilitaires comme des fonctions de comparaison et des fonctions de conversion que nous n'explicitons pas ici.

6 - Hritage
On peut considrer deux types d'hritages : l'hritage de type et l'hritage de table. L'hritage de type permet de dfinir des sous-types avec le mot cl UNDER. exemple : CREATE ROW TYPE personne_t ( nom VARCHAR(30), prenom VARCHAR(30)); CREATE ROW TYPE professeur_t UNDER personne_t ( categorie VARCHAR(10), discipline VARCHAR(20)); CREATE ROW TYPE etudiant_t UNDER personne_t ( diplme VARCHAR(10), numero INTEGER); On notera qu'il suffit d'ajouter les proprits nouvelles. L'hritage de table s'effectue galement avec le mot cl UNDER exemple : CREATE TABLE Personne ( nom VARCHAR(30), prenom VARCHAR(30)); CREATE TABLE Professeur UNDER Personne ( categorie VARCHAR(10), discipline VARCHAR(20)); CREATE TABLE Etudiant UNDER Personne ( diplme VARCHAR(10), numero INTEGER);

7 - Triggers
Un trigger (ou dclencheur) excute un programme en fonction d'vnements particuliers, notamment une mise jour par INSERT, UPDATE, DELETE).Les caractristiques d'un trigger sont les suivantes :
q q

un trigger est associ une table un trigger comprend deux sections : la description de l'vnement dclencheur et la description du traitement effectuer il y a deux catgories de triggers : le "row trigger" qui est un dclencheur pour un vnement particulier (mise jour d'un tuple par exemple) et le "statement trigger" qui est un dclencheur pour une srie de mises jour un trigger ne peut effectuer des manipulations sur la table qui lui est associe (IMPORTANT !)

La syntaxe de dfinition d'un trigger est la suivante : CREATE TRIGGER <nom_trigger>

(AFTER | BEFORE) <vnement> ON <nom de table> FOR EACH ROW BEGIN --- actions --END; exemple : CREATE OR REPLACE TYPE equipe_t ( numeq NUMBER, nomeq VARCHAR(30), effectif NUMBER) ; CREATE OR REPLACE TYPE cuisinier_t AS OBJECT ( numero NUMBER, nom VARCHAR(30), prenom VARCHAR(30), affectation NUMBER) . CREATE TABLE Equipe OF equipe_t (CONSTRAINT knumeq PRIMARY KEY(numeq) ) ; CREATE TABLE Cuisinier OF cuisinier_t ( CONSTRAINT knumero PRIMARY KEY(numero), CONSTRAINT fknumeq FOREIGN KEY(affectation) REFERENCES Equipe(numeq) ); La cration de deux tables Cuisinier et Equipe permet d'obtenir une situation analogue celle-ci :

Crons maintenant des triggers (de type row) sur la table Cuisinier : un trigger TIcuisinier pour l'ajout d'un cuisinier, un trigger TDcuisinier pour la suppression d'un cuisinier, un trigger TUcuisinier pour une mise jour d'un cuisinier existant. CREATE OR REPLACE TRIGGER TIcuisinier AFTER INSERT ON Cuisinier FOR EACH ROW BEGIN UPDATE equipe SET effectif = effectif + 1 WHERE numeq = NEW.affectation; END; CREATE OR REPLACE TRIGGER TDcuisinier AFTER DELETE ON Cuisinier FOR EACH ROW BEGIN UPDATE equipe SET effectif = effectif - 1 WHERE numeqq = :OLD.affectation; END; CREATE OR REPLACE TRIGGER TUcuisinier AFTER UPDATE OF affectation ON Cuisinier FOR EACH ROW BEGIN UPDATE equipe SET effectif = effectif - 1 WHERE numeq = :OLD.affectation; UPDATE equipe SET effectif = effectif + 1 WHERE numeq = :NEW.affectation; END; On notera que c'est la table Equipe qui est affecte par l'action du trigger et non pas la table Cuisinier (les triggers sont associs cette dernire table). Une autre formulation de la cration des triggers est donne ci-dessous : CREATE OR REPLACE TRIGGER TIDUcuisinier AFTER INSERT OR DELETE OR UPDATE OF affectation ON Cuisinier FOR EACH ROW BEGIN

IF (INSERTING) THEN UPDATE Equipe SET effectif = effectif + 1 WHERE numeq = :NEW.affectation; END IF; IF (DELETING) THEN UPDATE Equipe SET effectif = effectif 1 WHERE numeq = :OLD.affectation; END IF; IF (UPDATING(affectation)) THEN UPDATE Equipe SET effectif = effectif 1 WHERE numeq = :OLD.affectation; UPDATE Equipe SET effectif = effectif + 1 WHERE numeq = :NEW.affectation; END IF; END; exemple : nous procdons ici la mise jour automatique de plusieurs tables (Cuisinier, Equipe) partir d'une vue (Personnel) . Une vue se cre comme en SQL2. CREATE VIEW Personnel AS SELECT c.numero, c.nom, c.prenom, c.affectation, e.nomeq, e.effectif FROM Cuisinier c, Equipe e WHERE c.affectation = e.numeq; CREATE TRIGGER TIpersonnel INSTEAD OF INSERT ON Personnel BEGIN INSERT INTO Cuisinier VALUES ( :NEW.numero, :NEW.nom, :NEW.prenom, :NEW.affectation); UPDATE Equipe SET effectif = effectif + 1 WHERE numeq = :NEW.affectation; END; INSERT INTO Personnel VALUES (31, 'DUCHEMIN', 'Berthe', 4);

Oracle
1. Introduction Contenu : 2. Types abstraits de donnes 3 - Notions de PL/SQL

<chapitre encore en chantier>

1. Introduction
On considre parfois Oracle comme le premier SGBD Relationnel (1979). Toujours est-il qu'il s'est maintenu jusqu' aujourd'hui la premire place des systmes commercialiss. Il a su voluer du relationnel vers l'Objet-Relationnel depuis la version 8 complte par la version 8i qui intgre des fonctionnalits Web et multimdia. La version 9i intgre de nouveaux types de donnes (XML) et permet la construction d'entrepts de donnes. LA version actuelle est 10i. Il possde l'intrt majeur d'tre implmentable sur les deux principaux systmes d'exploitation Unix (et Linux) et Windows. Il est videmment concurrenc aujourd'hui par des SGBD libres et OpenSource. Par rapport aux 13 rgles dfinissant un SGBD Objet, le produit Oracle se positionne de la manire suivante (on se base ici sur Oracle8i) :
q q

q q q q q q q q q q

q q

objets composites : les types abstraits de donnes (TAD) dfinis par l'utilisateur permettent de dfinir des objets composites. identits d'objet : le concept d'identifiant existe encapsulation : oui, mais... classes, types, mthodes : TAD et tables permettent le concept hritage : hum.... surcharge et liaison dynamique : oui pour la surcharge extensibilit : oui langage de programmation OO : PL/SQL (limit) en interne et C++ et Java en externe. persistance des donnes : tout objet stock dans une base Oracle est persistant. grande quantit de donnes : la version 8 peut stocker thoriquement 512x1015 octets. partage des donnes et gestion d ela concurrence : Oracle propose une architecture NCA (Network Computing Architecture) permettant d'accueillir jusqu' 15 000 utilisateurs. fiabilit des donnes : dclaration de contraintes dans les tables ; dclenchement par triggers. langage de requte : SQL3 partiellement.

On voit donc que Oracle 8i et ses successeurs intgrent un nombre non ngligeable de concepts du modle objet. Dans ce qui suit, on ne s'intressera qu'aux apports d'Oracle par rapport au modle relationnel et SQL2.

2 - Types abstraits de donnes

Oracle 8 permet la cration de TAD spcifiques que SQL3 ne prvoit pas :
q q

le type OBJET les types du genre " COLLECTION " : VARRAY et NESTED TABLE

Le type OBJET Il est dfini de la faon suivante : CREATE TYPE <nom du type> AS OBJECT ( attribut 1 DATATYPE, attribut 2 DATATYPE, --------------------------, attribut n DATATYPE, [dfinition de mthode] ); Les mthodes sont des fonctions ou des procdures qui sont stockes dans la base (PL/SQL, Java) ou l'extrieur de la base (langage C). exemples : CREATE TYPE personne_t AS OBJECT ( nom VARCHAR(30), telephone VARCHAR(20) ); CREATE TYPE article_t AS OBJECT ( code VARCHAR(30), qte NUMBER, pu NUMBER(10,2) ); On peut ensuite utiliser le mot cl OF pour utiliser ce type : CREATE TABLE Personne OF personne_t; CREATE TABLE Article OF article_t; Il faut faire une distinction entre les tables types et les tables non types. Une table type est dclare l'aide d'un Tad comme dans l'exemple prcdent (CREATE TABLE <nom_table> OF <nom_type>). Un table non type est dfinie directement (CREATE TABLE <nom_table> (......attributs......)). Dans les tables types, les lignes de la table sont des objets possdant un oid. Dans les tables non types, les lignes de la table ne sont pas des objets (et ne possdent pas d'oid). On peut extraire l'oid avec REF() (SELECT REF(e) FROM <nom_table> e) ; si la table est non type, une erreur est retourne.

Le type COLLECTION Il permet la cration d'attributs multivalus et correspond aux deux possibilits VARRAY et NESTED TABLE.
q

VARRAY

tableau 1 dimension d'lments du mme type ; le tableau a une taille variable. CREATE TYPE <nom1 du type> AS ARRAY(nmax) OF <nom2 de type> exemple : rpertoire de clients pouvant avoir chacun 3 adresses au maximum CREATE TYPE client_adr_t AS OBJECT ( num NUMBER, voie VARCHAR(30), ville VARCHAR(30), cp NUMBER) ; CREATE TYPE adresses_t AS VARRAY(3) OF client_adr_t; CREATE TYPE client_type AS OBJECT( nomclient VARCHAR(30), adresses adresses_t); CREATE TABLE Client OF client_type;

NESTED TABLE

Ce type correspond un ensemble non ordonn et non limit d'lments de mme type CREATE TYPE <nom1 de type> AS TABLE OF <nom2 de type> exemple : description d'un stock d'articles CREATE TYPE article_t AS OBJECT ( nomart VARCHAR(30), qte NUMBER, pu NUMBER(10,2) ); CREATE TYPE tab_article_t AS TABLE OF article_t ; CREATE TYPE stock_t AS OBJECT ( categorie VARCHAR(30), liste tab_article_t); CREATE TABLE Stock OF stock_t; exemple : description d'une commande CREATE TYPE article_t AS OBJECT ( numart INTEGER;

qtecom INTEGER); CREATE type com_article_t AS TABLE OF article_t; CREATE TYPE ligne_com_t AS OBJECT ( numcom INTEGER, datecom DATE, numcli INTEGER, articles com_article_t); CREATE TABLE Commande OF ligne_com_t;

3 - Notions de PL/SQL

PL/SQL (Procedural Language / SQL) est une extension de SQL dans le SGBD Oracle. PL/SQL est structur en blocs

La section "declare" comprend des dclarations concernant les constantes, les variables, les curseurs. a) variables et constantes La dclaration suit la syntaxe suivante :

b) curseurs Un curseur dsigne un ensemble de tuples destins tre traits un par un. La dclaration d'un curseur suit la syntaxe suivante :

exemple : CURSOR cuisinier_cur (num NUMBER, name VARCHAR(30) ) IS SELECT prenom FROM cuisinier WHERE numero = num AND nom = name ;

La section place entre BEGIN et END comporte principalement des instructions reprenant des ordres de type SQL et des lments de langages spcifiques. exemple : declare maxnum cuisinier.numero%TYPE; begin SELECT MAX(numero) INTO maxnum FROM cuisinier; maxnum := maxnum + 1; end Noter le signe d'affectation (:=). PL/SQL possde des structures itratives (boucles) de trois types : indfinie, "while", "for" :

PL/SQL possde aussi des structures conditionnelles :

exemple (heureusement irrel !): IF nomsalarie = 'TARTEMPION' THEN salaire := salaire*2; ELSEIF salaire > 10000 THEN salaire := salaie/2; ELSE salaire := salaire*3; ENDIF; Examinons maintenant sur un exemple l'emploi de curseurs. exemple : tri, dans une table emploi, des salaris dont le salaire est infrieur 2000 et augmentation des salaires de ceux-ci de 100 : declare CURSOR salcur IS

SELECT * FROM emploi WHERE sal < 2000; salarie emploi%ROWTYPE; begin OPEN salcur; LOOP FETCH salcur INTO salarie; UPDATE emploi SET sal := sal + 100 WHERE numsal = salarie.numsal; EXIT WHEN salcur%NOTFOUND; END LOOP; end;

La section begin ....end peut aussi contenir des exceptions que l'on place dans une zone spciale "exception". Une exception est un vnement "non attendu" ; PL/SQL prvoit les actions entreprendre en ce cas. Oracle fournit des exceptions prdfinies : NO_DATA_FOUND : pas de rsultat une requte TOO_MANY_ROWS : plus d elignes qu'il n'est prvu CURSOR_ALREADY_OPEN : curseur dj ouvert INVALID_CURSOR : curseur invalide (en principe non dclar). L'utilisateur peut aussi dfinir ses propres exceptions ; il faut alors les dclarer dans la section "declare" par exception_i EXCEPTION; puis dfinir un traitement dans la zone "exception" : begin ----------exception WHEN <exception_1> THEN <instructions_1>; -----------------------------------------------------WHEN <exception_n> THEN <instructions_n>; end;

PL/SQL permet de dfinir et d'utiliser des procdures et des fonctions :

exemple : CREATE TABLE T (num1 INTEGER, num2 INTEGER); CREATE OR REPLACE PROCEDURE remplir(IN x NUMBER, OUT y NUMBER, INOUT z NUMBER) AS BEGIN y := x*z; z := z*z; INSERT INTO VALUES (x, z); END; declare a NUMBER; b NUMBER; begin a := 5; b := 10; remplir (2, a, b); a := a*b; end; IN signifie "lecture seule", OUT signifie "criture seule", INOUT signifie "lecture-criture". Aprs appel de la procdure, a = 20, b = 100 puis a devient 2000.

Bibliographie
G. GARDARIN Christian SOUTOU EL MASRI, NAVATHE Bases de Donnes, Objet et Relationnel Objet-relationnel sous Oracle 8, Modlisation avec UML Fundamentals of Database Systems Eyrolles Eyrolles International Edition

Webographie
q

Gamache - Modle tape : du relationnel vers le modle objet-relationnel, via le navigationnel - Chapitre 3 http://www.ift.ulaval.ca/~agamache/IFT19023/H2005/ecrans/3_Mnav.pdf#search=%22Mod%C3%A8le%20navigationnel%20MNAV%22

Gamache - Modle Objet-Relationnel - Module 4 http://www.ift.ulaval.ca/%7Eagamache/IFT19023/H2006/ecrans/pageOR.html

Gardarin : l'objet-relationnel http://www.prism.uvsq.fr/~gardarin/objsql3/sld001.htm

SQL3 Object Model http://www.objs.com/x3h7/sql3.htm