Chapitre V

Les Bases de données

Relationnelles Objets

1 F. BARIKA KTATA
Motivations
 La norme SQL 3 aussi appelée SQL’99, a introduit les extensions objet au
modèle relationnel.
 Principale motivation : Augmenter le niveau d’abstraction.
 "Abstraction informatique d'une entité du monde réel caractérisée par une identité, un
état et un comportement." [Gardarin, 1999]
 les inconvénients du modèle relationnel années 1980 :
Þ Première forme normale,
Þ Types complexes et collections : INTERDITS,
Þ Parfois la solution était la reconstitution d’objets complexes éclatés sur plusieurs
tables relationnelles ce qui est coûteux car cette opération occasionne de nombreuses
jointures
 Pour échapper aux éclatements-jointures, le relationnel-objet réhabilite :
 les références qui permettent d'implanter des structures complexes
 les attributs multivaluées (tableaux, ensembles ou listes)
Þ Apparition des modèles de données : Orientés objet, NF2 (non first normal form).
2 F. BARIKA KTATA
Motivations

Modèle de données NF2

Non première forme normale
(Non First Normal Form - NF2 ) Forme normale tolérant des domaines multivalués.

 Structure des objets complexes dans un contexte relationnel

 Cohabitation des notions de table (données en 1ère FN) et des données de type
complexe (ou objet)
 Une table en NF2 peut contenir un attribut composé d’une liste de valeurs et/ou
un attribut composé de plusieurs attributs
Þ Meilleurniveau conceptuel
Þ Moindre besoin « d’aplatir » le monde réel modélisé
Þ Moins de jointures

3 F. BARIKA KTATA
Le relationnel-Objet
 La norme SQL3 intègre les propriétés objets :
 objet complexe
 Un objet est caractérisé par
 Une identité propre  défini par son identifiant
 Un état  défini par ses attributs qui forment sa structure de données
 Un comportement  défini par ses méthodes
 Encapsulation
 Identifiant d’objet (OID)
 Classe ou type
 Attributs complexes et multi-valués (collections)
 Surcharge et lien dynamique
 Modèle relationnel imbriqué
 Complétude et extensibilité
 Héritage

4 F. BARIKA KTATA
 Le relationnel-Objet
 Principe de l’encapsulation
 Le fonctionnement interne de l’objet est caché au monde extérieur
 Les attributs ne devraient pas être directement manipulés par l’extérieur
 L'interface, qui définit les méthodes accessibles par l’utilisateur (publiques) est le seul moyen d'accéder à l'objet par l'envoi de
messages.
 Facilite la modularisation, la réutilisation et l’indépendance code - données

Interface Méthode
Méthode Objet
Messages Méthode
Méthode
Méthode
Méthode
Données
Données
Méthode
Méthode
Méthode
Méthode

 Souvent pas entièrement respecté dans les BD relationnel-objet

 La structure de données formée par les attributs est souvent publique
 Oracle donne la possibilité de définir les attributs comme étant public ou private

5 F. BARIKA KTATA
Motivations
 Le relationnel-objet :
 Supporte l’héritage de type pour profiter du polymorphisme (Mécanisme de
redéfinition du comportement des méthodes de la classe mère) et faciliter la
réutilisation
 Définit de nouveaux types complexes avec des fonctions pour les manipuler :
 Une colonne peut contenir une collection
 Ligne considérée comme un objet, avec un identificateur (Object Identifier OID)
 Utilisation de références aux objets ce qui permet d’accéder rapidement aux objets référencés
 Étendre le relationnel
 Oracle
 PostGrès
 Informix , …
 Inventer de nouveaux SGBD: Orientés objets
 O2,
 Versant, …

6 F. BARIKA KTATA
Ne pas se passer carrément du Relationnel!
 Bien que le relationnel présente quelques limites :
 Structure de données trop simple
 Pas d’intégration avec les langages de programmation objets
Solutions
 Pas de gestion des fonctions spécifiques à certaines données
Oracle8i :
(multimédia) (ajout de fonctions spécifiques dans Oracle 8)
 Le relationnel a ses avantages :
 Sa grande facilité et efficacité pour effectuer des recherches complexes dans des grandes bases de données
 la facilité de spécifier des contraintes d’intégrité sans programmation
 une théorie solide et des normes reconnues
 Constat et Inertie de l’existant :
 de très nombreuses bases relationnelles en fonctionnement
 Manque de normalisation pour les SGBDOO
 SGBDOO moins souple que le relationnel pour s’adapter à plusieurs applications et à l’augmentation de
charge
 Peu d’informaticiens formés aux SGBDOO
 Le modèle relationnel-objet permet un passage relaxé

7 F. BARIKA KTATA
Exemple : la table Service
 Par exemple, des services gérant des employés et enregistrant
des dépenses pourront directement être représentés par une
seule table externe imbriquant des tables internes :
 SERVICES (N° INT, CHEF VARCHAR, ADRESSE
VARCHAR, {EMPLOYES (NOM, AGE)}, {DEPENSES
(NDEP INT, MONTANT INT, MOTIF VARCHAR)})
 Employés correspond à une table imbriquée (ensemble de tuples)
de schéma (Nom, Age) pour chaque service, et de même,
Dépenses correspond à une table imbriquée pour chaque service.
 Notons que ce modèle relationnel-objet permet une imbrication
à plusieurs niveaux, par exemple, Motif pourrait correspondre à
une table pour chaque dépense.
8 F. BARIKA KTATA
Exemple : la table Service

XY Tunis Ali

Monia

Salah
AA Sousse
Saloua

9 F. BARIKA KTATA
Exemple : la table Personnes

Police Nom Adresse Conducteurs Accidents

Conducteur Age Accident Rapport Photo

24 Sami Tunis Sami 45

Olfa 17
134

219

037

Objet Police
10 F. BARIKA KTATA
Concrètement

2 extensions par rapport au modèle relationnel :

 I - Les TAD
(types abstraits de données),
1. Composition de types,
2. Collections, Types complexes
3. Références,
4. Méthodes.
 II - Les oid via les pointeurs.

