L ’OBJET-RELATIONNEL

u Présentation de la norme SQL3

u Support de SQL3 dans Oracle 8

u Les systèmes Objet-relationnel

© Béatrice Finance 1
1. Evolution des SGBD relationnels

u Années 80 :
w centrés sur le transactionnel
w applications dites OLTP (One Line Transaction Processing)

u Années 90 :
w développement du décisionnel
w applications dites OLAP (One Line Analysis Processing)
w intégration de données multi-dimensionnelle (cube 3D)

u Années 95 :
w besoins croissants des applications avancées (CAO, AGL, SIG,…)
w avènement des technologies objet et du Web

© Béatrice Finance 2
1. LA NORMALISATION

u SQL2 [ISO92] :
w diversification des domaines :
- dates, monnaies, le temps et les intervalles,
- les chaînes de bits (LOBs, BLOBs, CLOBs)
w meilleur support de l ’intégrité (clause CHECK)
w intégration étendue de l ’algèbre relationnelle (union et jointure
externes, meilleure gestion des valeurs nulles)
w possibilité de SELECT en argument d ’un FROM

u Des problèmes demeurent:

w absence de pointeurs visibles par l ’utilisateur
- restaurer la navigation et le partage référentiel d ’objets
w le non-support de domaines composés
- non-structurés et ne supportent pas les recherches associatives
w la non-intégration des opérations

© Béatrice Finance 3
 1. LE SUPPORT D ’OBJETS COMPLEXES

u Nécessité d'introduire des attributs

multi-valués

u Offrir des collections prédéfinies telles

que liste, ensemble, tableau, …

u Imbrication des collections pour

représenter des objets très compliqués

u Exemple :
w Molécule { list <Atome, Connexions>}
w Atome { Noyau, list <Electrons> }

© Béatrice Finance 4
 1. L ’OBJET-RELATIONNEL

u Extension du modèle relationnel

w attributs multivalués : structure, liste,
tableau, ensemble, ... OBJET
w héritage sur relations et types
w domaine type abstrait de données Polymorphisme
(structure cachée + méthodes)
w identité d'objets RELATIONNEL
Types Domaine
utilisateurs Table Collections
u Extension de SQL Attribut
Clé
w définition des types complexes avec
Référence
héritage
Opération Identifiant
w appels de méthodes en résultat et
qualification
w imbrication des appels de méthodes Héritage
w surcharge d'opérateurs

© Béatrice Finance 5
1. SQL3

u Objectifs
w supporter de manière intelligente des données multi-media
u Solutions
w support d ’objets complexes (ADTs)
w NF2 (Non Firts Normal Form) :
- forme normale supportant des domaines multivalués
w Modèle relationnel imbriqué (Nested Model)
- un domaine peut lui-même être valué par des tables
u Normalisation longue et difficile
w Committee Draft – 1/96
w Draft International Standard – 12/98
w International Standard – 7/99
u Spécification volumineuse
w plus de 1500 pages

© Béatrice Finance 6
1. LES COMPOSANTS

u Part 1: Framework
w description non-technique de comment le document est structuré.
u Part 2: Foundation
w noyau de spécification, incluant les types de données abstraits.
u Part 3: SQL/CLI
w interface d’appel client.
u Part 4: SQL/PSM
w le langage de spécifications de procédures stockées
u Part 5: SQL/Bindings
w les liens SQL dynamique et “embedded” SQL repris de SQL-92.
u Part 6: SQL/XA
w spécification de l’interface XA pour moniteur transactionnel.
u Part 7: SQL/Temporal
w support du temps dans SQL3

© Béatrice Finance 7
1. LES COMPOSANTS ...

u Part 8: abandonné
u Part 9: SQL/MED
w utilisation de SQL pour accéder à des données non SQL.
u Part 10: SQL/OBJ
w l ’utilisation de SQL depuis un langage objet et C++,
Smalltalk ou Java

u Au-delà de SQL3, vers SQL4 :

w SQL/MM
- pour la spécification de types utilisateurs multi-media
w SQL/RDA
- pour la spécification du protocole de transfert des données entre
le client et le serveur

© Béatrice Finance 8
1. LES PROCEDURES (PSM)

u Langage de programmation de procédures

w déclaration de variables
w assignation
w conditionnels CASE, IF
w boucles LOOP, FOR
w exceptions SIGNAL, RESIGNAL
w possibilité de procédures et fonctions externes

u Possibilité de structuration en modules

© Béatrice Finance 9
1. SQL3 - LES OBJETS

u Extensibilité des types de données

w Définition de types abstraits
w Possibilité de types avec ou sans OID

u Support d’objets complexes

