systèmes de gestion de bases de données orientés objet etude de cas avec un sgbdoo : o 2 philippe...

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

Etude de cas avec un SGBDOO : O2

Philippe [email protected]

Plan du Cours — 1Plan du Cours — 1

GénéralitésHistoriqueAspects Bases de Données ;

Aspects Orientés ObjetArchitecturePremiers pas avec O2

Plan du Cours — 2 Plan du Cours — 2

Aspects Orientés ObjetsObjet Complexe, Encapsulation, Classes Identité d'ObjetHéritageSurcharge, Lien retardéValeurs, Types

Plan du Cours — 3Plan du Cours — 3

Aspects Base de DonnéesModèle de persistanceTransactions InterrogationsOptimisations

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

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

Gestion de Fichiers SGBD Navigationnels

SGBD Relationnels SGBD Orientés Objets

abstractionabstraction

code unique

code

réutilisable

optimisation

données

fichiers

SGFSGF

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/NSGBD/N

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/RSGBD/R

code unique

code

réutilisable

optimisation

données

fichiers

SGBD/OSGBD/O



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

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

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


Objectifs des SGBDOO réduire le dysfonctionnement entre langage de

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

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

partager le code réutilisable au sein du SGBD


Définition des SGBDOOThe Object-Oriented Database

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

obligatoires, facultatives, ouvertes


Définition des SGBDOOODMG 93

Défini par des éditeursStandard de portabilité des SGBDOO

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

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

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

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

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

Architecture Fonctionnelle

Langage de Définition

Langages de Programmation

Langage de Requêtes

Autres interfaces

Outils de Développement

Gestion de Schéma Gestion d'Objets


Architecture Opérationnelle

Objets

Fichiers

Verrous Journal

Pages

ApplicationCompilationProgramme utilisateur


Architecture Client/ServeurServeur d'objets

Objets

Fichiers

Verrous Journal

Cache de Pages

Application

Objets

Application

Objets


Architecture Client/ServeurServeur d'objets

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

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


Architecture Client/ServeurServeur de pages

PagesVerrous Journal

Cache de Pages

Application

Objets

Fichiers

Pages

Application

Objets

Fichiers

Pages


Architecture Client/ServeurServeur de pages

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


Architecture Client/ServeurMulti-serveurs

Objets Répartis

Fichiers

Pages

Application

Objets Répartis

Fichiers

Pages

Application

objets ou pages

Généralités - Premiers pas avec O2Généralités - Premiers pas avec O2

Schéma, BaseLe support physique d'un système O2 est appelé

volume.Un volume comprend un catalogue d'associations

schéma - basesSCHÉMA =

STRUCTURES DE DONNÉES+ SIGNATURE DES TRAITEME + CODE DES TRAITEMENTS

BASE = DONNÉES

SCHEMA

BASE


Schéma, Base

BASE

BASEBASE

BASEBASE

SCHEMA

SYSTEME

VOLUME DISQUE


Fichier .o2serverrcLe fichier .o2serverrc permet de configurer les

différents systèmes O2.Pour chaque système est indiqué son nom, la

machine par défaut sur laquelle s’exécutera le serveur, les répertoires stockant le volume, le fichier de log et le fichier d’image, le comportement concurrentiel et de reprise sur panne, les utilisateurs autorisés du système.


Fichier .o2serverrc Le format de description est le suivant:

system_name.server = picassosystem_name.cachesize = 4000system_name.cataldir = /home/o2volsystem_name.defaultvolsize = 50000. . .system_name.mode = multi-user+verbose

L’initialisation d’un système O2 est effectuée par la commande

O2dba_init -system system_name [-server server_name] Cette commande détruit toutes les données qui se trouvaient dans le

système.


ConnexionLancement du processus serveur

o2server -system system_nameLancement du processus client

o2shell -system system_name [-server server_name]o2tools -system system_name [-server server_name]

