Systèmes de Gestion de Bases de Données Orientés Objet EPU SI3 Systèmes de Gestion de Bases de Données Orientés Objet Philippe SALVAN psalvan@supralog.com © Philippe SALVAN

Plan du Cours Généralités Aspects Orientés Objets 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 - 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

Généralités - Historique code unique code réutilisable optimisation données fichiers SGF code unique code réutilisable optimisation données fichiers SGBD/R code unique code réutilisable optimisation données fichiers SGBD/O code unique code réutilisable optimisation données fichiers SGBD/N abstraction

Généralités - Historique 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édural dysfonctionnement (conversion de types)

Généralités - Historique 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

Généralités - Historique Définition des SGBDOO The Object-Oriented Database System Manifesto (1989) Défini par des chercheurs Ensemble de règles caractérisant un SGBDOO: obligatoires, facultatives, ouvertes

Généralités - Historique 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ées un SGBDOO est un SGBD Persistance Gestion du disque Partage des données (multi-utilisateurs) Fiabilité des données Sécurité des données Interrogation ad hoc

Généralités - Aspects Orientés Objet Un SGBDOO est Orienté Objet Objets complexes Identité d'objet Encapsulation, Classes Héritage Surcharge, Lien retardé Valeurs, Types Polymorphisme

Gé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

Généralités - Architecture Architecture Opérationnelle Programme utilisateur Compilation Application Objets Verrous Journal Fichiers Pages

Généralités - Architecture Architecture Client/Serveur Serveur d'objets Objets Verrous Journal Application Objets Fichiers Cache de Pages Application Objets

Généralités - Architecture Architecture Client/Serveur Serveur d'objets Fort degré de concurrence (verrouillage et journalisation au niveau de l'objet) Possibilité d'exécution de méthodes sur le serveur

Généralités - Architecture Architecture Client/Serveur Serveur de pages Pages Verrous Journal Application Objets Cache de Pages Fichiers Pages Application Objets Fichiers Pages

Généralités - Architecture Architecture Client/Serveur Serveur de pages Utilisation de la puissance de calcul des clients Accroît le nombre de connections possibles Serveur isolé Verrouillage et journalisation par page

Généralités - Architecture Architecture Client/Serveur Multi-serveurs Application Application Objets Répartis Objets Répartis objets ou pages Fichiers Fichiers Pages Pages

Généralités Schéma, Base SCHEMA SCHEMA SYSTEME VOLUME DISQUE BASE BASE

Aspects Orientés Objets Objet complexe, encapsulation, classe OBJET = 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.

Aspects Orientés Objets Objet complexe, encapsulation, classe Vue externe: OBJET = BOITE NOIRE + BOUTONS Vue interne: OBJET = DONNEES + MECANIQUE LIEE AUX BOUTONS

Aspects Orientés Objets 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 concept Point de vue acteur : un objet est une entité autonome et active.

Aspects Orientés Objets 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.

Aspects Orientés Objets 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)

Aspects Orientés Objets 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.

Aspects Orientés Objets 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

Aspects Orientés Objets Identité d ’objet Chaque 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.

Aspects Orientés Objets 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: -

Aspects Orientés Objets 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".

Aspects Orientés Objets 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: -

Aspects Orientés Objets 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.

Aspects Orientés Objets L'identité d'objet permet de partager des objets de les rendre cycliques Nom: DUPOND Prénom: Jean Age: 25 Conjoint: [DURAND Jeanne] Nom: DURAND Prénom: Jeanne Age: 26 Conjoint: [DUPOND Jean]

Aspects Orientés Objets Héritage L'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.

Aspects Orientés Objets 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é

Aspects Orientés Objets Init (nom:string, prenom: string, age:integer, conjoint: Personne) Nom: DUPOND Prénom: Jean Age: 25 Conjoint: - Personne Salaire: real employeur: Employeur Employe Salaire: real Enseignant Chercheur Salaire_Enseignant: real salaire_Chercheur: real Employeur_Enseignant: Employeur employeur_Chercheur: Employeur Enseignant-Chercheur

Aspects Orientés Objets 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)

Aspects Orientés Objets 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