w Constructeurs de types (tuples, set, list, …)
w Utilisation de référence (OID)

u Héritage
w Définition de sous-types
w Définition de sous-tables

© Béatrice Finance 10
1. LES TYPES ABSTRAITS

u CREATE TYPE <nom ADT> <corps de l’ADT>

u <corps de l’ADT>
w <OID option> ::= WITH OID VISIBLE
- objets sans OID par défaut

w <subtype clause> ::= UNDER <supertype clause>

- possibilité d’héritage multiple avec résolution explicite

w <member list>
- <column definition> : attributs publics ou privés
- <function declaration> : opérations publiques
- <operator name list> : opérateurs surchargés
- <equals clause>, <less-than clause> : définition des ordres
- <cast clause> : fonction de conversion de types

© Béatrice Finance 11
1. QUELQUES EXEMPLES

u Un type avec référence

CREATE TYPE WITH OID PHONE (
country VARCHAR,
area VARCHAR,
number int,
description CHAR(20))

u Un type sans référence

CREATE TYPE PERSON
(nss INT,
nom VARCHAR,
tel phone)

u Un sous-type
CREATE TYPE STUDENT UNDER PERSON (
major VARCHAR,
year INT)

© Béatrice Finance 12
1. LES CONSTRUCTEURS DE TYPE

u Les constructeurs de base (types paramétrés):

w collections : SET(T), MULTISET(T), LIST(T)
CREATE TYPE PERSON (
nss INT,
nom VARCHAR,
prénoms LIST(varchar),
tel SET(phone))

u Les références
w possibilité de référencer un objet créé “without OID”
CREATE TYPE CAR (
number CHAR(9),
color VARCHAR,
owner REF(person))

u Les constructeurs additionnels

w stack, queue, array, insertable array (exemple : texte)
w non intégrés dans le langage mais peuvent être ajoutés

© Béatrice Finance 13
1. LES FONCTIONS

u Les fonctions peuvent être associées à une base,

un type, une table,...
u Syntaxe :
[<function type>] : CONSTRUCTOR, ACTOR, DESTRUCTOR
FUNCTION <function name> <parameter list>
RETURNS <function results> <SQL procedure> | <file name>
END FUNCTION

u Exemple :
CREATE FUNCTION sell (c Ref(Constructor), amount MONEY)
UPDATE Constructor
SET total = total + amount
WHERE Ref(Constructor) = c
END FUNCTION
u Langage de programmation
w SQL et SQL3 PSM, Langage externe

© Béatrice Finance 14
 1. LES TABLES

u Caractéristiques
w une table peut posséder des attributs d'un type abstrait
w un tuple contient des références ou des valeurs complexes
w un attribut peut être de type référence (REF <type> ou with OID)

u Exemples
CREATE TABLE Cars OF car ; // utilisation d ’un type prédéfini

CREATE TABLE Constructors OF NEW TYPE Constructor (

name VARCHAR,
total MONEY) ; // définition d ’un nouveau type

CREATE TABLE FrenchConstructors UNDER Constructors(

taxe MONEY) // définition d ’une sous-table

© Béatrice Finance 15
1. L ’APPEL DE FONCTIONS ET D ’OPERATEURS

u Appel de fonctions :
SELECT [Link]
FROM emp j, emp r
WHERE [Link] = 'Joe'
AND distance([Link],[Link]) < 1 ;

u Appel d'opérateurs ou prédicats :

SELECT [Link]
FROM emp e, emp r
WHERE [Link] = 'Joe ’
AND contained([Link], circle([Link],1)) ;

© Béatrice Finance 16
1. LE PARCOURS DES REFERENCES

u Les fonctions Ref et DeRef sont implicites :

CREATE TABLE cars OF TYPE car. ;
SELECT [Link] FROM cars c WHERE color = 'red ’;

u Possibilité de cascader la notation pointée :

SELECT dname FROM dept WHERE 1985 IN [Link] ;

u Généralisation possible aux chemins multiples :

SELECT dname FROM dept
WHERE autos.(year=1985 and name = 'Ford');

u Toute collection peut être utilisée en place d'une table

© Béatrice Finance 17
1. EXEMPLE DE TABLES IMBRIQUEES

Services
N° Chef Adresse Employés Dépenses

Nom Age NDep Montant Motif

24 Paul Versailles Pierre 45 1 2600

134 Livres
Marie 37
2219 8700 Mission

3037 15400 Portable

Nom Age NDep Montant Motif

Eric 42 5 3000 Livres

25 Patrick Paris
Julie 51
7185 4000 Mission

© Béatrice Finance 18
1. COMPARAISON AVEC LE RELATIONNEL

u Accès en relationnel

select effdate, name, vehicleyr