La connexion entre les deux processus s’effectue et le message (en mode alphanumérique)

Type your command and end with ^D

s’affiche. La session O2 est démarrée.


Utilisation couranteune 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, …)


o2server is up and running

Type your command and end with ^D.

Class Personnepublic type tuple( nom: string, age: integer, adresse: Adresse)end;


Langage de commandesManipulation de schémas

[create] schema schema_namedisplay schemasdisplay schema schema_name statset schema schema_nameimport schema schema_name class class_name |

name root_name


Langage de commandesManipulation de bases

[create] base base_name schema schema_namedisplay basesdisplay base base_name statset base base_name

Premiers pas avec O2Premiers pas avec O2

Validation de sessionLors du démarrage d’une session, une

transaction est implicitement entamée.Toutes les modifications de schéma(s), base(s), programme(s) sont sauvegardées si l’on déclenche (interactivement

ou par programme) une instruction commit,sont annulées si l’on déclenche (interactivement ou

par programme) une instruction abort.

Aspects Orientés ObjetsAspects Orientés Objets

Objet complexe, encapsulation, classeOBJET =

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

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


Objet complexe, encapsulation, classe

Vue externe: OBJET = BOITE NOIRE + BOUTONS

Vue interne:OBJET = DONNEES + MECANIQUE

LIEEAUX BOUTONS


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

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

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

le prototype d’un conceptPoint de vue acteur :

un objet est une entité autonome et active.


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

partie de l’interface.

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

nom: DUPONDprénom: Jean

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

conjoint: aucunfixe_age(age: integer)

age: 25


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

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

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

(composante dynamique)


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

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

Tout objet est instance de sa classe.


Exempleclass Personne

public type tuple(nom: string,prenom: string,private age: integer,private conjoint: Personne)


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;


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


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


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 la méthode init de la classe, si celle-ci a été définie.

{

…

o2 Personne dupond = new Personne;

…

}


public method init(nom: string, prenom: string,age: integer, conjoint: Personne)

in class Personne;

method body init(nom: string, prenom: string,age: integer, conjoint: Personne)

in class Personne { self->nom = nom; self->prenom = prenom; self->age = age; self->se_marie(conjoint); };


{ … o2 Personne dupont = new Personne( “ Dupont ”, “ Jean ”, 25, dupond);

… }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 d’affichage : display et edit

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 d’affichage : display et edit


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

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

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


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

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


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

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


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

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

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

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: [DURAND Jeanne]

Nom: DUPOND

Prénom: Jean

Age: 25

Conjoint: -


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

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

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


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

Nom: DUPOND

Prénom: Jean

Age: 25


Nom: DURAND

Prénom: Jeanne

Age: 26

Conjoint: [DUPOND Jean]


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

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

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

la super-classe.


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

de nouvelles propriétés à celles issues de la super-classe

la substitution : on redéfinit dans la sous-classe certaines propriétés issues de la super-classe.

L'héritage est dit simple si la sous-classe n'a qu'une super-classe ; il est dit multiple si la sous-classe a plusieurs super-classes.


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

modularité


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

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

Salaire: real employeur: Employeur

Salaire: real Salaire: real

Salaire_Enseignant: realsalaire_Chercheur: real

Employeur_Enseignant: Employeuremployeur_Chercheur: Employeur

Personne

Employe

Chercheur

Enseignant-Chercheur

Enseignant


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

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

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


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


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

{

…

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.


Lorsque le choix de la méthode à utiliser est réalisé à l'exécution, on parle de lien retardé ou lien dynamique.

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


{ … 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) { display(x->Employe@salaire()); } …}

Lien dynamique Lien statique

La possibilité d’évaluer des propriétés (attributs ou méthodes) d’objets de natures différentes s’appelle polymorphisme.


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

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

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

sa déclaration.o2 integer i;

o2 tuple(x: integer, y: integer) unPoint;

o2 list(Personne) lesPersonnes;


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

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

Nom: DUPOND

