Bases de Données Avancées

CHAPITRE II

Bureau 26
Bloc des enseignants- Université de Bejaia
& LIMED
[Link]@[Link]

2023/2024 M1RN RS/SIA/ASR

Dr. Nassima BOUADEM
CHAPITRE II
BASE DE DONNEES
RELATIONNELLE-OBJET
PLAN

 Types abstraits de données (ADT)

 Le schéma relationnel étendu
 Langage de définition et de manipulation des données Objet-
relationnelles
 Manipulations avancées de données Objet-relationnelles
 Méthodes
 Programmation PL/SQL
 Les curseurs
 Les vues
 Les triggers
 Structure de données simple
 Pas de référence entre tables
 Pauvreté du système de typage
 Programmation interdite dans le SGBD
 Sémantique insuffisante


LIMITES DU MODÈLE
RELATIONNEL
 BDRO est définit par [1]:
 Les tables (relations) ne suivent pas la première forme
normale NF2.
 Création de nouveaux types de données défini par
l’utilisateur appelés ADT.
 Association aux types de données ADT des programmes.
 Identité d’objet et utilisation de référence.
 Héritage entre types objets.
 Comptabilité ascendante conservée.

SOLUTON1: LE MODÈLE
RELATIONNEL ÉTENDU (OBJET-
RELATIONNEL)
LES SGBDRO

 Les SGBDRO sont nés du double constat de la puissance nouvelle

promise par les SGBDOO et de l'insuffisance de leur réalité pour
répondre aux exigences de l'industrie des BD classiques. Leur
approche est plutôt d'introduire dans les SGBDR, les concepts
apportés par les SGBDOO plutôt que de concevoir de nouveaux
systèmes (CROZAT, 2014).
 Cette approche intègre des éléments de structure complexe dans une
relation de type NF2 (Non First Normal Form) et pourra contenir un
attribut composé d’une liste de valeurs ou de plusieurs attributs
(Sans, 2000).
 Dans ce contexte, les SGBDRO peuvent (1) gérer des données
complexes (temps, géoréférencement, multimédia, types utilisateurs,
etc.), (2) rapprocher le modèle logique du modèle conceptuel et (3)
réduire les pertes de performance liées à la normalisation et aux
jointures (Sans, 2000).
Par rapport au modèle relationnel standard : on a moins besoin d’aplatir les données, ici on a
une seule table avec des tables imbriquées au lieu de 3 tables on a moins besoin de faire des
jointures pour récupérer les informations sur les accidents du contrat 1111, on accède
simplement à l’attribut accidents.
ADT: ABSTRACT DATA TYPE

CREAT [OR REPLACE] TYPE [nom schema.] <nom ADT><corps>;/

 Pour introduire un type abstrait de données (ADT: Abstract Data

Type)
 pour définir nouveaux types dépendant de l’application

Replace est pour modifier un type existant sans le supprimer et le recréer à nouveau.

Le corps du type est représenté comme suit:

AS <TYPE ADT> | UNDER <super type>
(<nom attribut1>) type d’attribut1, <nom attribut2> type
d’attribut2, ….
[<méthodes>
Spec sous-programmes, Spec constructeurs, Spec fonction
d’ordre map, Spec pragma])
<FINAL | NOT FINAL> <INSTANTIABLE | NOT
INSTANTIABLE>.
 Types d’ADT
Quatre type d’ADT:
Objet (OBJECT), tableau (VARRAY), table imbriqué (NESTED TABLE) et type référence (REF)
1/ TYPE OBJECT
Le type OBJECT permet de créer des valeurs structurées sous forme de couple <valeur, OID> tels que:
Valeur: une donnée
OID: identificateur d’objet
Exemple: création de type adresse:

SQL> CREATE OR REPLACE TYPE ADRESSE_T AS OBJECT <

2 Num INTEGER,
3 Rue VARCHAR2 <40>, ●
ADRESSE_T
4 Ville VARCHAR2 <40>,
5 Pays VARCHAR2 <40>;
●
Num ●
Rue ●
Ville ●
Pays
6 /

Exemple de création d’objet

L’héritage:
On peux créer un sous type à partir d’un type existant,

Exemple: le type ‘’ ETUDIANT_T ’’ hérite le type ’’Personne_T’’

NB:
• Le type abstrait ne possède qu’un seul super
type (héritage simple)
• Un type hérite les méthodes et les structures de
données de son super type,
• On peux assurer des imbrications d’héritage de
type (type2 hérite type1 et type3 hérite
type2,etc )
2/ Type VARRAY

Veut dire littérairement ’’variable de type Array’’ qui est concrètement un tableau dynamique: permet de
définir des collections de taille limitée de données ordonnées, indexées avec les doubles [1]

Exemple:
Création de type Prenoms de chaines de caractères est faite comme suit

SQL> CREATE OR REPLACE TYPE Prenoms as VARRAY (4) OF

