Bases de Données Avancées

CHAPITRE II

Bureau 26
Bloc des enseignants- Université de Bejaia
& LIMED
Nassima.bouadem@univ-bejaia.dz

2022/2023 M1RN RS/SIA/ASR

Dr. Nassima BOUADEM
CHAPITRE II
BASE DE DONNEES OBJET-
RELATIONNELLE
  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

PLAN
 Structure de données simple
 Pas de référence entre tables
 Pauvereté du système de typage
 Programmation interdite dans le SGBD
 Sémantique insuffisante

LIMITES DU MODÈLE RELATIONNEL

 BDOR est définit par [1]:
 Les tables (relations) ne suivent pas la première forme normale.
 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 NF 2 (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 [4,9]

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, ADRESSE_T
3 Rue VARCHAR2 <40>,
Num Rue Ville Pays
4 Ville VARCHAR2 <40>,
5 Pays VARCHAR2 <40>;
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.
Exemple: soit le schéma suivant
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
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))
/
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))
/
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 v.numero, v.depart, v.CDB.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'),2600) );

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’, p.paye=3700
WHERE p.brevet = ‘PL-11’ ;
DELETE FROM Pilotes p
WHERE NOT (p.adresse.ville = ‘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 p.brevet= ‘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_ty(‘PL1’, etat_civil_t (‘Bidal’, ’16-01-1965’),
NULL, 3000)) ;
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 schema.nomType [AS OBJECT | UNDER schema.nomSurType]

(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 a.pilote.nom,
TREAT(a.pilote as piloteLigne_t).compagnie as compagnie
FROM Avions a
WHERE a.pilote IS OF (piloteLigne_t) ;
HERITAGE DE TYPE
Fonction IS OF

PILOTE.NOM 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.