from policy, customers, vehicles
where [Link] = [Link]
and [Link] = [Link]
and model = ‘ferrari’;
u Accès en objet-relationnel

select [Link], [Link], [Link]

from policy p
where [Link] = ‘ferrari’;

© Béatrice Finance 19
 L ’objet-relationnel dans Oracle 8

ADTs
References
Nested Tables
Large Objects (LOBs)

[Link]

© Béatrice Finance 20
2. LES TYPES

CREATE TYPE PointType AS OBJECT(

Création d ’un type : x NUMBER,
CREATE TYPE t AS OBJECT ( y NUMBER );
/
list of attributes and methods
);
CREATE TYPE LineType AS OBJECT(
/ end1 PointType,
/ pour qu’Oracle intègre la définition end2 PointType);
/
Suppression d ’un type :
DROP TYPE t; CREATE TABLE Lines (
* toutes les tables contenant t doivent lineID INT,
être détruites au préalable, sinon line LineType);
« t : still in used »
INSERT INTO Lines
VALUES ( 27, LineType(
PointType(0.0, 0.0),
PointType(3.0, 4.0)));

© Béatrice Finance 21
2. LES METHODES

CREATE TYPE LineType AS OBJECT (

end1 PointType,
end2 PointType,
MEMBER FUNCTION length(scale IN NUMBER) RETURN NUMBER,
PRAGMA RESTRICT_REFERENCES(length, WNDS) );
/

u Il faut spécifier le mode de chaque argument : IN, OUT, INOUT

u Pragma : permet d ’indiquer à la BD
w WNDS = write no database state
w indispensable pour utiliser la méthode dans les requêtes

© Béatrice Finance 22
 2. LES METHODES ...

CREATE TYPE BODY LineType AS

MEMBER FUNCTION length(scale NUMBER) RETURN NUMBER IS
BEGIN
RETURN scale *
SQRT((SELF.end1.x-SELF.end2.x)*(SELF.end1.x-SELF.end2.x) +
(SELF.end1.y-SELF.end2.y)*(SELF.end1.y-SELF.end2.y)
);
END;
END;
/

u Self : référence le tuple courant sur lequel est appliquée la méthode

u Le langage de définition est PL/SQL, (ou Java dans Oracle8i)

© Béatrice Finance 23
2. LES REQUETES

u Utilisation d ’une méthode:

SELECT lineID, [Link](2.0)
FROM Lines ll;

u Traversée de chemin:
SELECT [Link].end1.x, [Link].end1.y
FROM Lines ll;

u Valeur complexe en retour:

SELECT [Link].end2
FROM Lines ll;
* le résultat de cette requête serait PointType(3,4), le constructeur de
type est utilisé pour afficher un résultat

© Béatrice Finance 24
2. LES RELATIONS

u Les types Oracle8 peuvent être utilisés :

w soit comme types abstraits de données (ADTs)
w soit comme « RowType » selon SQL3

CREATE TABLE Lines1 OF LineType;

w équivalent à :
CREATE TABLE Lines1 (
end1 PointType,
end2 PointType );

w mais en plus on peut utiliser la méthode length :

SELECT AVG([Link](1.0))
FROM Lines1 ll;

© Béatrice Finance 25
2. L ’UTILISATION DES REFERENCES

CREATE TABLE Lines2 (

end1 REF PointType,
end2 REF PointType );
u REF : permet de créer une référence à partir d ’un objet tuple

CREATE TABLE Points OF PointType;

INSERT INTO Lines2