VARCHAR(20);
2/
3/ Type NESTED TABLE

Le Type NESTED TABLE: ou table imbriquée, correspond à des collections non ordonnées et non limitées en
taille avec des doubles [4,11].

la création de type NESTED TABLE est faite par le mot clé TABLE OF.
Exemple1
On crée le type nested table ’’ens_diplomes’’ à partir du type ‘’diplomes’’
Exemple2
Création de table d’objets avec la table imbriquée Nested table

Remarque:Une Nested Table n’est pas une table objet, elle ne possède pas d’OID
3/ Type REF

Le type REF d'un attribut dit "attribut référence" ayant comme valeur d'identificateur d'objet OID.
Il permet de référencer une ou plusieurs instances d'un type d'objet afin de réduire les jointures entre
tables [4, 11]. Ce type conserve dans les tables une référence plutôt qu'une clé étrangère.
LE SCHÉMA RELATIONNEL ÉTENDU

 Le schéma relationnel étendu décrit les types ADT et les relations à travers le
langage SQL[4].Il existe deux modes d'associations [9,10]:
 Associaion symétrique: assure une imbrication partielle entre types. Dans ce
mode, deux relations sont dominantes. Il produit deux tables avec des
références entre elles.
 Association agrégation: dans ce mode d'association, l'un des types ADT domine
l'autre. Ce mode assure l'imbrication totale qui produit une seule table.


DÉCLARATION & MANIPULATION DU TYPE OBJET

Création
La commande CREATE TYPE permet de créer un type objet. Elle
possède trois parties :
(1) Déclaration de la structure du type
(2) Déclaration des méthodes associées au type
(3) Positionnement du type dans une hiérarchie d’héritage.
DÉCLARATION & MANIPULATION DU TYPE OBJET
EXEMPLE: DÉCLARATION & MANIPULATION DU TYPE OBJET

Exemple: type objet: Pilote-t

CREATE OR REPLACE TYPE etat_civil_t AS OBJECT

(nom VARCHAR(30), datenais DATE)
/

CREATE OR REPLACE TYPE adresse_t AS OBJECT

(nrue NUMBER(3), rue VARCHAR(40), ville VARCHAR(30))
/
EXEMPLE: DÉCLARATION & MANIPULATION DU TYPE OBJET

CREATE OR REPLACE TYPE pilote_t AS OBJECT

(brevet CHAR(6), etat_civil etat_civil_t, adresse adresse_t,
paye NUMBER(6,2))
/
EXEMPLE: DÉCLARATION & MANIPULATION DU TYPE OBJET

Suppression d’un type objet

DROP TYPE nom_du_type [OPTION]

Ex. 2 : Détruire le type « pilote_t »
DROP TYPE pilote_t
DÉCLARATION & MANIPULATION DU TYPE OBJET

Persistance d’objet
Un type objet permet de créer trois catégories d’objets sous Oracle :
Objets colonne : stockés en tant que colonne dans une table ;
Objets ligne : stockés en tant que ligne d’une table objet. Chaque objet
ligne possède un identificateur d’objet OID unique ;
Objet non persistant : existe durant l’exécution d’un programme PL/SQL.
DÉCLARATION & MANIPULATION DU TYPE OBJET

Objet colonne

Un type objet peut être utilisé comme type d’une colonne dans une table
relationnelle (ou objet). Cette colonne contiendra des objets colonne.
DÉCLARATION & MANIPULATION DU TYPE OBJET
Vols
numero
dateVol
Objet colonne nombrePax
depart,
arrivee,
Exemple: CDB
La colonne « CDB » est définie à l’aide du type « pilote_t ».
Elle contiendra des objets colonne.
DÉCLARATION & MANIPULATION DU TYPE OBJET

Vols
Objet colonne numero
dateVol
nombrePax
depart,
CREATE TABLE Vols ( numero NUMBER, dateVol DATE, arrivee,
nombrePax NUMBER(3), depart VARCHAR(30), CDB
arrivee VARCHAR(30),
CDB pilote_t,
CONSTRAINT pk_Vols PRIMARY KEY(numero) );
DÉCLARATION & MANIPULATION DU TYPE OBJET

Instanciation d’un objet colonne

L’instanciation des objets colonne fait obligatoirement appel au constructeur par

défaut du type objet.
DÉCLARATION & MANIPULATION DU TYPE OBJET

Instanciation d’un objet colonne

exemple: instantier le type pilote_t; pilote_t() est le constructeur du type

pilote_t
INSERT INTO Vols VALUES
(1, ‘1970-02-05’, 120, 'Orly-Ouest', ‘Blagnac’,
pilote_t('PL-11',
etat_civil_t('Peyrard','05-02-1970'),
adresse_t (1,'G. Brassens', 'Blagnac'),
3500)) ;
DÉCLARATION & MANIPULATION DU TYPE OBJET

