ANNEXE TD et TP Syntaxe Oracle 9i

Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
Bases de Données orientées Objet
ANNEXE TD et TP
Syntaxe Oracle 9i
TD/TP Bases de données objet-relationnelles
1
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
I- Type d’objets ............................................................................................................................... 3
1- Création d’un type d’objets ............................................................................................ 3
2- Suppression d’un type d’objets .................................................................................... 3
3- Modification d’un type d’objets : deux requêtes possibles........................... 3
II- Table objet-relationnelle..................................................................................................... 4
1- Création d’une table objet-relationnelle.................................................................. 4
2- Suppression d’une table objet-relationnelle ......................................................... 5
3- Modification de la définition d’une table objet-relationnelle ....................... 5
4- Ajout d’une instance dans une table objet-relationnelle : INSERT........... 5
5- Mise à jour d’une table objet-relationnelle : UPDATE / DELETE ................. 6
6- Consultation d’ une table objet-relationnelle : SELECT.................................. 6
III- Méthode : définition et activation. ............................................................................... 7
1- Spécification d’une méthode de type MEMBER.................................................. 7
2- Corps d’une méthode et corps du type................................................................... 8
3- Suppression du corps du type ...................................................................................... 8
4- Activation d’une Méthode. .............................................................................................. 9
IV- Collections de données ...................................................................................................... 9
1- Collections de type tableau : VARRAY ................................................................... 9
2- Collection de type table ................................................................................................. 10
3- Manipulation des collections en PL/SQL............................................................... 10
V- Procédures PL/SQL pour la manipulation d’objets .............................................. 11
1- Bloc PL/SQL anonyme ..................................................................................................... 11
2- Manipulation le résultat d’une requête dans un bloc PL/SQL.................... 12
3- Affichage de résultats dans un bloc PL/SQL....................................................... 13
VI- Table Objet-relationnelle : Complément ................................................................. 14
1) Portée d’une référence................................................................................................... 14
2) Table imbriquée.................................................................................................................. 14
3) Manipulation d’une table imbriquée ........................................................................ 15
4) Mise à jour dans une table imbriquée désignée par THE. ........................... 15
5) Consultation d’une table imbriquée. ....................................................................... 16
VII- Héritage sous Oracle 9i : Types et sous-types .................................................. 17
1) Types « spécialisables » et « non spécialisables » ....................................... 17
2) Types et méthodes non instanciables ................................................................... 17
3) Définition d’un sous-type ............................................................................................... 18
4) Surcharge d’une méthode héritée ............................................................................ 18
VIII- Vues Objet-relationnelles............................................................................................. 19
1) Définition d’une vue classique (rappel) ................................................................. 19
2) Définition d’une vue objet-relationnelle ................................................................ 19
IX- Références bibliographiques......................................................................................... 21
TD/TP Bases de données objet-relationnelles
2
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
I- Type d’objets
Module Bases de données orientées objet
B- Ajout d’une nouvelle méthode
1- Création d’un type d’objets
Recopie des définitions des attributs et des méthodes déjà définies
CREATE TYPE nom_type AS OBJECT
( att1 type_att1 ,…, attn type_attn
[ , spécification_méthode1
, … , spécification_méthodem ] )
avec
Université Paul Sabatier – Master 1 Informatique
atti : nom de l’attribut
type_atti : type de l’attribut (= type de base ou type d’objets déjà créé)
spécification_méthodej : spécification ou signature de la méthode
ALTER TYPE nom_type REPLACE AS OBJECT
(
att1 type_att1 ,
…,
attn type_attn ,
specification_methode1,
…,
specification_methodem,
specification_nouvelle_methodem+1 ,
[ …,
specification_nouvelle_methodem+j]
)
Spécifications des nouvelles méthodes à ajouter
2- Suppression d’un type d’objets
II- Table objet-relationnelle.
DROP TYPE nom_type [FORCE]
Lorsqu’il s’agit d’un type incomplet par exemple, il est nécessaire d’utiliser l’option FORCE
pour forcer la suppression.
1- Création d’une table objetobjet-relationnelle
CREATE TABLE nom_table OF nom_type
[ ( spécification_contrainte1
[, …, spécification_contrainten] ) ]
3- Modification d’un type d’objets : deux requêtes possibles
A- Modification des attributs et des méthodes initialement définies
avec nom_type : nom du type d’objets préalablement défini
spécification_contraintei : spécification de la contrainte liée à la table ou à un attribut
particulier. Celle-ci est de la forme : constraint nom_contrainte type_contrainte
CREATE OR REPLACE TYPE nom_type AS OBJECT
(
att1 type_att1 ,
…,
attn type_attn
[, specification_methode1, …
specification_methodem ]
)
et avec type_contrainte :
PRIMARY KEY (liste attributs clé primaire)
FOREIGN KEY (liste attributs clé étrangère)
REFERENCES table_ref (liste attributs clé primaire)
CHECK (condition à vérifier)
attribut NOT NULL
…
Seules Les instances d’objets répertoriées dans une table relationnelle-objet disposent d’un
OID.
TD/TP Bases de données objet-relationnelles
3
Isabelle Ferrané
TD/TP Bases de données objet-relationnelles
4
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
objet--relationnelle
2- Suppression d’une table objet
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
ou bien la totalité des valeurs figurent dans la base de données, et dans ce cas on
remplace VALUES par la sous-requête chargée de ramener toutes les valeurs.
INSERT INTO nom_table
( SELECT données FROM table(s) WHERE condition(s))
DROP TABLE nom_table
3- Modification de la définition d’une table objetobjet-relationnelle
objet--relationnelle : UPDATE / DELETE
5- Mise à jour 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).
4- Ajout d’une instance dans une table objetobjet-relationnelle : INSERT
A- Insertion d’un nouveau tuple
INSERT INTO nom_table
[( sous_liste_attributs ) ]
VALUES
( val1, …, valk )
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(…)
Si la valeur est une référence il faut aller la chercher à la’aide d’une requête imbriquée
(SELECT REF(a) FROM …)
DELETE FROM nom_table
[ WHERE condition(s)]
avec vali : valeur simple, NULL, ou bien nouvelle instance d’un type d’objet générée par
l’appel au consructeur du type nom_type_objet(liste_valeurs_attributs_objet)
INSERT INTO nom_table_objet_relationnelle
VALUES( val1, …, valk )
Ou
INSERT INTO nom_table_objet_relationnelle
VALUES( nom_type_objet(val1, …, valk ) )
Pour supprimer les instances d’objet répondant si il y a lieu à la condition posée
objet--relationnelle : SELECT
6- Consultation d’ une table objet
A- 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
Si la table dans laquelle on ajoute un tuple est une table objet-relationnelle, on peut faire
aussi intervenir le constructeur associé au type d’objets dont on veut créer une instance.
B- Accéder à un objet
Toute instance d’une table objet-relationnelle dispose d’un OID (identifiant interne ou
référence), il est donc accessible directement via cette référence.
B- Insertion de nouvelles instances d’objet à partir de données déjà existantes
INSERT INTO nom_table
VALUES ( val1, …valN) ;
C- Déréférencer un objet (= obtenir sa valeur à partir de sa référence)
avec vali = valeur atomique, nouvelle instance de type d’objets (utilisation du
constructeur associé) ou bien sous-requête ramenant la valeur souhaitée (référence par
exemple) :
vali = (select donnée from table …) *
TD/TP Bases de données objet-relationnelles
SELECT VALUE(alias_objet)
FROM nom_table alias_objet
WHERE condition_restriction_selection_objet
5
Isabelle Ferrané
SELECT DEREF(REF_objet)
FROM nom_table alias_objet
WHERE condition_restriction_selection_objet
TD/TP Bases de données objet-relationnelles
6
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
D- Accéder à un attribut complexe de type n-uplet
Utilisation de la notation pointée pour accéder aux différents champs d’un attribut de type nuplet. Si les attributs sont des attributs de premier niveau, l’alias est facultatif, sinon il doit
être utilisé.
SELECT
alias_objet.att_simple,
alias_objet.att_n_uplet.att_simple,
FROM nom_table alias_objet
WHERE condition_restriction_selection_objet
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
WNPS ( Writes No Package State ) : ne modifie pas les variables des paquetages
RNPS (Reads No Package State ) : ne lit pas les variables des paquetages
2- Corps d’une méthode et corps du type
A- Définition des corps des méthodes associés au corps du type
CREATE [OR REPLACE ] TYPE BODY nom_type IS
spécification_méthode1 IS
[Declarations_variables_curseurs_et_exceptions ]
III- Méthode : définition et activation.
BEGIN
Avant d’être utilisée, une méthode doit avoir été définie. La définition d’une méthode
comprend la spécification (ou signature) et le corps (code correspondant).
Instructions_PL/SQL_ou_requêtes_SQL
[ EXCEPTION Traitement_des_erreurs ]
méthode
1- Spécification d’une méth
ode de type MEMBER.
END nom_méthode1;
[spécification_méthode2 IS
…
La spécification d’une méthode peut être donnée lors de la création du type (CREATE
TYPE, CREATE OR REPLACE TYPE) ou bien ultérieurement avec la commande ALTER
TYPE.
END nom_méthode2 ;
…
]
END ;
A- Spécification d’une méthode de type fonction
MEMBER FUNCTION nom_methode [(paramètres_formels)]
Dans le corps d’une méthode de type MEMBER, les données de l’objet pour lequel la
méthode est activée sont désignées par le nom de l’attribut concerné préfixé par le
paramètre implicite SELF :
RETURN type_élément_retour, [ directive_associée ]
B- Spécification d’une méthode de type procédure
SELF.nom_attribut
MEMBER PROCEDURE nom_methode [(paramètres_formels)],[ directive_associée ]
Afin de pouvoir appeler la méthode dans une requête SQL il est nécessaire d’indiquer
explicitement que la méthode ne modifie ni la base de données ni les paquetages (directive
PRAGMA)
C- Directive associée concernant les effets de la méthode sur la base de données ou
sur un paquetage
Cette expression peut aussi bien apparaître dans une instruction (affectation, appel de
fonction ou de procédure, …) que dans une requête SQL.
3- Suppression du corps du type
Suppression du corps d’un type d’objets
DROP TYPE BODY nom_type
PRAGMA RESTRICT_REFERENCES(nom_methode, R1[, R2])
avec R1 et R2 tq : R1 et R2 ∈ { WNDS , RNDS, WNPS, RNPS } et R1 ≠ R2
Les spécifications des méthodes sont conservées. CREATE OR REPLACE TYPE permet de
supprimer la spécification d’une méthode.
WNDS ( Writes No Database State ) : ne modifie pas l’état de la BD
RNDS ( Reads No Database State) : n’interroge pas la BD
TD/TP Bases de données objet-relationnelles
7
Isabelle Ferrané
TD/TP Bases de données objet-relationnelles
8
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
4- Activation d’une Méthode.
A- Le constructeur d’objet
Chaque type d’objets dispose d’une méthode définie implicitement par le système et dont
le rôle est de créer une nouvelle instance de ce type d’objets. Il s’agit d’une fonction
appelée constructeur.
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
Le type tableau ainsi défini peut être utilisé comme :
- type d’un attribut dans la définition d’un type d’objet utilisé ensuite pour définir
une table objet-relationnelle ;
- type d’une donnée (variable, paramètre ou valeur de retour d’une fonction) dans
un sous-programme PL/SQL.
Dans les deux premiers cas, chaque tuple ou instance de type disposera d’un attribut
auquel sera associé un ensemble limité d’éléments. Ces éléments seront directement
stockés dans le tuple correspondant.
B- Définition d’un type d’objet comportant un attribut de type tableau
Construction d’une nouvelle instance du type nom_type
CREATE TYPE nom_type_objet AS OBJECT
nom_type( val_att1, …, val_attn)
( … , att_tableau nom_type_tableau, …)
B- Les méthodes de types MEMBER
Remarque : On ne peut pas créer d’index sur un attribut de type tableau.
objet_receveur.nom_méthode()
2- Collection de type table
objet_receveur.nom_methode(paramètres_effectifs)
Si la méthode est définie comme une fonction, alors elle peut être appelée aussi bien
dans une instruction (affectation, appel de fonction ou de procédure, …) que dans une
requête SQL, à condition que la méthode n’ait pas d’effets sur le contenu de la base de
données (cf. directive PRAGMA).
Une table est une collection non ordonnée d’éléments de même type. La taille d’une
telle collection n’est pas limitée.
La déclaration d’un attribut correspondant à une table passe par la définition d’un type
table.
Définition d’un type table
Ce n’est pas le cas d’une méthode définie comme une procédure. Elle ne peut pas être
utilisée dans une requête SQL puisque par définition, elle ne renvoie pas de valeur.
IV- Collections de données
CREATE TYPE nom_type_table
AS TABLE OF nom_type_élément
Une collection correspond à un ensemble d’éléments de même type. L’ordre des
éléments peut être significatif auquel cas on parle généralement de liste.
Sous Oracle, on dispose de tableaux de taille limitée ou de tables.
Le type table ainsi créé peut être utilisé comme :
- type d’un attribut dans la définition d’une table relationnelle ;
- type d’un attribut dans la définition d’un type d’objet utilisé ensuite pour définir
une table objet-relationnelle ;
- type d’une donnée (variable, paramètre ou valeur de retour d’une fonction) dans
un sous-programme PL/SQL
1- Collections de type tableau : VARRAY
Dans les deux premiers cas, cela revient à créer une table ayant un attribut de type
ensemble de n-uplets. Celui-ci correspond alors à une table imbriquée (NESTED TABLE).
A- Définition d’un type tableau d’éléments
3- Manipulation des collections en PL/SQL
CREATE TYPE nom_type_tableau
AS VARRAY(taille) OF nom_type_élément
Avant d’être utilisée une variable de type collection doit être déclarée et instanciée
(utilisation du constructeur associé au type utilisé).
avec nom_type_élément : type de base ORACLE ou bien type défini par le concepteur.
TD/TP Bases de données objet-relationnelles
9
Isabelle Ferrané
var_ens type_collection := type_collection() ;
TD/TP Bases de données objet-relationnelles
10
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
var_ens.extend ;
d’une
e requête dans un bloc PL/SQL
2- Manipulation le résultat d’un
Effectuer un traitement séquentiel, tuple sélectionné par tuple sélectionné.
A- Curseur implicite :
« la place » pour un nouvel élément est créée.
On peut connaître le nombre d’éléments effectivement présent dans un ensemble.
nb := var_ens.count ;
Module Bases de données orientées objet
la collection existe mais ne comporte aucun élément.
Avant d’ajouter un élément, il faut prévoir « la place nécessaire » pour cela et utiliser la
fonction associée extend
Université Paul Sabatier – Master 1 Informatique
Directement créée par Oracle dès que la requête se trouve dans un bloc PL/SQL –
Attention l’absence de résultat lève l’exception NO DATA FOUND et plus d’un résultat
lève l’exception TOO MANY ROWS. Il faut gérer ces exceptions.
SELECT donnée(s)
INTO variable(s)
FROM table(s)
[WHERE condition(s)]
nb contient le nombre d’éléments
On peut balayer un ensemble du premier au dernier élément.
FOR i in var_ens.first .. var_ens.last LOOP
…
var_ens(i) := … ;
…
END LOOP ;
B- Curseur explicite :
Pour placer un élément structuré dans un ensemble il faut que celui-ci corresponde à une
instance de type déjà existante. Si ce n’est pas le cas, il faut utiliser le constructeur associé
au type d’élément.
var_ens(i) := type_elem(val1, …valN) ;
D’autres fonctions associées au manipulation de collection existent et seront vues
ultérieurement : exists, limit (pour les VARRAY seulement), …
Défini par le programmeur, permet un pré calcul du résultat (plus rapide). Le curseur
correspond à une requête de sélection dont il permet d’exploiter le résultat tuple par tuple
afin, par exemple, d’effectuer un traitement itératif. Avant d’être utilisé dans le corps d’un
programme ou d’une méthode PL/SQL, le curseur doit être d’abord déclaré (curseur
explicite). Il doit être ensuite ouvert (OPEN) avant que l’on puisse récupérer un tuple
sélectionné (FETCH). Après son utilisation le curseur doit être fermé (CLOSE). On peut tester
le résultat de la sélection avec (%FOUND, %NOTFOUND, %ISOPEN, %ROWCOUNT)
V- Procédures PL/SQL pour la manipulation d’objets
1- Bloc PL/SQL anonyme
Structure d’un bloc PL/SQL
DECLARE
Declarations_des_variables
BEGIN
Instruction_PL/SQL_ou_requêtes_SQL
[ EXCEPTION
WHEN nom_exception THEN action
…]
END ;
TD/TP Bases de données objet-relationnelles
11
Isabelle Ferrané
TD/TP Bases de données objet-relationnelles
12
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
DECLARE
/* déclaration du curseur */
CURSOR nom_curseur IS
SELECT donnée(s)
FROM table(s)
[WHERE condition(s)]
BEGIN
…
/* Ouverture du curseur */
OPEN nom_curseur ;
/*récupération du premier tuple */
FETCH nom_curseur INTO variable(s) ;
/* Traitement itératif sur chaque tuple résultat */
WHILE(nom_curseur%FOUND) LOOP
…
/*récupération du tuple suivant */
FETCH nom_curseur INTO variable(s) ;
END LOOP ;
/* Fermeture du curseur */
CLOSE nom_curseur ;
…
END ;
3- Affichage de résultats dans un bloc PL/SQL
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
VI- Table Objet-relationnelle : Complément
1) Portée d’une référence
Cela concerne les attributs d’un type d’objet (type A) référençant (physiquement c’est-à-dire
via son OID) une instance d’un autre type (type B) et la table objet-relationnelle construite
sur ce type (type A).
A- Création d’un type comportant un attribut de type REF
CREATE TYPE nom_type AS OBJECT
(… , att_ref REF nom_type_objet_référencé, …)
Création d’un type (type A) ayant comme attribut une référence à une instance d’un autre
type (type B). Pour qu’il y ait référence, il faudra à terme que cette instance soit elle-même
contenue dans une table objet-relationnelle (contenant les instances de type B qui par
définition auront un OID).
Lors de la définition d’une table objet-relationnelle basée sur ce type d’objet (type A) il est
possible de spécifier une contrainte définisant la portée de la référence en précisant le nom
de la table objet relationnelle (construite sur le type B) ou devra se trouver la référence
B- Limitation de la portée d’une référence dans la table objet-relationnelle
Activer d’abord l’affichage écran sous sqlplus
CREATE TABLE nom_table OF nom_type
( [ specification_autres_contraintes ,]
constraint nom_ctr att_ref SCOPE IS nom_table_portée )
SQL> set serveroutput on
Utilisation du paquetage dbms_output pour affichage de données atomiques
Utiliser la fonction put_line du paquetage dbms_output dans le corps du programme
BEGIN
…
/* affichage d’une ligne résultat */
dbms_output.put_line(‘Chaine’ || resultat …) ;
…
END ;
La portée de l’ att_ref est limitée à la table objet-relationnelle mentionnée après
SCOPE IS, table dans laquelle l’OID doit se trouver.
Avec nom_ctr : nom de la contrainte de portée,
att_ref : nom de l’attribut de type REF dont on limite l’ensemble des valeurs.
nom_table_portée : nom de la table définie sur le type d’objet référencé dans laquelle la
référence devra prendre sa valeur.
2) Table imbriquée
Cela concerne l’utilisation d’un type collection préalablement défini (type TABLE et non
VARRAY) comme attribut d’un nouveau type d’objet.
A- Création d’un type d’objet comportant un attribut de type collection (type table)
CREATE TYPE nom_type_objet AS OBJECT
( … , att_table_imbriquée nom_type_table, …)
TD/TP Bases de données objet-relationnelles
13
Isabelle Ferrané
TD/TP Bases de données objet-relationnelles
14
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
Lors de la définition d’une table basée sur un type d’objet contenant un attribut défini sur
un type table (attribut de type collection autre que VARRAY), il est nécessaire de spécifier
où vont être stockés les éléments de l’ensemble de la table imbriquée. Ces éléments
seront stockés de manière transparente pour l’utilisateur dans une table auxiliaire spécifiée
lors de la définition de la table principale (clause STORE AS). Cette table auxiliaire ne sera
jalais mentionnée, c’est l’attribut qui sera directement utilisé.
B- Définition d’une table objet-relationnelle comportant une table imbriquée
Module Bases de données orientées objet
A- Insertion d’un nouveau tuple dans la table imbriquée associée à un tuple existant
INSERT INTO THE (SELECT alias.att_table_imbriquée
FROM nom_table alias
WHERE condition_restriction )
VALUES (valeur_tuple_imbriqué )
B- Modification d’un tuple dans la table imbriquée associée à un tuple existant
CREATE TABLE nom_table OF nom_type_objet
[( specifications_contraintes )]
NESTED TABLE att_table_imbriquée
STORE AS nom_table_imbriquée ;
Actuellement, sous Oracle 9i, on peut avoir plusieurs tables imbriquées au premier niveau
(autant de clauses NESTED TABLE nécessaires) MAIS seulement UN SEUL niveau
d’imbrication est autorisé. Pas de table imbriquée dans une table imbriquée.
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]
C- Suppression d’un tuple dans la table imbriquée associée à un tuple existant
3) Manipulation d’une table imbriquée
A- Initialisation d’une table imbriquée.
Deux cas de figure se présentent alors. Soit on spécifie une liste vide (1) et dans ce cas la
table imbriquée est initialisée mais ne comporte aucun tuple. Soit on donne une liste
d’objets en utilisant autant de fois le constructeur de type d’objet associé (2) .
5) Consultation d’une
d’une table imbriquée.
B- Insertion d’un nouveau tuple comportant une table imbriquée
Si on utilise le mécanisme de curseur dans la clause select (cf. ci-dessous) ou de jointure
implicite, il est nécessaire d’utiliser TABLE pour indiquer à Oracle que l’attribut mentionné
correspond à une table que l’on peut manipuler
INSERT INTO nom_table
VALUES (val1, val2, …, val_table_imbriquée, …, valn)
Si t désigne le tuple d’une table et que ce tuple contient un attribut A qui représente une
table imbriquée on écrira … FROM TABLE(t.A) … pour interroger la table imbriquée en
question.
avec val_table_imbriquée : du type (1) ou (2) ou NULL
Attention : Si aucune valeur n’est spécifiée (valeur NULL) aucune insertion de tuple ne
sera possible dans la table imbriquée. Il faut impérativement que celle-ci ait été initialisée.
4) Mise à jour dans une table imbriquée désignée par 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.
15
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 ]
Seront supprimés les tuples de la table imbriquée vérifiant la condition de restriction
spécifiée. S’il n’y a pas de condition tous les tuples de la table imbriquée sont supprimés.
Pour accéder à certains attributs de la table imbriquée, on utilise aussi un alias.
(1) nom_type_table()
(2) nom_type_table( nom_type_elem(valeur_objet1),
…,
nom_type_elem(valeur_objetk) )
TD/TP Bases de données objet-relationnelles
Université Paul Sabatier – Master 1 Informatique
Isabelle Ferrané
Utilisation d’un curseur dans une requête SQL
SELECT t.att,
CURSOR(sous-requête_de_sélection) "nom_colonne"
FROM nom_table t
[WHERE condition_de_selection_sur_t]
TD/TP Bases de données objet-relationnelles
16
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
permet de faire apparaître un ensemble de valeurs (récupérées par la sous-requête de
sélection) associé aux autres attributs sélectionnés. La colonne correspondant au curseur
peut être renommée (nom_colonne). Résultat équivalant à l’application de l’opération
NEST.
Université Paul Sabatier – Master 1 Informatique
VII- Héritage sous Oracle 9i : Types et sous-types
B- Définition d’une méthode générique
Le concept d’héritage est actuellement limité à l’héritage simple (pas d’héritage multiple) et
permet la définition de sous-types d’objets à partir de types d’objet existants. Le sous-type
hérite alors des attributs et des méthodes qui caractérisent le type initial (super-type). Il peut
être enrichi de nouveaux attributs et de nouvelles méthodes. Certaines méthodes héritées
peuvent être surchargée (même signature mais corps différent). Un sous-type peut lui aussi
donner lieu à la définition d’autres soustypes. Ainsi, grâce à ce mécanisme, on peut définir
une hiérarchie de types.
Module Bases de données orientées objet
Une méthode définie pour un type d’objets « non instanciable » peut être elle-même
déclarée « non instanciable ». Elle sera héritée mais implémentée seulement dans les soustypes ou sera également donnée la directive PRAGMA
CREATE TYPE nom_type_générique
AS OBJECT
( att1 type1,
… ,
attn typen,
NOT INSTANTIABLE specification_méthode_generique
…
)
NOT INSTANTIABLE NOT FINAL ;
1) Types « spécialisables » et « non spécialisables »
La mise en oeuvre de l’héritage n’est possible que sur les types dits « spécialisables » c’està-dire définis avec le mot clé NOT FINAL. Un type défini sans ce mot clé est non
spécialisable (pas d’héritage possible).
Définition d’un type « spécialisable »
CREATE TYPE nom_super_type AS OBJECT
(att1 type1, … attn typen)
NOT FINAL ;
Attention : si le mot clé NOT FINAL est omis lors de la redéfinition d’un type avec
CREATE OR REPLACE TYPE, le type sera considéré ensuite comme « non spécialisable »
c’est-à-dire FINAL.
2) Types et méthodes non instanciables
Il est possible de définir un type d’objets comme « non instanciable » c’est-à-dire générique.
Ainsi, on autorise la définition de sous-types mais on interdit la création d’instances
de ce type. Un tel type ne possède pas de constructeur. Seuls les sous-types sont
instanciables à moins bien sûr qu’ils ne soient définis eux-mêmes comme « non
instanciables ».
A- Définition d’un type non instanciable
CREATE TYPE nom_super_type AS OBJECT
(att1 type1, … attn typen)
NOT INSTANTIABLE NOT FINAL ;
17
Définition d’un sous-type à partir d’un super type déjà défini comme NOT FINAL
CREATE TYPE nom_sous_type
UNDER nom_super_type
[( attn+1 typen+1,
… ,
attn+k typen+k
[ , …, specification_méthodem+j,…] )]
[ [NOT INSTANTIABLE] NOT FINAL ];
avec attn+i : nom d’attribut spécifique au sous type qui se rajoute aux attributs hérités ;
typen+i : type de l’attribut spécifique au sous type ;
specification_methodem+j : spécification d’une nouvelle méthode associée au
sous-type qui se rajoute aux méthodes héritées ou bien surcharge d’une méthode héritée ;
L’option doit donc être systématiquement répétée.
TD/TP Bases de données objet-relationnelles
3) Définition d’un soussous-type
Isabelle Ferrané
4) Surcharge d’une méthode héritée
Si le sous-type a été obtenu à partir d’un type d’objet générique ( NOT NSTANCIABLE)et
que ce type comporte des méthodes génériques, celle-ci seront héritées et conserveront
leur caractère générique. Pour implémenter une telle méthode au niveau d’un sous-type, il
faut surcharger la méthode. La spécification de la méthode propre au sous-type doit alors
être redonnée accompagnée du mot clé OVERRIDING.La directive PRAGMA caractérisant
l’implémentation de la méthode doit alors être donnée.
TD/TP Bases de données objet-relationnelles
18
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
Syntaxe :
VIII- Vues Objet-relationnelles
Une vue objet-relationnelle permet de visualiser les données différemment de la façon
dont elles sont organisées. Par exemple, elle permet d’accéder au contenu d’une base de
données relationnelle, tout en présentant les données sous forme objet relationnelle. On
peut ainsi développer des applications basées sur une modélisation objet-relationnelle tout
en conservant l’organisation relationnelle de la base.
1) Définition d’une vue classique (rappel)
Une vue peut être construite sur une seule table ou résulter de la jointure de plusieurs
tables.
CREATE VIEW nom_vue_or
OF type_objet
WITH OBJECT IDENTIFIER ( att_oid )
[UNDER nom_vue_mère ]
AS
SELECT att1, att2
[,CAST(MULTISET(…)]
[, type_nuplet (att_np1, att_np2, …)] …
[ REF(alias)]
[ MAKE_REF(nom_autre_vue, att_oid)]
FROM nom_table alias [, nom_table2 alias2]*
WHERE condition(s)
Opérateur CAST(MULTISET())
Dans une vue objet il est possible de définir un attribut correspondant à une collection (table
imbriquée ou Varray) et de regrouper ainsi des données de même type.
CAST (MULTISET ( SELECT …) AS type_cible)
MULTISET permet de considérer le résultat de la sous-requête SELECT comme un
ensemble de données de même type. CAST indique que le résultat de la sous-requête sera
convertit en un ensemble du type spécifié par AS (type_cible).
CREATE VIEW nom_vue AS [(att1_vue, att2_vue, …)] AS
SELECT att1, att2, …
FROM nom_table [, autre_table…]
[ WHERE condition selection et/ou jointure ]
En fonction du mode de construction de la vue, les mises à jour seront ou non possibles
(oui pour une vue monotable à condition que les attributs qui composent la clé primaire ainsi
que les attributs non nuls figurent dans la vue ; non si la vue est construite à partir d’une
jointure).
Constructeur de n_uplet type_nuplet
De la même manière, un attribut structuré de type n_uplet peut être défini dans une vue. On
utilisera alors le constructeur du type associé pour représenter une instance de ce type
construite à partir des données présentes dans la base de données de manière isolée.
Référence à un objet
On peut utiliser :
- le mot clé REF appliqué à l’alias représentant soit une instance d’une table objetrelationelle, soit un tuple d’une vue objet-relationnelle
- l’opérateur MAKE_REF appliqué à une autre vue objet-relationnelle et à l’attribut sur
lequel est défini d’OID de la vue.
objet--relationnelle
2) Définition d’une vue objet
Etape 1 : définir un type d’objet
Ce type sera défini de façon à ce que chacun de ses attributs corresponde à une donnée
présente dans la base de données : attribut simple, ou complexe (ensemble ou n-uplet).
19
Module Bases de données orientées objet
Celle-ci est créée à partir d’une requête SELECT permettant d’extraire les données de la
table, ou des tables si une jointure est effectuée. Ces données sont soit des attributs
simples (att1, att2, …) soit des regroupements de données de même type
(CAST(MULTISET(…)) ou de types différents (utilisation du constructeur de type_nuplet…)
soit des références (REF ou MAKE_REF).
CREATE OR REPLACE TYPE nom_sous_type
UNDER nom_super_type
[( attn+1 typen+1,
… ,
attn+k typen+k,
…,
OVERRIDING spécification_surcharge_méth_héritéee,
PRAGMA RESTRICT_REFERENCES (…)
[, specification_nouvelle_méthodem+j, ]
)]
[ [NOT INSTANTIABLE] NOT FINAL ];
TD/TP Bases de données objet-relationnelles
Université Paul Sabatier – Master 1 Informatique
Etape 2 : Création de la vue objet relationnelle
Isabelle Ferrané
MAKE_REF permet de définir des références circulaires (A contient une référence à B
et B contient une référence à A).
TD/TP Bases de données objet-relationnelles
20
Isabelle Ferrané
Université Paul Sabatier – Master 1 Informatique
Module Bases de données orientées objet
Etape 3 : Association d’un identifiant interne (OID) à chaque tuple de la vue
La modélisation objet-relationnelle introduit la notion d’OID. Tout tuple d’une table objetrelationnelle possède un OID. De même une vue objet-relationnelle doit posséder un
identifiant qui sera construit sur un attribut de la vue (généralement clé primaire dans la
table d’origine).
Remarque : Dans une table relationnelle, les tuples n’ont pas d’OID, passer par une vuerelationnelle est un moyen de leur en attribuer un.
Clause WITH OBJECT IDENTIFIER
La clause WITH OBJECT IDENTIFIER permet alors de définir une valeur unique à partir
d’attributs de la relation sous-jacente (attributs clé primaire) qui servira d’OID dans la
modélisation objet-relationnelle. Ceci rend ensuite possible l’utilisation de références sur les
données auxquelles on accède grâce à la vue.
Etape 4 : Mise à jour à travers une vue objet-relationnelle
Si les attributs de la vue et donc du type associé ne correspondent pas exactement à ceux
de la table d’origine, il est nécessaire d’écrire un trigger INSTEAD OF qui se déclenchera
en fonction de l’opération de mise à jour demandée (insert, update, delete).
CREATE TRIGGER nom_trigger
INSTEAD OF INSERT [OR UPDATE [OR DELETE] ]
ON nom_vue_or
FOR EACH ROW
…/*declarations de variables */
BEGIN
…
IF INSERTING [ OR UPDATING [ OR DELETING] ] THEN …
… /* operation à réaliser en réalité */
END IF;
…
END;
IX- Références bibliographiques
Objet-relationnel sous Oracle 8 : Modélisation avec UML, SOUTOU, Christian, Eyrolles, Paris, 1999
ISBN : 2-212-09063-3
De UML à SQL : Conception de bases de données, SOUTOU, Christian , Eyrolles, Paris, 2002,
ISBN : 2-212-11098-7
Bases de données : Objet & Relationnel, GARDARIN, Georges, Eyrolles, Paris, 1999,
ISBN2-212-09060-9
TD/TP Bases de données objet-relationnelles
21
Isabelle Ferrané