Modèle d'implantation Objet-Relationnel

Modèle Objet-Relationnel (Oracle)

ou
Modèle pour les données non normalisées
Sous-Module 4A

(v. 2005-07-02)
 Représentation LINÉAIRE du modèle NF2

➢ L'objet relationnel (OR) repose sur la forme FN1 seulement, le relationnel

(R) sur la forme FN3, …
Terminées les formes nomales supérieures… retour à la réalité !
Mais attention aux pièges qui mènent vers l'incohérence…

➢ Représentation linéaire :
R (A1( A11, A12), A2, A3, A4(A41, A42(A421, A422, A423, A424)))
où
A2, A3 sont des attributs à valeur atomique

A1 et A4 sont des attributs de 1er niveau de type table (relation)

A42 attribut de 2e niveau de type table .

2 sur 94
Représentation ARBORESCENTE du modèle NF2 avec attributs complexes

➢ R ( A1( A11, A12), A2, A3, A4(A41, A42(A421, A422, A423)))

R Niveau 0

A1 A2 A3 A4 Niveau 1

Niveau 2
A11 A12 A41 A42

A421 A422 A423 A424

3 sur 94
 Rappel sur le Modèle étendu de NF2

➢ Pistor et Andersen VLDB (1986) propose une généralisation de NF2 :

1 Intégrant le modèle NF2 « Non First Normal Form » au modèle relationnel;

2 Permettant la combinaison des constructeurs d'objets : tuple,

set, collection;

3Les opérateurs Nest et Unnest sont intégrés au NF2

4- Le modèle NF2 n'a pas d'héritage!

Le modèle OR l'implémente de plus en plus…présent avec Oracle 10g, …

Ce modèle étendu est le début des implantations du genre OBJET-

RELATIONNEL de Oracle, Informix, …

4 sur 94
 Modèle objet-relationnel (OR)
Le modèle géré par Oracle 10g est OR parce qu'il peut gérer simultanément
les modèles relationnel et objet.

Avantages:
- Gère aussi les bases relationnelles très nombreuses (le legacy);
- Conserve les notions de tables qui sont bien comprises en terme de logique et de
physique;
- Permet l'encapsulation des données : implémentation des opérateurs
- Implémente les principaux mécanismes de l'objet : méthode, héritage, redéfinition
et surcharge;
- Capitalise sur les acquis par une évolution du SGBD relationnel en service;

Inconvénients :
- N'utilise pas la notion de classe et implémente une extension (container) de
structure unique (soit la structure de table);
- N'implémente pas l'héritage multiple;
- N'est pas conforme à la norme ODMG;
- Utilise la notion explicite de REF qui est en quelque sorte un pointeur logique

5 sur 94
 Quelques définitions: Structure, type et opération
➢ Structure complexe : structure de données (différente de celles dites
atomiques : entier, float, chaîne, …) pour stocker des données en
conservant (sauf exception) une relation d'ordre entre elles:
Exemples: vecteur, tableau, ensemble, liste, arbre AVL, arbre-B, …

➢ Un type est implémenté par une structure généralement complexe, le TAD

(Type Abstrait de Données) ou ADT à laquelle des méthodes ou des
opérations sont associées afin de gérer le comportement du TAD. Un
nouveau type est construit à partir des types existants ou définis au moyen
de constructeurs de types pré-définis ou définis par l'utilisateur.

➢ L'accès aux données se fait exclusivement au moyen des opérations dont

l'implémentation est masquée à l'utilisateur (encapsulation).

➢ Absence en OR: La notion de classe a un type et des interfaces; les objets

sont créés à son image. Cette notion apparaîtra qu'en BD OO.

6 sur 94
 Conventions d'écriture des types
1. Atomique ou de base : int, number, string, varchar(), carchar2(),… (15 en R,
indéfini en OR).

2. Tuple : [A1:t1, A2:t2,…] où A1 est un attribut et t1 un type avec l'écriture suivante

aussi équivalente: (A1:t1, A2:t2,…) ou avec le remplacement des [ ] par les ( ).
Exemple :employe := (no : int , nom: string, adresse: (no : int, rue: sting))
En Oracle le type d'un tuple a le nom de la table suffixé par ' _type' ou '_t'

3. Ensemble (notation linéaire): { t1 } où t1 est un type et { } représente l'ensemble

typé.
4. Le nom d'une classe ou le nom d'une table débute par une lettre majuscule. Le
type est défini et son nom est suffixé par _t et débute par une lettre minuscule.

5. Un attribut primaire est marqué par l'astérisque *. Avec un seul attribut primaire
dans une classe, il en constitue la clé primaire.
Exemple: Personne: [nom*: string, age*: int,
histoSal: { [annee:string, montant:float] }, ville: ville_t]

7 sur 94
 Constructeur de type
➢ Les types simples ou d'usager peuvent être combinés pour former des types plus
complexes.
➢ Passage du navigationnel à l'objet-relationnel :
Les structures ou classes (interne et externe) du Mnav sont des types OR:
La structure externe instantie un type objet de table, tandis que celle interne
objet colonne.

