Les Diff´erents Motifs d’Arbre

Comme nous avons pu le voir jusqu’ici, les TGV s sont un ensemble de TreePat-terns contenant des arbres de nœuds, chacun d’eux reli´es par des Hyperlink s. Le langage de requˆete XQuery ´etant riche, nous devons d´efinir les diff´erentes sp´ecifica-tions des variables et les clauses de construction de r´esultats. Il va donc nous falloir introduire de nouveaux types de TreePatterns pour r´epondre `a nos besoins. Ainsi,

3.3.4 Formalisation des Tree Graph Views 81

nous allons ´etudier les Types Abstraits suivants : SourceTreePattern, Intermediate-TreePattern, ReturnTreePattern et AggregateIntermediate-TreePattern, dont les caract´eristiques d’h´eritage peuvent ˆetre repr´esent´ees dans le diagramme de la figure 3.13. Les trois types SourceTreePattern, IntermediateTreePattern et ReturnTreePattern h´eritent des TreePatterns, alors que le Type Abstrait AggregateTreePattern h´erite des carac-t´eristiques du ReturnTreePattern.

TreePattern

SourceTreePattern ReturnTreePattern IntermediateTreePattern

AggregateTreePattern

Fig. 3.13 – Diagramme d’h´eritage des TreePatterns

3.4.4.1 SourceTreePattern

Le SourceTreePattern (ou STP) est un TreePattern qui permet de d´efinir un motif d’arbre de s´election pour des documents XML. Nous devons d´efinir la source du Tree-Pattern par le document cible, et la racine par l’XPath de d´efinition du domaine (ie. for $i in collection(”catalog”)/catalog/book). Dans le cas o`u aucun document n’est d´efini (ie. for $i in /catalog/book), il faut alors choisir la source ”*” (correspondant `

a l’ensemble des collections).

TA 21 SourceTreePattern extends TreePattern STP

Utilise : String, XP, P Operations

O1 createSTP String × String × XP → STP

O2 getSourceSTP STP → N

Axiomes : v, s ǫ String; xp ǫ XP ;

A1 getVariable (createSTP (v, s, xp)) = v

A2 getSourceSTP (createSTP (v, s, xp)) = createNode (s)

L’op´eration O1 permet de d´efinir un SourceTreePattern. La variable de ce motif d’arbre est d´efinie par l’op´eration getV ariable, provenant du type T reeP attern (dont STP ´etend). L’axiome A1 permet de d´efinir d’o`u provient la variable lors de la cr´eation. La source ´etant la collection, elle est d´etermin´ee par l’op´eration O2 et l’axiome A2 qui nous permet de voir qu’un nœud est cr´e´e `a partir de la chaˆıne de caract`eres donn´ee `a la cr´eation. Les op´erations et axiomes provenant du TA 6 restent inchang´es, tel que l’ajout de l’XPath se rajoute sur la source, et le dernier ´el´ement donne la racine. Le reste se comporte donc comme un TreePattern.

3.4.4.2 ReturnTreePattern

Un ReturnTreePattern (ou RTP ) est un TreePattern dont les nœuds repr´esentent les balises `a construire pour le document XML r´esultat. Un nœud se projette dans le SourceTreePattern `a l’aide d’un ProjectionHyperlink et un TreePattern avec un GeneralizedHyperlink, ces hyperliens permet de bˆatir le r´esultat demand´e dans la clause de reconstruction de r´esultats. Nous pouvons ajouter que chacun des Node-Link s d’un SourceTreePattern ont un axe type ’child ’. En effet, il n’existe aucun autre type d’axe entre les balises d’un document XML. De plus, ces NodeLink s sont obligatoires car la balise est n´ecessaire `a la construction du r´esultat.

TA 22 ReturnTreePattern extends TreePattern RTP

Utilise : String, XP Operations

O1 createRTP String → RTP

O2 addXPathToRTP RTP × XP → RTP

Op´eration `a ajouter au TA XP

O3 isAllChildren XP → boolean

Pr´e-conditions : rtp ǫ RT P ; xp ǫ XP ;

P1 define (addXPathToRTP (rtp, xp)) ⇐⇒ isAllChildren (xp) = true Axiomes : s ǫ String; i ǫ int; p ǫ P ; xp ǫ XP ;

A1 getVariable (createRTP (s)) = s

A2 getRoot (createRTP (s)) = createPattern (s) A3 getSource (createRTP (s)) = createPattern (s) A4 isEmpty (xp) ⇒ isAllChildren (xp) = true A5 isAllChildren (xp) ⇒ getAxis (first (xp)) = ’child’

&& isAllChildren (deleteFirst (xp))

A6 addXPathRTP (rtp, xp) = addXPathToTreePattern (rtp, xp, true)

Nous pouvons cr´eer un ReturnTreePattern `a l’aide d’une chaˆıne de caract`ere grˆace `

a l’op´eration O1. Cette variable permet de d´efinir la variable de d´eclaration (A1 ), la racine (A2 ) et la source (A3 ) de ce TreePattern avec cette chaˆıne de caract`ere. Ainsi, nous obtenons un ReturnTreePattern auquel nous pouvons ajouter des XPaths. Pour ajouter un XPath `a un ReturnTreePattern, il faut v´erifier que l’XPath est compos´e exclusivement de liens de type parents/enfants (P1 ). En effet, les liens du ReturnTreePattern ne doivent pas poss´eder de liens ancˆetres/descendants, ce qui est v´erifi´e par l’op´eration O3 et les axiomes A4 et A5 qui testent chacun des liens de l’XPath.

Pour finir, nous pouvons ajouter chaque XPath (O2 ) de mani`ere obligatoire dans le ReturnTreePattern, ce qui est impliqu´e par l’axiome A6 qui reprend l’op´eration O8 du Type Abstrait TP avec la valeur «true».

Afin d’int´egrer les ´el´ements textuels `a notre repr´esentation, nous identifions ces nœud s par une quote ’ ” ’ entourant la chaˆıne de caract`ere `a identifier dans la clause return.

Les op´erations nous permettant de relier les hyperliens ProjectionHyperlink , Explo-rationHyperlink et IfThenElseHyperlink au ReturnTreePattern sont d´etaill´ees dans le Type Abstrait TGV .

3.3.4 Formalisation des Tree Graph Views 83

3.4.4.3 IntermediateTreePattern

Un IntermediateTreePattern ( ou ITP) correspond `a la d´efinition d’une sp´ecialisation d’un nœud d´efini dans un autre TreePattern. La source de ce TreePattern correspond donc `a l’´el´ement projet´e, ainsi nous devons copier le label du nœud du TreePattern d’origine pour cr´eer la source du nouvel IntermediateTreePattern. Comme pour le TreePattern, la racine de cet ITP est d´etermin´e par un XPath d´efini par la d´ecla-ration de la variable dans la requˆete XQuery. De plus, nous pouvons ajouter qu’il existe donc un ExplorationHyperlink entre le nœud d’origine et le nœud source de l’IntermediateTreePattern.

TA 23 IntermediateTreePattern extends TreePattern ITP

Utilise : String Op´erations

O1 createITP String × String → ITP Axiomes : v, r ǫ String;

A1 getVariable (createITP (v, r)) = v

A2 getSource (createITP (v, r)) = createNode (r)

A3 getRoot (createITP (v, r)) = getSource (createITP (v, r))

Un IntermediateTreePattern se construit `a l’aide de deux chaˆınes de caract`eres (O1 ). Les axiomes A1, A2 et A3 permettent de red´efinir les axiomes du TreePattern en fonction de la d´efinition d’un ITP, ainsi nous pouvons voir que la variable de d´efinition est d´etermin´ee par la premi`ere chaˆıne de caract`eres (A1 ), la source de l’ITP est d´efinie par la seconde chaˆıne de caract`eres (A2 ) et enfin, la racine est ´equivalente `a la source (A3 ).

3.4.4.4 AggregateTreePattern

Un AggregateTreePattern (ou ATP ) est un TreePattern repr´esentant un agr´egat de donn´ees. Cette op´eration d’agr´egat s’applique `a l’ensemble des donn´ees filtr´ees par l’ATP . Le contenu de l’AggregateTreePattern correspond `a une reconstruction de r´esultats que l’on pourra alors projeter dans le ReturnTreePattern par l’interm´ediaire d’un GeneralizedHyperlink . Cet hyperlien g´en´eralise le contenu de l’ATP . Nous allons donc introduire le nouveau Type Abstrait AggregateTreePattern. La clause order by permet de traiter de mani`ere globale les donn´ees, de ce fait, cette clause sera repr´esent´ee par un AggregateTreePattern dont la fonction sera un «order by». Comme nous pouvons le constater dans le TA 24, un AggregateTreePattern se construit de la mˆeme mani`ere qu’un ReturnTreePattern `a ceci prˆet que nous lui associons une contrainte d’agr´egation. Cette fonction est d´efinie dans l’op´eration de cr´eation O1, ainsi que dans l’op´eration de d´efinition O2 d´etermin´ee par l’axiome A4. Les axiomes A1, A2 et A3 nous permettent de red´efinir les op´erations getDeclarationName, ge-tRoot et getSource par rapport au constructeur de l’AggregateTreePattern : O1.

TA 24 AggregateTreePattern extends ReturnTreePattern ATP

Utilise : String, C Operations :

O1 createATP String × C → ATP

O2 getATPConstraint ATP → C

Axiomes : s ǫ String; c ǫ C;

A1 getVariable (createATP (s, c)) = s

A2 getRoot (createATP (s, c)) = createNode (s) A3 getSource (createATP (s, c)) = createNode (s) A4 getATPConstraint (createATP (s, c)) = c

3.4.4.5 Conclusion

Nous avons dans cette section ´etudi´e les quatre types de motifs d’arbre nous per-mettant de d´efinir les diff´erents cas possibles d’arbres pour repr´esenter une requˆete XQuery. Les SourceTreePatterns nous permettent de d´efinir un domaine bas´e sur une collection o`u un ensemble de collections sur lequel nous associons un TreePat-tern. Le ReturnTreePattern nous permet de d´efinir la reconstruction de r´esultat sous forme d’un arbre contenant les balises pour bˆatir le document XML, ainsi que des ProjectionHyperlink s d´eterminant les nœuds `a projeter pour ce document. Les IntermediateTreePatterns d´efinissent de nouveaux sous-domaines `a partir d’un Tree-Pattern existant, ils se basent sur un ExplorationHyperlink entre le nœud d’origine et l’ITP. Enfin, les AggregateTreePatterns d´eterminent les op´erations d’agr´egats et les op´erations sur les ensembles r´esultats, ils sont aussi utilis´es pour d´efinir les clauses let. Nous ´etudions maintenant le Type Abstrait TGV qui nous permettra de relier les TreePatterns et les Hyperlink s pour obtenir les repr´esentations g´en´erales d’une requˆete XQuery.