Extraction d’information d’un objet colonne

La notation pointillée est utilisée pour accéder à des colonnes terminales des
objets colonne.

exemple: Quelques informations des vols avec le nom du commandant de bord

pour chaque vol.
SELECT [Link], [Link], [Link].etat_civil.nom
FROM Vols v ;
CREATION D’UNE TABLE OBJET

Une table objet dépend d’un type objet. La directive OF dans l’instruction CREATE
TABLE permet de créer une table objet.

CREAT TABLE [schema.]nomTableObjet

OF [schema.]nomType [(Contraintes)] ;

Contraintes d’intégrité
Les contraintes (PRIMARY KEY, NOT NULL, CHECK, UNIQUE, etc.) doivent être
déclarées lors de la création de la table objet.
CREATION D’UNE TABLE OBJET

CREATE TABLE Pilotes OF Pilote_t

(CONSTRAINT pk_Pilote PRIMARY KEY(brevet),
CONSTRAINT df_paye paye DEFAULT 3000,
CONSTRAINT ck_paye CHECK(paye BETWEEN 3000 AND 5000),
CONSTRAINT nn_nom CHECK(etat_civil.nom IS NOT NULL),
CONSTRAINT un_nom UNIQUE(etat_civil.nom) ) ;
CONCEPT D’OBJET LIGNE

Les objets ligne sont stockés en tant que lignes d’une table objet.
Les valeurs d’un objet ligne occupent toutes les colonnes de la table.
Le constructeur par défaut du type objet est facultatif lors de l’instanciation des
objets ligne.
CONCEPT D’OBJET LIGNE
Exemple:
Un pilote sera stocké en tant qu’objet ligne alors que son état civil sera stocké en
tant qu’objet colonne.
INSERT INTO Pilotes VALUES (pilote_t('PL-11',
etat_civil_t('Peyrard', '05-02-1970'),
adresse_t(1,'G. Brassens', 'Blagnac'),3500));

INSERT INTO Pilotes VALUES (pilote_t('PL-12',

etat_civil_t('Laroche', '15-12-1963'),
adresse_t(2, 'Foch','Montauban'),4600) );

INSERT INTO Pilotes VALUES ('PL-13',

etat_civil_t('Labat','25-12-1965'),
adresse_t(3,'Camparols','Pau'),3000) ;
MANIPULATION D’OBJET LIGNE

Les tuples des tables objets sont modifiés par la commande UPDATE et supprimés
par la commande DELETE.
Un alias de la table objet est utilisé pour parcourir les colonnes terminales des
objets colonne.
MANIPULATION D’OBJET LIGNE
Exemple: Modifier et supprimer des pilotes de la table Pilotes

UPDATE Pilotes p
SET p.etat_civil.nom = ‘Sigaudes’, [Link]=3700
WHERE [Link] = ‘PL-11’ ;
DELETE FROM Pilotes p
WHERE NOT ([Link] = ‘Blagnac’);
CHARGEMENT D’UN OBJET
VALUE(alias) renvoie le contenu d’un objet sous forme d’un type.

Exemple: Récupérer sous forme d’objets les pilotes de la table

Pilotes.
SELECT VALUE(p)
FROM Pilotes p
WHERE [Link]= ‘PL-11’ ;
CHARGEMENT D’UN OBJET

Valeurs NULL
Un objet ligne ne peut être valué à NULL.
Un objet colonne (ou non persistant) peut être initialisé à
NULL.
CHARGEMENT D’UN OBJET

Exemple
INSERT INTO Pilotes VALUES( Pilote_t(‘PL1’, etat_civil_t (‘Bidal’, ’16-
01-1965’), adresse_t (NULL, NULL, NULL), 3000)) ;
L’objet colonne adresse est vide

INSERT INTO Pilotes VALUES(

Pilote_t(‘PL1’, etat_civil_t (‘Bidal’, ’16-01-1965’),
NULL, 3000)) ;
EXEMPLE: HÉRITAGES
HERITAGE DE TYPE

À partir d’un type utilisateur déjà créé, il est possible de définir un

sous-type en se basant sur le concept d’héritage.
La directive UNDER permet de définir un sous-type d’un type
générique.
HERITAGE DE TYPE

CREATE [OR REPLACE] TYPE [Link] [AS OBJECT | UNDER [Link]]

(colonne1 type1, ...

methode1 (paramètres1), ...)

