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

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 © 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

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

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)

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 SGBDOO The Object-Oriented Database System Manifesto (1989) Défini par des chercheurs Ensemble 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é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

Architecture Opérationnelle Programme utilisateur Compilation Application Objets Verrous Journal Fichiers Pages

Architecture Client/Serveur Serveur d'objets Objets Verrous Journal Application Objets Fichiers Cache de Pages Application Objets

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

Architecture Client/Serveur Serveur de pages Pages Verrous Journal Application Objets Cache de Pages Fichiers Pages Application Objets Fichiers Pages

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

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.

Objet complexe, encapsulation, classe Vue externe: OBJET = BOITE NOIRE + BOUTONS Vue interne: OBJET = DONNEES + MECANIQUE LIEE AUX 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 concept Point 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.

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 ’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.

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É 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 Conjoint: [DURAND Jeanne] Nom: DURAND Prénom: Jeanne Age: 26 Conjoint: [DUPOND Jean]

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.

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: 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

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, 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.

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

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 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).

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.

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)

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

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())

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

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 »

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())

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

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)

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

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)

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

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

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é).

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

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.

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

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.

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))

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

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)

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.

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)

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érateur DBag bag = (DBag) query.execute()

Axiom query_program ::={define_query;} query define_query ::=define identifier as query

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)

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

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

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} ])

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} ] )

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

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} ]

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

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

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

.. : , (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

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

Présentations similaires

Présentation au sujet: "Systèmes de Gestion de Bases de Données Orientés Objet"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

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

Présentations similaires

Présentation au sujet: "Systèmes de Gestion de Bases de Données Orientés Objet"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back