Chapitre 1: Introduction aux Base

de données Objets Oracle

 Objets d’oracle
• Le type objet d’oracle est un type utilisateur
qui modélise une entité du monde réel:
– Client, Ordre d’ achat…..
• Un nouveau objet peut être créer à partit
d’une base de données ou un autre type qui
existe déjà.
• Les types objets peuvent définir des données
complexes telles que:
– Image, audio, vidéo
 Objets d’oracle
• Oracle stocke les donnée pour un type objet
dans un schéma qui peut être utiliser par SQL,
PL/SQL, Java et autre langage.
• Les objets d’oracle peuvent stocker des
données sous forme de tableaux et de tables
imbriquées:
– L’approche objet ne respecte pas les formes
normales des BD relationnelles.
 Avantage de Oracle Objet
• Le model objet d’oracle est similaire au
mécanisme de classe de C++ et Java.
– Permet d’utiliser les méthodes déjà définies dans
le type objet et ainsi développer des applications
rapidement et efficacement.
 Avantage de Oracle Objet
• L’objet peut encapsuler des données et les
opérations.
• Exemple:
– Un objet ordre d’achat peut inclure une méthode
pour calculer le prix de tous les articles achetés.
– Un objet client peut inclure une méthode pour
afficher l’historique des payements.
 Avantage de Oracle Objet
• Les Objets sont efficaces:
– Les développeurs d’application peuvent utiliser les
méthodes encapsuler sans avoir besoin d’en
redéfinir d’autres.
– On peut chercher et manipuler une collection
d’objets comme s’il s’agit d’une seule entité.
 Avantage de Oracle Objet
• Les objets peuvent réduire l’utilisation abusive
des clés primaires et clé étrangère et des
jointures complexe entre les tables
• Un objet peut avoir un autre objet dans ces
attributs qui à son tour peut avoir un autre
objet parmi ces attributs.
L’aspect Objet-Relationnel d’oracle
• Les bases de données oracle implémentent
l’approche objet tout en conservant les
fonctionnalités standards des bases de
données relationnelles.
• SQL et une variétés de langage tels que
PL/SQL, Java, Oracle Call interface, Pro*C/C++,
C# ont été améliorés pour supporter les objets
d’oracle
Le type Objet (ou type utilisateur)
• Un type objet est une sorte de type de donnée
qu’on peut utiliser comme n’importe quel
type primitif – varchar2, number…
• Un attribut d’une table peut être de type
objet
• Une variable peut être d’un type objet
• La valeur est une instance (ou objet ) du type
objet
• Un type objet est un schéma de la base de
données: le code d’une application peut
 Type Objet et instances objet
OObject Type person_typ
Attributes Methods
dno get_idno
first_name display_details
last_name
email
phone

Objet 1 Objet 2

idno: 65 idno: 101

first_name: Verna first_name: John
last_name: Mills last_name: Smith
email: vmills@example.com email: jsmith@example.com
phone: 1-650-555-0125 phone: 1-650-555-0135
 Type Objet
• Un type objet défini la structure et le
comportement des objets: il est composé des
attributs et des méthodes.
• Les attributs contiennent les données de
l’objet.
• Les méthodes sont des procédures ou
fonctions que les applications peuvent utiliser
afin de perfectionner les opérations sur les
données de l’objets.
 Créer un type objet: Spécification de
l’objet
CREATE TYPE person_typ AS OBJECT (
idno NUMBER,
first_name VARCHAR2(20),
last_name VARCHAR2(25),
email VARCHAR2(25),
phone VARCHAR2(20),
MAP MEMBER FUNCTION get_idno RETURN NUMBER,
MEMBER PROCEDURE display_details ( SELF IN OUT NOCOPY
person_typ ));
/
 Créer un type objet : Corps de l’objet
CREATE TYPE BODY person_typ AS
MAP MEMBER FUNCTION get_idno RETURN NUMBER IS
BEGIN
RETURN idno;
END;
MEMBER PROCEDURE display_details ( SELF IN OUT NOCOPY person_typ ) IS
BEGIN
-- La procedure PUT_LINE du paquetage DBMS_OUTPUT permet d’afficher
DBMS_OUTPUT.PUT_LINE(TO_CHAR(idno) || ' ' || first_name || ' ' || last_name);
DBMS_OUTPUT.PUT_LINE(email || ' ' || phone);
END;
END;
/
 Instances (objet) de type objet
• La définition d’un type objet n’entraine aucun
stockage au niveau de la mémoire.
• Une fois une instance est crée, la mémoire est
allouée.
• La création de l’objet est réalisé en appelant le
constructeur du type objet. Example:
persone_typ(65, ‘Verna’, ‘Mills’,
‘vmills@example.com’, ‘1-650-555-0125
’ ),
 Colonnes de type objet