11 F. BARIKA KTATA
Instances de TAD
 Une table d’un TAD est une table d’objets.
 Uniquement créable avec la commande :
create table nom_table of nom_TAD;
 Toute instance d’une telle table possède un oid unique,
ce sont des n-uplets objet.
 La portée de cet oid est globale.

 Attention,
 Les autres tables (non directement construite sur un
TAD) ne sont pas des tables d’objets.
12 F. BARIKA KTATA
Oracle Objet – Classes et Instances
 Classe d’objets
 Définit un type d'objets similaires en spécifiant ses attributs et
méthodes
 Oracle  TYPE OBJET
 CREATE TYPE <nom> AS OBJECT <spécification>
 CREATE TYPE BODY AS <implémentation>

 Instance d’objet (ou Objet)

 Représentation d’un objet individuel d’un certain type ayant son
existence propre, son propre identifiant et ses propres valeurs
(état). Stockées dans une table d’objets
 Oracle  TABLES d’OBJET

13 F. BARIKA KTATA
 Oracle Objet – TYPE OBJET
- Crée un type d’objet défini par l'utilisateur qui encapsule
– une spécification qui détermine l’interface publique du type, qui contient
- une structure de données (déclaration d’attributs)  état
- la spécification des méthodes permettant leur manipulation  comportement
– CREATE TYPE <nom> AS OBJECT <spécification>
– une implémentation (corps), qui contient
- l’implémentation des méthodes et défini par la spécification
– CREATE TYPE BODY AS <implémentation>

Spécification
Déclaration des attributs
Interface publique
Spécification des méthodes

Corps Implémentation privée

Corps des méthodes

14 F. BARIKA KTATA
 Oracle Objet – TYPE OBJET – Attributs
 Syntaxe (spécification):
 CREATE [ OR REPLACE ] TYPE <nom_type> AS OBJECT (

<nom_attribut> <type_attribut>,*

); ); [ [NOT] FINAL] [ [NOT] INSTANTIABLE ]

 Notes :
 Un attribut est déclaré avec un nom qui doit être unique dans un type donné (il peut être réutilisé par
d’autres types)
 Type peut être un des types de données Oracle (exceptions) ou un type défini par l’utilisateur (formant
ainsi une structure de données imbriquée)
 Un type peut être utilisé à l’intérieur d’un autre ou comme type de table
 L'accès à un attribut peut se faire avec la notation pointée (type.attribut).
 INSTANTIABLE : permet de définir l’équivalent d’une méthode abstraite ou d’une classe Abstraite en
Java. Une méthode de ce genre n’a pas de corps elle doit être redéfinie dans les types fils
 NOT FINAL : héritable

15 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Attributs
Exemple de création d’un TAD sous Oracle
 Type abstrait sans champs complexes
CREATE OR REPLACE TYPE adresse_t as object
(Numero NUMBER(4),
Rue VARCHAR2(20),
Code_Postal NUMBER(5),
Ville VARCHAR2(20));
 Type abstrait avec champs complexes
CREATE OR REPLACE TYPE Pilote_t AS OBJECT
(PL NUMBER(4),
nom VARCHAR2(12),
adresse adresse_t, -- type défini préalablement
Tel VARCHAR2(12),
dnaiss DATE,
salaire NUMBER(7,2));

16 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Attributs
 Exemples:
 Créer un type d’objet T_Point défini par ses coordonnées x et y définis comme
nombre entiers
 CREATE TYPE T_Point AS OBJECT (
x number,
y number
);
 Créer un type d’objet T_Ligne caractérisée par deux points définis précédemment
 CREATE TYPE T_Ligne AS OBJECT (
point1 T_Point,
point2 T_Point
);

 Exercice:
 Créer un type d’objet T_Cercle caractérisée un centre (point) et un rayon

17 F. BARIKA KTATA
Oracle Objet – TABLE OBJET
 Crée une table stockant des instances d’objet (table objet)
 Chaque ligne correspond à une instance d’objet
 Chaque colonne correspond à un attribut du type objet
 Chaque enregistrement dans une table objet a un identifiant objet (OID),
qui identifie l'objet de façon unique et sert comme référence à l'objet.

 Syntaxe:
 CREATE TABLE <nom_table> OF <nom_type>;

 Exemple:
 CREATE TABLE Pilote OF pilote_t;

18 F. BARIKA KTATA
Oracle Objet – TABLE OBJET
 Les types objets peuvent aussi être utilisés simplement dans les instructions CREATE
TABLE classiques pour spécifier un type de données d'une colonne.

 Syntaxe:
CREATE TABLE <nom_table> (
<nom-col> <type-col> [ [CONSTRAINT] <contrainte-col>]*
[ [CONSTRAINT] <contrainte-table>]* );

 Exemple:
 CREATE TABLE Rectangles2 (
point1 T_Point,
point2 T_Point,
surface number,
constraint CkSurf CHECK surface = ABS((point1.x-point2.x)*(point1.y-point2.y)) );

19 F. BARIKA KTATA
 Oracle Objet – Références
 Le mot clé « REF» permet de définir une référence dans un objet vers un autre objet
 REF : permet d'obtenir la référence associée à un objet (son oid)
 Syntaxe:
 <nom_attribut> REF <type_objet>
 Exemple:
create type Typevoiture as object
( modele varchar2(15),
immat varchar2(10) )
create table Ovoiture of Typevoiture;
create or replace type Typepersonne as object
( nom varchar2(15),
Prenoms varchar2(15) ,
voiture REF Typevoiture );
create table Opersonne of Typepersonne;
 REF sert à définir des liens de correspondance
20 F. BARIKA KTATA
 Oracle Objet – References
 Identifiant objet (OID) :
 Toute instance d’une table objet-relationnelle dispose d’un OID
 Identifie de façon unique et invariante un objet indépendamment du valeur de ses attributs