Prénom: Jean

Age: 25


Dupond

p

p = *Dupond


O2 fournit des fonctions prédéfinies d'affichage et d'édition de valeurs :display()input()

{

…

o2 Personne Dupont = new Personne(" Dupont ", " Jean ", 25, dupond);

Dupont->display();

display(*Dupont);

…

}


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


L'accès à un champ d'une valeur de type n-uplet se fait à l'aide de l'opérateur " . »

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


{

…

o2 Personne Dupont = new Personne(" Dupont ", " Jean ", 25,

dupond);

display(Dupont->nom);

Dupont->conjoint->edit();

display((*Dupont).nom);

(*Dupont).conjoint->edit();

…

}


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 atomiquetuple(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 est vérifié par le compilateur.


Opérations sur les collectionsListes

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

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

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

Aspects Bases de DonnéesAspects Bases de Données

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

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

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

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


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

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

nécessité de racines de persistance


Les racines de persistance sont nommées explicitement dans le schéma à l'aide de l'instruction namename.Les racines de persistance peuvent être des

objets et/ou des valeurs, de classes et/ou de type quelconques.name LesHommes: set(Personne);name LePresident: Personne;


{

…

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


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

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

perdurent »)


Par défaut, tout programme accède aux données de la base de données en mode "transaction lecture seule ".

Pour pouvoir mettre à jour ces données, il faut démarrer une transaction.


2 possibilités pour débuter une transaction :

utiliser un programme transactionnelutiliser une instruction transactionnelle


Programme transactionnel : c'est un programme de l'application

implémenté en tant que transactionune validation est automatiquement effectuée à

la fin du programmeapplication monApplication

program public p1,

public p2

end;


program body p1 in application monApplication {

…

}

transaction body p2 in application monApplication {

…

}


Transaction sur instruction : dans un programme, on démarre

explicitement une transaction que l'on valide ou que l'on avorte explicitementpour valider une transaction, on utilise l'instruction

commit ou valid.pour avorter une transaction, on utilise l'instruction

abort.


program body p1 in application monApplication {

…

transaction;

…

[ [commit | valid] | abort];

…

}


InterrogationLangage OQL (Object Query Language)

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

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


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

LePresident->conjoint->age() + 1

construction et instanciation:struct(nom: LePresident->nom, age: LePresident->age())


Requêtes complexes sélection/extraction/jointure

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

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

order by … le résultat est une liste

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


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

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

LePresident


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

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

3, « coucou »


AtomesOn dispose d'autres requêtes propres à chaque

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

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

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


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

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

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


ListesExtraction

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

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


ListesOpérations particulières

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

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

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

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


EnsemblesExtraction

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

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

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


EnsemblesOpérations particulières

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

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

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

disjointe de tous les éléments de x


Variable quelconqueOn peut associer, de façon bijective, à chaque

entité (objet ou valeur) de la base une entier unique: magic()


Construction de valeursOn dispose des constructeurs habituels

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

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

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

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


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

Personne(nom: LePresident->nom, age: 70)

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

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

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


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

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

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


PrédicatsCe sont des requêtes retournant une valeur

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

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

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

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


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

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


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

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

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


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

select q

from x1 in f1, …, xn in fn

where p

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

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

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

mais pas les variables xi, …, xn.


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

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

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

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


Tri y order by f1, …, fn

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

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


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

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

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


PartitionnementPossibilité d’utiliser la clause having

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

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


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

requête:

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

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


Réutilisationdefine f as q

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


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

}


en C++:#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);…


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


Index On peut définir des index sur des collections nommées et

constantes de n-uplets.constant name Bibliotheque: set(Document);

la collection peut être objet ou valeur, le lien nom --> collection doit être constant, les n-uplets peuvent être objets ou valeurs.

Les collections sont indexées : sur un attribut atomique, sur un attribut référençant un objet, sur un attribut collection d'atomiques ou d'objets, via un chemin de composition ne traversant que des n-uplets valeurs.


