systèmes de gestion de bases de données orientés objet philippe salvan [email protected]

Systèmes de Gestion de Bases Systèmes de Gestion de Bases de Données Orientés Objetde Données Orientés Objet

Philippe [email protected]

Plan du CoursPlan du Cours

Généralités Historique Aspects Bases de Données ;

Aspects Orientés Objet Architecture

Aspects Orientés Objets Objet Complexe, Encapsulation, Classes Identité d'Objet Héritage Surcharge, Lien retardé Valeurs, Types

Aspects Base de Données Modèle de persistance Transactions Interrogations Optimisations

ODMG 3.0

Généralités - HistoriqueGénéralités - Historique

Besoin d’organiser de manière cohérente des données permanentes et accessibles par des utilisateurs concurrents

Gestion de Fichiers SGBD Navigationnels

SGBD Relationnels SGBD Orientés Objets

abstractionabstraction

code unique

code

réutilisable

optimisation

données

fichiers

SGFSGF

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/NSGBD/N

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/RSGBD/R

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/OSGBD/O



Limites des SGBDR le modèle de données est très pauvre la normalisation conduit à un éclatement des

données intégration de SQL à un langage de

programmation :ensembliste vs procéduraldysfonctionnement (conversion de types)


Objectifs des SGBDOO réduire le dysfonctionnement entre langage de

programmation et langage de base de données en offrant un unique langage de programmation de base de données

supporter directement les objets arbitrairement complexes par un modèle objet

partager le code réutilisable au sein du SGBD


Définition des SGBDOOThe Object-Oriented Database

System Manifesto (1989)Défini par des chercheursEnsemble de règles caractérisant un SGBDOO:

obligatoires, facultatives, ouvertes


Définition des SGBDOO ODMG 1.0 (1993)

Défini par des éditeurs Standard de portabilité des SGBDOO

ODMG 2.0 (1997) Binding langages objet (c++, smalltalk, java) vers SGBDO

ODMG 3.0 (2000) Améliorations du binding java prémisses de JDO Dernière version avant dissolution de l’ODMG

Généralités - Aspects Base de DonnéesGénéralités - Aspects Base de Données

un SGBDOO est un SGBDPersistanceGestion du disquePartage des données (multi-utilisateurs)Fiabilité des donnéesSécurité des données Interrogation ad hoc

Généralités - Aspects Orientés ObjetGénéralités - Aspects Orientés Objet

Un SGBDOO est Orienté ObjetObjets complexes Identité d'objetEncapsulation, ClassesHéritageSurcharge, Lien retardéValeurs, TypesPolymorphisme

Généralités - ArchitectureGénéralités - Architecture

Architecture Fonctionnelle

Langage de Définition

Langages de Programmation

Langage de Requêtes

Autres interfaces

Outils de Développement

Gestion de Schéma Gestion d'Objets


Architecture Opérationnelle

Objets

Fichiers

Verrous Journal

Pages

ApplicationCompilationProgramme utilisateur


Architecture Client/ServeurServeur d'objets

Objets

Fichiers

Verrous Journal

Cache de Pages

Application

Objets

Application

Objets


Architecture Client/ServeurServeur d'objets