(deux objets aux valeurs identiques peuvent être différents)
 Générés et indexés automatiquement par Oracle
 Invisibles et pas manipulables directement par l’utilisateur
 Est utilisé pour référencer un objet à partir d’autres objets ou tables (REF)
 Attributs Reference (REF)
 Un type de données particulier contentant une référence vers une autre objet (i.e. l’identifiant
OID de l’autre objet)
 C’est un pointeur logique sur un autre objet. Si une REF pointe sur un objet non-existant elle
est dite (DANGLING). Tester grâce à IS [NOT] DANGLING
 Utilisé pour modéliser des associations entre objet. Permet de chaîner les objets entre eux sans
passer par des jointures, permettant ainsi une navigation directe entre objets (notation pointée)
 Les références peuvent porter à un partage d’objets: les données ne sont pas répliqués et les
modifications sont effectués une seule fois et tout référant y a accès
 Dans une instruction SQL il faut passer par l'opérateur DEREF, qui prend comme paramètre
une référence à un objet, pour en avoir la valeur
21 F. BARIKA KTATA
Oracle Objet – TYPE OBJET
Traduction d’un diagramme UML en Relationnel-objet Oracle

Etat_Civil Personne

Nom : String IdPer : int

Prénom : String etCiv : Etat_Civil
Datenaiss : Date Adr : Adresse

Adresse
Enseignant Etudiant
Rue : String
CP : String Statut : String Diplômes : String
Ville : String

22 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Le constructeur
 Un Constructeur est une méthode spéciale ayant le même nom que
le type.
 Le constructeur du type ADRESSE_T s’appelle ADRESSE_T.
 Un constructeur sert à la création et à la mise à jour des objets (dans
les ordres SQL : INSERT, UPDATE, dans des fonctions PL/SQL).
 Un Constructeur en Oracle est appelable partout
 Un constructeur par défaut est disponible. Ses paramètres sont
l’ensemble des champs du type

23 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
 Syntaxe (spécification):
CREATE [ OR REPLACE ] TYPE <nom_type> AS OBJECT (
<nom_attribut> <type_attribut>,*
{MAP | ORDER} MEMBER specification_fonction,
{STATIC | MEMBER} {specification_fonction | specification_procedure}
); [ [NOT] FINAL] [ [NOT] INSTANTIABLE ]

 Syntaxe (implémentation):
CREATE [OR REPLACE] TYPE BODY <nom_type> AS
MEMBER <declaration_methode> AS BEGIN <code> END ;*
END;

24 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
 L’utilisateur peut définir autant de méthodes qu’ils le souhaite dans un TAD
 Par contre il ne peut définir AUCUN CONSTRUCTEUR.
 Seul le constructeur par défaut est utilisable
 La déclaration des méthodes se fait dans le TYPE SPECIFICATION et
l’implémentation dans le TYPE BODY
 Le mot clé MEMBER précède chaque méthode d’instance
 Le mot clé STATIC précède chaque méthode de classe: Une méthode statique
n'a pas l'objet courant comme paramètre implicite. Elle n’ a pas besoin d’ un objet
pour être invoquée.

25 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
 La déclaration des signatures des méthodes se trouve dans la spécification du

TYPE, qui définit l’interface de l’objet (méthodes accessibles).

 Déclarée par le mot-clé MEMBER (méthode d’instance) ou STATIC (méthode de classe)

 Une méthodes peut être une fonction (FUNCTION) ou une procédure (PROCEDURE)

 L’implémentations des méthodes se trouve dans le TYPE BODY

 Contient le code (PL/SQL) à exécuter pour chaque méthode définie par l’interface

 Accès possible aux valeurs de l’objet appelée grâce au mot clé SELF

26 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Exemple 1:

CREATE TYPE departement_type AS OBJECT

(numDept integer,
nomD varchar(30),
lieu varchar(30),
MEMBER FUNCTION getLieu RETURN varchar);

CREATE TYPE BODY departement_type AS

MEMBER FUNCTION getLieu RETURN varchar
IS
begin return lieu;
end;
end;

27 F. BARIKA KTATA
 Oracle Objet – TYPE OBJET – Méthodes
Exemple 2 :

CREATE OR REPLACE TYPE etudiant_t as OBJECT (idE CREATE OR REPLACE TYPE BODY etudiant_t AS
VARCHAR2(15), nom VARCHAR2(20), prenom
MEMBER FUNCTION compteStage RETURN NUMBER IS
VARCHAR2(30), adresse adresse_t,
MEMBER FUNCTION compte_stages RETURN resultat NUMBER;
NUMBER,
BEGIN
MEMBER PROCEDURE changeAdresse (a IN adresse_t),
); SELECT count(s.idS) INTO resultat FROM stage s
CREATE TABLE Etudiant OF etudiant_t;
WHERE s.etudiantS.idE = SELF.idE;
CREATE TYPE stage_t as OBJECT (idS VARCHAR2(10),
sujetS VARCHAR(30), etudiantS REF etudiant_t, return resultat;
MEMBER PROCEDURE modifSujet(s IN VARCHAR2 ));
END compteStage;
CREATE TABLE Stage OF stage_t;
MEMBER PROCEDURE changeAdresse (a IN adresse_t)
BEGIN UPDATE etudiant SET adresse:=a WHERE idE=
SELF.idE;
End changeAdresse;
End;

28 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Exemple 3 :
CREATE OR REPLACE TYPE Pilote_t AS OBJECT
( PL NUMBER(4),
nom VARCHAR2(12),
adresse adresse_t,
Tel VARCHAR2(12),
dnaiss DATE,
salaire NUMBER(7,2),
MEMBER FUNCTION getPiloteSalaire RETURN NUMBER,
MEMBER FUNCTION setPiloteSalaire(SELF IN OUT pilote_t, plNum IN NUMBER, newSalaire IN NUMBER)
RETURN BOOLEAN,
MEMBER PROCEDURE testSetSalaire,);

le paramètre SELF doit être passé en paramètre si l’ on souhaite modifier l’objet courant dans UNE FONCTION.
Ce passage n’ est pas nécessaire s’ il s’agit d’une PROCEDURE

