OQL (Object Query Language) est un langage de type déclaratif, qui peut être utilisé seul ou à partir d'un langage de programmation, tel que C++ ou Java

(1)

Un langage de manipulation de données orientées objets: OQL 1. Introduction

OQL, est la norme proposée par le groupe ODMG et implémentée par les SGBDO participant à ce groupe.

OQL (Object Query Language) est un langage de type déclaratif, qui peut être utilisé seul ou à partir d'un langage de programmation, tel que C++ ou Java.

Les requêtes d'OQL peuvent appeler des méthodes, et inversement tout programme ou méthode peut contenir des requêtes OQL. OQL permet d'écrire des requêtes, mais pas des instructions de mise à jour. Ces dernières se font grâce aux méthodes associées aux classes.

1. Requêtes, points d'entrée et résultats 2.1Points d'entrée

En relationnel le point d’entrée est la relation.

En ODMG ce sont les noms des populations déclarées pour les classes (clause "Extent" de la définition des classes), ou des noms permanents associés à des objets particuliers de la base.

En effet, en ODMG, on peut donner à tout objet un ou plusieurs noms permanents, qui pourront servir de point d’entrée dans la base. Pour cela, il suffit de déclarer un nom grâce à l’instruction "Name". Par exemple, l'instruction: Name directeur : Personne

Déclare un nom permanent, directeur, de type Personne. Il suffit alors d’affecter un objet à ce nom, par exemple en créant un nouvel objet comme ci-dessous :

directeur = Personne(nom:"XXX", prénoms:LIST("YYY","ZZZ"), adresse:"Msila") chercher :

- Dans les populations associées aux classes (clause EXTENT )nom de l'étudiant de numéro 111 :

SELECT e.nom

FROM e IN LesEtudiants WHERE e.n°E = 111

Soit Phil= Etudiant (nom:"XXX", prénoms:LIST("YYY","ZZZ"), adresse:"Msila"………..)

- A partir des variables nommées Phil.nom noms des cours suivis par Phil :

SELECT c.nomC

FROM c IN Phil.cours_suivis

2.2 Accès direct à des éléments nommés Directeur objet (non imprimable)

Directeur.nom valeur (imprimable)

Directeur.age() appel de méthode de résultat valeur LesPersonnes collection d'objets

2.3Résultat d'une requête : Type du résultat : choix entre :

- Objet

- valeur : simple, structurée En utilisant les constructeurs STRUCT, SET, LIST ..

l'utilisateur peut créer de nouvelles valeurs structurées - élément

- collection

La sémantique de la requête définit si le résultat est un élément ou une collection et son genre (SET, BAG…)

Requête : l’ensemble des enseignants assistants

(2)

SELECT e

FROM e IN LesEnseignants WHERE e.statut = 'assist'

=> SET d'objets Enseignant Requête : villes des enseignants SELECT e.adresse.ville

FROM e IN LesEnseignants

BAG de valeurs simples de type STRING (avec doubles) Requête : nom et ville de chaque enseignant

Valeur structurée => mot clé STRUCT

SELECT STRUCT(nom: e.nom, ville: e.adresse.ville) FROM e IN LesEnseignants

=> BAG de valeurs complexes de type STRUCT(nom: STRIN_G, ville: STRING) ATTENTION : La création explicite d'une nouvelle structure complexe (STRUCT...) est obligatoire (nom: e.nom, ville: e.adresse.ville) n'est pas d'un type connu d'OQL.

Requête : pour chaque enseignant donner son nom et les noms de ses cours

SELECT STRUCT( nom: e.nom, cours:(SELECT c.nomC FROM c IN e.cours_assurés)) FROM e IN LesEnseignants

BAG de valeurs complexes de type STRUCT(nom: STRIN_G, cours: SET(STRING)) NB Ces structures comportant des multivalués seraient impossibles en relationnel

2. Manipulation d'objets et de valeurs structurées Création d'objets

a- via la méthode associée à chaque classe : le constructeur permet de créer des objets de type classe , le nom de cette méthode est celui de la classe .

bda = Cours(nomC:'BDA' , cycle:2)