[[NOT] INSTANTIABLE] [[NOT] FINAL]
/
HERITAGE DE TYPE
Le graphe d’héritage suivant décrit une hiérarchie de types ou « pilote_t » est à la fois sur-type et sous-
type.
HERITAGE DE TYPE
CREATE OR REPLACE TYPE etat_civil_t AS OBJECT (nom VARCHAR(30), datenais DATE)
/
CREATE OR REPLACE TYPE adresse_t AS OBJECT (nrue NUMBER(3), rue VARCHAR(40), ville
VARCHAR(30))
/
CREATE TYPE employe_t AS OBJECT (codemp CHAR(6), etat_civil etat_civil_t, adresse adresse_t, paye
NUMBER(6,2))
INSTANTIABLE NOT FINAL
/
CREATE TYPE pilote_t UNDER employe_t (nbHvol NUMBER, compagnie VARCHAR(6))
NOT INSTANTIABLE NOT FINAL
/
CREATE TYPE pilInstructeur_type UNDER pilote_t (nbHvolIns NUMBER, expireQualif DATE)
INSTANTIABLE FINAL
/
HERITAGE DE TYPE
Évolution des types
La commande ALTER TYPE permet de modifier les options FINAL et INSTANTIABLE d’un type

ALTER TYPE pilote_t FINAL;

ERROR: ORA-22326: cannot change a type to FINAL if it has subtypes
(creating a FINAL NOT INSTANTIABLE type)

ALTER TYPE employe_t NOT INSTANTIABLE CASCADE;

Type modifié

ALTER TYPE pilote_t INSTANTIABLE CASCADE;

Type modifié
HERITAGE DE TYPE
Évolution des types
La commande ALTER TYPE permet de modifier les options FINAL et INSTANTIABLE d’un type

ALTER TYPE pilInstructeur_t NOT INSTANTIABLE CASCADE;

ERROR: creating a FINAL NOT INSTANTIABLE type.
HERITAGE DE TYPE
Objets dérivés Le type « employe_t » est NOT INSTANTIABLE alors que les types «pilote_t»
et «pilInstructeur_t» sont INSTANTIABLE
HERITAGE DE TYPE
Objets dérivés
CREATE TABLE Pilotes OF pilote_t (
CONSTRAINT pk_Pilotes PRIMARY KEY(codemp));

CREATE TABLE PilotesInstructeurs OF pilInstructeur_t

(CONSTRAINT pk_PilotesInstructeurs PRIMARY KEY(codemp));
HERITAGE DE TYPE
Objets dérivés
INSERT INTO Pilotes VALUES (pilote_t ('E1',
etat_civil_t('Diffis','05-02-1970'),
adresse_t(1,'G. Brassens','Blagnac'),
3500, 1000, 'ALIB') );
Ligne insérée.
INSERT INTO PilotesInstructeurs VALUES ('E2',
etat_civil_t('Ente', '11-09-1968'),
adresse_t(10,'Perantony','B/leze'),
5500, 1500, 'ALIB', 500, '28-02-2003') ;
Ligne insérée.
HERITAGE DE TYPE
Objets dérivés
INSERT INTO Employes VALUES ('E3',
etat_civil_t('lacombe', '05-02-1960'),
adresse_t(1, 'Di Roma', 'Aucamville'), 8500);
ERROR : ORA-22826 : cannot construct an instance of a non
instantiable type.
HERITAGE DE TYPE
Substitution d’objets colonne
La capacité de pouvoir substituer un objet d’un type par un objet sous-
type est appelée la substitution.

Une colonne de type T pourra contenir des objets colonne créés à partir
du type T ou de tout sous-type de T.
HERITAGE DE TYPE
Substitution d’objets colonne
Exemple

CREATE TYPE pilote_t AS OBJECT (brevet VARCHAR(6), nom VARCHAR(20), ) NOT FIANL
/
CREATE TYPE pilotechasse_t UNDER pilote_t (baseAerienne VARCHAR(20), surnom VARCHAR(10))
/

CREATE TYPE piloteLigne_t UNDER pilote_t (compagnie VARCHAR(15))

/
CREATE TYPE avion_t AS OBJECT ( immat VARCHAR(6), pilote pilote_t)
HERITAGE DE TYPE
Substitution d’objets colonne
Exemple
CREATE TABLE Avions OF avion_t (CONSTRAINT pk_Avions PRIMARY KEY (immat));
/

La colonne pilote de type pilote_t pourra contenir des objets du type pilote_t ou des objest de tous
sous types ( ici pilotechasse_t et piloteligne_t)
/
HERITAGE DE TYPE
Substitution d’objets colonne
Exemple
Pour insérer des nouveau tuples dans la table Avions on feras ainsi:

INSERT INTO Avions VALUES (avion_t (‘F-NTSS', pilote_t (‘PL-1’, ‘MIRANDA’)))

INSERT INTO Avions VALUES (avion_t (‘F-PAUL', pilotechasse_t (‘PL-2’, ‘Soutou’, ‘Mt de Marsan’,
‘Faucon’)));
INSERT INTO Avions VALUES (avion_t (‘F-ENTE', piloteligne_t (‘PL-3’, ‘Ente’, ‘Air-littoral’)))
HERITAGE DE TYPE
Substitution d’objets ligne
Une table objet créée à base du type T pourra contenir des objets ligne créés à partir du type T ou de
tout sous-type de T.

Exemple

CREATE TABLE Pilotes OF pilote_t (CONSTRAINT pk_Pilotes PRIMARY KEY (brevet));

/
Ensuite pour insérer une instantiation on fait:
INSERT INTO Pilotes VALUES (pilote_t('PL-1', 'Miranda’));
INSERT INTO Pilotes VALUES ( pilotechasse_t('PL-2', 'Soutou', 'Mt de Marsan', 'Faucon'));
INSERT INTO Pilotes VALUES ( piloteLigne_t('PL-3', 'Ente', ‘Air-Littoral’));
HERITAGE DE TYPE
Fonction TREAT
TREAT (nomObjet AS nomType) permet d’accéder à un élément substituable en particulier. Elle traite
un objet d’un sur-type comme un objet d’un sous-type.

Exemple: Afficher les objets de la colonne pilote de la table Avions en tant

qu’instance du type piloteLigne_t

SELECT TREAT(pilote AS piloteLigne_t)

FROM Avions;
HERITAGE DE TYPE
Fonction TREAT
Exemple: Afficher les objets de la colonne pilote de la table Avions en tant
qu’instance du type piloteLigne_t

TREAT(PILOTEASPILOTELIGNE_T) (BREVET, NOM, COMPAGNIE)

---------------------------------------------------------
Ligne vide
Ligne vide
PILOTELIGNE_T ('PL-3', 'Ente, ‘Air-Littoral’)
HERITAGE DE TYPE
Fonction IS OF
IS OF ([ONLY] nomType [, nomType1, ...] permet de comparer un objet à un ou plusieurs objets.
La direction ONLY permet de spécifier un niveau précis de la hiérarchie des types.

Exemple: Afficher à partir de la table Avions les noms et les compagnies des
pilotes de ligne.
SELECT [Link],
TREAT([Link] as piloteLigne_t).compagnie as compagnie
FROM Avions a
WHERE [Link] IS OF (piloteLigne_t) ;
HERITAGE DE TYPE
Fonction IS OF

[Link] COMPAGNIE
------------------------------------------------------
Ente Air-Littoral
HERITAGE DE TYPE
Exercice
1. Afficher les objets ligne de la table Pilotes en tant qu’instance du type piloteLigne_t
2. Afficher à partir de la table Avions les pilotes de chasse et les pilotes de ligne.
3. Afficher à partir de la table Pilotes les noms et les compagnies des pilotes de ligne.
4. Afficher à partir de la table Pilotes les pilotes de chasse et les pilotes de ligne.
5. Afficher l’immatriculation des avions et les noms des pilotes qui ne sont ni pilotes de
chasse ni pilotes de ligne.
6. Afficher les pilotes (table Pilotes) qui ne sont ni pilote de chasse ni pilote de ligne.
LANGAGE DE DÉFINITION DES DONNÉES OBJET-
RELATIONNELLES

 Nous distinguons trois types de tables de données:


 table relationnelle: une table classique qui contient des données simple (sans ADT)
 table NF2: Not First Normal Form) contenant des attributs complexes
 table d'objets: une table créée à partir de type OBJECT


LANGAGE DE DÉFINITION DES DONNÉES OBJET-
RELATIONNELLES

La modification d'une table relationnelle classique ou table NF2 est faite par la commande:

Alter TABLE nom-table <Action>

Action peut être: renommer, supprimer (drop), ajouter (ADD) et modifier (MODIFY) les éléments de la
table

Exemple

Alter TABLE Person RENAME Person to Personne

LANGAGE DE DÉFINITION DES DONNÉES OBJET-
RELATIONNELLES

Modifier les attributs et méthodes d'une table d'objet revient à modifier son type d'objet par la
commande:

Alter TYPE nom-type <Action> CASCADE;

avec Action permet de: Ajouter, Modifier, Supprimer, et mettre à jour des attributs, méthodes [4]

Exemple: ajouter au type adresse_T deux attributs "CodePostal" et "Code"

LANGAGE DE DÉFINITION DES DONNÉES OBJET-
RELATIONNELLES
Langage de manipulation de données
Objet-relationnelles
Vise à effectuer les opérations d’insertion, de suppression, de modification et de recherche de données [4,6,9]

A. Insertion de données: La syntaxe générale d’insertion de données est la suivante:

Langage de manipulation de données
Objet-relationnelles
Exemple: L’insertion de l’employé Farah Ahmed dans la table employe est:
Cas: une collection (table imbriquée)
●
Num ●
Nom ●
DateP ●
Voitures
●
1 ●
Djaber Ilyes ●
10/12/2015 ●
Matricule modèle
Marque
●
I-2020- ●
F355 ●
Ferrari
120
●
A- ●
2CV ●
Citroen
2021-
240

●
Matricule ●
Modele ●
Marque
CREATE OR REPLACE TYPE voiture_t OF Object ( Matricule VARCHAR (30),
Modele VARCHAR (30),
Marque VARCHAR(30));
/

CREATE TYPE ens_voitures as TABLE OF voiture_t

CREATE OR REPLACE TYPE personne_t OF Object ( Num INTEGER (5), Nom VARCHAR2(20),
Date-p DATE, Voitures ens_voitures);
/
CREATE TABLE Personne of personne_t ( primary key (num)),
NESTED TABLE Voitures STORE AS lesvoitures;
/
Dans le cas de l’insertion d’un nouveau tuple tuple dans la table imbriquée, on utilise le constructeur voiture_t

Exemple: insérer une nouvelle personne appelé Djaber

INSERT INTO Personne VALUES ( 121212, ‘Djaber’, ‘Ilyas’,

ens_voitures(voiture_t(17201820020, ‘Toyota’, ‘Yaris’),
voiture_t(98979897989, ‘Renault’,’Kango’)), 10/12/2020,50);
/
Dans le cas de l’insertion d’un tuple dans la table imbriquée pour une personne déjà insérée, on utilise la clause TABLE
Exemple: Ajouter à la personne ‘’Djaber’’ une nouvelle voiture
Dans le cas d’insertion d’un tuple dans une table contenant un attribut de type VARRAY, on
procède de la même manière que le NESTED TABLE

Exemple:
Exemple

Le type REF d'un attribut dit "attribut référence" ayant comme valeur d'identificateur d'objet OID.
Il permet de référencer une ou plusieurs instances d'un type d'objet afin de réduire les jointures entre
tables [4, 11]. Ce type conserve dans les tables une référence plutôt qu'une clé étrangère.
Exemple: Insérer un nouveau étudiant et lui affectant le poste ordinateur 10

INSERT INTO Etudiant VALUES ( 34933, ‘Moufak’, ‘Amine’,’2Master’,1,

(SELECT REF (P) FROM Poste P WHERE Num =10);

1row created

Le mot clé REF joue le rôle d’un opérateur qui consiste à récupérer l’OID à partir
d’une table d’objet
B. Suppression de données:
DELETE FROM Etudiant
WHERE PC= (SELECT REF (V) FROM Poste V
WHERE [Link] =‘windows10’);

1row deleted

On souhaite supprimer tous les étudiants ayant un pc avec SE windows10

B. Modification de données:

Exemple
Modification d’une valeur de type structuré: on utilise son constructeur

UPDATE Personne P
SET [Link] =Adresse_t (01, ‘rue 08 mai 45’, ‘Setif’)
WHERE [Link] =1234);

1row updated
Modification d’une valeur d’un attribut d’une table imbriquée

UPDATE TABLE( SELECT [Link] from Personne P WHERE

[Link]=‘DJABER’) H
SET [Link] =‘ZOE’
WHERE [Link] =‘Renault’);

1rows updated
Modification d’une valeur d’un attribut REF

UPDATE Etudiant
SET PC= (SELECT REF (V) FROM Poste V
WHERE SE =‘ubuntu’),
WHERE nom=‘hadri’;

1row updated
B. Recherche de données:
B. Cas un attribut objet (complexe):

Select [Link], [Link]

From personne P

Name [Link]
KHLOADI CONSTANTINE
MOUSSA ORAN
B. Cas un attribut NESTED TABLE:
On doit utiliser le mot clé TABLE dans la clause FROM

Select V.column_value.Marque
From personne P, TABLE ([Link]) V;

COLUMN_VALUE.MARQUE
RENAULT
BMW
B. Cas un attribut VARRAY:

Select [Link] [Link]

From personne P

NOM
PRENOM

TOUMI
Prenoms(‘Nada’, ‘Ania’)
B. Cas un attribut VARRAY:
B. Pour définir l’attribut de type VARRAY dans la clause FROM on doit
utiliser le mot clé TABLE pour parcourir le tableau dynamique VARRAY
Select [Link]
From personne P, TABLE([Link]) PN
WHERE PN.column_value=‘nada’

NOM

TOUMI
ZERARRI
B. Cas un attribut REF:
Nous distinguons deux opéartions:
REF(objet): permet d’obtenir l’OID de cet objet
DEREF (OID): opération inverse de REF elle récupère la valeur d’objet à
partir de son identificateur (OID)

Select P.*
From personne P, TABLE([Link]) V;

Column_value

00000002200882067965DE2A387E574568FFFF72447B9A4A18450AA2A8E2A020F4600
 Exemple d’utilsation de DEREF

Select DEREF(V. column_value)

From personne P, TABLE([Link]) V;

DEREF(V.column_value)(Num, SE, Adrese IP)

Poste_t ( 00000002200882067965DE2A387E574568FFFF72447B9A4A18450AA2A8E2A020F4600,
Windows10, [Link]) )
Poste_t(00000002200882067965DE2A387E574568FFFF72447B9A4A1821BBBBB012A8E2A020F460,
Ubuntu, [Link])
LE SCHÉMA RELATIONNEL ÉTENDU

 Exemple: Soit le schéma conceptuel modélisant une personne et sa possession

d’une voiture
 Personne (Num, Nom, DateP, voitures )
 Voiture(Matricule, Modele, marque, Num)
 La figure suivante illustre la création de ce shéma qui se traduit par une association
symétrique entre une personne et sa voiture (création de deux tables)


Voiture Personne

Matricule 1,1 1,n Num

Posséder
Modele Nom
Marque DateP

Voir règles de passage

Manipulations avancées de données Objet-
relationnelles
Méthodes

AS <TYPE ADT> | UNDER <super type>

(<nom attribut1>) type d’attribut1, <nom attribut2> type
d’attribut2, ….
[<méthodes>
Spec sous-programmes, Spec constructeurs, Spec fonction
d’ordre map, Spec pragma])
<FINAL | NOT FINAL> <INSTANTIABLE | NOT
INSTANTIABLE>.
Exemple: Function Getmodel(matricule)

Voiture

Matricule
Marque
Modèle
carburant

Getmodel (matricule)
Exemple
SQL> CREATE TYPE Voiture_T AS OBJECT(Matricule INTEGER,
2 Marque VARCHAR2(40), Modele VARCHAR2(40), Carburant VARCHAR2(20),
3 MEMBER FUNCTION Get_Modele (Matricule IN INTEGER) RETURN VARCHAR2);
5/
Type created.

Le corps de la fonction Get_Modele est défini comme suit :

SQL> CREATE TYPE BODY Voiture_T AS
2 MEMBER FUNCTION Get_Modele(Matricule IN INTEGER) RETURN VARCHAR2 IS
T VARCHAR2(40);
BEGIN
SELECT [Link] INTO T
FROM Voiture V
WHERE [Link] = Matricule;
RETURN T;
END Get_Modele;
END
Type body created.
Déclaration des méthodes

 Soit au début lors de la déclaration de l’objet

 Soit plus tard avec commande ALTER TYPE
 Le corps de la méthode correspond aux
opérations effectuées sur l’objet, il peut
faire référence à l’objet concerné grâce à
SELF.
MÉTHODES: EXEMPLE : TYPE OBJET
CONTENANT UNE FONCTION

La fonction age n’a pas de paramètres donc elle s’applique sur l’objet lui-même
grâce au paramètre self
MÉTHODES: TYPE OBJET CONTENANT UNE
FONCTION
MÉTHODES: TYPE OBJET CONTENANT UNE
FONCTION
MÉTHODES: TYPE OBJET CONTENANT UNE
FONCTION (ALTER TYPE )

alter type tpersonne add member function age return numeric cascade;
create or replace type body tpersonne as member function age return numeric Déclaration par
is ajout de la
age_val number; fonction à
Begin l’objet grâce à
Select round((sysdate-self.date_naiss)/365) into age_val From dual; Alter type
Return age_val;
End ;
End;
/
Programmation PL/SQL
Programmation PL/SQL
Exemple
Les vues objet-relationnelle
Les triggers
Comparaison
TYPES RÉCURSIFS
CREATE TYPE PILOTE_T;
/

/
CREATE TYPE PILOTE_TYPE AS
OBJECT
(Brevet CHAR(6), paye NUMBER(6,2),
nbhvol NUMBER(5), Compagnie
NUMBER(6), ESTCHEF_P REF
PILOTE_T)
 Contraintes d’intégrité
Exemple d’une BDD relationnel objet

 CREATE TYPE Siegesocial_t AS OBJECT (nrue NUMBER(3), rue VARCHAR(20), ville VARCHAR(15))
 /
 CREATE TYPE Compagnie_t AS OBJECT (comp VARCHAR(4), siege_social siegesocial_t, nomComp VARCHAR(15))
 /
 CREATE TABLE Compagnie OF Compagnie_t (CONSTRAINT axComp PRIMARY KEY(comp));


 CREATE type Filiale_t as object (im VARCHAR(6), localisation VARCHAR(20), chiffre-affaire NUMBER(4),
rCompagnie REF Compagnie_t)

 Contraintes d’intégrité: SCOPE IS et NOT NULL
Exemple

 Ceci veut dire

CREATE type Filiale_t as object (im VARCHAR(6), localisation VARCHAR(20), chiffre-affaire NUMBER(4), rCompagnie que l’attribue
rCompagnie pointe sur la table
REF Compagnie_t)
 Pour la création de la table: Compagnie et ne peut pas pointer les tables qui héritent la table
 compagnie (s’ils existent)
CREATE TABLE Filiale of Filiale_t ;
 CONSTRAINT axrCompagnie REFERENCES Compagnie,
 CONSTRAINT axrCompagnie SCOPE IS Compagnie //
 CONSTRAINT axfiliale PRIMARY KEY(im),
 CONSTRAINT axrComp CHECK (rCompagnie IS NOT NULL))
 Contraintes d’intégrité: REFERENCES et NOT NULL
Exemple

 CREATE TABLE Filiale of Filiale_t ;

 CONSTRAINT axrCompagnie REFERENCES Compagnie,
 CONSTRAINT axfiliale PRIMARY KEY(im),
 CONSTRAINT axrComp CHECK (rCompagnie IS NOT NULL))
 Contraintes d’intégrité: Cohérence du père (parent) vers son (ses) fils
(child) (suite)
Exemple

Supposons on veut supprimer une compagnie ‘’SING’’

 Qui est objet de la table père qui est référencée par la filiale « F-M1 » (objet de la
table fils).
 DELETE FROM Compagnie WHERE comp=’SING’;
 Le message suivant s’affiche: ERREUR : violation de contraintes axrComp …
enregistrement fils existant
 La BDD devient incohérente à cause des références perdues (DANGLING REF)..

 Contraintes d’intégrité: Cohérence du fils (child) vers son père (parent)
Exemple

 Insérer un filiale qui référence une compagnie inexistante.

 INSERT INTO Filiale VALUES (‘F-M2’, ‘Alger’, 235M, (SELECT REF(c) FROM Compagnie c WHERE
[Link]=’ALIB’)) ;
 ERREUR …. violation de contraintes axrComp de vérification
 La cohérence est assurée du fait de la contrainte NOT NULL.
 Insérer une filiale contenant une référence vers une autre table dépendant du type Compagnie_t.
 INSERT INTO Filiale VALUES (‘F-T’, ‘Certa’, 200m, (SELECT REF(c) FROM Compagniebis c WHERE
[Link]=’AF’)) ;
 ERREUR …. la valeur REF ne pointe pas sur une table scoped. La compagniebis n’est pas mis dans scope is
 La contrainte REFERENCES remplit le rôle de la contrainte SCOPE IS précédemment décrite.
CONCLUSION

Selon (CROZAT, 2014) (Sans, 2000), les atouts du modèle relationnel peuvent se résumer
comme suit :
1. C’est un modèle fondé sur une théorie rigoureuse et des principes simples. Il est aussi fiable et performant car il assure
l’indépendance entre les programmes et données
2. Les SGBDR sont les plus utilisés, connus et maîtrisés.
3. L’utilisation du SQL pour une implémentation standard du modèle relationnel, avec des API pour la plupart des
langages de programmation.
4. Les SGBDR incluent des outils performants de gestion de requêtes, de générateurs d'applications, d'administration,
d'optimisation, etc.
5. C’est un modèle bien implanté dans le monde professionnel car il permet une organisation structurée des données et
un accès par des utilisateurs concurrents.
CONCLUSION

le modèle objet-relationnel (OR) ou le modèle relationnel-objet (RO) est un modèle relationnel étendu avec des
principes objet pour en augmenter les potentialités (Informix, Oracle, Sybase, IBM/DB2, CA-OpenIngres,
PostGres, ....). Il offre de nouvelles possibilités comme :

1. La définition de nouveaux types complexes avec des fonctions pour les manipuler (une colonne peut contenir
une collection (ensemble, liste) et une ligne considérée comme un objet avec un objet)

2. Utilisation de références aux objets ou des Identificateur (Object Identifier OID)

3. Extensions du langage SQL (SQL3) pour la recherche et la modification des données

CONCLUSION

Cependant
l’OR ne s’appuie pas sur une théorie solide comme le modèle relationnel et il manque d’implémentation standard de
SGBD. Le concept central du RO est celui de type utilisateur, correspondant à la classe en POO, qui permet d'injecter
la notion d'objet dans le modèle relationnel. Les apports principaux des types utilisateurs sont :
o La gestion de l'imbrication (données structurées et collections)
o Les méthodes et l'encapsulation
o L'héritage et la réutilisation de définition de types
o L'identité d'objet et les références physiques
CONCLUSION

Nouveauté apporté par le modèle relationnel objet:

1. Les tables imbriquées (Nested model) qui permettent de dépasser les limites de la première forme normale et de
limiter la fragmentation de l'information.

2. Les tables objets qui permettent d'ajouter les identifiants d'objets (OID), les méthodes et l'héritage aux tables
classiques.

3. les tableaux dynamiques

 CROZAT, S. (2014). Le modèle logique relationnel-objet et son implémentation sous Oracle.
[Link]
Sans, V. (2000). BASE DE DONNÉES OBJET. Université de RENNE 1.
‘’ Bases de données Avancées’’, Aicha Aggoune, Université de Guelma

RÉFÉRENCES