Les Noms constantsconstant 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 */


Index sur attribut atomique ou objetcreate index Bibliotheque on titre create index Bibliotheque on imprimeur

Ils sont utilisés lors de requêtes du type :select d from d in Bibliothequewhere d->imprimeur = Hachette

ousort d in Bibliothequeby d->titre

ou avec l'opérateur like select x from x in Bibliothequewhere x->titre like "Le *"


Index sur attribut collectioncreate 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.


Index sur chemin de compositioncreate 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.


Utilisation via le langage de requête OQLToute 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


Axiomquery_program ::={define_query;} query

define_query ::=define identifier as query


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


Simple Expressionquery ::= query + query 1

query ::= query - query

query ::= query * query

query ::= query / query

query ::= - query

query ::= query mod query

query ::= abs (query)

query ::= query || query


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

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


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

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

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


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

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


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

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

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


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

Select Expressionquery ::= select [ distinct ] projection_attributes

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


projection_attributes ::= projection {, projection}

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

partition_attributes ::= projection {, projection}

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


Set Expressionquery ::= query intersect query

query ::= query union query

query ::= query except query

Conversionquery ::= listtoset (query)

query ::= element (query)

query ::= distinct(e)

query ::= flatten (query)

query ::= (class_name) query


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

= ! = l i k eand exists for allor


.. :

,

(identifier) this is the cast operator

order

having

group by

where

from

select

Outils environnant OOutils environnant O22: O: O22LookLook

Affichage et édition des objets et des valeurs selon deux modes:prêt à porterprê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

sur mesuresur mesure primitives de construction d'affichage spécifique adapté à des

types de données particuliers (images, texte, hypertexte...)


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


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


Masque "calques" ou modèles définissant le degré

d'expansion des objets et/ou valeurs affichés dans une présentation

type Lk_maskpour chaque entité, il existe une fonction de

création de masque


type atomique lk_atom(...)

ensemble lk_set(…)

liste lk_list(…)

n-uplet lk_tuple(…)

objets lk_object(…)

lk_protected()

quelconque lk_generic()


Fonctions de création de masque lk_atom(chaine_id, nb_rsc, tab_rsc)

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)

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


Fonctions de création de masque lk_tuple(chaine_id, nb_rsc, tab_rsc

nb_att, tab_masque_att)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


typedef struct {

char *name;Lk_mask mask; } Lk_attribute_mask;

name est le nom de l'attribut tel qu'il est déclaré dans le schéma

mask est un masque correspondant au type de l'attribut


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

…}


Fonctions de création de masque lk_object(chaine_id, nb_rsc, tab_rsc

masque_valeur)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()retourne un masque pour tout objet ou valeur; pour

un objet, le masque est iconique


Fonctions de création de masque lk_protected(chaine_id, nb_rsc,

tab_rsc)retourne un masque pour tout objet; le paramètre

masque_valeur définit le masque associé au type de la valeur de l'objet

contrairement à lk_generic() et lk_object(), cette fonction respecte l'encapsulation


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_listLk_list

Lk_atom

Lk_atom

Lk_generic

Lk_tupleLk_tuple

Lk_objectLk_object


RessourcesPermet de contrôler finement le masque d'un objet

ou d'une valeuraspect graphique (police, couleur, libellé, dimensions,

position des champs, etc.)é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


RessourcesUne ressource est toujours associée à un ou

plusieurs masques, sauf pour la fonction lk_generic()

Il y a 3 manières de positionner des ressourcespar fichier utilisateurpar contexteen dur dans le code


Ressources par fichier utilisateurLes ressources doivent être positionnées dans un

fichier .LKDefaults, chaque ligne étant de la forme

<chemin>.<nom>: <valeur><chemin> 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

<nom> est de nom de la ressource à positionner<valeur> est la valeur que l'on veut donner à la

ressource


