La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

Systèmes de Gestion de Bases de Données Orientés Objet Etude de cas avec un SGBDOO : O 2 Philippe SALVAN

Présentations similaires


Présentation au sujet: "Systèmes de Gestion de Bases de Données Orientés Objet Etude de cas avec un SGBDOO : O 2 Philippe SALVAN"— Transcription de la présentation:

1 Systèmes de Gestion de Bases de Données Orientés Objet Etude de cas avec un SGBDOO : O 2 Philippe SALVAN

2 Plan du Cours 1 m Généralités ê Historique ê Aspects Bases de Données ; Aspects Orientés Objet ê Architecture ê Premiers pas avec O2

3 Plan du Cours 2 m Aspects Orientés Objets ê Objet Complexe, Encapsulation, Classes ê Identité d'Objet ê Héritage ê Surcharge, Lien retardé ê Valeurs, Types

4 Plan du Cours 3 m Aspects Base de Données ê Modèle de persistance ê Transactions ê Interrogations ê Optimisations

5 Généralités - Historique m Besoin dorganiser de manière cohérente des données permanentes et accessibles par des utilisateurs concurrents m Gestion de Fichiers SGBD Navigationnels SGBD Relationnels SGBD Orientés Objets

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

7 m 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 : F ensembliste vs procédural F dysfonctionnement (conversion de types)

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

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

10 Généralités - Historique m Définition des SGBDOO ê ODMG 93 F Défini par des éditeurs F Standard de portabilité des SGBDOO

11 Généralités - Aspects Base de Données m 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

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

13 Généralités - Architecture m Architecture Fonctionnelle Langage de Définition Langages de Programmation Langage de Requêtes Autres interfaces Outils de Développement Gestion de SchémaGestion d'Objets

14 Généralités - Architecture m Architecture Opérationnelle Objets Fichiers Verrous Journal Pages ApplicationCompilation Programme utilisateur

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

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

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

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

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

20 Généralités - Premiers pas avec O2 m Schéma, Base ê Le support physique d'un système O2 est appelé volume. ê Un volume comprend un catalogue d'associations schéma - bases F SCHÉMA = STRUCTURES DE DONNÉES +SIGNATURE DES TRAITEME +CODE DES TRAITEMENTS F BASE = DONNÉES

21 SCHEMA BASE Généralités - Premiers pas avec O2 m Schéma, Base BASE SCHEMA SYSTEME VOLUME DISQUE

22 Généralités - Premiers pas avec O2 m Fichier.o2serverrc F Le fichier.o2serverrc permet de configurer les différents systèmes O2. F Pour chaque système est indiqué son nom, la machine par défaut sur laquelle sexécutera le serveur, les répertoires stockant le volume, le fichier de log et le fichier dimage, le comportement concurrentiel et de reprise sur panne, les utilisateurs autorisés du système.

23 Généralités - Premiers pas avec O2 m Fichier.o2serverrc ê Le format de description est le suivant: system_name.server = picasso system_name.cachesize = 4000 system_name.cataldir = /home/o2vol system_name.defaultvolsize = system_name.mode = multi-user +verbose ê Linitialisation dun système O2 est effectuée par la commande O2dba_init -system system_name [-server server_name] F Cette commande détruit toutes les données qui se trouvaient dans le système.

24 Généralités - Premiers pas avec O2 m Connexion F Lancement du processus serveur o2server -system system_name F Lancement du processus client o2shell -system system_name [-server server_name] o2tools -system system_name [-server server_name] F La connexion entre les deux processus seffectue et le message (en mode alphanumérique) Type your command and end with ^D saffiche. La session O2 est démarrée.

25 Généralités - Premiers pas avec O2 m Utilisation courante ê une fenêtre réservée au serveur O2 (éventuellement en mode verbose) ê une fenêtre réservée au client O2 (dans laquelle on lancera les commandes de compilation et d'exécution des programmes ainsi que celles de maintenance de la base de donnée) ê une fenêtre réservée à l'édition des programmes (emacs, vi, …)

26 Généralités - Premiers pas avec O2 o2server is up and running Type your command and end with ^D. Class Personne public type tuple( nom: string, age: integer, adresse: Adresse) end;

27 Généralités - Premiers pas avec O2 m Langage de commandes ê Manipulation de schémas F [create] schema schema_name F display schemas F display schema schema_name stat F set schema schema_name F import schema schema_name class class_name | name root_name

28 Généralités - Premiers pas avec O2 m Langage de commandes ê Manipulation de bases F [create] base base_name schema schema_name F display bases F display base base_name stat F set base base_name

29 Premiers pas avec O2 m Validation de session ê Lors du démarrage dune session, une transaction est implicitement entamée.Toutes les modifications de schéma(s), base(s), programme(s) F sont sauvegardées si lon déclenche (interactivement ou par programme) une instruction commit, F sont annulées si lon déclenche (interactivement ou par programme) une instruction abort.

30 Aspects Orientés Objets m Objet complexe, encapsulation, classe ê OBJET = DONNÉES + DESCRIPTION DINTERFACE (STRUCTURES DE DONNÉES + COMPORTEMENTS) ê Un objet est lencapsulation, 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.

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

32 Aspects Orientés Objets m Point de vue structurel : ê un objet est un type de données qui définit une structure et lensemble des opérations applicables à cette structure. m Point de vue conceptuel : ê un objet est une unité de connaissance représentant le prototype dun concept m Point de vue acteur : ê un objet est une entité autonome et active.

33 Aspects Orientés Objets F Lencapsulation est le principe qui consiste à préserver la structure et la mécanique interne des objets des regards indiscrets pour nen montrer quune interface choisie Ý Les propriétés de visibilité permettent de définir ce qui fera partie de linterface. Ý Seules les parties publiques (appelées spécifications ou interfaces) sont accessibles.

34 Aspects Orientés Objets ê Une classe est la description abstraite dun ensemble dobjets 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)