1) crée un objet permanent de format Cours 2) rend l'oid (dans la variable bda)

3) si une population existe (EXTENT...) y range l'objet (dans LesCours) b- Création de valeurs structurées d'un type existant dans le schéma (TYPEDEF)

a = Tadresse(rue:'chemin des oiseaux' , numéro:'10A' , ville:'Morges' , NPA: 1033).

c- Création de valeurs structurées d'un type nouveau via les constructeurs STRUCT, SET, LIST x = STRUCT(nomCours:'BDA' , nomprof:'C. Parent' , nomAssistant:'A.

Osterwalder' , faculté:'HEC' , étudiants: SET ('P. Rochat', 'A. Muller', 'N. Cullot', ….)) Accès à un attribut composant d'un STRUCT

-Notation pointée : composé_monovalué . composant Phil.adresse.ville OK

Phil.études n'est pas de type STRUCT, mais de type LIST, donc Phil.études.diplôme N'EST PAS CORRECT

Accès à un composant d'un composé multivalué Solution générale : variable IN collection

1) variable IN composé_multivalué

=> la variable parcourt la collection 2) variable.composant

Le (les) diplôme que Phil a eu en 2000 SELECT x.diplôme

FROM x IN Phil.études WHERE x.année = 2000

4. Parcours des liens de composition

(3)

De l'objet composé à l'objet composant :

 notation pointée (comme pour attribut complexe)

 Jointures très faciles … dans le sens du lien - Objet composé monovalué => notation pointée Nom du professeur du cours BD

SELECT c.prof.nom FROM c IN LesCours WHERE c.nomC = 'BD'

- Objet composé multivalué => variable Noms des étudiants inscrits au cours BD SELECT e.nom

FROM c IN LesCours, e IN c.étudiants WHERE c.nomC = 'BD'

c.étudiants.nom N'EST PAS CORRECT 5. Opérateurs sur les collections

Le format général d'une requête Select…from...where est le suivant:

Select [distinct] <définition-résultat>

from x in <collection1>, y in <collection2>, ...

[ where <condition> ] ;

où <définition-résultat> est une expression qui, soit désigne un objet ou une valeur existants, soit définit une nouvelle valeur structurée avec son type. Cette requête déclare x, y … comme variables locales à la requête. Elle est équivalente à la suite d'opérations:

a- faire le produit cartésien des collections citées dans la clause "from". Si certaines de ces collections sont des listes ou des tableaux, elles sont auparavant transformées en ensembles;

b- filtrer selon la condition de la clause "where";

c- pour chaque élément obtenu, construire un élément du résultat selon le format déclaré dans la clause "Select [distinct] <définition-résultat>", c'est à dire :

- si <définition-résultat> désigne un objet ou une valeur, extraire l'oid ou la valeur,

- si <définition-résultat> définit une valeur structurée via le constructeur STRUCT, construire cette valeur structurée;

d- si le mot clé "distinct" est présent, supprimer les doubles du résultat. Dans ce cas, le résultat estun ensemble (SET), sinon c'est un multi-ensemble (BAG).

Le résultat d'une requête peut être affecté à une variable de type ensemble ou multi-ensemble.

Noms des cours suivis par Phil et Annie Muller (Annie et Phil doivent suivre tous les deux ces cours)

SELECT c.nomC

FROM c IN Phil.cours_suivis WHERE c IN ( SELECT x

FROM e IN LesEtudiants, x IN e.cours_suivis

WHERE e.nom='Muller' AND e.prénoms=LIST('Annie') ) 5.1 Quantificateur existentiel :

L'expression:

exists x in <collection> : <condition(x)>

déclare une variable locale x sur la collection et a pour résultat un booléen qui est vrai si et seulement si un élément au moins de la collection satisfait la condition.

Exemple, trouver les enseignants qui donnent au moins un cours de 3^ème cycle.

Select e from e in LesEnseignants where exists c in e.cours-assurés : c.cycle=3 ;

(4)

5.2 Quantificateur universel : L'expression:

for all x in <collection> : <condition(x)>

déclare une variable locale x sur la collection et a pour résultat un booléen qui est vrai si et seulement si tous les éléments de la collection satisfont la condition.