Ressources par fichier utilisateurNe nécessite aucune recompilation de

l'applicationExemple:

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 *


Ressources par contexteUn 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

<nom_du_contexte>.<chemin>.<nom>: <valeur>


Ressources "en dur"Non modifiables par l'utilisateur finalNécessitent de recompiler le corpsPrioritaires sur tous les autres types de ressourcesPositionnées à l'aide des paramètres nb_rsc et

tab_rsc des fonctions de création de masquenb_rsc désigne le nombre de ressources tab_rsc est un tableau de Lk_resource


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

…}


Interactions utilisateursAffichage

lk_map(<presentation>, <placement>, <lien>, <reference>, x, y)

<presentation> : présentation à afficher <placement>: MANUAL, MOUSE, COORDINATE, RIGHT,

LEFT, STACK, BOTTOM <lien>: FREE, GEOMETRIC, CONTENT, SLAVE <reference>: présentation de référence (pour le placement et le lien,

éventuellement) x, y: coordonnées


Interactions utilisateursVerrouiller une présentation ou "donner la main

à l'utilisateur"lk_wait(<presentation>)

pose un verrou d'affichage sur la présentation <presentation> 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.)


Interactions utilisateursVerrouiller une présentation ou "donner la main

à l'utilisateur"lk_grab(<presentation>)

pose un verrou d'affichage sur la présentation en empêchant l'utilisateur d'accéder aux autres présentations (modal)

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)


Interactions utilisateursDéverrouiller une présentation

lk_free(<presentation>, <valeur_de_retour>) déverrouille la présentation précédemment verrouillée

avec lk_wait ou lk_grab; le paramètre <valeur_de_retour> sera celui rendu par la fonction qui avait posé le verrou.


Actions automatiques clic sur le crayon

sur une présentation verrouillée objet ou valeur : lk_free(<presentation>, LK_SAVE)

sur une présentation déverrouillée objet: déclenchement de la méthode save sur l'objet valeur: rien


Actions automatiques clic sur la gomme

sur une présentation verrouillée objet ou valeur : lk_free(<presentation>, LK_ERASE)

sur une présentation déverrouillée objet: déclenchement de la méthode erase sur l'objet valeur: destruction de la présentation


Enregistrement lk_consult (presentation, variable)

Raffraichissement lk_refresh_presentation(

presentation,objet_ou_valeur, masque[, chaine_id, nb_rsc, tab_rsc])

Effacement, destruction lk_unmap(presentation) lk_delete_presentation(presentation)


Autres fonctions lk_delete_all() lk_all_presentations() lk_all_mapped_presentations() lk_current_presentation()


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)

Outils environnant OOutils environnant O22: O: O22KitKit

ChargementO2Kit est livrée en version "dumpée"; il est

nécessaire de le recharger avec l'instruction o2dba_schema_load -system <nom>

-file <fichier_dump> ...

Utiliser import pour importer dans uns chéma des classes ou objet nommés de O2Kit


Boîtes de dialogueMéthodes implémentées de la classe BoxUtilisation: importer la classe Box; déclarer une

instance persistante (ou importer Dialoger de O2Kit) 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; }


La classe Boxmessage(label: string, ed_name: string)

affichage d'un message à l'utilisateur

question(label: string, ed_name: string): booleanquestion OUI/NON posée à l'utilisateur

dialog(label: string, ed_name: string): stringdemande à l'utilisateur de saisir une information;

retourne l'information saisie ou chaine vide si l'utilisateur a cliqué sur la gomme


La classe Box selection(title: string, ed_name: string, items:

list(string)): stringpermet 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)): stringidem avec possibilité de saisie de l'item


La classe Boxmult_selection(title: string, ed_name: string,

items: list(string)): list(string)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


Autres classesclass Dialog_Boxclass Component, Button, Radio_Box, Button_box,

Single_selection, Editable_selection, Multiple_selection, Prompt, Label, Picture…

class Dateclass Textclass Bitmapclass Image