35 Aspects Orientés Objets ê Les attributs caractérisent létat des objets durant lexécution des programmes. ê Les méthodes caractérisent les comportements des objets durant lexécution des programmes. ê Tout objet est instance de sa classe.

36 Aspects Orientés Objets ê Exemple F class Personne public type tuple( nom: string, prenom: string, private age: integer, private conjoint: Personne)

37 Aspects Orientés Objets method public init( nom: string, prenom: string, age: integer, conjoint: Personne ), public vieillir, public donne_age: integer, public donne_conjoint: Personne, public se_marie(conjoint: Personne) private fixe_age(age: integer) end;

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

39 Aspects Orientés Objets public method se_marier(conjoint: Personne) in class Personne; method body se_marier(conjoint: Personne) in class Personne { self->conjoint = conjoint; }; ê 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. public method vieillir in class Personne; method body vieillir in class Personne { self->fixe_age(self->donne_age() + 1); };

40 Aspects Orientés Objets ê Pour instancier une classe, on fait appel à lopérateur new, prédéfini pour toute classe, qui réalise lallocation mémoire nécessaire, crée un objet et déclenche automatiquement la méthode init de la classe, si celle-ci a été définie. { … o2 Personne dupond = new Personne; … }

41 Aspects Orientés Objets F public method init(nom: string, prenom: string, age: integer, conjoint: Personne) in class Personne; F method body init(nom: string, prenom: string, age: integer, conjoint: Personne) in class Personne { F self->nom = nom; F self->prenom = prenom; F self->age = age; F self->se_marie(conjoint); };

42 Aspects Orientés Objets { … Ý o2 Personne dupont = new Personne( Ý Dupont, Ý Jean, Ý 25, Ý dupond); … } F O2 fournit des méthodes génériques pour toutes les classes Ý méthodes de copie : copy et deep_copy Ý méthodes de comparaison : equal et deep_equal Ý méthodes daffichage : display et edit m O2 fournit des méthodes génériques pour toutes les classes m méthodes de copie : copy et deep_copy m méthodes de comparaison : equal et deep_equal m méthodes daffichage : display et edit

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

44 Aspects Orientés Objets ê Deux personnes différentes mais de mêmes caractéristiques (pour le modèle) ! ê Exemple: deux cousins éloignés 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:-

45 Aspects Orientés Objets m L'identité est la relation d'équivalence "avoir même identificateur que" m L'égalité est la relation d'équivalence "avoir les mêmes propriétés que".

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

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

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

49 Aspects Orientés Objets m 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. F 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. F La sous-classe est une spécialisation (ou raffinement) de la super-classe.

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

51 Aspects Orientés Objets m Intérêts de l héritage: ê factorisation du code des classes ê structuration hiérarchisée des classes, modularité

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

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

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

55 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é. { … o2 Employe e; e = …; … display(e->salaire()); … } e vu comme un employé, est peut-être en réalité un Enseignant ou un Chercheur ou un Enseignant-Chercheur. C'est à l'exécution que le système déterminera, en fonction du type réel de e (connu après le calcul), la méthode à exécuter.

56 Aspects Orientés Objets m Lorsque le choix de la méthode à utiliser est réalisé à l'exécution, on parle de lien retardé ou lien dynamique. m Lorsque le choix de la méthode à utiliser est réalisé à la compilation, on parle de lien statique.

57 Aspects Orientés Objets { … o2 list(Employe) lesEmployes; o2 Employe x; … for (x in lesEmployes) { display(x->salaire()); } … } { … o2 list(Employe) lesEmployes; o2 Employe x; … for (x in lesEmployes) { } … } Lien dynamiqueLien statique La possibilité dévaluer des propriétés (attributs ou méthodes) dobjets de natures différentes sappelle polymorphisme.