Fort degré de concurrence (verrouillage et journalisation au niveau de l'objet)

Possibilité d'exécution de méthodes sur le serveur


Architecture Client/ServeurServeur de pages

PagesVerrous Journal

Cache de Pages

Application

Objets

Fichiers

Pages

Application

Objets

Fichiers

Pages


Architecture Client/ServeurServeur de pages

Utilisation de la puissance de calcul des clientsAccroît le nombre de connections possiblesServeur isoléVerrouillage et journalisation par page


Architecture Client/ServeurMulti-serveurs

Objets Répartis

Fichiers

Pages

Application

Objets Répartis

Fichiers

Pages

Application

objets ou pages

SCHEMA

BASE

GénéralitésGénéralités

Schéma, Base

BASE

BASEBASE

BASEBASE

SCHEMA

SYSTEME

VOLUME DISQUE

Aspects Orientés ObjetsAspects Orientés Objets

Objet complexe, encapsulation, classeOBJET =

DONNÉES + DESCRIPTION D’INTERFACE(STRUCTURES DE DONNÉES + COMPORTEMENTS)

Un objet est l’encapsulation, dans une même entité, de données conformes à une structure de données et des opérations permettant de manipuler cette structure de données.


Objet complexe, encapsulation, classe

Vue externe: OBJET = BOITE NOIRE + BOUTONS

Vue interne:OBJET = DONNEES + MECANIQUE

LIEEAUX BOUTONS


Point de vue structurel : un objet est un type de données qui définit une

structure et l’ensemble des opérations applicables à cette structure.

Point de vue conceptuel : un objet est une unité de connaissance représentant

le prototype d’un conceptPoint de vue acteur :

un objet est une entité autonome et active.


L’encapsulation est le principe qui consiste à préserver la structure et la mécanique interne des objets des regards indiscrets pour n’en montrer qu’une interface choisie Les propriétés de visibilité permettent de définir ce qui fera

partie de l’interface.

Seules les parties publiques (appelées spécifications ou interfaces) sont accessibles.

nom: DUPONDprénom: Jean

init(nom: string, prenom: string, age: integer, conjoint: Personne)vieillir()donne_age(): integerdonne_conjoint(): Personnese_marie(conjoint: Personne)

conjoint: aucunfixe_age(age: integer)

age: 25


Une classe est la description abstraite d’un ensemble d’objets partageant les mêmes caractéristiques.

Elle possède deux composantes : description des données, appelées attributs

(composante statique) description des procédures, appelées méthodes

(composante dynamique)


Les attributs caractérisent l’état des objets durant l’exécution des programmes.

Les méthodes caractérisent les comportements des objets durant l’exécution des programmes.

Tout objet est instance de sa classe.


Une méthode est toujours associée à une classe et se compose de deux parties : sa signature qui indique les structures de données sur lesquelles

elle opère son corps qui indique la manière dont elle opère

Une méthode est toujours déclenchée sur un objet appelé objet receveur et désigné, dans le corps de la méthode, par la variable self ou this.

Pour instancier une classe, on fait appel à l’opérateur new, prédéfini pour toute classe, qui réalise l’allocation mémoire nécessaire, crée un objet et déclenche automatiquement l’initialisation de l’objet


Identité d ’objetChaque objet est caractérisé par un identifiant

unique, immuable, géré par le système. Cet identifiant est un moyen discriminant de

désigner un objet ; il est indépendant de la valeur des attributs de l'objet. Deux objets peuvent coïncider en tout point (selon la modélisation effectuée) : on dit qu'ils sont égaux.


Deux personnes différentes mais de mêmes caractéristiques (pour le modèle) !

Exemple: deux homonymes, de même prénom et de même âge…

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: -

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: -


L'identité est la relation d'équivalence "avoir même identificateur que"

L'égalité est la relation d'équivalence "avoir les mêmes propriétés que".


Jean DUPOND (1) se marie avec Jeanne DURANT Jean DUPOND (1) le conjoint de Jeanne DURANT sont

deux objets identiques (ou sont un seul objet) Jean DUPOND (1) et Jean DUPOND (2) ne sont plus

égaux (une de leurs propriétés diffère: le conjoint)

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: [DURAND Jeanne]

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: -


IDENTITÉ != ÉGALITÉIDENTITÉ != ÉGALITÉ

Deux objets sont identiques si et seulement si ce sont le même ! (symbole = )

Deux objets sont égaux si et seulement si leurs valeurs sont égales.


L'identité d'objet permet de partager des objets de les rendre cycliques

Nom: DUPOND

Prénom: Jean

Age: 25


Nom: DURAND

Prénom: Jeanne

Age: 26

Conjoint: [DUPOND Jean]


HéritageL'héritage est un mécanisme de transmission des

propriétés d'une classe vers une sous-classe. C'est une relation entre classes. Le graphe de cette relation est le graphe d'héritage.

Une sous-classe possède toutes les propriétés de sa super-classe mais elle peut en redéfinir certaines et en posséder d'autres. La sous-classe est une spécialisation (ou raffinement) de

la super-classe.


L ’héritage a deux objectifs : l'enrichissement : on adjoint, dans la sous-classe, de

nouvelles propriétés à celles issues de la super-classe la substitution : on redéfinit dans la sous-classe

certaines propriétés issues de la super-classe. L'héritage est dit simple si la sous-classe n'a

qu'une super-classe ; il est dit multiple si la sous-classe a plusieurs super-classes.

Intérêts de l ’héritage: factorisation du code des classes structuration hiérarchisée des classes, modularité


Init (nom:string, prenom: string, age:integer, conjoint: Personne)

Nom: DUPONDPrénom: Jean Age: 25Conjoint: -

Salaire: real employeur: Employeur

Salaire: real Salaire: real

Salaire_Enseignant: realsalaire_Chercheur: real

Employeur_Enseignant: Employeuremployeur_Chercheur: Employeur

Personne

Employe

Chercheur

Enseignant-Chercheur

Enseignant


Surcharge, Lien retardé Chaque propriété d'une super-classe peut être redéfinie

dans une sous-classe à condition de respecter certaines conditions :

Pour les attributs : les types des attributs de la sous-classe doivent être des sous-types de ceux de la super-classe

Pour les méthodes : le nombre de paramètres doit être identique et les types des paramètres et de la valeur de retour de la méthode dans la sous-classe doivent être des sous-types de ceux de la méthode dans la super-classe (covariance)


Lorsqu ’on déclenche une méthode sur un objet, on ne peut pas nécessairement déterminer, à la compilation, le code qui sera réellement exécuté.Lorsque le choix de la méthode à utiliser est réalisé

à la compilation, on parle de lien statique.Lorsque le choix de la méthode à utiliser est réalisé

à l'exécution, on parle de lien retardé ou lien dynamique.

Polymorphisme


Valeurs, TypesUne valeur est une donnée organisée selon une

certaine structure appelée type. Le type définit une structure de données et les

opérations que l'on peut lui appliquer.Toute valeur est typée et son type est défini lors

de sa déclaration.


Les valeurs ne supportent pas le concept d'identité : elles ne peuvent donc être ni partagées ni cycliques.

On accède à la valeur d'un objet en utilisant l'opérateur de déréférencement noté * .

Nom: DUPOND

Prénom: Jean

Age: 25


Dupond

p

p = *Dupond


Les types supportés par le système sont obtenus par application récursive de constructeurs de types à des types atomiques.

Constructeurs de types : tuple() (constructeur n-uplet) list() (constructeur de collection ordonnée) set() (constructeur de collection non ordonnée) unique set() (idem mais sans doublon) type() (accès au type d'une classe)

Types atomiques: boolean, char, integer, real, string, bits, etc.


Les types sont organisés selon une relation d'ordre partiel, défini par les règles suivantes : il n'existe pas de sous-type d'un type atomique tuple(a: t1, b: t2) est un sous-type de tuple(a: t1) tuple(a: t1) est un sous type de tuple(a: t2) si

t1 et un sous type de t2

list(t1) [resp. set(t1), unique set(t1)] est un sous-type de list(t2) [resp. set(t2), unique set(t2)] si t1 est un sous type de t2

De la même manière, les classes sont organisées selon un ordre partiel, décrit par le graphe d'héritage.

L'ordre des types et des classes doit être vérifié par le compilateur.


Opérations sur les collectionsListes

affectation, comparaison, concaténation, accès direct, appartenance, extraction de sous-liste, taille, remplacement, effacement, insertion, parcours itératif conditionnel

Ensembles, Multi-ensemblesaffectation, comparaison, union, intersection,

différence, appartenance, taille, insertion, suppression, parcours itératif conditionnel

Aspects Bases de DonnéesAspects Bases de Données

Modèle de persistanceFaculté pour un objet ou une valeur d'exister

au-delà du programme qui l'a créé(e).

Modèle de persistance par attachementTout objet ou valeur référencé(e) par un objet

ou valeur persistant(e) est persistant(e).


Conséquences du modèle par attachement transparent pour le développeur ramasse-miettes pour détruire les objets et

valeurs qui ne sont plus référencés par un objet ou une valeur persistant(e)

nécessité de racines de persistance


Les racines de persistance sont nommées explicitement dans le schéma de la base de données (déclations)

Les racines de persistance peuvent être des objets et/ou des valeurs, de classes et/ou de type quelconques.


TransactionsTransactions C'est un programme d'accès à la base de données

qui vérifie les propriétés d'ACIDité : Atomicité (« tout ou rien ») Cohérence (« sémantique des objets garantie ») Isolation (« comme en mono-utilisateur ») Durabilité (« les effets d’une transaction validée

perdurent ») Délimitées par un début de transaction et un

achèvement (commit/validate ou rollback/abort)


InterrogationLangage OQL (Object Query Language)

standardisé par ODMG 93Langage déclaratif, fonctionnel de syntaxe

proche de SQL (Structured Query Language) permettant l'exécution de requêtes arbitrairement complexes combinant requêtes élémentaires et requêtes complexes


Requêtes élémentaires accès aux instances nommées: LeDoyen envois de messages: LeDoyen>age() sélection d'un champ: LeDoyen>conjointopérations sur les types atomiques et construits:

LeDoyen>conjoint->age() + 1

construction et instanciation:struct(nom: LeDoyen>nom, age: LeDoyen>age())


Requêtes complexes sélection/extraction/jointure

select [distinct]… from … where… le résultat est un

multi-ensemble (bag) ou ensemble (set) Tri

order by … le résultat est une liste

Partitionnement group by … le résultat est un ensemble de structures


Entrées dans la baseSi n désigne un objet ou une valeur nommée

alors l'expression n est une requête qui retourne l'objet ou la valeur nommé(e) considéré(e)

LeDoyen


AtomesSi a désigne un atome, i.e. une valeur de type

atomique (entier, réel, caractère, chaîne, booléen) alors l'expression a est une requête retournant cet atome.

3, « coucou »


AtomesOn dispose d'autres requêtes propres à chaque

type atomiquenombres : opérations arithmétiques (+, -, *, /),

modulo (mod()), valeur absolue (abs())chaînes de caractères: concaténation (+), extraction

(x[i], x[i:j]), longueur (count())booléens: et (and), ou (or), négation 'not())


TuplesSi x désigne une valeur ou un objet de type

tuple alors x.a ou a est un attribut de x est une requête qui retourne l'attribut a de x.

(*LeDoyen).conjoint

Si x désigne un objet de type tuple alors x->a ou a est un attribut de x est une requête qui retourne l'attribut a de x.

LeDoyen>conjoint


ListesExtraction

x[i] : d'un élémentx[i:j], x[:j], x[i:]: d'une sous liste

Opérations généralesfirst(x), last(x)min(x), max(x), count(x), sum(x), avg(x)


ListesOpérations particulières

x+y: concaténation de listeslistoset(x): conversion en unique setflatten(x):

si x est une liste de listes, retourne la concaténation de tous les éléments de x

si x est une liste d'ensembles, retourne l'union de tous les éléments de x

si x est une liste de unique set, retourne l'union disjointe de tous les éléments de x


EnsemblesExtraction

element(x): extraction de l'unique élément d'un singleton

Opérations généralesmin(x), max(x), count(x), sum(x), avg(x)

Opérations ensemblistesx union y (x+y), x except y (x-y), x intersect y (x*y)


EnsemblesOpérations particulières

flatten(x): si x est un ensemble de listes, retourne l'union disjointe de

tous les éléments membres des listes de x si x est un ensemble d'ensembles, retourne l'union de tous

les éléments de x si x est un ensemble de unique set, retourne l'union

disjointe de tous les éléments de x


Construction de valeursOn dispose des constructeurs habituels

permettant d'obtenir des tuples, des listes et ensemblestuple(); struct(a1: x1, … an: xn): les attributs du tuple

peuvent être des objets et/ou des valeurslist(), list(x1, …, xn):les membres de la liste doivent

être de même nature (objet ou valeur) et doivent avoir un supertype ou une superclasse commun(e)

set(), set(x1, …, xn): idem


Construction d’objetsUne requête peut créer un objet :

Personne(nom: LeDoyen>nom, age: 70)

Le nom de la fonction est le nom de la classe.Les attributs peuvent être initialisés avec les

résultats d'autres requêtes.Les attributs non cités sont initialisés par défaut (le

constructeur de la classe n'est pas appelé).


Envoi de messages x->m: où m est une méthode de la classe (ou d'une

super classe) de x ne prenant aucun paramètre, retourne le résultat de l'application de la méthode m à l'objet x

x->m(a1, …, an): où m est une méthode de la classe (ou d'une super classe) de x prenant n paramètres, retourne le résultat de l'application de la méthode m à l'objet x avec les paramètres a1, …, an.


PrédicatsCe sont des requêtes retournant une valeur

booléenneq like wild_card_exp: possibilité d'utiliser les

caractères génériques ('*'…)x = y (x == y): retourne la valeur true si et

seulement si x et y sont deux valeurs égales ou bien si et seulement si x et y sont deux objets identiques

x != y: attention, signifie not(x = y)


Prédicatsx < y, x <= y, x > y, x >= yx in y: retourne la valeur true si et seulement si la

valeur ou l'objet x appartient à la collection y ou bien si et seulement si le caractère x appartient à la chaîne y ou bien si et seulement si x est une sous-chaîne de la chaîne y.


Prédicats: QuantificateursUniversel: forall x in y: p

Retourne true si et seulement si tout élément de la collection y satisfait le prédicat pselect p from p in LesPersonnes where forall x in p->amis: x->age() < 18

Existentiel: exists x in y : pRetourne true si et seulement si il existe un élément de la collection y qui satisfasse le prédicat pselect p from p in LesPersonnes where exists x in p->amis: x->age() < 18


Sélection / Extraction / JointureFont appel à un bloc select… from … where …

select q

from x1 in f1, …, xn in fn

where p

où q est une requête impliquant les variables x1, …, xn

où p est un prédicat impliquant les variables x1, …, xn

où fi est une requête impliquant les variables x1, …, xi-1

mais pas les variables xi, …, xn.


Sélection / Extraction / JointureLa structure du résultat est un bag par défaut.

On peut éliminer la répétition de valeurs ou d'objets dans le résultat en utilisant la clause distinct(la structure du résultat est alors un unique set)

On peut trier le résultat avec la clause order by(la structure du résultat est alors une liste)

On peut utiliser la caractère ‘ * ’select * from Person p, Flower f le résultat est du type bag(struct(p: Person, f:Flower))


Tri y order by f1, …, fn

si y est une collection, retourne la liste contenant tous les éléments de y, rangés suivant les clés f1, …, fn et, en dernier ressort par appel à magic()

les clés doivent être de type numérique ou chaîne de caractèresSelect p from p in LesPersonnes order by p->nom asc, p->prenom desc


Partitionnementy group by (a1: q1, …, an: qn)

Si y est une collection résultat d ’un select, l ’expression retourne une partition de y suivant les critères q1, …, qn.

Le résultat est un ensemble (bag) de n-uplets dont les attributs sont a1, …, an, partition.partition est du même type que y, et désigne l ’ensemble des éléments de y associés à une valeur de (a1…an)


PartitionnementPossibilité d’utiliser la clause having

select p.age, card: count(partition)from LesPersonnes pgroup by p.age having count(partition) < 50

Pour réaliser un filtre utilisant une fonction d ’agrégation.


TypageOn peut sous-typer un élément dans une

requête:

select ((Employe) c) from c in LesPersonneswhere c in LesEmployes

select ((Employe) c)->salary() from c in LesPersonneswhere (c in LesEmployes) && (c->age() > 25)


OQL encapsulé dans un programme On peut lancer une requête OQL depuis un langage supportant le binding ODMG elle sera passée sous forme de chaîne de caractères, en paramètre à une fonction du type

OQLquery

Exemple en C++ avec O2#include "OQL_CC.hxx"{

int i, j, c;d_Bag<d_Ref<Person>>group, result;...d_OQL_Query query("select x from x in $1 where \

count(x->children) > $2 and x->age <$3");j=40;i= f(j);query << group << i<< j;c= d_oql_execute(query, result);if (result.cardinality())

result.insert_element ( new Person);…


Exemple en Java avec O2:

OQLQuery query = new OQLQuery(“select p from Person p where age > $1”);

query.bind(40);Iterator it = query.iterate();Person p;while (it.hasNext()) { p = (Person) it.next(); p.display();} Note : pour obtenir une collection plutôt qu'un itérateurDBag bag = (DBag) query.execute()


Axiomquery_program ::={define_query;} query

define_query ::=define identifier as query


Basicquery ::= nilquery ::= truequery ::= falsequery ::= integer_literalquery ::= float_literalquery ::= character_literalquery ::= string_literalquery ::= entry_namequery ::= query_namequery ::= bind_argument 1query ::= from_variable_namequery ::= (query)


Simple Expressionquery ::= query + query 1

query ::= query - query

query ::= query * query

query ::= query / query

query ::= - query

query ::= query mod query

query ::= abs (query)

query ::= query || query


Comparisonquery ::= query comparison_operator queryquery ::= query like string_literalcomparison_operator ::= =comparison_operator ::= !=comparison_operator ::= >comparison_operator ::= <comparison_operator ::= >=comparison_operator ::= <=

Boolean Expressionquery ::= not queryquery ::= query and queryquery ::= query or query


Constructorquery ::= type_name ( [query ] )query ::= type_name (identifier:query {, identifier: query})

query ::= struct (identifier: query {, identifier: query})

query ::= set ( [query {, query} ])query ::= bag ( [query {,query} ])query ::= list ( [query {,query} ])query ::= (query, query {, query})query ::= [ list ](query .. query)query ::= array ( [query {,query} ])


Accessorquery ::= query dot attribute_namequery ::= query dot relationship_namequery ::= query dot operation_namequery ::= query dot operation_name( query {,query} )

dot ::= . | ->query ::= * queryquery ::= query [query]query ::= query [query:query]query ::= first (query)query ::= last (query)query ::= function_name( [ query {,query} ] )


Collection Expressionquery ::= for all identifier in query: query

query ::= exists identifier in query: queryquery ::= exists(query)query ::= unique(query)query ::= query in queryquery ::= query comparison_operator quantifier query

quantifier ::= somequantifier ::= anyquantifier ::= all


query ::= count (query)query ::= count (*)query ::= sum (query)query ::= min (query)query ::= max (query)query ::= avg (query)

Select Expressionquery ::= select [ distinct ] projection_attributes

from variable_declaration {, variable_declaration}[where query ][group by partition_attributes ][having query ][order by sort_criterion {, sort_criterion} ]


projection_attributes ::= projection {, projection}

projection_attributes ::= *projection ::= queryprojection ::= identifier: queryprojection ::= query as identifiervariable_declaration ::= query [ [ as ] identifier ]

partition_attributes ::= projection {, projection}

sort_criterion ::= query [ordering ]ordering ::= ascordering ::= desc


Set Expressionquery ::= query intersect query

query ::= query union query

query ::= query except query

Conversionquery ::= listtoset (query)

query ::= element (query)

query ::= distinct(e)

query ::= flatten (query)

query ::= (class_name) query


Operator Priorities.() [] . ->not - (unary) + (unary)i n* / mod intersect+ - union except | |< > <= >= < some < any < all (etc ... for all comparison operators)

= ! = l i k eand exists for allor


.. :

,

(identifier) this is the cast operator

order

having

group by

where

from

select

ODMG 3.0ODMG 3.0

Objectifs fournir des standards permettant d'écrire des

applications portables, i.e. qui puissent fonctionner sur un ou plusieurs SGBDOle schéma, le couplage aux langages de

programmation, la manipulation de données et le langage de requêtes doivent être standards

si possible, le standard devra faciliter l'interopérabilité entre SGBDO

ODMG 3.0ODMG 3.0

Les composants majeursModèle objet

= modèle objet de l'OMG + relations

Langages de spécifications objetODF Object Definition Language = IDL + relationsOIF Object Interchange Format: échange d'objets inter

bases, support de documentation…

Langage de requêtes: OQLOML Couplage aux langages de programmation (C+

+, Smalltalk, Java)

ODMG 3.0ODMG 3.0

Modèle objet établit une distinction entre Litéral et Objet Litéral

Types atomiques: int, real, string Constructeurs de type

énumération enum structures struct, union collections génériques : set, bag, list, array

Chaque litéral est « caractérisé » par sa valeurL1 et L2 sont égaux si leurs valeurs sont égales

Objet définition de l ’interfacechaque objet est identifié par son identitéO1 et O2 sont égaux si leurs identifiants sont égaux

ODMG 3.0ODMG 3.0

Built-in Types

Object_type Literal_type

Atomic_object Collection_object Structured_object

Set Bag List Array Dictionnary

Date Time Timestamp Interval

ODMG 3.0ODMG 3.0

Interface = spécification d ’un type super (Héritages simple et multiple) extent, clés candidates attributs

attribute <type> <nomattr>; associations et associations inverses

relationship <type> <nomasso>inverse <nom-d-interface>::<nomasso>;

méthodes<type-retourné> <nommeth> (<type-paramêtre> : <type>, …)

raise (<type-d-exception>);<type-paramêtre> : in, out, inout

Classe interface + une implantation particulière du type dans un des LMD

disponibles

ODMG 3.0ODMG 3.0

Exempleinterface Employee {

attribute int numemp; attribute string name;attribute float basesalary; attribute Date birthday;attribute Struct Addr { string street, string city, int zip } address;attribute enum TypeEmp { worker,manager} typeEmp;attribute Set<string> phones;relationship Dept dept inverse Dept::members;float salary();

}interface Dept {

attribute string name;attribute Struct Employee::Addr address;relationship Set<Employee> members inverse Employee::deptfloat totsalary() raise(Uncalculable);

}

ODMG 3.0ODMG 3.0

Modèle objet Une base stocke des objets, qui peuvent être partagés par différents

utilisateurs et applications. Elle repose sur un schéma, défini en ODL, et contient des instances des types définis dans ce schéma.

Eléments clés Propriétés: attributs et relations Opérations: méthodes. Exceptions. Héritage multiple Extensions et clés Nommage d'objets, durée de vie et identité Littéraux atomiques, structurés et ensemblistes Classes de collections

systèmes de gestion de bases de données orientés objet philippe salvan [email protected]

Documents