Aspects Orientés Objets Valeurs, Types Une 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.

Aspects Orientés Objets 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 Conjoint: [DURAND Jeanne] p = *Dupond Dupond p

Aspects Orientés Objets 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.

Aspects Orientés Objets 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.

Aspects Orientés Objets Opérations sur les collections Listes affectation, comparaison, concaténation, accès direct, appartenance, extraction de sous-liste, taille, remplacement, effacement, insertion, parcours itératif conditionnel Ensembles, Multi-ensembles affectation, comparaison, union, intersection, différence, appartenance, taille, insertion, suppression, parcours itératif conditionnel

Aspects Bases de Données Modèle de persistance Faculté pour un objet ou une valeur d'exister au-delà du programme qui l'a créé(e). Modèle de persistance par attachement Tout objet ou valeur référencé(e) par un objet ou valeur persistant(e) est persistant(e).

Aspects Bases de Données 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

Aspects Bases de Données 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.

Aspects Bases de Données Transactions 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)

Aspects Bases de Données EPU SI3 Aspects Bases de Données Interrogation Langage OQL (Object Query Language) standardisé par ODMG 93 Langage 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 © Philippe SALVAN

Aspects Bases de Données Requêtes élémentaires accès aux instances nommées: LeDoyen envois de messages: LeDoyen>age() sélection d'un champ: LeDoyen>conjoint opérations sur les types atomiques et construits: LeDoyen>conjoint->age() + 1 construction et instanciation: struct(nom: LeDoyen>nom, age: LeDoyen>age())

Aspects Bases de Données 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

Aspects Bases de Données Entrées dans la base Si 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

Aspects Bases de Données Atomes Si 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 »

Aspects Bases de Données Atomes On dispose d'autres requêtes propres à chaque type atomique nombres : 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())

Aspects Bases de Données Tuples Si 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

Aspects Bases de Données Listes Extraction x[i] : d'un élément x[i:j], x[:j], x[i:]: d'une sous liste Opérations générales first(x), last(x) min(x), max(x), count(x), sum(x), avg(x)

Aspects Bases de Données Listes Opérations particulières x+y: concaténation de listes listoset(x): conversion en unique set flatten(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

Aspects Bases de Données Ensembles Extraction element(x): extraction de l'unique élément d'un singleton Opérations générales min(x), max(x), count(x), sum(x), avg(x) Opérations ensemblistes x union y (x+y), x except y (x-y), x intersect y (x*y)

Aspects Bases de Données Ensembles Opé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

Aspects Bases de Données Construction de valeurs On dispose des constructeurs habituels permettant d'obtenir des tuples, des listes et ensembles tuple(); struct(a1: x1, … an: xn): les attributs du tuple peuvent être des objets et/ou des valeurs list(), 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

Aspects Bases de Données Construction d’objets Une 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é).

Aspects Bases de Données 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.

Aspects Bases de Données Prédicats Ce sont des requêtes retournant une valeur booléenne q 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)

Aspects Bases de Données Prédicats x < y, x <= y, x > y, x >= y x 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.

Aspects Bases de Données Prédicats: Quantificateurs Universel: forall x in y: p Retourne true si et seulement si tout élément de la collection y satisfait le prédicat p select p from p in LesPersonnes where forall x in p->amis: x->age() < 18 Existentiel: exists x in y : p Retourne true si et seulement si il existe un élément de la collection y qui satisfasse le prédicat p select p from p in LesPersonnes where exists x in p->amis: x->age() < 18

Aspects Bases de Données Sélection / Extraction / Jointure Font 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.

Aspects Bases de Données Sélection / Extraction / Jointure La 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))

Aspects Bases de Données 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ères Select p from p in LesPersonnes order by p->nom asc, p->prenom desc

Aspects Bases de Données Partitionnement y 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)

Aspects Bases de Données Partitionnement Possibilité d’utiliser la clause having select p.age, card: count(partition) from LesPersonnes p group by p.age having count(partition) < 50 Pour réaliser un filtre utilisant une fonction d ’agrégation.