58 Aspects Orientés Objets m 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. o2 integer i; o2 tuple(x: integer, y: integer) unPoint; o2 list(Personne) lesPersonnes;

59 Aspects Orientés Objets m Les valeurs ne supportent pas le concept d'identité : elles ne peuvent donc être ni partagées ni cycliques. m 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] Dupond p p = * Dupond

60 Aspects Orientés Objets ê O2 fournit des fonctions prédéfinies d'affichage et d'édition de valeurs : F display() F input() { … o2 Personne Dupont = new Personne(" Dupont ", " Jean ", 25, dupond); Dupont->display(); display(*Dupont); … }

61 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 : F tuple() (constructeur n-uplet) F list() (constructeur de collection ordonnée) F set() (constructeur de collection non ordonnée) F unique set() (idem mais sans doublon) F type() (accès au type d'une classe)

62 Aspects Orientés Objets ê Types atomiques : F boolean F char F integer F real F string F bits

63 Aspects Orientés Objets m L'accès à un champ d'une valeur de type n-uplet se fait à l'aide de l'opérateur ". » m L'accès à un champ d'un objet dont la valeur est de type n-uplet se fait à l'aide de l'opérateur " - > ".

64 Aspects Orientés Objets { … o2 Personne Dupont = new Personne(" Dupont ", " Jean ", 25, dupond); display(Dupont->nom); Dupont->conjoint->edit(); display((*Dupont).nom); (*Dupont).conjoint->edit(); … }

65 Aspects Orientés Objets ê Les types sont organisés selon une relation d'ordre partiel, défini par les règles suivantes : F il n'existe pas de sous-type d'un type atomique F tuple(a: t 1, b: t 2 ) est un sous-type de tuple(a: t 1 ) F tuple(a: t 1 ) est un sous type de tuple(a: t 2 ) si t 1 et un sous type de t 2 F list(t 1 ) [resp. set(t 1 ), unique set(t 1 )] est un sous-type de list(t 2 ) [resp. set(t 2 ), unique set(t 2 )] si t 1 est un sous type de t 2

66 Aspects Orientés Objets m De la même manière, les classes sont organisées selon un ordre partiel, décrit par le graphe d'héritage. m L'ordre des types et des classes est vérifié par le compilateur.

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

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

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

70 Aspects Bases de Données name m Les racines de persistance sont nommées explicitement dans le schéma à l'aide de l'instruction name. ê Les racines de persistance peuvent être des objets et/ou des valeurs, de classes et/ou de type quelconques. F name LesHommes: set(Personne); F name LePresident: Personne;

71 Aspects Bases de Données { … o2 Personne Dupont = new Personne ( & "DUPONT", "Jean", 25, nil ); o2 Personne Durant = new Personne ( & "DURANT", "Jeanne ", 23, nil ); LesHommes += set(Dupont); LePresident->se_marie(Durant); … } Dupont devient persistant Durant devient persistant

72 Aspects Bases de Données m Transactions m 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 dune transaction validée perdurent »)

73 Aspects Bases de Données m Par défaut, tout programme accède aux données de la base de données en mode "transaction lecture seule ". m Pour pouvoir mettre à jour ces données, il faut démarrer une transaction.

74 Aspects Bases de Données m 2 possibilités pour débuter une transaction : ê utiliser un programme transactionnel ê utiliser une instruction transactionnelle

75 Aspects Bases de Données m Programme transactionnel : ê c'est un programme de l'application implémenté en tant que transaction ê une validation est automatiquement effectuée à la fin du programme application monApplication program public p1, public p2 end;

76 Aspects Bases de Données program body p1 in application monApplication { … } transaction body p2 in application monApplication { … }

77 Aspects Bases de Données m Transaction sur instruction : ê dans un programme, on démarre explicitement une transaction que l'on valide ou que l'on avorte explicitement F pour valider une transaction, on utilise l'instruction commit ou valid. F pour avorter une transaction, on utilise l'instruction abort.

78 Aspects Bases de Données program body p1 in application monApplication { … transaction; … [ [commit | valid] | abort]; … }

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

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

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

82 Aspects Bases de Données m 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) LePresident

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

84 Aspects Bases de Données m Atomes ê On dispose d'autres requêtes propres à chaque type atomique F nombres : opérations arithmétiques (+, -, *, /), modulo (mod()), valeur absolue (abs()) F chaînes de caractères: concaténation (+), extraction (x[i], x[i:j]), longueur (count()) F booléens: et (and), ou (or), négation 'not())

85 Aspects Bases de Données m 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. (*LePresident).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. LePresident->conjoint

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

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

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

89 Aspects Bases de Données m Ensembles ê Opérations particulières F 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