29 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Exemple 3 (suite):
CREATE OR REPLACE TYPE BODY pilote_t IS
MEMBER FUNCTION getPiloteSalaire RETURN NUMBER IS
BEGIN
RETURN salaire;
END;
MEMBER FUNCTION setPiloteSalaire (SELF IN OUT pilote_t, plNum IN NUMBER, newSalaire IN NUMBER) RETURN BOOLEAN IS
BEGIN
IF pl = plNum THEN salaire := newSalaire;
return true;
ELSE return false;
END IF;
END;
MEMBER PROCEDURE testSetSalaire IS
retour BOOLEAN;
BEGIN retour := Self.setPiloteSalaire(10, 10000);
END;
END;

30 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
 Une méthode se caractérise par un ensemble
d'indicateurs précisant la nature de la méthode :
 La fonction MAP : permet de définir une règle de comparaison s’appuyant une
des colonnes du type (La fonction de type MAP doit renvoyer un résultat
d'un type scalaire standard comme DATE, NUMBER, VARCHAR, CHAR ou
REAL et ne doit admettre aucun argument).
 La fonction ORDER : permet de comparer deux objets. Cette fonction doit
comparer le SELF au paramètre fourni et renvoyer :
 -1/+1 : si SELF inférieur/supérieur au paramètre
 0 : si identiques

31 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Exemple (fonction MAP) :
CREATE TYPE type_rationnel AS OBJECT
(numerateur INTEGER, denominateur INTEGER, On crée le type rationnel avec une
MAP MEMBER FUNCTION conversion RETURN real) fonction MAP qui associe à un objet
CREATE TYPE BODY type_rationnel IS de ce type le réel qui lui correspond,
MAP MEMBER FUNCTION conversion RETURN REAL IS ce réel sera utilisé pour les
BEGIN RETURN numerateur/denominateur; comparaisons entre rationnels. La
END conversion; fonction de type MAP sera appelée
END;
implicitement lors d'une comparaison
Exploitation :
de deux objets avec les signes =, <,
DECLARE
>, <=, >=.
ratio1 type_rationnel:=type_rationnel(4,3);
ratio2 type_rationnel:=type_rationnel(5,2);
BEGIN
if (ratio1 > ratio2) then... /* utilisation implicite de la fonction conversion */

Ce type de fonction peut aussi être appelé explicitement par un SELECT ou encore dans
un ORDER BY ou un GROUP BY.
Exemple : ORDER BY ratio1.conversion();
32 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
Exemple (fonction ORDER ) :
CREATE TYPE rationnel AS OBJECT
(numerateur INTEGER,
denominateur INTEGER,
ORDER MEMBER FUNCTION compare(r rationnel) RETURN integer)

CREATE TYPE BODY rationnel IS

ORDER MEMBER FUNCTION compare(r rationnel) RETURN integer IS
s,t REAL; Cette fonction est utilisée implicitement lors d'un
BEGIN
s:= SELF.numerateur/SELF.denominateur; ORDER BY.
t:= r.numerateur/r.denominateur;
IF s < t THEN RETURN -1; Exploitation :
ELSIF s=t THEN RETURN 0;
ELSE RETURN 1; SELECT * FROM Lesrationnels r
END compare;
END;
ORDER BY VALUE (r);
33 F. BARIKA KTATA
Oracle Objet – TYPE OBJET – Méthodes
A noter

 Il est impossible de définir à la fois une méthode ORDER MEMBER et une

méthode MAP MEMBER dans un même type

 Pas plus d’une méthode ORDER ou MAP par type

 MAP et ORDER sont appelées automatiquement lors de la comparaison d’objets

34 F. BARIKA KTATA
Manipulation de la table Relationnelle-objet
 Instructions INSERT, UPDATE et DELETE
 Equivalentes aux instructions SQL standards, sauf qu’il faut inclure la notation pointée, en
cas d’imbrication d’objets et objets complexes ainsi que l’usage des constructeurs.

 Syntaxe:
 INSERT INTO <nom_table> VALUES (<valeurs>)
 UPDATE <nom-table> SET <nom-colonne> = <expression> [WHERE <condition>]
 DELETE FROM <nom-table> [WHERE <condition>]

 Exemples:
 CREATE TABLE Lignes OF T_Ligne;
 INSERT INTO Lignes VALUES (T_Point(15,15),T_Point(20,20));
 INSERT INTO Rectangles VALUES ( T_Point(0,0), T_Point(20,20) );
 UPDATE Lignes SET Point1 = T_Point(15,15) where Point1=T_Point(0,0);
 DELETE FROM Lignes WHERE Point1=T_Point(15,15);

35 F. BARIKA KTATA
Manipulation de la table Relationnelle-objet
 Mise à jour d’une table relationnelle-objet : UPDATE / DELETE
 UPDATE nom_table SET nom_att = nouvelle_valeur [ WHERE condition(s)]
 Si l’attribut à modifier est un n-uplet il faut utiliser le constructeur