Exemple : trouver les enseignants qui ne donnent que des cours de 3^ème cycle (ainsi que ceux qui ne donnent aucun cours).

Select e from e in LesEnseignants where for all c in e.cours-assurés : c.cycle=3 ; 5.3 Test d'appartenance à une collection :

L'expression:

<élément> in <collection>

a pour résultat un booléen qui est vrai si et seulement si l'élément appartient à la collection.

Par exemple, la requête suivante retrouve les enseignants du cours "BDA".

Select e from e in LesEnseignants, c in LesCours where c.nomC = "BDA" and c in e.cours-assurés ; 5.4 Fonctions d'agrégation :

Les fonctions min, max, count, sum et avg, peuvent être employées sur toute collection, comme par exemple:

Count (Select e from e in LesEnseignants where e.statut="prof") ; qui compte le nombre total de professeurs.

5.5 Partitionnement d'une collection :

La fonction "Group by" permet, de partitionner une collection en sous ensembles et de calculer des résultats agrégés sur ces sous-ensembles. Ces sous-ensembles sont appelés d'un nom prédéfini "partition". L'instruction:

Group x in <collection>

by ( nom11: <expression11> , ... , nom1n: <expression1n> ) [ with ( nom21: <expression21> , ... , nom2p: <expression2p> ) ] ;

où x est une variable locale à l'instruction Group by, crée en résultat un ensemble de valeurs structurées du type:

set ( struct ( nom11:domaine11,..., nom1n:domaine1n , nom21:domaine21,...

nom2p:domaine2p))

où domaineij est le domaine de valeurs du résultat de <expressionij>.

Une telle instruction, appliquée à une collection d'éléments de type T est équivalente à:

- partitionner la collection selon la clause "by": un sous-ensemble est créé pour chaque valeur prise par <expression11>x... x <expression1n>. La collection est donc transformée en un ensemble du type: Set(struct(nom11: domaine11, ..., nom1n: domaine1n, partition: set(T))) où "partition" est le nom de l'attribut nouvellement créé qui contient l'ensemble des instances ayant même valeur pour ( <expression11>x... x <expression1n> );

- pour chaque élément de cet ensemble, calculer la valeur des expressions

<expression21>, ... , <expression2p> sur l'attribut ensembliste partition, et construire l'élément correspondant du résultat.

Par exemple, l'expression:

Group c in LesCours by ( cycle : c.cycle )

with ( nbcours : count(partition) ) ;

donne en résultat un ensemble de couples (cycle:INT, nbcours:INT) qui définissent pour chaque cycle le nombre de cours de ce cycle.

5.6 Transformation d'une collection d'un élément en élément :

Si une collection ne contient qu'un seul élément, la fonction "Element" rend en réponse l'élément.

(5)

Cette fonction est utile quand on sait que le résultat d'une requête "Select...." est un seul élément et qu'on veut le traiter en tant que tel, alors que du point de vue de la syntaxe ce résultat est un ensemble.

Element(<collection>) <élément>

Attention, si la collection comporte plusieurs éléments, l'instruction génère une alerte ("exception") lors de l'exécution.

5.7 Opérateurs ensemblistes :

Les opérateurs des ensembles, union (appelé "union"), différence (appelé "except") et intersection

(appelé "intersect"), existent pour des collections de type ensemble ou multi-ensemble. Par exemple, la requête suivante recherche les étudiants qui ont obtenu le cours 'BD', mais pas le cours 'SI' :

(select e from e in LesEtudiants, c in e.cours_obtenus where c.cours.nomC='BD') except

(select e from e in LesEtudiants, c in e.cours_obtenus where c.cours.nomC='SI’) ; 6. Méthodes

Dans une requête, tout élément de type T peut être remplacé par une méthode fournissant un résultat de type T. Par exemple, la requête suivante recherche les noms des cours qui ont plus de 120 inscrits

(nb_inscrits() est une méthode de la classe Cours) :

select c.nomC from c in LesCours where c.nb_inscrits()>120 ; nom et âge des étudiants

SELECT STRUCT(nom: e.nom , âge: e.age()) FROM e IN LesEtudiants ;