90 Aspects Bases de Données m Variable quelconque ê On peut associer, de façon bijective, à chaque entité (objet ou valeur) de la base une entier unique: magic()

91 Aspects Bases de Données m Construction de valeurs ê On dispose des constructeurs habituels permettant d'obtenir des tuples, des listes et ensembles F tuple(); struct(a 1 : x 1, … a n : x n ): les attributs du tuple peuvent être des objets et/ou des valeurs F list(), list(x 1, …, x n ):les membres de la liste doivent être de même nature (objet ou valeur) et doivent avoir un supertype ou une superclasse commun(e) F set(), set(x 1, …, x n ): idem

92 Aspects Bases de Données m Construction dobjets ê Une requête peut créer un objet : Personne(nom: LePresident->nom, age: 70) F Le nom de la fonction est le nom de la classe. F Les attributs peuvent être initialisés avec les résultats d'autres requêtes. F Les attributs non cités sont initialisés par défaut (le constructeur de la classe n'est pas appelé).

93 Aspects Bases de Données m 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(a 1, …, a n ): 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 a 1, …, a n.

94 Aspects Bases de Données m Prédicats ê Ce sont des requêtes retournant une valeur booléenne F q like wild_card_exp: possibilité d'utiliser les caractères génériques ('*'…) F 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 F x != y: attention, signifie not(x = y)

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

96 Aspects Bases de Données m Prédicats: Quantificateurs F 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

97 Aspects Bases de Données m Sélection / Extraction / Jointure ê Font appel à un bloc select… from … where … select q fromx 1 in f 1, …, x n in f n wherep Ý où q est une requête impliquant les variables x 1, …, x n Ý où p est un prédicat impliquant les variables x 1, …, x n Ý où f i est une requête impliquant les variables x 1, …, x i-1 mais pas les variables x i, …, x n.

98 Aspects Bases de Données m Sélection / Extraction / Jointure ê La structure du résultat est un bag par défaut. F 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) F 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 * F select * from Person p, Flower f F le résultat est du type bag(struct(p: Person, f:Flower))

99 Aspects Bases de Données m Tri ê y order by f1, …, fn F si y est une collection, retourne la liste contenant tous les éléments de y, rangés suivant les clés f 1, …, f n et, en dernier ressort par appel à magic() F 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

100 Aspects Bases de Données m Partitionnement y group by (a 1 : q 1, …, a n : q n ) F Si y est une collection résultat d un select, l expression retourne une partition de y suivant les critères q 1, …, q n. F Le résultat est un ensemble (bag) de n-uplets dont les attributs sont a 1, …, a n, partition. partition est du même type que y, et désigne l ensemble des éléments de y associés à une valeur de (a 1 …a n )

101 Aspects Bases de Données m Partitionnement ê Possibilité dutiliser 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.

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

103 Aspects Bases de Données m Réutilisation ê define f as q F si q est une requête, on lui attache le nom f que l'on peut utiliser pour faire appel à la requête q sans avoir à réécrire q. ê L'ensemble des requêtes nommées est accessible par la commande display queries