SELECT REF(pp), REF(qq)
FROM Points pp, Points qq
WHERE pp.x < qq.x;
* restriction : pour manipuler des références, il faut que l ’objet soit un tuple
* INSERT INTO LInes2 VALUES( REF(PointType(1,2), REF(PointType(3,4)) n ’est
pas possible car PointType(1,2) n ’appartient à aucune relation

SELECT ll.end1.x, DEREF(ll.end2)

FROM Lines2 ll;

© Béatrice Finance 26
 2. LES TABLES IMBRIQUEES

u Pour obtenir une relation comme type d ’un

attribut, il faut définir un nouveau type :

CREATE TYPE PolygonType AS TABLE OF PointType;

/

CREATE TABLE Polygons (

name VARCHAR2(20),
points PolygonType)
NESTED TABLE points STORE AS PointsTable;

© Béatrice Finance 27
2. LES TABLES IMBRIQUEES ...

INSERT INTO Polygons VALUES (

‘ square ’, PolygoneType(
PointType(0.0,0.0),PointType(0.0,1.0),
PointType(1.0,0.0),PointType(1.0,1.0)));

SELECT points
FROM Polygons
WHERE name = ‘ square ’;

SELECT ss.x
FROM THE (SELECT points FROM Polygons WHERE name = ‘ square ’) ss
WHERE ss.x = ss.y;

© Béatrice Finance 28
2. RELATIONS IMBRIQUEES & REFERENCES

CREATE TYPE PolygonRefType AS TABLE OF REF PointType; /

CREATE TABLE PolygonsRef (

name VARCHAR2(20),
pointsRef PolygonRefType)
NESTED TABLE pointsRef STORE AS PointsRefTable;

SELECT ss.COLUMN_VALUE.x
FROM THE ( SELECT pointsRef
FROM PolygonsRef
WHERE name = 'square' ) ss
WHERE ss.COLUMN_VALUE.x = ss.COLUMN_VALUE.y;

* Puisque la relation imbriquée n ’a pas de nom d ’attribut, alors Oracle

fournit un nom par défaut COLUMN_VALUE

© Béatrice Finance 29
2. CONVERSION : RELATION -> OBJET-RELATION

u Supposons une vieille relation de lignes plates :

CREATE TABLE LinesFlat(
id INT, x1 NUMBER, y1 NUMBER, x2 NUMBER, y2 NUMBER);

u Transfert dans la relation Lines :

INSERT INTO Lines
SELECT id, LineType(PointType(x1,y1), PointType(x2,y2))
FROM LinesFlat;

© Béatrice Finance 30
2. CONVERSION : RELATION -> OBJET-RELATION ...

u Soit la relation représentant des polygones à plat :

CREATE TABLE PolyFlat(
name VARCHAR(20), x NUMBER, y NUMBER);

u Transfert d ’un polygone dans la relation Polygons :

INSERT INTO Polygons
VALUES ('square',
CAST(
MULTISET( SELECT x, y
FROM PolyFlat
WHERE name = 'square')
AS PolygonType
)
);

© Béatrice Finance 31
2. CONVERSION : RELATION -> OBJET-RELATION ...

u Transfert de tous les polygones dans la relation

Polygons :

INSERT INTO Polygons

SELECT [Link],
CAST(
MULTISET( SELECT x, y
FROM PolyFlat qq
WHERE [Link] = [Link] )
AS PolygonType
)
FROM PolyFlat pp;

*Pb : insertion d ’autant de n-uplets Polygon que de n-uplets dans PolyFlat

© Béatrice Finance 32
2. CONVERSION : RELATION -> OBJET-RELATION ...

INSERT INTO Polygons

SELECT [Link],
CAST(
MULTISET( SELECT x, y
FROM PolyFlat qq
WHERE [Link] = [Link] )
AS PolygonType
)
FROM PolyFlat pp
WHERE NOT EXISTS(
SELECT *
FROM PolyFlat rr
WHERE [Link] = [Link]
AND ( rr.x < pp.x OR rr.x = pp.x )
AND rr.y < pp.y);
*Idée : ne faire l ’insertion que pour un point suivant l ’ordre lexicographic

© Béatrice Finance 33
2. Large Objects (LOBs)

u Oracle distingue 3types de LOBs :

w BLOBs (Binary Large Objects) & CLOBs (Character Large
Objects) :
- taille < 4 Go
- stocké dans la BD mais à l ’extérieur de la relation

w BFILE (Binary File)

- taille illimitée
- stocké à l ’extérieru de la BD (fichier référencé dans la BD)
- NB : la cohérence des données n ’est pas assurée par Oracle

u Fonctions de manipulation accessibles via PL/SQL :

w read, write, getlength, substr, instr, append, erase, compare, copy

© Béatrice Finance 34
2. Large Objects (LOBs) ...

u Exemples :

CREATE TABLE Personne (

nom VARCHAR(10)
photo BFILE,
cv CLOB,
prog BLOB);

INSERT INTO Personne VALUES (

‘ Tintin ’,
bfilename(‘$envir/images ’, ‘ [Link]),
‘ Tintin est un journaliste très connu,……………. ’,
empty_blob()
);

© Béatrice Finance 35
CONCLUSION

u Etendre un système relationnel signifie ajouter :

w des ADTS ou des LOBs :
- UDTs (User-defined Data Types)
- UDFs (User-defined Functions) ou procédures stockées
w des méthodes d ’accès pour les UDTs
w adaptation de l ’optimiseur :
- statistiques, propriétés des opérateurs, règles de transformation
w des triggers

u Les technologies :
w DB2 relational extenders
w Informix DataBlades
w Oracle Cartridges

© Béatrice Finance 36
3. DB2 Relational Extenders

© Béatrice Finance 37
3. Informix DataBlades

© Béatrice Finance 38
3. Oracle Cartridges

© Béatrice Finance 39