Aspects Bases de Données Typage On peut sous-typer un élément dans une requête: select ((Employe) c) from c in LesPersonnes where c in LesEmployes select ((Employe) c)->salary() from c in LesPersonnes where (c in LesEmployes) && (c->age() > 25)

Aspects Bases de Données 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); …

Aspects Bases de Données 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érateur DBag bag = (DBag) query.execute()

Aspects Bases de Données Axiom query_program ::={define_query;} query define_query ::=define identifier as query

Aspects Bases de Données Basic query ::= nil query ::= true query ::= false query ::= integer_literal query ::= float_literal query ::= character_literal query ::= string_literal query ::= entry_name query ::= query_name query ::= bind_argument 1 query ::= from_variable_name query ::= (query)

Aspects Bases de Données Simple Expression query ::= query + query 1 query ::= query - query query ::= query * query query ::= query / query query ::= - query query ::= query mod query query ::= abs (query) query ::= query || query

Aspects Bases de Données Comparison query ::= query comparison_operator query query ::= query like string_literal comparison_operator ::= = comparison_operator ::= != comparison_operator ::= > comparison_operator ::= < comparison_operator ::= >= comparison_operator ::= <= Boolean Expression query ::= not query query ::= query and query query ::= query or query

Aspects Bases de Données Constructor query ::= 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} ])

Aspects Bases de Données Accessor query ::= query dot attribute_name query ::= query dot relationship_name query ::= query dot operation_name query ::= query dot operation_name( query {,query} ) dot ::= . | -> query ::= * query query ::= query [query] query ::= query [query:query] query ::= first (query) query ::= last (query) query ::= function_name( [ query {,query} ] )

Aspects Bases de Données Collection Expression query ::= for all identifier in query: query query ::= exists identifier in query: query query ::= exists(query) query ::= unique(query) query ::= query in query query ::= query comparison_operator quantifier query quantifier ::= some quantifier ::= any quantifier ::= all

Aspects Bases de Données query ::= count (query) query ::= count (*) query ::= sum (query) query ::= min (query) query ::= max (query) query ::= avg (query) Select Expression query ::= select [ distinct ] projection_attributes from variable_declaration {, variable_declaration} [where query ] [group by partition_attributes ] [having query ] [order by sort_criterion {, sort_criterion} ]

Aspects Bases de Données projection_attributes ::= projection {, projection} projection_attributes ::= * projection ::= query projection ::= identifier: query projection ::= query as identifier variable_declaration ::= query [ [ as ] identifier ] partition_attributes ::= projection {, projection} sort_criterion ::= query [ordering ] ordering ::= asc ordering ::= desc

Aspects Bases de Données Set Expression query ::= query intersect query query ::= query union query query ::= query except query Conversion query ::= listtoset (query) query ::= element (query) query ::= distinct(e) query ::= flatten (query) query ::= (class_name) query

Aspects Bases de Données Operator Priorities . () [] . -> not - (unary) + (unary) i n * / mod intersect + - union except | | < > <= >= < some < any < all (etc ... for all comparison operators) = ! = l i k e and exists for all or

Aspects Bases de Données .. : , (identifier) this is the cast operator order having group by where from select

ODMG 3.0 Objectifs fournir des standards permettant d'écrire des applications portables, i.e. qui puissent fonctionner sur un ou plusieurs SGBDO le 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.0 Les composants majeurs Modèle objet = modèle objet de l'OMG + relations Langages de spécifications objet ODF Object Definition Language = IDL + relations OIF Object Interchange Format: échange d'objets inter bases, support de documentation… Langage de requêtes: OQL OML Couplage aux langages de programmation (C++, Smalltalk, Java)

ODMG 3.0 Modèle objet établit une distinction entre Litéral et Objet 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 valeur L1 et L2 sont égaux si leurs valeurs sont égales Objet définition de l ’interface chaque objet est identifié par son identité O1 et O2 sont égaux si leurs identifiants sont égaux

ODMG 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.0 Interface = spécification d ’un type Classe 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.0 Exemple interface Employee { } interface Dept { 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 Struct Employee::Addr address; relationship Set<Employee> members inverse Employee::dept float totsalary() raise(Uncalculable);

ODMG 3.0 Modèle objet Eléments clés 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