104 Aspects Bases de Données m OQL encapsulé dans un programme ê On peut lancer une requête en O2C, en C++, en Java, elle sera passée sous forme de chaîne de caractères, en paramètre à la fonction o2query ê en O2C: { o2 list (Person) mylist; o2 set(string) theNames; o2 integer age; theNames =... o2query(mylist,« select x from x in Group \ where x.age = $2 and x.name in $1 \ order by x.name", theNames, age ); }

105 Aspects Bases de Données ê en C++: #include "OQL_CC.hxx" { int i, j, c; d_Bag >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); …

106 Aspects Bases de Données ê en Java: 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()

107 Aspects Bases de Données m Index ê On peut définir des index sur des collections nommées et constantes de n-uplets. constant name Bibliotheque: set(Document); F la collection peut être objet ou valeur, F le lien nom --> collection doit être constant, F les n-uplets peuvent être objets ou valeurs. ê Les collections sont indexées : F sur un attribut atomique, F sur un attribut référençant un objet, F sur un attribut collection d'atomiques ou d'objets, F via un chemin de composition ne traversant que des n-uplets valeurs.

108 Aspects Bases de Données m Les Noms constants constant name Hachette: Editeur; constant name Bibliotheque: set(Document); ê Un objet constant est initialisé par le système. ê Un nom constant ne doit jamais être réinitialisé. ê Bibliotheque = set(d1, d2); /* change la collection -> KO */ Hachette = new Editeur /* new interdit -> KO */ Bibliotheque += set(d0); /* modifie la collection -> OK */ Bibliotheque = set(); /* zap de la collection -> OK */ * Hachette = x; /* ne modifie que la valeur -> OK */

109 Aspects Bases de Données m Index sur attribut atomique ou objet create index Bibliotheque on titre create index Bibliotheque on imprimeur ê Ils sont utilisés lors de requêtes du type : select d from d in Bibliotheque where d->imprimeur = Hachette ê ou sort d in Bibliotheque by d->titre ê ou avec l'opérateur like select x from x in Bibliotheque where x->titre like "Le *"

110 Aspects Bases de Données m Index sur attribut collection create index Bibliotheque on mots_cles ê Si d->mots_cles = set( m1, m2, m3 ) Alors (m1, d), (m2, d), (m3, d) sont des entrées dans l'index. ê Des requêtes du type : select d from d in Bibliotheque where "juju music" in d->mots_cles ê peuvent alors être optimisées.

111 Aspects Bases de Données m Index sur chemin de composition create index Bibliotheque on date.annee ê ---> index sur un chemin ne traversant que des valeurs ê Si d->date = tuple(mois: 11, annee: 1979) Alors (1979, d) est une entrée dans l'index ê Des requêtes du type : select d from d in Bibliotheque where d->date.annee = 1960 ê peuvent alors être optimisées.

112 Aspects Bases de Données m Utilisation via le langage de requête OQL ê Toute recherche sur une clé d'index devient équivalente à un accès direct. ê Attention la longueur maximum d'une clé de type string est de 256 caractère

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

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

115 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

116 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

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

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

119 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

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

121 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

122 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

123 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

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

125 Outils environnant O 2 : O 2 Look ê Affichage et édition des objets et des valeurs selon deux modes: F prêt à porter Ý mécanismes génériques d'affichage et d'édition Ý déclenchement interactif de méthodes Ý couper/copier/coller respectant l'identité et l'égalité Ý paramétrage par définition de masques et positionnement de ressources F sur mesure Ý primitives de construction d'affichage spécifique adapté à des types de données particuliers (images, texte, hypertexte... )

126 Outils environnant O 2 : O 2 Look m Présentation ê support graphique dans lesquels seront affichés et/ou édités les objets et valeurs. ê "fenêtre" d'affichage, existant indépendamment de sa visibilité à l'écran type Lk_presentation création par la fonction lk_present

127 Outils environnant O 2 : O 2 Look lk_present(objet_ou_valeur, masque [, chaine_id, nb_rsc, ref_tab_rsc]) objet_ou_valeur : désigne l'objet ou la valeur pour laquelle on crée une présentation masque : désigne le masque i.e. le degré d'expansion de l'affichage; on peut utiliser le masque générique par défaut en écrivant 0 ou lk_generic()

128 Outils environnant O 2 : O 2 Look m Masque ê "calques" ou modèles définissant le degré d'expansion des objets et/ou valeurs affichés dans une présentation type Lk_mask ê pour chaque entité, il existe une fonction de création de masque

129 Outils environnant O 2 : O 2 Look type atomique lk_atom(...) ensemble lk_set(…) liste lk_list(…) n-uplet lk_tuple(…) objets lk_object(…) lk_protected() quelconque lk_generic()

130 Outils environnant O 2 : O 2 Look m Fonctions de création de masque ê lk_atom(chaine_id, nb_rsc, tab_rsc) F retourne un masque pour toute valeur de type atomique (char, string, integer, real, boolean…) ê lk_set (chaine_id, nb_rsc, tab_rsc, s_masque) ê lk_list(chaine_id, nb_rsc, tab_rsc, s_masque) F retourne un masque pour toute valeur de type ensemble (resp. liste); le paramètre s_masque définit un masque pour les éléments de la collection

131 Outils environnant O 2 : O 2 Look m Fonctions de création de masque ê lk_tuple(chaine_id, nb_rsc, tab_rsc nb_att, tab_masque_att) F retourne un masque pour toute valeur de type n-uplet. Le paramètre nb_att indique le nombre d'attributs qui seront affichés. Le paramètre tab_maque_att est un tableau de spécifications des masques des attributs du n-uplet. Les éléments de ce tableau sont du type Lk_attribute_mask

132 Outils environnant O 2 : O 2 Look typedef struct { char *name; Lk_mask mask; } Lk_attribute_mask; F name est le nom de l'attribut tel qu'il est déclaré dans le schéma F mask est un masque correspondant au type de l'attribut

133 Outils environnant O 2 : O 2 Look m Exemple: {… Lk_attribute_mask masque_att[1]; Lk_mask monMasque; masque_att[0].name = 'nom'; masque_att[0].mask = lk_atom(0, 0, 0); monMasque = lk_tuple(0, 0, 0, \ 1, masque_att); …}

134 Outils environnant O 2 : O 2 Look m Fonctions de création de masque ê lk_object(chaine_id, nb_rsc, tab_rsc masque_valeur) F retourne un masque pour tout objet; le paramètre masque_valeur définit le masque associé au type de la valeur de l'objet ê lk_generic() F retourne un masque pour tout objet ou valeur; pour un objet, le masque est iconique

135 Outils environnant O 2 : O 2 Look m Fonctions de création de masque ê lk_protected(chaine_id, nb_rsc, tab_rsc) F retourne un masque pour tout objet; le paramètre masque_valeur définit le masque associé au type de la valeur de l'objet F contrairement à lk_generic() et lk_object(), cette fonction respecte l'encapsulation

136 Outils environnant O 2 : O 2 Look m Construction du masque Class Fiche type tuple( client: Personne, code: string, prix: list(real) ) Class Fiche type tuple( client: Personne, code: string, prix: list(real) ) Lk_list Lk_atom Lk_generic Lk_tuple Lk_object

137 Outils environnant O 2 : O 2 Look m Ressources ê Permet de contrôler finement le masque d'un objet ou d'une valeur F aspect graphique (police, couleur, libellé, dimensions, position des champs, etc.) F éditabilité des présentations: couper/copier/coller, édition de masques, etc. ê Ressource = (nom, valeur) ê Toute ressource non positionnée a une valeur par défaut

138 Outils environnant O 2 : O 2 Look m Ressources ê Une ressource est toujours associée à un ou plusieurs masques, sauf pour la fonction lk_generic() ê Il y a 3 manières de positionner des ressources F par fichier utilisateur F par contexte F en dur dans le code

139 Outils environnant O 2 : O 2 Look m Ressources par fichier utilisateur ê Les ressources doivent être positionnées dans un fichier.LKDefaults, chaque ligne étant de la forme. : F est une suite de noms séparés par des points, désignant la suite des chaine_id définies lors des créations de masque F est de nom de la ressource à positionner F est la valeur que l'on veut donner à la ressource

140 Outils environnant O 2 : O 2 Look m Ressources par fichier utilisateur ê Ne nécessite aucune recompilation de l'application ê Exemple: ma_pres.mon_objet.tuple.fontList: aberdeen-12 NB: tout ou partie du chemin de la ressource peut être remplacé par le caractère générique *

141 Outils environnant O 2 : O 2 Look m Ressources par contexte ê Un contexte est repéré explicitement par un appel à la fonction lk_prologue(…) et s'achève à l'appel de la fonction lk_epilogue() associée. ê Les ressources associées doivent être positionnées dans.LKDefaults ou dans un fichier portant le nom du contexte et se trouvant dans $O2HOME:look/$O2RESOURCE ou dans $O2HOME/look sous la forme.. :

142 Outils environnant O 2 : O 2 Look m Ressources "en dur" ê Non modifiables par l'utilisateur final ê Nécessitent de recompiler le corps ê Prioritaires sur tous les autres types de ressources ê Positionnées à l'aide des paramètres nb_rsc et tab_rsc des fonctions de création de masque F nb_rsc désigne le nombre de ressources tab_rsc est un tableau de Lk_resource

143 Outils environnant O 2 : O 2 Look m Ressources "en dur" typedef struct { char *name; char *value; } Lk_resource; {… o2 Personne p = new Personne; Lk_mask masque; Lk_resource tab_res[1]; tab_res[0].name = "menuTitleString"; tab_res[0].value = "saisie"; masque = lk_object(0,1,tab_rsc,lk_generic()); …}

144 Outils environnant O 2 : O 2 Look m Interactions utilisateurs ê Affichage lk_map(,,,, x, y) Ý : présentation à afficher Ý : MANUAL, MOUSE, COORDINATE, RIGHT, LEFT, STACK, BOTTOM Ý : FREE, GEOMETRIC, CONTENT, SLAVE Ý : présentation de référence (pour le placement et le lien, éventuellement) Ý x, y: coordonnées

145 Outils environnant O 2 : O 2 Look m Interactions utilisateurs ê Verrouiller une présentation ou "donner la main à l'utilisateur" lk_wait( ) Ý pose un verrou d'affichage sur la présentation bloquant l'exécution du code tant que le verrou n'a pas été libéré par un lk_free() Ý un tel verrou permet à l'utilisateur d'interagir avec la présentation (déclenchement de méthodes, etc.)

146 Outils environnant O 2 : O 2 Look m Interactions utilisateurs ê Verrouiller une présentation ou "donner la main à l'utilisateur" lk_grab( ) Ý pose un verrou d'affichage sur la présentation en empêchant l'utilisateur d'accéder aux autres présentations (modal) F lk_wait et lk_grab retournent LK_SAVE (resp. LK_ERASE, resp. LK_FAILED) si l'utilisateur a cliqué sur le crayon (resp. la gomme, resp. si la présentation n'existe pas ou est déjà verrouillée)

147 Outils environnant O 2 : O 2 Look m Interactions utilisateurs ê Déverrouiller une présentation lk_free(, ) Ý déverrouille la présentation précédemment verrouillée avec lk_wait ou lk_grab; le paramètre sera celui rendu par la fonction qui avait posé le verrou.

148 Outils environnant O 2 : O 2 Look m Actions automatiques ê clic sur le crayon F sur une présentation verrouillée Ý objet ou valeur : lk_free(, LK_SAVE) F sur une présentation déverrouillée Ý objet: déclenchement de la méthode save sur l'objet Ý valeur: rien

149 Outils environnant O 2 : O 2 Look m Actions automatiques ê clic sur la gomme F sur une présentation verrouillée Ý objet ou valeur : lk_free(, LK_ERASE) F sur une présentation déverrouillée Ý objet: déclenchement de la méthode erase sur l'objet Ý valeur: destruction de la présentation

150 Outils environnant O 2 : O 2 Look m Enregistrement lk_consult (presentation, variable) m Raffraichissement ê lk_refresh_presentation( presentation, objet_ou_valeur, masque [, chaine_id, nb_rsc, tab_rsc]) m Effacement, destruction ê lk_unmap(presentation) ê lk_delete_presentation(presentation)

151 Outils environnant O 2 : O 2 Look m Autres fonctions ê lk_delete_all() ê lk_all_presentations() ê lk_all_mapped_presentations() ê lk_current_presentation()

152 Outils environnant O 2 : O 2 Look m Méthodes ê present(mask: Lk_mask) ê consult(presentation: Lk_presentation) ê refresh_all ê erase_all ê all_presentations ê save(presentation: Lk_presentation) ê erase(presentation: Lk_presentation) menu: list(string)

153 Outils environnant O 2 : O 2 Kit m Chargement O 2 Kit est livrée en version "dumpée"; il est nécessaire de le recharger avec l'instruction o2dba_schema_load -system -file... ê Utiliser import pour importer dans uns chéma des classes ou objet nommés de O 2 Kit

154 Outils environnant O 2 : O 2 Kit m Boîtes de dialogue ê Méthodes implémentées de la classe Box ê Utilisation: importer la classe Box; déclarer une instance persistante (ou importer Dialoger de O 2 Kit) et l'initialiser; invoquer les méthodes désirées sur cette instance. import schema o2kit class Box; import schema o2kit name Dialoger; run body { Dialoger = new Box; }

155 Outils environnant O 2 : O 2 Kit m La classe Box ê message(label: string, ed_name: string) F affichage d'un message à l'utilisateur ê question(label: string, ed_name: string): boolean F question OUI/NON posée à l'utilisateur ê dialog(label: string, ed_name: string): string F demande à l'utilisateur de saisir une information; retourne l'information saisie ou chaine vide si l'utilisateur a cliqué sur la gomme

156 Outils environnant O 2 : O 2 Kit m La classe Box ê selection(title: string, ed_name: string, items: list(string)): string F permet la sélection d'un item dans une liste; retourne l'item sélectionné ou chaine vide si l'utilisateura cliqué sur la gomme ê edit_selection(title: string, ed_name: string, items: list(string)): string F idem avec possibilité de saisie de l'item

157 Outils environnant O 2 : O 2 Kit m La classe Box ê mult_selection(title: string, ed_name: string, items: list(string)): list(string) F permet la sélection multiple d'items parmi une liste; retourne la liste des items sélectionnés ou liste vide si l'utilisateur a cliqué sur la gomme

158 Outils environnant O 2 : O 2 Kit ê Autres classes F class Dialog_Box F class Component, Button, Radio_Box, Button_box, Single_selection, Editable_selection, Multiple_selection, Prompt, Label, Picture… F class Date F class Text F class Bitmap F class Image ê Éditeurs spécifiques: pour les dates, le texte, les structure hyper

159 Outils environnant O 2 : le débogueur m Intérêts ê Contrôler l'exécution de tout ou partie d'une application en F posant des points d'arrêt dans l'application F visualisant/modifiant des variables F visualisant la pile d'exécution F exécutant le code pas à pas m Utilisation F le code doit avoir été compilé avec l'option debug invoquée par la commande set options -g

160 Outils environnant O 2 : le débogueur m Passer sous debug debug m Suspension du mode debug o2 m Sortie du mode debug debug off quit

161 Outils environnant O 2 : le débogueur m Points d'arrêt break in [body | [at line no] [*] m Exécution run body run program prgName run application appliName

162 Outils environnant O 2 : le débogueur m Exécution particulière next : avance à l'instruction suivante step : idem mais descend dans la méthode appelée skip : passe à l'instruction suivante cont : continue jusqu'au prochain point d'arrêt finish : termine l'exécution courante (sauf si point d'arrêt) kill : tue le processus d'exécution en cours

163 Outils environnant O 2 : le débogueur m Trace ê On peut demander une trace des appels de méthodes, fonctions ou programmes avec la valeur de leurs paramètres trace in trace all

164 Outils environnant O 2 : le débogueur m Variables On peut visualiser la valeur d'une variable ou d'un paramètre à l'aide de print(var) ou printp(par) Pour l'édition, utiliser assign (var) et assignp(par) En mode graphique, utiliser lkprint, lkprintp, lkassign et lkassignp

165 Outils environnant O 2 : le débogueur m Etat courant status : récapitule tous les points d'arrêt, trace et affichage demandés delete : permet de supprimer des points d'arrêt ou des demandes de trace ou d'affichage Pile where [n] : affichage de la pile jusqu'à la profondeur n [up|down] n : déplacement de n niveaux dans la pile

166 ODMG 2.0 m Objectifs ê fournir des standards permettant d'écrire des applications portables, i.e. qui puissent fonctionner sur un ou plusieurs SGBDO F 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

167 ODMG 2.0 m Les composants majeurs ê Modèle objet = modèle objet de l'OMG + relations ê Langages de spécifications objet F Object Definition Language = IDL + relations F Object Interchange Format: échange d'objets inter bases, support de documentation… ê Langage de requêtes: OQL ê Couplage aux langages de programmation F C++, Smalltalk, Java (1.1)

168 ODMG 2.0 m Modèle objet ê 2 notions de base: les objets et les littéraux. Un objet a un identifiant unique, un littéral n'a pas d'identifiant. ê Objets et littéraux sont catégorisés par un type, qui définit l'ensemble de leurs états possibles et de leurs comportements ê L'état d'un objet est défini par les valeurs de ses propriétés (attributs et relations); son comportement par un ensemble d'opérations

169 ODMG 2.0 m 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.

170 ODMG 2.0 m Modèle objet: élé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

171 Architecture O2Web m L'architecture o2Web repose sur 3 éléments ê un dispatcher o2open_dispatcher ê un serveur o2web_server, qui se connecte en tant que client à un serveur o2 ê une passerelle o2web_gateway m Une boîte à outils est fournie sous la forme d'un schéma à charger avec o2dba_schema_load $O2HOME/o2schemas/o2web.dump

172 Architecture O2Web o2open_dispatcher o2web_server o2server o2web_gateway Serveur HTTP Client WWW

173 Architecture O2Web 1. Un client WWW envoie une URL au format HTTP, qui contient une requête OQL 2. Le serveur HTTP passe la requête à la passerelle 3. La passerelle se connecte à un dispatcher 4. Le dispatcher indique à quel serveur o2web se connecter 5. La passerelle se connecte au serveur o2web adéquat 6. Le serveur o2web exécute la requête OQL intégrée à l'URL et transforme le résultat en HTML en invoquant des méthodes génériques 7. Le résultat est renvoyé au client WWW

174 Architecture O2Web m 3 niveaux d'utilisation d'o2web ê mode générique: repose intégralement sur le mapping par défaut du modèle objet sur le modèle HTML ê personnalisation globale (en-têtes, pieds de page…), réaction à des événements (connexion, déconnexion…) ê personnalisation pour chaque classe par surcharge de méthodes génériques

175 Architecture O2Web ê Mode générique F valeurs atomiques valeurs affichées F tuples liste HTML de couples nom d'attribut + production récursive d'HTML F collections liste HTML, chaque élément est obtenu par production récursive de HTML F objet production récursive sur la valeur de l'objet F sous-objet lien vers une URL contenant la requête OQL retournant le sous-objet F classe d'o2kit (Date, Text, Bitmap, Image) date, texte, images en lignes et images GIF en ligne

176 Architecture O2Web ê Personnalisations globales F Définition d'un en-tête, pied de page pour chaque page, d'une page d'erreur, d'actions à exécuter sur une connexion ou déconnexion connect(query: string, userdate: string): boolean disconnect(size: integer, kind: string) error(kind: integer): bits header: bits footer: bits

177 Architecture O2Web ê Personnalisations par classe F format spécifique html_prolog: bits F en-tête et pied de page html_header(query:string, userdata:string):bits html_footer(query:string, userdata:string):bits F corps html_report(query:string, userdata:string):bits

178 Architecture O2Web F titre de lien html_title: string F optimisation de la génération de requête get_query: string PROLOG HEADER BODY FOOTER EPILOG

179 Architecture O2Web m Classes utilitaires ê O2WebAssistant ê O2WebFormAnalyser ê O2WebFormItem ê O2WebImageAttributes ê O2WebImageInliner


Télécharger ppt "Systèmes de Gestion de Bases de Données Orientés Objet Etude de cas avec un SGBDOO : O 2 Philippe SALVAN"

Présentations similaires


Annonces Google