• Une table relationnelle peut avoir une colonne
de type objet. Exemple:
CREATE TABLE contacts (
contact person_typ,
contact_date DATE );
• Insertion dans la table:
INSERT INTO contacts VALUES ( person_typ (65,
'Verna', 'Mills', 'vmills@example.com',
'1-650-555-0125‘ ), '24 Jun 2003' );
 Les objets colonnes
• Les objets qui occupent une colonnes d’une
table relationnelle sont appelées « objets
colonnes ».
• Les instance sont stockés avec les données de
la table.
 Les méthodes d’un objet
• Méthode membre : Permet un accès au données de
l’objet et faire des traitement là-dessus
• Méthode statique: Fonction ou procédure qui n’utilise
aucun attribut de l’objet. Elle dépendent seulement de
type objet.
• Méthode Constructeur: Appelée pour construire un
nouveau objet. Un constructeur par défaut est fourni
pour le type objet.
– Mais si le type objet défini une méthode constructeur, le
constructeur par défaut n’existe plus.
 Utilisation d’une méthode
• Exemple: appel de get_idno() du person_Typ
SELECT c.contact.get_idno() FROM contacts c;
 Création d’une table Objet
• Exemple:
CREATE TABLE person_obj_table OF person_typ;

• On peut voir cette table de deux maniere:

– Comme un seule colonne dans laquelle chaque ligne est un
objet de type person_typ. Donc permet d’appliquer les
fonctionalité de l’orienté objet
– Comme une table à plusieurs colonne, dans laquelle
chaque attribut de l’objet type occupe une colonne. Donc
permet d’appliquer les fonctionalité du relationnelles.
 Table Objet
persone_typ(65, ‘Verna’, ‘Mills’, ‘vmills@example.com’, ‘1-650-555-0125’)

persone_typ(70, ‘John’, ‘Evin, ‘jEvin@example.com’, ‘1-650-555-0315’)

persone_typ(95, ‘Alain’, ‘Paul’, ‘apaul@example.com’, ‘1-650-555-0401’)

INSERT INTO person_obj_table VALUES (
person_typ (65, 'Verna', 'Mills',
'vmills@example.com', '1-650-555-0125‘ ))
 Table relationnelle
idno first_name last_name email phone
 Operation sur la table objet
person_obj_table
• Insertion en utilisant person_obj_table comme une table multicolonne:

INSERT INTO person_obj_table VALUES ( person_typ(101, 'John', 'Smith',

'jsmith@example.com', '1-650-555-0135') );

• Sélection en utilisant person_obj_table comme une seule colonne en utilisant la

fonction “value” qui retourne une ligne comme instance d’objet:

SELECT VALUE(p) FROM person_obj_table p

WHERE p.last_name = 'Smith';
 Operation sur la table objet
person_obj_table
• block select PL/SQL pour sélectionner une
personne et afficher les détail
DECLARE
person person_typ;
BEGIN
SELECT VALUE(p) INTO person FROM
person_obj_table p WHERE p.idno = 101;
person.display_details();
END;
/
 Les « Object Identifiers , OIDs»
• Les identifiant des Objets “OIDs” identifient de manière
unique les ligne des objets dans les tables objets,
• On ne peut pas acceder directement aux “OIDs”, mais
on peut les manupuler par des references .
• Il existe deux types de “OIDs”
– OIDs par défaut, generés par le systeme
– OIDs basés sur les clés primaire : Au moment de la creation
d’une table par CREATE TABLE, on a l’option de créer des
« OIDs » basé sur la clé primaire
 Utilisation de la référence REF
• REF est un pointeur global pour les lignes
objet que vous pouver créer à partir d’un
“OID”.
• On peut utiliser REF pour pointer, examiner ou
mettre à jour l’objet.
• On peut changer un REF de telle manière qu’il
pointe un objet different du meme type objet
ou lui assigner la valeur “null”
 Utilisation de REF
CREATE TYPE emp_person_typ AS OBJECT (
name VARCHAR2(30),
manager REF emp_person_typ );

CREATE TABLE emp_person_obj_table OF emp_person_typ;

INSERT INTO emp_person_obj_table VALUES (

emp_person_typ ('John Smith', NULL));

INSERT INTO emp_person_obj_table

SELECT emp_person_typ ('Bob Jones', REF(e))
FROM emp_person_obj_table e
WHERE e.name = 'John Smith';
 Utilisation de REF
COLUMN name FORMAT A10
COLUMN manager FORMAT A50
select * from emp_person_obj_table e;
NAME MANAGER
----------
-------------------------------------------------
John Smith
Bob Jones 0000220208424E801067C2E..
Utilisation de DEREF pour déréférencer
REF
• Pour accéder aux valeurs des attributs d’un
objet colonne de type « ref » on utilise le mot
clé DEREF.
• Exemple:
SELECT DEREF(e.manager) FROM
emp_person_obj_table e;
 Utilisation de SCOPE
• On peut forcer un type colonne ou un attribu de
type objet de referencer un objet d’une table objet
specifique en utilisant le mot clé “SCOPE IS”
• Scoped REF requière moins d’espace de stockage et
permet plus d’efficacité pour acceder aux type REF
CREATE TABLE contacts_ref (
contact_ref REF person_typ SCOPE IS
person_obj_table,
contact_date DATE );
 Insérer une ligne
INSERT INTO contacts_ref
SELECT REF(p), '26 Jun 2003'
FROM person_obj_table p
WHERE p.idno = 101;
Déréférencement implicite de REF
SELECT e.name, e.manager.name FROM
emp_person_obj_table e
WHERE e.name = 'Bob Jones';
 Obtenir un REF pour une ligne objet
DECLARE
person_ref REF person_typ;
person person_typ;
BEGIN
SELECT REF(p) INTO person_ref
FROM person_obj_table p
WHERE p.idno = 101;
select deref(person_ref) into person from dual;
person.display_details();
END;
 Comparaison de référence
• Deux variable REF peuvent être comparés si
elle référencer le même type d’objet
 Les collections
• Pour modéliser des attributs multivalués et
des relation n-n, Oracle supporte deux types:
Tableaux (varrays) et Tables imbriquées
(nested tables)
• Un type collection peut être utiliser là ou un
autre type l’est.
• On peut avoir un attribut de type collection
• Syntaxe pour définir un type collection:
CREATE TYPE . . . AS TABLE OF ….
 Exemple:
CREATE TYPE people_typ AS TABLE OF person_typ;
/
CREATE TYPE dept_persons_typ AS OBJECT (
dept_no CHAR(5),
dept_name CHAR(20),
dept_mgr person_typ,
dept_emps people_typ);
/
• Le type people_typ, est une table imbriquées.
Chapitre 2: Composants de bases
d’oracle Objets
 Connection au serveur SqlPlus
• Connection en mode ligne de commande :
menu démarrer -> sqlplus
Connect system/esto
• En mode interface web :
127.0.0.1: 8080/apex
• Ou bien cliquez sur get started du menu
demarrer (oracle express…)
 Plan du chapitre
• Types Objets et références
• Méthodes
• L’héritage en Type Objets
• Fonctions et opérateurs utiles avec les Objets
oracle.
 Types Objets et références

• Un type et crée en deux étapes:

– Spécification du type avec e la requête SQL :
• CREATE TYPE …..
– Corps du type
• CREATE TYPE BODY…
 Objets null
• Un objets est null si il est initialisé a null ou
n’est pas initilisé.
• Null pourra être remplacé par une valeur plus
tard.
• Un objet initialisé à null ne peut pas appeler ni
les méthodes ni les sous programme de
l’objet
 Objets null: Exemple.
• Dans le cas suivant, Oracle alloue de l’espace dans la table
contacts pour une nouvelle ligne et met la date dans la
colonne DATE et réserve de l’espace pour un objets de type
person_typ dans la colonne CONTACT.
INSERT INTO contacts VALUES (
person_typ (NULL, NULL, NULL), '24 Jun 2003' );
• Mais dans le cas suivant, Oracle met le champs person_typ à
null et ne reserve aucun espace pour l’objet!
INSERT INTO contacts VALUES ( NULL, '24 Jun 2003' );
 Objets null
• Une ligne de table relationnelle ou objet ne
peut pas etre null.
• Une table imbriquée d’objets ne peux pas
contenir des éléments avec la valeur null
Contraintes pour les tables objets
• On peut définir des contraintes pour les table
objets comme pour les autres tables.
• On peut aussi définir des contraintes pour les
champs des colonnes objet exceptés les REFs
non «Scopé »
 Contraintes pour les tables objets
CREATE OR REPLACE TYPE location_typ AS OBJECT (
building_no NUMBER,
city VARCHAR2(40) );
/
CREATE OR REPLACE TYPE office_typ AS OBJECT (
office_id VARCHAR(10),
office_loc location_typ,
occupant person_typ );
/
CREATE TABLE office_tab OF office_typ (
office_id PRIMARY KEY );
 Table avec multiple contraintes
CREATE TABLE department_mgrs (
dept_no NUMBER PRIMARY KEY,
dept_name CHAR(20),
dept_mgr person_typ,
dept_loc location_typ,
CONSTRAINT dept_loc_cons1
UNIQUE (dept_loc.building_no, dept_loc.city),
CONSTRAINT dept_loc_cons2
CHECK (dept_loc.city IS NOT NULL) );

INSERT INTO department_mgrs VALUES

( 101, 'Physical Sciences',
person_typ(65,'Vrinda’, ‘ Mills', ’vmills@example.com’, '1-1-650-555-0125'),
location_typ(300, 'Palo Alto'));
 Index pour les tables objets
• On peut définer des index pour une table
objet de la même manière que les autres
tables.
• Un index peut être défini sur un attribut d’une
colonne objet.
• Un index peut aussi être défini sur les attributs
d’un REF qui est scopé.
CREATE TABLE department_loc (
dept_no NUMBER PRIMARY KEY,
dept_name CHAR(20),
dept_addr location_typ );
CREATE INDEX i_dept_addr1
ON department_loc (dept_addr.city);
INSERT INTO department_loc VALUES
( 101, 'Physical Sciences', location_typ(300, 'Palo Alto'));
INSERT INTO department_loc VALUES
( 104, 'Life Sciences', location_typ(400, 'Menlo Park'));
INSERT INTO department_loc VALUES
( 103, 'Biological Sciences', location_typ(500, 'Redwood
Shores'));
 Triggers
• On peut définir un triggers sur une table objet
comme on le fait pour les autres table.
• On ne peut pas définir des triggers pour les
tables de stockage utilisé avec une table
imbriquée
Règles pour les objets et REF NULL
• PRIMARY KEY contrainte ne peut pas etre
definie sur une colonne REF. Mais on peut
definir une contrainte NOT NULL sur de telle
colonne.
• Sur une colonne REF, on peut définir la
contrainte REFERENTIAL similaire à une clé
étrangère . L’objet reference de cette colonne
doit referencer une ligne existante dans la
table objet specifique
Règles pour les objets et REF NULL
• Une colonne REF ou un attribut contraint par
la clause SCOPE peut être contraint par une
contrainte referentielle.
• Oracle n’assure pas que l’objet reference
stocké dans la colonne pointe une ligne
existante dans la table objet!
 Résolution des noms
• Si le nom de table est implicite, on peut
l’omettre. Exemple:
CREATE TABLE movement (
idno NUMBER,
old_office location_typ,
new_office location_typ );
• SELECT * FROM department_loc WHERE EXISTS
(SELECT * FROM movement WHERE dept_addr =
old_office);
• Oracle determine les tables corespondantes
 Résolution des noms
• Utilisons la notation « . »
SELECT * FROM department_loc WHERE EXISTS
(SELECT * FROM movement WHERE
department_loc.dept_addr =
movement.old_office);

SELECT * FROM department_loc d WHERE EXISTS

(SELECT * FROM movement m WHERE
d.dept_addr = m.old_office);
 Les cas où l’alias de la table est requis
#1 SELECT idno FROM person_obj_table;
--Correct

#2 SELECT contact.idno FROM contacts; --Illegal

#3 SELECT contacts.contact.idno FROM contacts; --Illegal

#4 SELECT p.contact.idno FROM contacts p;

--Correct
 Méthodes
• Méthodes Objet ou sous-programme sont des
fonctions ou procédure qu’on peut déclarer
dans un type objet pour implémenter un
traitement spécifique pour l’objet.
• Une méthode peut être écrite en PL/SQL ou
dans un autre langage.
• Les méthodes écrite en PL/SQL ou Java sont
stockées dans la base de données.
• Les méthodes écrite dans un autre langage
sont stocké à l’extérieur de la base.
 Méthodes membres
• Une méthode membre permet d’accéder aux
Objets du type.
• Les méthodes de comparaison utilisent:
– MAP MEMBER FUNCTION ou ORDER MEMBER
FUNCTION
 Le paramètre SELF
• Le paramètre SELF est utilisé dans les
méthodes membre pour appeler l’objet
courant : Qui a appelé la méthodes.
 Création de méthodes membres
CREATE OR REPLACE TYPE solid_typ AS OBJECT (
len INTEGER,
wth INTEGER,
hgt INTEGER,
MEMBER FUNCTION surface RETURN INTEGER,
MEMBER FUNCTION volume RETURN INTEGER,
MEMBER PROCEDURE display (SELF IN OUT
NOCOPY solid_typ) );
/
 Création de méthodes membres
CREATE OR REPLACE TYPE BODY solid_typ AS

MEMBER FUNCTION volume RETURN INTEGER IS

BEGIN

RETURN len * wth * hgt;

-- RETURN SELF.len * SELF.wth * SELF.hgt; -- equivalent to previous line

END;

MEMBER FUNCTION surface RETURN INTEGER IS

BEGIN -- not necessary to include SELF in following line

RETURN 2 * (len * wth + len * hgt + wth * hgt);

END;

MEMBER PROCEDURE display (SELF IN OUT NOCOPY solid_typ) IS

BEGIN

DBMS_OUTPUT.PUT_LINE('Length: ' || len || ' - ' || 'Width: ' || wth

|| ' - ' || 'Height: ' || hgt);

DBMS_OUTPUT.PUT_LINE('Volume: ' || volume || ' - ' || 'Surface area: '

|| surface);

END;

END;

/
 Exemple d’appel de méthode
CREATE TABLE solids of solid_typ;

INSERT INTO solids VALUES(10, 10, 10);

INSERT INTO solids VALUES(3, 4, 5);

SELECT * FROM solids;

SELECT s.volume(), s.surface() FROM solids s WHERE s.len = 10;

DECLARE
solid solid_typ;
BEGIN -- PL/SQL block for selecting a solid and displaying details
SELECT VALUE(s) INTO solid FROM solids s WHERE s.len = 10;
solid.display();
END;
/
 Le parametre SELF
• SELF est souvent le premier parametre passé à
une méthode member.
• Si SELF n’est pas declaré dans une fonction
membre, par défaut , il est en mode IN
• Si SELF n’est pas declaré dans une procedure
membre, par défaut , il est en mode IN OUT
• Le traitement par défaut n’inclu pas NOCOPY
 Méthodes de comparaison
• La méthode Map est automatiquement
appelée pour evaluer une comparaison telle
que obj_1 > obj_2 et les comparaison utilisant
les clauses DISTINCT, GROUP BY, UNION, and
ORDER BY
 Exemple d’une méthodes MAP
CREATE OR REPLACE TYPE rectangle_typ AS OBJECT (
len NUMBER,
wid NUMBER,
MAP MEMBER FUNCTION area RETURN NUMBER);
/
CREATE OR REPLACE TYPE BODY rectangle_typ AS
MAP MEMBER FUNCTION area RETURN NUMBER IS
BEGIN
RETURN len * wid;
END ;
END;
/
Obj1> Obj2 est équivalent à Obj1.area()> Obj2.area() ,
 Exemple d’appel
DECLARE
po rectangle_typ;
BEGIN
po := NEW rectangle_typ(10,5);
DBMS_OUTPUT.PUT_LINE('AREA:' || po.area());
END;
 Méthode ORDER
• Une méthode ORDER permet simplement de
comparer l’objet courant (SELF) avec un objet
passé en parametre . Mais ne peut pas
comparer plusieurs:
• Une méthode ORDER est tres utile dans le cas
où l’algorithme de comparaison n’est pas
approprié à MAP.
• Attention: on peut declarer une methode
MAP ou ORDER mais pas toutes les deux !!
 Méthode ORDER: Exemple
DROP TYPE location_typ FORCE;
-- above necessary if you have previously created
-----object
CREATE OR REPLACE TYPE location_typ AS OBJECT (
building_no NUMBER,
city VARCHAR2(40),
ORDER MEMBER FUNCTION match (l location_typ)
RETURN INTEGER );
/
CREATE OR REPLACE TYPE BODY location_typ AS
ORDER MEMBER FUNCTION match (l location_typ) RETURN
INTEGER IS
BEGIN
IF building_no < l.building_no THEN
RETURN -1; -- any negative number will do
ELSIF building_no > l.building_no THEN
RETURN 1; -- any positive number will do
ELSE
RETURN 0;
END IF;
END;
END;
/
 Appel de méthode membre
DECLARE
loc location_typ;
secloc location_typ;
a number;
BEGIN
loc :=NEW location_typ(300, 'San Francisco');
secloc :=NEW location_typ(200, 'Redwood Shores');
a := loc.match(secloc);
DBMS_OUTPUT.PUT_LINE('order (1 is greater, -1 is lesser):' ||a); --
prints order:1
END;
 Méthodes Statiques
• Les méthodes statiques est appelée par un
type et pas par ses objets. Elle n’ont pas de
paramètre SELF.
• Les méthodes statiques sont déclarées STATIC
FUNCTION ou STATIC PROCEDURE.
• Pour appeler une méthodes statique, on
utilise la syntaxe:
type_name.method();
 Méthodes constructeurs
• Une méthodes constructeur est une méthodes
qui permet de créer un nouveau objet et
mettre une valeur dans chacun de ses
attributs.
• On peut utiliser l’opérateur NEW pour appeler
une méthode constructeur mais il n’est pas
requis!
 Constructeur défini par le system
• Par défaut, le system offre un constructeur
pour les objets qui ont des attributs
• Exemple:
person_typ (1, 'John Smith', '1-650-555-0135'),
• Le programmeur peu definir un nouveau
constructeur
 Appel de constructeurs
CREATE TABLE people_tab OF person_typ;

INSERT INTO people_tab VALUES (

person_typ(101, 'John Smith', '1-650-555-0135')
);
 Méthodes externes
• PL/SQL peut appeller une méthode qui a été
ecris dans un autre langage. Cela fourni un
accès aux puissances et capacités de ces
langage
 Héritage en SQL pour les types objets
• L’héritage pour les types objets consiste d’une arborescence formées de
super-Types (type parent) et sous-Types (types dérivé, type fils )
• Le sous type hérite automatiquement les attributs et les méthodes de son super
type.
• Un sous type défini une variante spécialisée du type parent qui pourra ajouter de
nouveau attributs et de nouvelle méthodes, ou redéfinir les méthodes hérités du
type parents.
• Un type peut avoir plusieurs sous types mais un sous type n’a qu’un seul parent:
(pas d’héritage multiple)
• La relation d’héritage est réalisé par le mot clé UNDER
 Types et méthodes déclarés FINAL et NOT
FINAL

• Un type déclaré FINAL ne peut pas avoir des

sous types
– Par défaut, un type est défini FINAL
• Une méthode déclarée FINAL ne peut pas être
redéfinie dans un sous type
– Par défaut une méthode est NOT FINAL.
DROP TYPE person_typ FORCE;
CREATE OR REPLACE TYPE person_typ AS OBJECT (
idno NUMBER,
name VARCHAR2(30),
phone VARCHAR2(20),
FINAL MAP MEMBER FUNCTION get_idno RETURN
NUMBER)
NOT FINAL;
/
• On peut modifier le type de FINAL à NOT FINAL :
– ALTER TYPE person_typ FINAL;
CREATE OR REPLACE TYPE person_typ AS OBJECT (
idno NUMBER,
name VARCHAR2(30),
phone VARCHAR2(20),
MAP MEMBER FUNCTION get_idno RETURN NUMBER,
MEMBER FUNCTION show RETURN VARCHAR2)
NOT FINAL;
/
CREATE OR REPLACE TYPE BODY person_typ AS
MAP MEMBER FUNCTION get_idno RETURN NUMBER IS
BEGIN
RETURN idno;
END;
-- function that can be overriden by subtypes
MEMBER FUNCTION show RETURN VARCHAR2 IS
BEGIN
RETURN 'Id: ' || TO_CHAR(idno) || ', Name: ' || name;
END;
END;
/
 Création de sous type
CREATE TYPE student_typUNDER person_typ (
dept_id NUMBER,
major VARCHAR2(30),
OVERRIDING MEMBER FUNCTION showRETURN VARCHAR2)
NOT FINAL;
/
• Ici la méthodes show est redéfinie.
CREATE TYPE BODY student_typ AS
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2 IS
BEGIN
RETURN (self AS person_typ).show|| ' -- Major: ' || major ;
END;
END;
/
 Appel généralisé
• Cet appel fourni un mécanisme pour appeler la méthode de type parent au lieu de la méthodes de sous
type :
– (SELF AS person_typ).show

• Exemple:
DECLARE
myvar student_typ := student_typ(100, 'Sam', '6505556666', 100, 'Math');
Name VARCHAR2(100);
BEGIN
name := (myvar AS person_typ).show ;
--Generalized invocation
END;
/
– Compléter le bloc pour afficher « name »!
 Appel généralisé
• Appel généralisé pour une méthodes avec un explicite arguments:
DECLARE
myvar2 student_typ := student_typ(101, 'Sam', '6505556666', 100,
'Math');
name2 VARCHAR2(100);
BEGIN
name2 := person_typ.show((myvar2 AS person_typ));
-- Generalized expression
END;
/
 Appel généralisé

• Les constructeurs ne peuvent pas utilisée cet

appel généralisé
• Le nom de type qui apparait apres AS doit etre
un nom d’un type parent.
• Cet appel généralisé peut etre utilisé
seulement par des méthodes redefinies.
 sous types Multiple
• Un type peut avoir plusieurs sous types.
• Chaque sous type peut avoir a son tour
plusieurs sous types.
DROP TYPE employee_typ FORCE; -- if previously created
CREATE OR REPLACE TYPE employee_typ UNDER person_typ (
emp_id NUMBER,
mgr VARCHAR2(30),
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2);
/
CREATE OR REPLACE TYPE BODY employee_typ AS
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2 IS
BEGIN
RETURN (SELF AS person_typ).show|| ' -- Employee Id: '
|| TO_CHAR(emp_id) || ', Manager: ' || mgr ;
END;
END;
/
CREATE TYPE part_time_student_typ UNDER student_typ (
number_hours NUMBER,
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2);
/
CREATE TYPE BODY part_time_student_typ AS
OVERRIDING MEMBER FUNCTION show RETURN VARCHAR2 IS
BEGIN
RETURN (SELF AS person_typ).show|| ' -- Major: ' || major ||
', Hours: ' || TO_CHAR(number_hours);
END;
END;
/
• Dans une Table on peut insérer un objets d’un type et de ses sous types

CREATE TABLE person_obj_table OF person_typ;

INSERT INTO person_obj_table

VALUES (person_typ(12, 'Bob Jones', '650-555-0130'));
INSERT INTO person_obj_table
VALUES (student_typ(51, 'Joe Lane', '1-650-555-0140', 12, 'HISTORY'));
INSERT INTO person_obj_table
VALUES (employee_typ(55, 'Jane Smith', '1-650-555-0144',
100, 'Jennifer Nelson'));
INSERT INTO person_obj_table
VALUES (part_time_student_typ(52, 'Kim Patel', '1-650-555-0135', 14,
'PHYSICS', 20));

• La même istruction suivante produira differentes resultats: POLYMORPHISM !

SELECT p.show() FROM person_obj_table p;

 Types et méthodes non instanciables
• Un type non instanciable n’a pas de
constructeur et donc on peut pas créer des
objets avec.
• Une méthode non instanciable ne fourni pas
un traitement mais juste l’entête. Le
traitement pourra être défini dans un sous
type.
 • Exemple:
DROP TYPE person_typ FORCE;
-- if previously created
CREATE OR REPLACE TYPE person_typ AS OBJECT (
idno NUMBER,
name VARCHAR2(30),
phone VARCHAR2(20),
NOT INSTANTIABLE MEMBER FUNCTION get_idno RETURN
NUMBER)
NOT INSTANTIABLE NOT FINAL;
• Si le sous type ne fourni pas une implémentation de la
méthodes, il doit être lui aussi déclaré non instanciable
• Un sous type non instanciable peut être défini à partir
d’un type instanciable
 • On peut rendre un type instanciable par « alter »:
CREATE OR REPLACE TYPE person_typ AS OBJECT (
idno NUMBER,
name VARCHAR2(30),
phone VARCHAR2(20))
NOT INSTANTIABLE NOT FINAL;
/
ALTER TYPE person_typ INSTANTIABLE;
• Un type non instanciable ne peut pas être déclaré FINAL !!
(contradiction )
 Méthodes surchargées
• Ajouter au sous type des méthodes qui ont les mêmes noms que
des méthodes du type parent sont appelés surcharge.
• Dans un type, une méthode est surchargée lorsqu’elle a le même
nom qu’une méthodes existante dans le type mais une signature
différente: nombre, type et ordre de paramètre.
CREATE TYPE ellipse_typ AS OBJECT (...,
MEMBER PROCEDURE calculate(x NUMBER, y NUMBER),
) NOT FINAL;
CREATE TYPE circle_typ UNDER ellipse_typ (...,
MEMBER PROCEDURE calculate(x NUMBER),
...);
 Redéfinition et correction
• Redéfinition: Dans un sous type, la méthode a
le même nom et la même signature qu’une
méthode dans le type parent mais son
comportement est personnalisé.
• Dans le cas d’une méthode statique, la
redéfinition est appelée correction.
• Pour redéfinir une méthodes, on utilise le mot
clé OVERRIDING.
• OVERRIDING n’est pas requise pour corriger
une méthode statique.
 Limitations sur la redéfinition
• Une méthode déclaré FINAL ne peut pas être
redéfinie.
• Une méthode statique dans un sous type ne
peut pas redéfinir une méthode membre du
super type.
• Inversement, Une méthode membre dans un
sous type ne peut pas redéfinir une méthode
statique du super type.
 Liaison dynamique des méthodes
• Un objet peut appeler une méthode de son type ou d’un type parent. Mais pas une
méthode d’un sous type.
• Dans une arborescence de types, une méthodes peut être définie plusieurs fois et
donc peut avoir dans chaque type une implémentation spécifique.
• Au moment de l’appel de la méthode c’est le type réel de l’objet qui détermine
l’implémentation à exécuter.
• Ce mécanisme est appelé, liaison dynamique car il est fait au moment de
l’exécution et pas au moment de la compilation
• Pour une méthode statique cet liaison est faite au moment de la compilation
 Substitution de types dans une
hiérarchie
• Les super types sont substituable: on peut
mettre un objet d’un sous type dans une
colonne déclarée de super type.
– Employee_typ et student_type peuvent être
substitués dans la colonne de type person_typ.
• Un attribut déclaré REF de type person_typ
peut avoir un REF de type Employee_typ ou
student_type
 Lignes et colonnes substituables.
• TP: Executer le code aux pages 2-24 et 2-25
• Pour acceder aux attributs du sous type d’une
ligne ou colonne de type declaré, on peut
utiliser la fonction TREAT
• Exemple:
SELECT TREAT(contact AS student_typ).major
FROM contacts;
 OBJECT_VALUE et OBJECT_ID
• OBJECT_VALUE : permet d’acceder et
d’identifier la valeur et l’OID de la ligne Objet
substituée dans une table objet:
• Exemple 2-25
 super type en attribut

• Un sous type peut avoir un attribut de super

type.
CREATE TYPE student_typ UNDER person_typ (
dept_id NUMBER,
major VARCHAR2(30),
advisor person_typ);
/
• Pourtant, les colonnes de ce type ne sont pas
substituable par un super type.
 Substitution d’un nouvel type
• Si un nouveau sous type est crée new_typ ,
toute table qui a une colonne d’un super type
de new_typ peut stocker des objets de
new_typ.
• Dans le cas ou la table existe, il faut s’assurer
que les sous types ne violent pas les
contraintes de table.
• Exemple page: 2-26(Exemple 2-27)
Chapitre 3: Les collections

Tables imbriquées et Tableaux

de données
• Oracle supporte deux types de collections de
données:
• Les Tableaux (VARRAY) : Collection ordonnées
d’éléments.
– Les tableaux sont utilisés pour stocker un nombre
fixe d’éléments, ou parcourir avec une boucle des
éléments stockés dans l’ordre.
• Tables imbriquées (Nested table): Peut stocker
n’importe quel nombre de données.
– Utilisées pour exécuter des requêtes efficaces sur
une collection de données.
 • Création d’un type objet comme une table
imbriquée.
• Syntaxe : type comme table imbriquées
CREATE TYPE people_typ AS TABLE OF
person_typ;
• Exemple de constructeurs de type :
people_typ( person_typ(1, 'John Smith',
'1-650-555-0135'), person_typ(2, 'Diane Smith',
NULL)
);
people_typ()– Table imbriquée vide.
 • Création d’une table contenant une table imbriquée:
CREATE TABLE people_tab (
group_no NUMBER,
people_column people_typ )
NESTED TABLE people_column STORE AS people_column_nt;
• Indique la table dans laquelle sont stockés les lignes de la
table imbriquées
• Insertion dans la table
INSERT INTO people_tab VALUES (
100,
people_typ( person_typ(1, 'John Smith', '1-650-555-0135'),
person_typ(2, 'Diane Smith', NULL)));
• TP: Example 5-5
• Création d’une table avec des valeurs par défauts.
CREATE TABLE department_persons (
dept_no NUMBER PRIMARY KEY,
dept_name CHAR(20),
dept_mgr person_typ DEFAULT person_typ(10,'John Doe',NULL),
dept_emps people_typ DEFAULT people_typ() ) -- instance of nested table type
NESTED TABLE dept_emps STORE AS dept_emps_tab;

INSERT INTO department_persons VALUES

( 101, 'Physical Sciences', person_typ(65,'Vrinda Mills', '1-650-555-0125'),
people_typ( person_typ(1, 'John Smith', '1-650-555-0135'),
person_typ(2, 'Diane Smith', NULL) ) );

INSERT INTO department_persons VALUES

( 104, 'Life Sciences', person_typ(70,'James Hall', '1-415-555-0101'),
people_typ() );
 • Interroger une table imbriquées avec SELECT:
SELECT d.dept_emps FROM department_persons
d;
-- la colonne de type table est interrogée comme
une colonne scalaire(varchar, number…)
SELECT * FROM department_persons
-- les données de la colonne de type collection
sont imbriquées.
• Pour afficher les données de la colonne
collection sur un ou plusieurs ligne
relationnelles, on utilisant l’expression TABLE.
SELECT e.* FROM department_persons d,
TABLE(d.dept_emps) e;
• La requête suivante affiche les lignes
seulement pour les département qui ont des
employés
SELECT d.dept_no, e.* FROM
department_persons d, TABLE(d.dept_emps) e;
• Pour afficher même les ligne pour lesquelles
les département n’ont pas des employés, on
utilise la syntaxe:
SELECT d.dept_no, e.* FROM
department_persons d, TABLE(d.dept_emps) (+)
e;
• L’expression TABLE avec une sous requête:
SELECT *
FROM TABLE(SELECT d.dept_emps
FROM department_persons d
WHERE d.dept_no = 101);
• Restriction:
– La sous requête de TABLE doit retourner une
collection de données
– La liste de la sous requête de TABLE doit contenir
exactement un item
• Utiliser l’expression TABLE dans une
expression CURSOR.
SELECT d.dept_no , CURSOR(SELECT * FROM
TABLE(d.dept_emps))
FROM department_persons d
WHERE d.dept_no = 101;
• Manipulation des données d’une table imbriquée
• Insertion:
INSERT INTO TABLE(SELECT d.dept_emps FROM department_persons d
WHERE d.dept_no = 101)
VALUES (5, 'Kevin Taylor', '1-408-555-0199');
• Mise à jours
UPDATE TABLE(SELECT d.dept_emps
FROM department_persons d
WHERE d.dept_no = 101) e
SET VALUE(e) = person_typ(5, 'Kevin Taylor', '1-408-555-0199')
WHERE e.idno = 5;
• Suppresion
DELETE FROM TABLE(SELECT d.dept_emps
FROM department_persons d
WHERE d.dept_no = 101) e
WHERE e.idno = 5;
• Utiliser VALUE() pour insérer des données
dans la table imbriquées.
UPDATE TABLE (SELECT d.dept_emps FROM department_persons d
WHERE d.dept_no = 101) p
SET VALUE(p) = person_typ(2, 'Diane Smith', '1-650-555-0148')
WHERE p.idno = 2;
• Spécifier un tablespace
La table imbriquée peut être stockée dans un
tablespace different:
CREATE TABLE people_tab (
people_column people_typ )
NESTED TABLE people_column STORE AS
people_column_nt (TABLESPACE system);
• On peut déplacer la table au different table space
ALTER TABLE people_tab MOVE TABLESPACE
system; -- moving table
ALTER TABLE people_column_nt MOVE
TABLESPACE example; -- moving storage table
 • On peut augmenter la Taille d’un élément dans
une table imbriquées.
CREATE TYPE email_list_tab AS TABLE OF
VARCHAR2(30);
ALTER TYPE email_list_tab MODIFY ELEMENT
TYPE VARCHAR2(40) CASCADE;
• Le mot clé MODIFY est utilisé avec deux
options:
INVALIDATE: Ne modifie pas les objets déjà crées
CASCADE: Modifie les tables liées
 Les tableaux
• Un tableau est un ensemble ordonné d’éléments.
• Tous les éléments du tableau sont du même type ou d’un
sous type de type déclaré
• On manipule un élément par son indice
• La taille du tableau est précisée à la déclaration. Cette taille
pourra changer par la suite. (VARRAY: Variable ARRAY )
• Un tableau est normalement stocké dans le même
tablespace que les autres attributs de la ligne. Si il est très
large, il est stocké comme un BLOB
• Les types tableau (VARRAY ) et TABLE pourront
être utilisé comme :
– Un type d’une colonne dans une table
– Un attribut d’un type objet
– Un type d’une variable PL/SQL
– Paramètre de fonctions
– Type de retour d’une fonction.

create type auteur_typ as object(

nom varchar(40),
prenom varchar(40),
email varchar(80)
);
create table auteurs_obj of auteur_typ(
email primary key);
create index email_Ind ON auteurs_obj(nom);

create type auteurs_typ as varray(10) of ref auteur_typ;

create table Livre (

ISBN varchar(10),
• Création d’un type tableau qui a au plus 10
element, chaque élément est de type
VARCHAR(80).
CREATE TYPE email_list_arr AS VARRAY(10) OF
VARCHAR2(80);
• Pour augmenter la taille d’un tableau on utilise la
syntaxe:
ALTER TYPE ... MODIFY LIMIT
• Cette syntaxe est utilisée avec deux option:
INVALIDATE: Ne modifie pas les objets déjà crées
CASCADE: Modifie les tables liées
• TP ex 5-8.
• Création d’un type tableau qui a au plus 10
element, chaque élément est de type
VARCHAR(80).
CREATE TYPE email_list_arr AS VARRAY(10) OF
VARCHAR2(80);
• Pour augmenter la taille d’un tableau on utilise la
syntaxe:
ALTER TYPE ... MODIFY LIMIT
• Cette syntaxe est utilisée avec deux option:
INVALIDATE: Ne modifie pas les objets déjà crées
CASCADE: Modifie les tables liées
• TP ex 5-8.
• Exemple de creation et insertion d’une table contenant une colonne de type tableau: (Ex 5-4)
CREATE TYPE phone_typ AS OBJECT (
country_code VARCHAR2(2),
area_code 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),
create type auteurs_typ as varray(10) of ref auteur_typ;
phone_list phone_varray_typ);
create table Livre (
INSERT INTO dept_phone_list VALUES ( ISBN varchar(10),
Titre varchar(40),
100, auteurs auteurs_typ
)
phone_varray_typ( phone_typ ('01', '650', '5550123'),
phone_typ ('01', '650', '5550148'),
phone_typ ('01', '650', '5550192')));
• Créer un tableau contenant des références.
CREATE TYPE ref_email_varray_typ AS
VARRAY(5) OF REF email_list_typ;
/
CREATE TABLE dept_email_list (
dept_no NUMBER,
email_addrs ref_email_varray_typ)
VARRAY email_addrs STORE AS LOB
dept_emails_lob3;
 Insertion, MAJ, Suppression et
Sélection avec un type tableau
• On peut pas modifier ou supprimer un seul
élément d’un tableau en utilisant une requête
SQL. Pour ce faire, on doit utiliser un block
PL/SQL.
• Exemple (5-25)
 Collection de données à niveaux
multiples.
• Les collection de données à plusieurs niveaux peuvent être:
– Une table imbriquée d’une autre table imbriquée
– Une table imbriquée d’un tableau
– Un tableau de tableaux
– Une table ou un tableau d’un type objet qui a un attribut de type
table ou tableau.
• De même ce type de collections pourront être utilisés
comme:
– Un type d’une colonne dans une table, Un attribut d’un type
objet, Un type d’une variable PL/SQL, Paramètre de fonctions,
Type de retour d’une fonction.
• Exemple 5-10
…
• Si la table imbriquées d’une table imbriquée
n’est pas une colonne objet dans une table,
elle n’a pas de nom. Le mot clé
COLUMN_VALUE est fourni pour ce cas.
• Exemple 5-11
• Toute table imbriquée a une colonne
NESTED_TABLE_ID qui repère les lignes dans
la table de stockage d’une ligne associée dans
la table « parent » associée,
• La table parent, qui est elle-même une table
imbriquée, a deux colonnes d’identification de
lignes
– Une colonne qui repèrent ses lignes par rapport
aux lignes associée dans la table parent
– Une colonne cachée et référencé par
NESTED_TABLE_ID dans sa table fille.
 Organisation d’index
• Assigne à la table imbriquée une clé primaire dont une colonne est
NESTED_TABLE_ID.
• Cette colonne contient L’ID de la ligne dans la table parent avec qui la
table de stockage est associée.
• En spécifiant la clé primaire avec première colonne NESTED_TABLE_ID et
organisant l’index permet à oracle de cluster physiquement toutes les
lignes des tables imbriquées appartenant à la même ligne dans la table
parent. Cela offre un meilleur accès.
• Toute table imbriquée a besoin d’un table de stockage: on doit avoir
autant de tables de stockage qu’on a de tables imbriquées
 Stockage des tableaux pour les
collection à nivaux multiples.
• Les tableaux à niveaux multiples sont stockés
de deux manière.
– Pour un tableau des tableaux, il est stocké
entièrement dans une ligne jusqu’à ce que sa
taille dépasse 4000 octets. Dans ce cas, LOB est
explicitement spécifié.
– Pour un tableau de tables imbriquées, le tablau
entier est stocké en un LOB
• IL n y as pas de stockage de table associé aux
éléments tables imbriquées du tableau.
On peut, explicitement spécifier un stockage
LOB pour un tableau: Ex 5–13.
• COLUMN_VALUE a la même signification que
pour les tables imbriquées.
• Stockage explicite LOB Ex 5-14
Constructeur d’une collection à nivaux
multiples.
• Les niveau multiple d’une collection sont crées
en appelant leur constructeurs de type, juste
comme les collection à un seul niveau et les
autres objets.
 Requêtes MLD sur une collection à
nivaux multiples
• Les requêtes de manipulation sont possible
sur une tables imbriquées d’une table
imbriquées mais pas sur un tableau de
tableaux
• Exemple 5.23
• Exemple 5.24
• Exemple 5.26
 BULK COLLECT
• Permet de retourner un ensemble de résultat
en une seule opération:
• Exemple 5.27.
 Comparaison de table imbriquées
• Egalité (=) , Diffèrent (<>): Deux table imbriquées sont
égales si elles ont le même type la même cardinalité et
ses éléments sont égaux.
– Ex 5-28
• IN: Verifie si une table imbriquées est dans une liste de
table imbriquées:
– Ex 5-29
• SUBMULTISET : Vérifie si une table imbriquée est un sous
ensemble d’une autre table imbriquée
– Ex 5-30
• MEMBER [OF] , NOT MEMBER [OF] : Teste si
un élément est un membre d’une table
imbriquée ou non.
– Ex 5-31
• IS [NOT] EMPTY: Test si une table imbriquée
est vide ou non.