correspondant type_objet(…)
 Exemple : constructeur par défaut
 Soit la table objet Pilote de pilote_t:
 INSERT INTO Pilote VALUES ( pilote_t(1, ’Ali Ben Hadid’, adresse_t(1, ’rue Argent’,6000,
’TUNIS’), ’0021631333333’, ’12-JUN-67’, 12000) );
 Modification via un constructeur
 UPDATE Pilote op set op.adr = adresse_t(5, 'rue de la traverse',6000, ‘TUNIS');

 Si la valeur est une référence il faut aller la chercher à l’aide d’une requête
imbriquée (SELECT REF(a) FROM …)

36 F. BARIKA KTATA
 Manipulation de la table Relationnelle-objet
 Revenons à l’exemple:
 CREATE TABLE Points OF T_Point;
 CREATE TABLE Segments (
point1 REF T_Point,
point2 REF T_Point
);

 Pour tester
 INSERT INTO Points VALUES(0,5);
 INSERT INTO Points VALUES(10,1);
 INSERT INTO Segments SELECT REF(p1), REF(p2)
FROM Points p1, Points p2
WHERE p1.x=0 and p1.y=5 AND p2.x=10 and p2.y=1
37 F. BARIKA KTATA
Manipulation de la table Relationnelle-objet
 Modification de la définition d’une table objet
 ALTER TABLE ne peut s’appliquer qu’ à une table relationnelle. Modifier la définition d’une table
relationnelle-objet revient à modifier le type d’objets sur lequel elle est définie (CREATE OR
REPLACE TYPE)
 Suppression d’une table objet-relationnelle
 DROP TABLE nom_table;
 Consultation d’une table relationnelle-objet :
 Obtenir l’OID d’un objet (= sa référence REF) :
 SELECT REF (alias_objet) FROM nom_table alias_objet WHERE
condition_restriction_selection_objet
 Accéder à un objet :
 SELECT VALUE (alias_objet) FROM nom_table alias_objet WHERE
condition_restriction_selection_objet
 Déréférencer un objet (= obtenir sa valeur à partir de sa référence) :
 SELECT DEREF (REF_objet) FROM nom_table alias_objet WHERE
condition_restriction_selection_objet
38 F. BARIKA KTATA
Manipulation de la table Relationnelle-objet
 Exemples:
 select * from Pilote;
 La syntaxe suivante est fausse : select nom, ville from Pilote;
 Pour accéder à la valeur de la ville, il faut indiquer les attributs des
TAD avec leur chemin complet avec notation pointée. On utilise
alors une variable de corrélation pour accéder aux attributs des TAD
 select nom, p.adresse.ville from Pilote p;
 select nom
from Pilote p
where p.adresse.ville like ’Tunis’ ;

39 F. BARIKA KTATA
Exercice
 Soit le modèle suivant :

1. Déclarer en relationnel-objet.
2. Insérer l’employé : 1002, Med Ali KATEB, 3700, directeur ressources humaines
3. Insérer l’employé : 1006, Anas BEN MALEK, 1500 ayant comme directeur
Med Ali KATEB.

40 F. BARIKA KTATA
Exercice
1. Déclarer en relationnel-objet.
CREATE TYPE employe AS OBJECT (
Id number,
Nom VARCHAR2(10),
Salaire number,
Emploi VARCHAR2(20),
Directeur REF employe );
CREATE TABLE employes OF employe;

2. Insérer l’employé : 1002, Med Ali KATEB, 3700, directeur ressources

humaines
INSERT INTO employes VALUES (employe(1002, ‘Med Ali KATEB’, 3700, ‘directeur
ressources humaines’, NULL));

3. Insérer l’employé : 1006, Anas BEN MALEK, 1500 ayant comme directeur
Med Ali KATEB.
INSERT INTO employes VALUES (employe(Select 1006, ‘Anas BEN MALEK’, 1500, NULL,
REF (d) From employe d Where d.nom = ‘Med Ali KATEB’ ));

41 F. BARIKA KTATA
Objet Complexe
Les collections avec ORACLE 10g
 Un type d’objet permet la déclaration d’attributs multivalués
qui sont organisés selon un des type de collection suivants:
(ORACLE 10g n’offre que 2 types de collections)
 NESTED TABLE : table imbriquée
 Définit un ensemble non ordonné
 De taille variable et non limité
 Les éléments peuvent être accédé singulièrement

 VARRAY : tableau prédimensionné

 Définit un ensemble ordonné
 De taille variable mais limitée (à définir au début)
 Les éléments ne peuvent pas être accédé singulièrement

42 F. BARIKA KTATA
Objet Complexe
Les VARRAY
 Tableau de taille variable
 Syntaxe :
CREATE [ OR REPLACE ] TYPE nom_type AS VARRAY (nb_max) of nom_type2

Définit un type tableau nommé nom_type de maximum nb_max éléments de type

nom_type2
nom_type2 peut être n'importe quel type oracle ou créé par l'utilisateur

Exemple :
CREATE TYPE Tprices AS VARRAY(10) OF NUMBER(12,2);
Le type VARRAY nommé TPRICES ne peut pas posséder plus de 10 éléments,
Chaque élément est de type NUMBER(12,2).
CREATE table Product ( nb Number, price TPrice);

43 F. BARIKA KTATA
Objet Complexe
Les VARRAY
 Les types VARRAYs peuvent être utilisés comme
CREATE TYPE Telephones AS VARRAY(3) OF NUMBER(10);
 Domaine de valeur d'une colonne d'une table :
 CREATE table Personne ( nom VARCHAR(20), telephone TELEPHONES)
 Domaine de valeur d'un attribut d'un autre type défini par l'utilisateur :
 CREATE type Personne ( nom VARCHAR(20), telephone TELEPHONES)
 Aussi dans une autre collection (collection de collection)
 Pour un type plus complexe :
 CREATE TYPE cust_address_typ AS OBJECT ( street_address
VARCHAR2(40), postal_code VARCHAR2(10), city VARCHAR2(30),
state_province VARCHAR2(10), country_id CHAR(2));
 CREATE TYPE address_array_t AS VARRAY(3) OF cust_address_typ;
 CREATE TABLE Customers (id_cust NUMBER, addresses
address_array_t);
44 F. BARIKA KTATA
Objet Complexe
Les VARRAY
 Plusieurs prénoms pour une personne :
 CREATE TYPE liste-prenom as Varray(10) of varchar2(15);
 CREATE TYPE tvoiture type as object (modele varchar2(15), annee
date, no integer));
 CREATE TYPE Tpersonne as object (nom varchar2(15), Date_n
Date, prenoms liste_prenom, voiture Tvoiture)
 CREATE TABLE personnes of Tpersonne;
 Remarque :
 Une collection peut contenir :
 Des types de données élémentaires.
 Des types de données abstraits.
 Des références vers des types de données abstraits.

45 F. BARIKA KTATA
Objet Complexe
Les VARRAY
 Exercice 1 :
Dept_no Phone_list

 Chaque ligne du phone_list est un objet définit par un code, une région est un
numéro de téléphone

CREATE TYPE phone_typ AS OBJECT ( code VARCHAR2(2), région

VARCHAR2(3), ph_number VARCHAR2(7) );
CREATE TYPE phone_varray_typ AS VARRAY(5) OF phone_typ;
CREATE TABLE dept_phone_list ( dept_no NUMBER(5), phone_list
phone_varray_typ);