Éditeurs spécifiques: pour les dates, le texte, les structure hyper

Outils environnant OOutils environnant O22: le débogueur: le débogueur

IntérêtsContrôler l'exécution de tout ou partie d'une

application enposant des points d'arrêt dans l'applicationvisualisant/modifiant des variablesvisualisant la pile d'exécutionexécutant le code pas à pas

Utilisation le code doit avoir été compilé avec l'option debug

invoquée par la commande set options -g


Passer sous debugdebug

Suspension du mode debugo2

Sortie du mode debugdebug off

quit


Points d'arrêtbreak in [body | method@class]

[at line no] [*]Exécution

run body

run program prgName

run application appliName


Exécution particulièrenext: avance à l'instruction suivantestep: idem mais descend dans la méthode appeléeskip: passe à l'instruction suivantecont: continue jusqu'au prochain point d'arrêtfinish: termine l'exécution courante (sauf si

point d'arrêt)kill: tue le processus d'exécution en cours


TraceOn peut demander une trace des appels de

méthodes, fonctions ou programmes avec la valeur de leurs paramètres

trace in method@class

trace all


VariablesOn 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


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

Pilewhere [n]: affichage de la pile jusqu'à la profondeur

n

[up|down] n: déplacement de n niveaux dans la pile

ODMG 2.0ODMG 2.0

Objectifs fournir des standards permettant d'écrire des

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

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

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

ODMG 2.0ODMG 2.0

Les composants majeursModèle objet

= modèle objet de l'OMG + relations

Langages de spécifications objetObject Definition Language = IDL + relationsObject Interchange Format: échange d'objets inter bases,

support de documentation…

Langage de requêtes: OQLCouplage aux langages de programmation

C++, Smalltalk, Java (1.1)

ODMG 2.0ODMG 2.0

Modèle objet2 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

ODMG 2.0ODMG 2.0

Modèle objetUne 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.

ODMG 2.0ODMG 2.0

Modèle objet: éléments clésPropriétés: attributs et relationsOpérations: méthodes. Exceptions.Héritage multipleExtensions et clésNommage d'objets, durée de vie et identitéLittéraux atomiques, structurés et ensemblistesClasses de collections

Architecture O2WebArchitecture O2Web

L'architecture o2Web repose sur 3 élémentsun dispatcher o2open_dispatcherun serveur o2web_server, qui se connecte en

tant que client à un serveur o2une passerelle o2web_gateway

Une boîte à outils est fournie sous la forme d'un schéma à charger avec o2dba_schema_load

$O2HOME/o2schemas/o2web.dump


o2open_dispatcher

o2web_server o2web_server o2web_server

o2server

o2web_gateway o2web_gateway

Serveur HTTP

Client WWW Client WWW


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


3 niveaux d'utilisation d'o2webmode 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


Mode génériquevaleurs atomiques valeurs affichéestuples liste HTML <ul> de couples nom d'attribut +

production récursive d'HTMLcollections liste HTML <ul>, chaque élément est obtenu

par production récursive de HTMLobjet production récursive sur la valeur de l'objetsous-objet lien vers une URL contenant la requête OQL

retournant le sous-objetclasse d'o2kit (Date, Text, Bitmap, Image) date, texte,

images en lignes et images GIF en ligne


Personnalisations globalesDé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


Personnalisations par classeformat spécifique

html_prolog: bits

en-tête et pied de pagehtml_header(query:string,

userdata:string):bits

html_footer(query:string,


corpshtml_report(query:string,



titre de lienhtml_title: string

optimisation de la génération de requêteget_query: string

PROLOG

HEADER

BODY

FOOTER

EPILOG


Classes utilitairesO2WebAssistantO2WebFormAnalyserO2WebFormItemO2WebImageAttributesO2WebImageInliner

systèmes de gestion de bases de données orientés objet etude de cas avec un sgbdoo : o 2 philippe...

Documents