➢ Un objet est produit (généré) avec un type lorsque le constructeur de type est
appelé implicitement (par le NEW) ou explicitement par le constructeur de type:

➢ En Oracle : le nom du constructeur de type est idem au nom du type

Exemple:
adresse_t est le type de l'attribut adresse, alors adresse_t() est son constructeur.
Des valeurs sont structurées dans un objet en appelant le constructeur de type :
ex. : adresse_t (24, 'des Lilas', 'Québec')

Le tuple de valeurs est transformé en objet (doté d'un oid), et devient persistant
en OR dès son insertion dans une table. Le constructeur est souvent utile pour
initialiser un objet dès sa création.
v_employe_t := NEW employe_t ( 123, 'Jacques', 55); -- PL/SQL

8 sur 94
 Objet et valeur typée

Objet : une paire (oid, valeur typée) oid Valeur typée

Interfaces

oid est l'identifiant unique d'un objet (Object Identifier); généré par le
système et marquant l'objet qui en principe ne change pas durant le
cycle de vie d'un objet.

La valeur d'un objet est une structure généralement complexe.

Souvent un tuple ( [ ] = record) formé de données typées simples et
complexes.

** La valeur d'un objet peut être aussi vue comme un objet non persistant,
i.e. sans oid.

9 sur 94
 Relationnel-Objet (OR)

En OR les types complexes sont disponibles et sont extensibles

Create type adressse_t as Object (no int, rue varchar2(50))

/
Évolution des types par ajout d'un attribut ou d'une méthode :

ALTER TYPE adresse_t ADD ATTRIBUTE lieu varchar2(50);

Voir Describe adresse_t.

La notion de classe (= structure générique) est rendue approximativement par

le type de la Table.

Imbrication des tables OR (Oracle 8, limitée à 1, illimitée avec Oracle9i et +);

Une table OR typée a des tuples (qualifiés d'objets persistants, avec pour
chacun, un OID)

10 sur 94
 Suite… Nouveau type : REF (OR)

REF : type OR permettant la navigation sous-tendue dans le Mnav.

C'est une référence vers un objet, construit avec l'oid (+ le rowid)

Navigation possible entre les tables d'une base OR en utilisant le type REF:
formulation d'une requête plus simple et éventuellement accès plus rapide;
Employe Domicile Create type employe_tAs Object (noE
noE:int int, nomE varchar2(50),
no
rue refAdresse REF domicile_t);
nomE: string
refAdresse telD
Select E.nomE, E.refAdresse.telD
From Employe E
Where E.refAdresse.rue = 'desPignes';
refAdresse est un attribut de Employe de type REF référant à une autre table typée
Domicile

11 sur 94
 OID de l'objet

➢ Un oid est un identifiant unique jamais réutilisé qui caractérise un objet.

➢ L'oid peut être généré par le système ou dérivé des données selon la
spécification définie pour chaque table objet.

➢ Une table relationnelle n'a pas de oid pour les tuples.

➢ Oid compose une REF:

REF := oid + metadonnée + [rowid].

A. Gamache Objet-Relationnel 12:4A

14 sur 94
 Affichage de l'oid d'un objet de table typée

➢ Oid visualisé (codé hexadécimal); ne peut être modifié par programmation.

Affichage de l'oid d'un objet de table objet :
employe_t : (mat:int, nom: varchar, metier :varchar)
Select Ref(v)
From Employe v En OR alias est nécessaire
Where v.mat = 350; Si la table Employe est déclarée
avec un oid SYSTEM
GENERATED

8BC6FCA……………7654DD687DDAC23 (32 car. Hex.)

Affichage de la valeur de l'objet ou de l'objet sans oid (non persistant):
Select Value(p) -- l'objet fournit sa valeur (sans oid )
From Employe p Where Where p.mat = 350;

A. Gamache Objet-Relationnel
13 sur 94
 Différences entre table typée et non typée du OR

➢Table typée réfère à un stock non ordonné d'objets (avec oid). Chaque
objet peut avoir en sus une ou plusieurs colonnes d'objets (objets-colonnes).

Exemple table typée :

Create type employe_t as Object
(matricule int, nom varchar(50), adresse adresse_t ) ;
/
employe_t et adresse_t sont des types usager (UAD).

2 tables possibles:

=> Create table Employe of employe_t; -- (table typée)

 Create table Employe (matricule int, nom varchar(50), adresse adresse_t); --(table non typée)

 Tuple de la table typée est un objet avec son oid.

 Tuple de la table non typée a un rowid seulement

 Objet de colonne : instance de adresse_t dans un tuple (non typé) de Employe n'a pas de oid propre
mais est persistant via l'objet hôte. C'est une caractéristique de OR et non pas de OO.

14 sur 94
 Persistance d'un objet

➢ Un objet en OR devient persistant après sa création dans un applicatif :

- lorsqu'il est inséré dans une table typée: Insert Into …;

- lorsqu'il est inséré dans un objet hôte persistant.

Un objet persistant n'a pas besoin d'être écrit explicitement dans la BD par
l'applicatif; le SGBB s'en charge automatiquement.

15 sur 94
 Les objets OR (Oracle)
➢ Objet de table Oracle typée (OT)
Objet avec oid correspondant à un tuple ou une ligne de la table typée.

➢ Objet-colonne Oracle (OC)

'Objet' sans oid ayant un type (structure) défini et composant un autre objet
d'une table typée ou non. Un objet-colonne peut contenir un autre objet colonne.
L' objet-colonne est persistant parce qu' intégré dans un autre objet (son hôte).

Création d'un objet: par son constructeur de type : employe_t() ou adresse_t().

Un objet doté d'un oid est alors persistant. Un objet de colonne dans un objet de table,
il est aussi persistant.

Insert into Chef values

( chef_t(99, 'Sergiu', adresse_t( 23, 'rue des Roses', 'Québec'), 45));
** le 1er constructeur, chef_t() est facultatif, car il correspond au type de la table.

16 sur 94
 Objet colonne dans une table typée ou non

➢ Une table non typée donc essentiellement relationnelle peut contenir un

objet-colonne.

Exemple:

Create Type employeur_t as object (noEmployeur int, nomEmployeur)

/
Create Table Employe (nas int, nom varchar2(50), employeur employeur_t);

17 sur 94
Initialisation par défaut des objets-colonnes

18 sur 94
 Initialisation de l'OC par défaut dans une table non typée

Initialisation d'un attribut et d'un objet colonne (OC):

➢ Create Type adr_t as object (no int, rue varchar2(50), ville varchar2(50));

➢ Create table Cadre (

matE int,
nomE varchar2(50) DEFAULT 'inconnu',
Adr adr_t DEFAULT adr_t(100, 'des Roses', 'Québec') -- OC
);

Insert into Cadre (matE, nomE) values (100, 'Desbiens');

Insert into Cadre values ( 101, 'Desbiens', DEFAULT); -- la valeur défaut
Insert into Cadre values (102, 'Desbiens', NULL); -- objet vide
Insert into Cadre values (103, 'Desbiens', adr_t(null, null,null)); -- objet null

19 sur 94
 Suite …

➢ SQL> Select * From Cadre c;

MATE NOME ADR(NO, RUE, VILLE)

100 Desbiens ADR_T(100, 'des Roses', 'Québec')

101Desbiens ADR_T(100, 'des Roses', 'Québec')

102 Desbiens -- objet vide

103 Desbiens ADR_T(NULL, NULL, NULL) –objet null maj possible

➢ Affichage de la valeur des objets de Cadre.

20 sur 94
 Mise à jour dans une table non typée (objet colonne)

- Mise à jour de l'objet nul:

Update Cadre c SET c.adr.no =99 Where c.matE = 103;
Select * From Cadre c Where c.matE = 103;

Un objet mis à jour et plus particulièrement son objet colonne :

MATE NOME ADR(NO, RUE, VILLE)

103 Desbiens ADR_T(99, NULL, NULL)

- Mise à jour de l'objet-colonne vide du matE = 102: -- non modifiable

Update Cadre c SET c.adr.no =99 Where c.matE = 102 *

ERREUR à la ligne 1 :
ORA-02309: violation de NULL atomique

21 sur 94
 Initialisation d'une table typée avec objet-colonne vide et null

Create Type adr_t as object (no int, rue varchar2(50), ville varchar2(50));
Create Type employe_t as Object (matE int, nomE varchar2(50), adr adr_t);

Create table Employe of employe_t

(Constraint df_nom nomE DEFAULT 'inconnu');

Insert into Employe values (employe_t(101, 'Desbiens', NULL)); –objet vide

Insert into Employe values (employe_t(104, 'Desbiens', adr_t(null, null,

null))); -- objet null

Avec le Default : ????

Insert into Employe1 values (employe_t(104, DEFAULT,adr_t(23, 'rue des
Lilas', 'Qc')));
** expression absente : n'accepte pas le DEFAULT avec table typée

22 sur 94
 Affichage des objets (table typée) et des valeurs

➢ Affichage des objets : Select Value(o) From Employe o ;

VALUE(O) (MATE, NOME, ADR(NO, RUE, VILLE))

EMPLOYE_T(101, 'Desbiens', NULL) -- objet OC vide
EMPLOYE_T(104, 'Desbiens', ADR_T(NULL, NULL, NULL)) – OC Null

Affichage des valeurs d'objet: SQL> Select * From Employe;

MATE NOME ADR(NO, RUE, VILLE)

101 Desbiens ---objet vide—
104 Desbiens ADR_T(NULL, NULL, NULL)

23 sur 94
 Mise à jour de l'objet-colonne d'une table typée
Update Employe p SET p.adr = adr_t(99, null, null)
Where p.matE = 103;
SQL> Select * From Employe;

MATE NOME ADR(NO, RUE, VILLE)

103 Desbiens ADR_T(99, NULL, NULL) -- OC mis à jour
101 Desbiens -- objet vide---

Mise à jour de l'objet vide OC (matE = 101)

Update Employe p SET p.adr = adr_t(88, null, null)
Where p.matE = 101;

MATE NOME ADR(NO, RUE, VILLE)

103 Desbiens ADR_T(NULL, NULL, NULL)
101 Desbiens ADR_T(88, NULL, NULL) -- objet mis à jour ???

24 sur 94
 Création des objets nul et vide
Create type metier_t as Object(metier varchar2(25), classe char(1));
Create type employe_t as Object (mat int, metier metier_t);

➢ Declare
v employe_t ;
n employe_t ;
o employe_t ;
Begin -- le constructeur employe_t() exige une valeur pour tous ses paramètres.
v := NEW employe_t(250, NULL); --objet vide
n := NEW employe_t (500, metier_t(null, null)); -- objet nul
o := NEW employe_t (500, metier_t('technologiste', 'A')); --objet initialisé
Insert into Employe values(o); -- objet o rendu persistant
End;
L'objet v est vide et non modifiable; l'objet n est null et modifiable. L'objet o
est initialisé par le constructeur.

25 sur 94
 Méthode de l'objet OC : objet vide et null

➢ Un objet-colonne peut avoir ses propres méthodes. Le partage, comme la

création d'une autre table objet sur la base du type de l'OC est possible et
ses méthodes deviennent celles de la nouvelle table objet.

➢ Les méthodes propres au type metier_t ne s'appliquent pas à un objet

vide, v.

➢ Les méthodes de metier_t peuvent s'appliquer à l'objet o.

26 sur 94
 Persistance des objets OR (Oracle)

➢ Objet-colonne persistant si son hôte-objet est un objet de table (OT)

❑ Insertion de l'objet hôte dans une table rend l'objet de colonne (qui n'a
pas de oid) persistant. Indexation possible des objets colonnes via.
Méthodes possibles avec ces objets.

➢ Objet de table (ligne/tuple) : indexation possible des objets via leur oid
❑ Correspond à un tuple ou à une ligne dans une table et chacun a un
oid.
Ces objets peuvent être indexés et partitionnés.
Création avec le INSERT et les constructeurs de type approprié.

27 sur 94
 Persistance des objets OR (Oracle)

➢ Objet de travail non persistant

Objet sans oid, mais ayant une valeur et manipulée via des variables
PL/SQL (déclencheur, procédure, bloc)

Création d'un objet non persistant (dans une procédure PL/SQL) par la
Directive NEW de PL/SQL :
…
v_empl employe_t; -- déclaration d'une var en PL/SQL
v_empl := NEW employe_t (123,…..); -- empl est une variable PL/SQL

Représente un objet non persistant qui le deviendra par un Insert

Un objet devient persistant lorsqu'il inséré dans une table OR

28 sur 94
 Suppression d'objets / types OR-Oracle
➢ Via la suppression d'une table : DROP table Employe;
Entraîne la suppression des objets, des privilèges et des index éventuels
définis sur cette table.

Rend inopérant les composants dépendants : déclencheurs (triggers),

vues.

➢ TRUNCATE TABLE Employe ;

Supprime que les objets et non les index,…. Les composants demeurent
en place et éventuellement seront de nouveau opérationnels.

➢ Suppression forcée d'un type

DROP TYPE empoye_t FORCE;

– suppression même si des objets sont rattachés au type. Objets restent
dans la base et sont temporairement invalides.

29 sur 94
 Contraintes définies au niveau des tables

➢ Une contrainte est toujours définie au niveau de la table et non au niveau

du type qui est partageable avec d'autres tables qui n'ont nécessairement
les mêmes contraintes.

➢ Contraintes de table: clé primaire, clé étrangère, Unicité, Check, …

Create table Employe of employe_t

(Constraint pkEmploye Primary Key (mat),
Constraint c_salaire Check(salaire is not null and salaire < 99999.00));

La définition suivante est INTERDITE:

Create type employe_t (mat int, salaire number (8,2),
Constraint pkEmploye Primary Key (mat),
Constraint C_salaire check(salaire is not null and salaire < 99999.00);
/

30 sur 94
 Différences entre table typée et non typée

➢ Table non typée évolue plus facilement : ex. Ajout d'un attribut age dans
la table non typée Employe .

Raison: le MR normalisé sous-tend la présence d'un attribut dans une seule

table.

❑Création d'une table temporaire avec le schéma de Employe

Create table Tempo (matricule int, nom varchar(50) adresse adr_t);
Insert into Tempo Select * from Employe;
❑ Création de la nouvelle table : (Drop table Employe)
Create table Employe (matricule int, nom varchar(50) adresse adr_t,
age int);
❑ Rangement des tuples stockés dans la table Tempo:
Insert into Employe Select * from Tempo;

*** âges absents sont alors représentés par des indicateurs de NULL.

31 sur 94
 Suite … différences entre table typée et non typée
Plus difficile (?) éventuellement avec table typée:
Ajout de age dans la table typée Employe:

Raison :
Répercussion possible sur d'autres tables partageant le type employe_t ou sur
un autre type défini avec employe_t (sous-type).
Create table Employe of employe_t;
Alter type employe_t ADD attribute age int;

Si le type employe_t est utilisé comme objet de colonne dans les types :
cadreSup_t delegue_t chef_t

L'âge peut ne pas être utile! Le type modifié est marqué Type Evolving.
Doit alors être recompilé. Directive : recompile

32 sur 94
 Méthode incluse dans le type

La table typée peut avoir des signatures de méthode de son type (ex. :
Member Procedure via son type): ajout et suppression d'une méthode;

Alter type employe_t ADD Member Procedure augmentationSal (s IN number);

Alter type employe_t DROP Member Procedure augmentationSal (s IN number);

** Le type de la signature excluded la longueur : Number et non Number(8,2),

varchar2 et non varchar2(50), …

NB : L'évolution d'un type avec le ALTER change le type dans la base mais pas
celui placé dans la cache. Pour voir le changement, il faut vider la cache en se
déconnectant et en créant une nouvelle connexion (nouvelle session).

33 sur 94
 Création d'une table OR non typée

SQL> Create Type adr_t as Object (no int , rue varchar(40)) ; /

--création de la structure (TAD)
Type created.
SQL> desc adr_t ; -- description du type adr_t
Name Null? Type

NO NUMBER(38)
RUE VARCHAR2(40)

Chaque attribut d'une table OR a cependant un type.

Create Table Employe (mat int, nom varchar(50), adr adr_t);

Table created -- l'attribut adr a le type adr_t.

Les objets de cette table OR n'ont pas de oid et non référençables par un REF.

A. Gamache Objet-Relationnel

34 sur 94
 Insertion dans une table non typée sans oid et sans REF

Insert into Employe values (55, 'Gagnon', adr_t(25, 'Lilas'));

Insertion d'une valeur dont un élément est un objet OC ** En OR, le
constructeur de type porte le nom du type.
-- adr_t() est aussi un constructeur d'instance de type (un objet, si fait
persistant).

Comme le tuple n'a pas de oid, impossible donc d'afficher ce dernier!

-- Ref() une fonction pour afficher le oid

Select Ref(z) -- fonction Ref exige une variable objet

From Employe z; -- erreur car absence de oid pour les tuples
-- d'une table non typée.

35 sur 94
 Table OR typée (rangement des objets OR)

Les objets (tuples) de cette table sont typés:

SQL> Create table Adresse of adr_t; -- la table est basée seulement sur un TAD
La table ne contient que des objets avec oid:

Insert into Adresse values (adr_t(250, 'Chemin St-Louis'));

1 row created. -- 1 tuple objet-relationnel avec oid (séquelle du relationnel)

Notez l'usage du constructeur adr_t() qui retourne un objet : (= valeur + oid).

Un objet de la table Adresse est une instance d'un type + 1 oid:
Select Ref(z) -- Ref une fonction pour afficher le oid

From Adresse z; -- fournit le oid des objets de Adresse via l'alias

36 sur 94
 Suite… affichage d'un objet rangé dans une table typée

Le résultat affiché est un objet représenté dans l'environnement SQLPlus par

son constructeur et la valeur de l'objet.

La recherche d'un objet ne requiert pas l'usage de son constructeur et

l'affichage avec * fournit que les valeurs.
Select * From Adresse ;
NO RUE .
250, Chemin St-Louis

Rien ne laisse croire que la réponse est composée d'objets !

Qu'affiche alors : Select Value(p) From Adresse ?
La présence du constructeur de type rappelle que c'est un objet qui est affiché
par l'utilitaire SQLPlus!

37 sur 94
 Mnav de Employe et sa transposition en OR

Employe Employe
matricule * matricule *
nom nom
Cas B
Cas A histSal histSal

histoSal_t histoSal_t
annee: Date annee
SalNet
salNet : real refSal
montantBrut
chargesSoc

➢Dans le OR, la table est le concept de base pour référer aux données via les
tuples-objets ou les tuples-non-objets : la table est le container d'objets les
rendant persistants.

38 sur 94
 Représentation tabulaire avec une table typée et un lien multi et intra

Cas A: Exemple : Vision tabulaire avec Employe de type employe_t :

Employe: employe_t
matricule*:int nom:varchar(50) histoSal:{ }
annee salNet
1234 Savoie 2000 45K$ Une 1ère collection
2001 46K$
1456 Lachance 2003 38K$

1. La table OR typée par employe_t a 3 attributs: matricule, nom et histoSal ;

2. Chaque attribut a un nom et un type soit atomique soit complexe;
3. L'attribut histoSal est une collection de tuples formés avec deux attributs, [annee
et salNet] . Chaque objet (tuple) identifié par un matricule peut inclure un
ensemble de salaires comme valeur d'attribut (une instance de l'objet colonne)

A. Gamache Objet-Relationnel

39 sur 94
 Objet avec Collection (instances)

➢ La table précédente Employe contient 2 objets :

➢ Le 1er objet : l'objet de table qui contient un (instance de) objet-colonne

de type collection lui-même formé d'objets-colonnes qui n'ont pas de oid.

[1234, 'Savoie', { [2000, 45K$], [2001, 46K$]}

le 2e objet : contient aussi une collection d'un seul objet de colonne.

[1456, 'Lachance', { [2003, 38K$] }

40 sur 94
 Suite… Vision tabulaire du cas B avec table typée et un lien mono externe

Description graphique de la table typée employe_t avec des références:

cas B: Employe: employe_t
matricule:int nom:varchar(50) histoSal:{ }
annee refSal
1234 Savoie 2000
2001 1 objet

1456 Lachance 2003

SalNet : montantBrut chargesSoc

50K$ 5K$
49K$ 3K$
1. L'attribut net est un pointeur (type Ref) vers un objet de la table SalNet;
2. L'attribut histoSal est un set de tuples défini par les attributs annee et le lien refSal
3. La sous-table intégrée est une vision logique, pas nécessairement une implantation
physique.

41 sur 94
 Représentation graphique d'une table et d'un objet OR

➢ La structure de table du modèle R comme container logique des objets

repris en OR.

➢ La table OR est une structure logique de rangement à laquelle les

énoncés SQL se réfèrent via ses attributs, que la table soit typée ou non.
Employe: matricule* nom schéma de table OR

123 Gérin Tuple ou objet

de table OR

Select E.matricule From Employe E

Where E.nom = 'Gérin' ;

Le type des attributs complexes n'est pas utilisé directement dans la

formulation des requêtes SQL.
A. Gamache Objet-Relationnel

42 sur 94
 Exemple de schéma de table non typée (tuples)

Create Table AdresseReg (reg number, adr adr_t) ; Schéma de table non typée

AdresseReg: reg : number adr : adr_t

noRue rue ville codePost

Les instances de cette table OR non typée n'ont pas de oid. Ce sont des tuples
avec un rowid ayant cependant un attribut qui est un objet-colonne (adr).
Le constructeur rappelle que c'est un objet-
Select p.reg, p.adr. p.codePostal colonne et que l'accès aux valeurs doit se
From AdresseReg p; faire par une interface.

p.reg p.adr p.codePostal

8 adr_t ( 23, 'laRose', 'Québec', 'G1D 5W3')

43 sur 94
 Imbrication des types (partage de types)
Type utilisant un autre type déjà défini. Ce partage est mal représenté avec le
Mnav. Il y a alors dépendance du type etudiant_t sur adr_t

Create type adr_t as Object ( noRue int, ville varchar2(50), codePostal varchar2(6)) /
Create type etudiant_t as Object (reg number, adr adr_t) /
Create type professeur as Object (reg number, adrP adr_t)/
Partage de type

Create Table Etudiant OF etudiant_t;

Etudiant: etudiant_t
nas adr : adr_t
noRue rue ville codePost

Les instances de cette table ont un oid, donc sont des objets.
Le type adr_t est imbriqué dans celui de etudiant_t et partagé entre
etudiant_t et professeur_t.

44 sur 94
 Vision tabulaire des types partagés par les tables
Exemple : (*** CREATE OR REPLACE***) Table typée pour ranger des objets

CREATE Type adr_t as Object (noRue NUMBER, rue varchar2(30), ville varchar2 (20),
codePost varchar2 (10) ) ; / -- sans méthode

adr_t
Un type
noRue rue ville codePost

Ex. 2 tables typées partageant le même type (structure) :

Create Table Adresse of adr_t;
Adresse: adr_t
noRue rue ville codePost

1234 Des Piments Lévis G4S 3E2

Create Table Coordonnee of adr_t;

Coordonnees: adr_t
noRue rue ville codePost

23 De la Rose Québec G4T 1X3

A. Gamache Objet-Relationnel

45 sur 94
 Création de type incomplet et d'une Référence inverse
Avec Oracle, un type peut utiliser qu'un type déjà existant.
Aucune définition anticipée, shadowed. C ( c1: int , c2: ref)

La référence inverse est définie via un type incomplet. D ( d1:int , d2: ref)

Create type c_t ; / --- type incomplet

Create Type d_t as Object ( d1 int, d2 REF c_t) ; /

Create or Replace c_t as object ( c1 int, c2 REF d_t); -- mise à jour du type

Ou ALTER type c_t ADD Attribute c1: int;

ALTER type c_t ADD Attribute c2: int;

46 sur 94
 Accès à un attribut (idem pour une méthode)

➢ Pour accéder à la valeur d'un attribut (ou à une méthode via un objet) d'un
type, utilisez la notation pointée.

Ex.:
Create Type atelier_t (nomA varchar2(50), adrA varchar2(5), refD REF
description_t)
Atelier Description
nomA* texte
nomObjet.nomAttribut adrA refA
Ex.: Atelier.nomA refD photo
modifAtelier
nomObjet.nomAttributRef.nomAttribut
Navigation via une ref
Ex.: Atelier.refD.texte -- navigation vers l'autre classe
nomObjet.nomMethode() – appel de la méthode de cet objet
Ex.: x.modif où x est un objet de Atelier

47 sur 94
 Représentation tabulaire du lien entre implémenté par REF

➢ CREATE type etudiant_t as Object(nas number, refBac REF bac_t, adr adr_t ) ; /

➢ CREATE type bac_t as Object(nomB char(20), moyResultats99 number); /

Etudiant: : etudiant_t

adr : adr_t
no:int refBac: Ref
noRue: int ville: codePost:
rue: varchar varchar2
varchar2

Bac:
bac_t Attribut composé

nomB: varchar2 anCreationB:Date moyResultats99B

A. Gamache Objet-Relationnel

48 sur 94
 Ref avec les données de tables typées : défini dans le type

➢ CREATE TABLE Bac OF bac_t ;

➢ CREATE TABLE Etudiant OF etudiant_t ;

Bac : nomB anCreationB moyResultats99

IFT 1982 75

Gestion 1992 85

Etudiant: : etudiant_t

adr : adr_t
no:int refBac: Ref
noRue: int ville: codePost:
rue: varchar varchar2
varchar2

122 7 Jean Dijon G1K 1S3

A. Gamache Objet-Relationnel

49 sur 94
 Avantage du REF dans une recherche (jointure implicite)

La recherche du no des étudiants et de l'année de création de leur

programme IFT nécessite pas de jointure explicite grâce à la REF. Il y a
navigation entre les tables. Dans le R, la formulation de la jointure sera
explicite.
Select b.no, b.refBac.anCreationB (OR)
From Etudiant b
Where b.refBac.nomB = 'IFT';

En relationnel il faut l'ajout de l'attribut nomB (dans Etudiant) partageant un

domaine commun (clé étrangère) avec les tables R correspondantes pour
formuler explicitement une jointure:
Select E.no, B.anCreationB (R)
From Etudiant E, Bac B

Where E.nomB = B.nomB And B.nomB = 'IFT';

50 sur 94
 Ref déclarée dans une table non typée

Personne Table non typée

Bac Table typée
nas*: int noB* : char(3)
nom:varchar2(50) univ: varchar3(50)
@bac_t annee: Date
refBac
nbCr : int

Chercheur Create Table Personne (nas int, nom varchar2(50),

refBac REF bac_t, Constraint pk_Personne Primary Key
theme: varchar2(50)
(nas), Constraint c_bac Check(refBac is not null));

ajoutMail(…) Insertion d'une référence dans un tuple de Personne:

-Insert into Personne values (10, 'Gingas',
(Select Ref(b) From Bac b where b.noB = 'IFT'));
--insertion d'une Ref null avec rejet par la contrainte:
Insert into Personne values (20, 'Dussault', NULL);

51 sur 94
 Ref déclarée dans une table typée

Personne Table typée Bac Table typée

nas*: int
noB* : char(3)
nom:varchar2(50)
@bac_t univ: varchar3(50)
refBac
annee: Date

nbCr : int

Chercheur Create Table Personne of personne_t

theme: varchar2(50)
(Constraint pk_Personne Primary Key (nas),

ajoutMail(…)
Constraint c_bac Check(refBac is not null),
Constraint c1_bac refBac REFERENCES Bac)) ;
Insertion d'une référence dans un objet de Pe rsonne:
-Insert into Personne values (personne_t(10, 'Gingas',
(Select Ref(b) From Bac b where b.noB = 'IFT')));

52 sur 94
 Opérations avec les types: création, suppression, …

➢ Création d'un type:

Create or Replace type .. As object (…);
Interdit de type pour: Boolean, rowid, Long, Long Raw, %Type

➢ Description d'un type : Directive Describe fournit les attributs et leur type
Desc [ribe] personne_t

➢ Suppression d'un type:

Drop type personne_t [FORCE| VALIDATE]
❑ Force : force la suppression du type même si des objets l'utilisent; les
objets demeurent dans la BD mais deviennent inaccessibles;
❑ Validate: vérifie s'il y a substitution de type par les sous-types

➢ Synonyme du type : Create Synonym inventaire_t FOR stock_t;

53 sur 94
Implémentation de la contrainte référentielle en OR

54 sur 94
 Contrainte référentielle en OR

➢ La cohérence d'une BD relationnelle est assurée par l'intégrité

référentielle.

En objet, cette même cohérence est prise en charge au moyen de la

contrainte REFERENCES

➢ Deux cohérences à assurer:

❑ Insertion dans la table enfant: Cohérence des objets de la table enfant:

ce dernier ne peut pas référer a un objet du parent absent.

❑Suppression dans la table parent: Cohérence des objets de la table

parent : ce dernier ne peut pas être supprimé si un REF de la table
enfant y réfère;

55 sur 94
 Cohérence des tables Atelier et Ouvrier

Cohérence du parent: suppression dans Atelier

Cohérence de l'enfant : insertion dans Ouvrier

Mnav Ouvrier
Atelier Ouvrier mat*
nomA* mat* nom
1 1..* Atelier
adrA Travaille > nom nomA* ville
ville refA
UML adrA

(parent) (enfant)

A. Gamache Objet-Relationnel

56 sur 94
 Contrainte référentielle avec table typée (objet)

➢ Create type atelier_t as Object (nomA varchar2(50), adrA varchar2(50))

/
➢ Create type ouvrier_t as Object (mat char(6), nom varchar2(50), ville
varchar2(50), refA REF atelier_t)
/
➢ Create Table Atelier of atelier_t
(constraint pk_Atelier Primary Key (nomA));

➢ Create Table Ouvrier of ouvrier_t

(Constraint pk_Ouvrier Primary Key (mat),
Constraint c1_refAtelier check( refA is not null),
Constraint c29_refAtelierrefA REFERENCES Atelier);

57 sur 94
 Suite … intégrité référentielle avec les oid et table typée

➢ Delete from Atelier Where nomA = 'AtelierQuébec'; -- cet objet existe!

Cette suppression du parent peut engendrer une incohérence de l'enfant. Il

peut y avoir un ouvrier qui pointe vers un atelier (parent). Donc un atelier est
supprimé même s'il y a des ouvriers qui y travaillent ! Anomalie potentielle.
Avec l'intégrité référentielle déclarée en relationnelle cette suppression serait
interdite.

Correction de cette faiblesse avec la clause REFERENCES :

Create Table Ouvrier of ouvrier_t (Constraint pk_Ouvrier Primary Key (mat),

Constraint c_Atelier Check( refA IS NOT NULL),
Constraint ref_Atelier refA REFERENCES Atelier) ;
La suppression de l'atelier est bloquée par la contrainte ref_Atelier assurant la
cohérence du fils.
Par contre, la suppression ne serait pas bloquée avec le SCOPE IS

58 sur 94
 Suite … intégrité référentielle avec les oid et table typée

Insertion d'un fils (cohérence de l'enfant)

Insert into Ouvrier values ( '123', 'Ferland', 'Québec', (Select Ref(a) From
Atelier a Where a.nomA = 'AtelierQuébec'));
*** Erreur *** l'atelier (parent) recherché n'existant pas.

Cohérence de l'enfant est vérifiée : le Select ne trouvant pas d'objets retourne

un null dont l'insertion est interdite par la contrainte c1_refAtelier de Ouvrier
qui interdit la référence null.

59 sur 94
 Contrainte référentielle avec une table non typée (relationnelle)

Ouvrier
mat*

Atelier nom
nomA* ville

adrA refA

parent enfant

Create Table Ouvrier (mat char(6), nom varchar2(50), ville varchar2(50),

refA REF atelier_t ,
Constraint c_refA refA SCOPE IS Atelier, -- ref limitée à la table Atelier
Constraint pk_Ouvrier Primary Key (mat),
Constraint c1_refA Check(refA Is Not Null)); --
Table OR pour avoir les oid

Create Table Atelier of atelier_t (

Constraint pk_Atelier Primary Key (nomA));

60 sur 94
 Cohérence référentielle du parent avec une table typée

➢ Cohérence du parent Atelier

Delete From Atelier Where nomA = 'Mécano' ;

** ERREUR à la ligne 1
ORA-02292 > Referential Constraint Violation …

En supprimant cet atelier la contrainte de tuple ci-dessous est non validée:

Constraint c_refA refA References Atelier

*** Erreur violation de la contrainte c_refA

A tout moment l'attribut refA doit se référer à un oid valide de la table
Atelier, soit un oid d'objet existant dans la base.

A. Gamache Objet-Relationnel

61 sur 94
 Cohérence de la table ENFANT avec une table non typée

➢Insertion d'un ouvrier qui référence un atelier non encore créé

Insert Into Ouvrier values('12356', 'Paul Dacroix', 'Paris',

( Select Ref(a) From Atelier a Where noA = 'TecMec'));
*** ERREUR à la ligne 1

L'atelier TecMec n'existant pas encore, le Select imbriqué retourne un NULL

pour l'attribut refA ce qui viole la contrainte c1_refA.

Insertion en se référant à une autre table de même schéma

Insert Into Ouvrier values('12356', 'Paul Dacroix', 'Paris',

( Select Ref(a) From AtelierART a Where noA = 'TecMec'));

Insertion limitée par le SCOPE IS Atelier.

62 sur 94
 Suite …Cohérence de la table PARENT avec une table non typée

Insertion correcte d'un Atelier (parent)

Insert Into Atelier Values ( 'TecMec', '25 ave Moufftard');

1 row (object) inserted

Toutes les contraintes sont alors vérifiées.

PS: le message de Oracle est intéressant : 1 row inserted.

Not an object inserted but…. Oracle 10g est-il objet???

63 sur 94
 Actions référentielles en OR

La contrainte référentielle avec la technologie relationnelle a les actions

référentielles ON DELETE CASCADE et ON DELETE SET NULL.

En objet les mêmes actions sont possibles:

➢ (parent) Create Table Atelier of atelier_t
(constraint pk_Atelier Primary Key (nomA));

➢ (enfant) Create Table Ouvrier of ouvrier_t

(Constraint pk_Ouvrier Primary Key (mat),
Constraint c1_refAtelier check( refA is not null),
Constraint c2_refAtelier refA REFERENCES Atelier
ON DELETE CASCADE
);
Toute suppression d'un atelier supprime les ouvriers qui y travaillent.

A. Gamache Objet-Relationnel

64 sur 94
 Action ON DELETE SET NULL

➢ (enfant) Create Table Ouvrier of ouvrier_t

(Constraint pk_Ouvrier Primary Key (mat),
Constraint c1_refAtelier check( refA is not null),
Constraint c2_refAtelier refA REFERENCES Atelier
ON DELETE SET NULL
);
Toute suppression d'un atelier met à null la ref des ouvriers qui y travaillent.

65 sur 94