46 F. BARIKA KTATA
Objet Complexe
Les Varray
 Exercice 2 :
 Créer une table de courses qui contient un nom et une liste de participants
définis comme un VARRAY de participants (définis par un rang et un nom)

CREATE TYPE T_Participant AS OBJECT (Rang Number(4), Nom varchar(32) );

CREATE TYPE T_ ParticipantList AS VARRAY(50) OF T_Participant

CREATE TABLE Course (

Course varchar(32),
ParticipantList T_ParticipantList
);

47 F. BARIKA KTATA
Objet Complexe
Les VARRAY
 N. B. :
 Le stockage d’un VARRAY se fait à l’intérieur de la table
ou il a été déclaré
 Si un VARRAY est trop grand, il peut être stocké en
dehors du segment de la table
 Un constructeur d’objet existe aussi sur un type VARRAY
 Dans les Ordres SQL (UPDATE, INSERT, DELETE), un
VARRAY est manipulable comme un TOUT
 La mise à jour d'un élément particulier est possible dans
PL/SQL
48 F. BARIKA KTATA
Objet Complexe
Les VARRAY - Manipulation
 Pour accéder au contenu du Varray, on peut :
 Utiliser la requête suivante :
 select * from Personne ;
 Utiliser la clause table :
 select nom, q.* from Personne p, table (p.prenoms) q;
 Exemple pour insertion :
 insert into Personne values (’KASSEM’,
liste_prenoms(’Med’,’Ali’,’Amine’), ’18-12-1991’,
Tvoiture(’Berlin’, 2012,5700)));
 Utiliser un programme PL/SQL en utilisant une fonction count et la
notation tab(i) pour accéder au nième élément du tableau
49 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Exercice :
 CREATE TYPE tadresse AS OBJECT ( num NUMBER, rue VARCHAR(30), ville VARCHAR(20),
codepostal CHAR(5) ) ;
 CREATE TYPE tvadresses AS VARRAY(2) OF tadresse ;
 CREATE TABLE etudiants ( noine VARCHAR(10), nom VARCHAR(30), adresses tvadresses) ;

 C’est correct ou pas? :

 INSERT INTO etudiants VALUES (‘12345’, ‘Ali’, tvadresses(‘Charles de Gaule’,‘Tunis’));
 INSERT INTO etudiants VALUES (‘12345’, ‘Ali’, tvadresses(tadresse(‘liberté’,‘Tunis’)));
 -- on a un VARRAY qui contient un seul élément
 INSERT INTO etudiants VALUES (‘9999’, ‘Donia’, tvadresses(tadresse(‘martyres’ , ‘Tunis’),null));
 -- on a un VARRAY qui contient les deux éléments du VARRAY dont un n’est pas renseigné
 INSERT INTO etudiants VALUES (‘2340’, ‘Nadia’, null);
 -- aucun VARRAY n’est créé
 INSERT INTO etudiants VALUES (‘54321’, ‘Line’, tvadresses()) ;
50 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Exemple :
 UPDATE etudiants SET adresses = tvadresses(tadresse(‘Charles de Gaule’, ‘Tunis’),
tadresse(‘la poste’, ‘Ariana’)) WHERE nom = ‘Ali’ ;
 Si on veut manipuler un seul élément d’un varray, il faut utiliser un bloc PL/SQL.
 Exemple : pour ajouter une nouvelle adresse à l’étudiante nommée Donia.
DECLARE
lesadr tvadresses;
BEGIN
SELECT adresses INTO lesadr FROM etudiants WHERE nom = ‘Donia’ ;
-- modification de la deuxième valeur
lesadr(2) := tadresse(‘avenir’, ‘Mannouba’) ;
-- mise à jour de la relation
UPDATE etudiants SET adresses = lesadr WHERE nom = ‘Donia’ ;
END ;

51 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 PL/SQL propose un ensemble de fonctions qui permettent de manipuler des collections :
 EXISTS, COUNT, LIMIT :
 La fonction EXIST(n) teste si le nième élément de la collection existe.
 La fonction COUNT retourne le nombre d’éléments de la collection
 La fonction LIMIT retourne le nombre maximum d’éléments de la collection
 FIRST, LAST :
 Les fonctions FIRST et LAST retournent le premier indice et le dernier indice de la collection.
 PRIOR(n), NEXT(n), TRIM(n) :
 Les fonctions PRIOR(n) et NEXT(n) retournent l’indice de l’élément qui précède le n ième et qui suit le nième)
élément.
 La fonction TRIM(n) supprime n éléments à partir de la fin de la collection.
 EXTEND, EXTEND(x), EXTEND(x,y) : La fonction EXTEND insère 1 à plusieurs éléments (VARRAY)
 EXTEND ajoute/insère un élément NULL
 EXTEND(x) ajoute/insère x éléments NULL
 EXTEND(x,n) ajoute/insère x copies du nième élément dans la collection
 DELETE ne s’applique pas au Varray!
52 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Etant donnée la déclaration suivante :
 CREATE TYPE tel_type AS OBJECT (numtel VARCHAR2(20));
 CREATE TYPE tels_type AS VARRAY(3) OF tel_type ;
 CREATE TYPE enseignant_type AS OBJECT ( Code VARCHAR(10), nom VARCHAR2(30), grade Number,
telsE tels_type);
 CREATE TABLE enseignant OF enseignant_type;

DECLARE
new_tels tels_type;
BEGIN
SELECT telsE INTO new_tels FROM enseignant WHERE code=1;
IF new_tels.EXISTS(2) THEN
DBMS_OUPUT.PUT_LINE(‘le 2ième élément existe’);
ELSE
DBMS_OUPUT.PUT_LINE(‘le 2ième élément n’’existe pas’);
END;
53 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Etant donnée la déclaration suivante :
 CREATE TYPE tel_type AS OBJECT (numtel VARCHAR2(20));
 CREATE TYPE tels_type AS VARRAY(3) OF tel_type ;
 CREATE TYPE enseignant_type AS OBJECT ( Code VARCHAR(10), nom VARCHAR2(30), grade
Number, telsE tels_type);
 CREATE TABLE enseignant OF enseignant_type;

Exemple :
ajout de 2 copies du 1ier élément de la table
DECLARE
new_tels tels_type;
BEGIN
SELECT telsE INTO new_tels FROM enseignant WHERE code=1;
new_tels.EXTEND(2,1);
UPDATE enseignant SET tels=new_tels WHERE code=1;
END;
54 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Etant donnée la déclaration suivante :
 CREATE TYPE tel_type AS OBJECT (numtel VARCHAR2(20));
 CREATE TYPE tels_type AS VARRAY(3) OF tel_type ;
 CREATE TYPE enseignant_type AS OBJECT ( Code VARCHAR(10), nom VARCHAR2(30),
grade Number, telsE tels_type);
 CREATE TABLE enseignant OF enseignant_type;

DECLARE Suppression dans un tableau

new_tels tels_type
BEGIN
SELECT telsE INTO new_tels FROM enseignant WHERE code=1;
new_tels(2).numtel := null;
UPDATE enseignant SET telsE = new_tels WHERE code =1;
END;
55 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Etant donnée la déclaration suivante :
 CREATE TYPE tel_type AS OBJECT (numtel VARCHAR2(20));
 CREATE TYPE tels_type AS VARRAY(3) OF tel_type ;
 CREATE TYPE enseignant_type AS OBJECT ( Code VARCHAR(10), nom VARCHAR2(30), grade Number, telsE
tels_type);
 CREATE TABLE enseignant OF enseignant_type;

DECLARE
TYPE NumList IS VARRAY(20) OF NUMBER;
ensids NumList;
BEGIN
ensids := NumList(101,102,103,104,105);
FORALL i IN ensids.FIRST..ensids.LAST
UPDATE enseignant SET grade = grade * 1.02 WHERE code = ensids(i);
... END;
--La boucle FORALL remplace le FOR et permet de regrouper les instructions LMD de
la boucle en une seule série. Ca optimise le traitement.
56 F. BARIKA KTATA
 Objet Complexe
Les VARRAY
 Etant donnée la déclaration suivante :
 CREATE TYPE tel_type AS OBJECT (numtel VARCHAR2(20));
 CREATE TYPE tels_type AS VARRAY(3) OF tel_type ;
 CREATE TYPE enseignant_type AS OBJECT ( Code VARCHAR(10), nom VARCHAR2(30), grade Number, telsE tels_type);
 CREATE TABLE enseignant OF enseignant_type;

Ajout d’un élément sans savoir combien d’éléments comporte le tableau

DECLARE
lesadr tvadresses ;
BEGIN
SELECT adresses INTO lesadr FROM enseignant
WHERE nom = ‘Mohamed’ ;
lesadr.extend;
lesadr(lesadr.last) := tadresse(‘avenir’, ‘Tunis’) ;
-- valeur du dernier élément
UPDATE enseignant SET adresses = lesadr WHERE nom = ‘Mohamed’ ;
END ;
57 F. BARIKA KTATA
Objet Complexe
Les Varray
 Revenons à l’exemple :
 CREATE TYPE T_Participant AS OBJECT (Rang Number(4), Nom varchar(32) );
 CREATE TYPE T_ ParticipantList AS VARRAY(50) OF T_Participant
 CREATE TABLE Course (
Course varchar(32),
ParticipantList T_ParticipantList );

 Insérer une ligne dans la table course 1 Ali BEN HADID

ayant pour intitulé ‘Athletisme’ 2 Sami KASSEM
et pour participants la liste suivante :
3 Rami GHANEM

 INSERT INTO Course VALUES ( 'Athletisme',

T_ParticipantList( T_Participant(1,’Ali BEN HADID'), T_Participant(2,’Sami KASSEM'),
T_Participant(3,’Rami GHANEM‘)) );

 Afficher toutes les courses et tous les participants

SELECT C.Course, CL.* FROM Course C, TABLE(C.Participantlist) CL ;

58 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
 Ensemble non limité et non ordonné d'éléments de même type
 Syntaxe:
 Création du type table :
 CREATE [OR REPLACE] TYPE nomType AS TABLE OF type_def;
 Création de la table maître :
 CREATE TABLE nomTable ( nomColonne1 type1, ... nomColonnen typen) NESTED TABLE
nomColonnei STORE AS nomTableEnreg;
 nomColonnei est une colonne de type table
qui fait le lien entre la table maître
et la table imbriquée;
 nomTableEnreg est le nom de la table
qui contient les lignes de la table imbriquée

59 F. BARIKA KTATA
Objet Complexe
Les tables insérées (Nested Table)
 Exemple
CREATE OR REPLACE TYPE ref_Vol2_t AS OBJECT
( Vol NUMBER(4),
VD VARCHAR2(20),
VA VARCHAR2(20),
Pilote REF pilote_t);
CREATE OR REPLACE TYPE vol2_set_t AS TABLE OF ref_vol2_t ;
CREATE OR REPLACE TYPE Avion2_ns_t AS OBJECT
( Av_num NUMBER(3),
Av_type VARCHAR2(12),
Av_loc VARCHAR2(20),
Av_cap NUMBER(3),
Av_rem CLOB,
Av_liste_vol Vol2_set_t) ;
60 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
 Les Store Tables sont des segments physiques où sont stockés les
instances des Nested Tables

 Exemple :
 Table non Objet avec Table imbriquée
CREATE TABLE Avion2_ns
( Av_num NUMBER(3), Av_type VARCHAR2(12), Av_loc VARCHAR2(20),
Av_cap NUMBER(3), Av_rem CLOB, Av_liste_vol Vol2_set_t)
NESTED TABLE av_liste_vol STORE AS storeVols2Set;
 Table objet avec Table imbriquée.
CREATE TABLE avion2_ns OF Avion2_ns_t NESTED TABLE Av_liste_vol STORE
AS vols2_set ;

61 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
 Un constructeur par défaut est fourni pour construire les objets d'une NESTED
TABLE, il doit être du même type :
 du même nom que le type de la table.
 retourne une table dont les éléments sont une liste de valeurs (la valeur NULL
est permise).
 appelé sans argument pour construire une table vide.

 Exemple :
CREATE OR REPLACE TYPE Avion3_t AS OBJECT ( Av_num NUMBER(3),
Av_type VARCHAR2(12), Av_loc VARCHAR2(20), Av_cap NUMBER(3),
Av_rem CLOB);
CREATE OR REPLACE TYPE avion3_set_t AS TABLE OF avion3_t ;

62 F. BARIKA KTATA
Objet Complexe
Les tables insérées (Nested Table)
 Exercice:
 Créer une table d’objets Groupes qui contient le nom du groupe et ses
components (un ensemble d’artistes ayant un nom, prénom et instrument ).
CREATE TYPE T_Artiste AS OBJECT (
Nom varchar(32), Prenom varchar(32), Instrument varchar(32)
);
CREATE TYPE T_Components AS TABLE OF T_Artiste;
CREATE TABLE Groupes (
NomGroupe varchar(32),
Components T_Components
)
NESTED TABLE Components STORE AS GroupeComponents;

63 F. BARIKA KTATA
Exercice

Créer cette table

sous oracle
relationnel objet

64 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
CREATE OR REPLACE TYPE typeCertificats AS OBJECT (
discipline varchar2(50),
acronyme varchar2(20)
);
CREATE OR REPLACE TYPE typeListeCertificats AS TABLE OF typeCertificats ;
CREATE TABLE formateurs (
prenom_formateur varchar2(20),
nom_formateur varchar2(20),
certifier typeListeCertificats
)
NESTED TABLE ceritifier STORE AS formateursnt;

65 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
Insertion dans les tables insérées Insérer la première ligne de la table :
INSERT INTO nom_table (..., INSERT INTO formateurs (prenom_formateur,
attribut_type_collection, ...) nom_formateur, certifier)
VALUES ( VALUES (
nom_type_collection( 'Casper',
nom_type_objet(valeur1, valeur2, ...), 'SCOUT',
nom_type_objet(valeur1, valeur2, ...), typeListeCertificats (typeCertificats (‘Securite
...); informatique’,’CEH'), typeCertificats ('Securite
... informatique ',‘CISSP'),
); typeCertificats(‘Infonuagique',’EMC CLOUD'))
);

66 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
Sélection dans les tables insérées
Supposons une colonnes C un attribut Afficher la précédente insertion :

de la table T contenant une table

insérée : SELECT f.prenom_formateur, t.*

SELECT TI.* FROM formateurs f, TABLE(f.certifier) t;

FROM T TM, TABLE(TM.C) TI;

Prenom_formateur Discipline Acronyme

------------------------------------------------------------------------------
Casper Securite informatique CEH
Casper Securite informatique CISSP
Casper Infonuagique EMC CLOUD

67 F. BARIKA KTATA
 Objet Complexe
Les tables insérées (Nested Table)
 Manipulation de la table imbriquée par le mot clé THE:
 La clause THE permet de désigner, comme ensemble de tuples à traiter, le résultat
de la requête SELECT associée. Si celle-ci sélectionne un attribut correspondant à
une table imbriquée, c’est sur cette table imbriquée que porte la mise à jour.
 INSERT INTO THE (SELECT alias.att_table_imbriquée FROM nom_table alias
WHERE condition_restriction ) VALUES (valeur_tuple_imbriqué )

 UPDATE THE ( SELECT alias.att_table_imbriquée FROM nom_table alias WHERE

condition_restriction ) alias_t_imbriquée SET alias_t_imbriquée.att_a_modifier =
nouvelle_valeur [, … autres_modifications]

 DELETE FROM THE ( SELECT alias.att_t_imbriquée FROM nom_table alias

WHERE condition_restriction ) alias_t_imbriquée [ WHERE
condition_restriction_sur_t_imbriquée ]

68 F. BARIKA KTATA
Objet Complexe
Les tables insérées (Nested Table)
Manipulation de la table imbriquée par le mot clé THE:
INSERT INTO THE (SELECT f.certifier FROM formateurs f WHERE
f.prenom_formateur=‘Casper') VALUES (typeCertificats (‘inforgraphie',’SDR'));
UPDATE THE (SELECT f.certifier FROM formateurs f WHERE
f.prenom_formateur=‘Casper') ti
SET ti.discipline=‘Securite des reseaux‘ WHERE ti.acronyme=‘CISSP‘;
 Remarque :
L’opérateur CURSOR permet de spécifier un ensemble d'objets issus d'une Nested
Table
SELECT f.prenom_formateur, CURSOR ( SELECT e.discipline FROM TABLE (certifier)
e ) FROM formateurs f ;
Pour dire que pour chaque n-uplet de formateurs on veut afficher les informations
venant de la table imbriquée certifier.
69 F. BARIKA KTATA
 Oracle Objet – Heritage
 Héritage de type
 Permet de définir un sous-type d'un type existant. Le sous-type hérite alors de la
structure et des opérations du type de base (qu’il peut redéfinir).

 Syntaxe (spécification):
 CREATE [ OR REPLACE ] TYPE <nom_type> [ UNDER
<nom_supertype> ] (
<nom_attribut> <type_attribut>,*
[ MEMBER <declaration_methode> ],*
); [ [NOT] FINAL] [ [NOT] INSTANTIABLE ]

 Notes:
 [NOT] FINAL permet de déterminer si un type peut être spécialisé (ou pas). Il
n’est donc pas possible d’hériter d’un type défini comme FINAL. Par défaut un
70
type est défini comme FINAL F. BARIKA KTATA
 Oracle Objet – Heritage

 Exemple:
 CREATE TYPE T_Carre UNDER T_Rectangle NOT FINAL;
 CREATE OR REPLACE TYPE BODY T_Carre AS
MEMBER FUNCTION surface RETURN NUMBER AS
BEGIN
RETURN POWER(point1.x-point2.x,2);
END surface;
END;

71 F. BARIKA KTATA