Rapport de Ter Version Final Final

!!
UNIVERSITE PARIS-SUD
INFO
!!
!
M1 TER STAGE
Algorithme efficace pour le

traitement des requtes XPath
!
Huibo SHI
Responsable Kim Nguyen
07/05/2014
ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

HUIBO SHI UNIVERSIT PARIS-SUD INFORMATIQUE
Remerciement!
Je tiens remercier monsieur Kim Nguyen, mon directeur de stage. Il ma accord sa
confiance ds le premier jour. Il ma encourag quand jai rencontr des problmes. Il ma
guid dans mes dmarches tout au long de mon stage. Il est lorigine de nombre dides
et de conseils, dont ce rapport est le reflet. Jai apprci de pouvoir travailler ses cts
durant ces 4 mois.

Rsum !
Le langage XPath est un langage de requte pour les documents XML. Lvaluation
efficace de requte XPath est un problme critique en base de donnes. Le but de mon
stage est limplmentation en OCaml dun algorithme efficace propos par Gotlob, Koch,
Pichler [Efficient algorithm for processing XPath queries]. Jai aussi effectu des
comparaison avec un algorithme alternatif bas sur les automates darbres dvelopp par
Kim Nguyen.!
Mots-cls: XPath; Ocaml

Sommaire!
Remerciement!................................................................................................................................2!
Rsum !..........................................................................................................................................3!
Sommaire!........................................................................................................................................4!
1 Introduction !..............................................................................................................................5!
1.1 XPath et XML!...................................................................................................................................5!
1.2 Problme de lvaluation efficace!.................................................................................................6!
1.3 Introduction du projet Tatoo!.........................................................................................................6!
1.4 Travail de TER!.................................................................................................................................6!
2 Prsentation de XPath !.............................................................................................................7!

2.1 XML vu comme un arbre!...............................................................................................................7!
2.2 XPath!.................................................................................................................................................7!
2.3 Ralisation en OCaml!.....................................................................................................................9!
3 Algorithme de Gottlob, Koch et Pichler !..............................................................................10!

3.1 Prsentation de lalgorithme!.......................................................................................................10!
3.2 Algorithme de traduction de XPath vers QueryTree!...............................................................12!
3.3 Evaluation du QueryTree en temps O(|D|*|Q|)!...................................................................13!
3.3.1 Evaluation des oprateurs en temps O(|D|)!...........................................................................14!
3.3.2 Evaluation des axes XPath!.....................................................................................................14!
3.4 Optimisations !...............................................................................................................................16!

3.4.1 Hash consing!..........................................................................................................................16!
3.4.2 Utilisation des bitvectors pour enlever les tris intermdiaires!................................................18!
4 Exprience !...............................................................................................................................20!
4.1 Correction!.......................................................................................................................................20!
4.2 Lefficacit!.......................................................................................................................................21!
5 Conclusion!...............................................................................................................................24!
6 Bibliographie !...........................................................................................................................25

!
1 Introduction !
1.1 XPath et XML!

XML est un langage de balisage extensible standardis par W3C [1]. Un document
XML est ensemble de donnes. Le langage XPath permet d'identifier les lments dans un
document XML. Il fournit une syntaxe permettant de cibler directement un fragment du
document trait, comme un ensemble de nuds ou un attribut d'un nud en particulier,
de manire relativement simple. Comme son nom le suggre, path signifiant chemin en
anglais, la syntaxe de ce langage ressemble aux chemins d'accs aux fichiers dans un
systme : les lments d'une expression XPath sont en effet spars par des slashs /. !
Voici un exemple de XML fichier et la requte de XPath :!
/descendant::country[child::capital and ancestor::asia]/child::name!
Lvaluation slectionne dabord les descendants partir de la racine, puis ne garde

que ceux qui ont ltiquette country. Ensuite elle filtre le rsultat prcdant en vrifiant des
conditions entre crochet. Enfin elle renvoie les fils des rsultats filtrs qui ont ltiquette
name. Le rsultat est le noeud <name>China</name>. Une requte XPath doit toujours
renvoyer les noeuds sans doublons et lordre du document. !
!
1.2 Problme de lvaluation efficace!

Lalgorithme naf dvaluation de XPath a une complexit en temps O (2 |Q| * |D|),
o |D| est la taille du document et |Q| est la taille de la requte. Comme le volume des
donnes XML devient de plus en plus important, il est ncessaire de faire lvaluation
efficace des requtes XPath. Je vais vous prsenter un algorithme linaire qui est propos
par Georg Gottlob, Christoph Koch, et Reinhard Pichler pour valuer XPath. Il a la
complexit en temps O (|D| * |Q|). Le but du stage est d'implanter cet algorithme en
OCaml.!
1.3 Introduction du projet Tatoo!
Le projet tatoo est un moteur dvaluation XPath dvelopp par Kim Nguyen. Il
ralise lvaluation le requte XPath en temps O(|Q| * |D|), base sur des automates.!
Le projet est crit en OCaml et est disponible ladresse : !
http://git.nguyen.vg/~git/repository/tatoo.git!
1.4 Travail de TER!
Durant ces 4 mois, jai pass 4 tapes pour accomplir ma mission de stage.!
1) 1re tape : lecture de l'article, bibliographie sur XML, comprhension de
l'algorithme sur le papier. (13/01-19/01)!
2) 2me tape : codage de l'algorithme de l'article en OCaml pour fournir une
stratgie dvaluation alternative Tatoo (dont jai rutilis le lexer et parser XPath).
(20/01-02/03)
Difficults: !
I. Comprhension du formalisme de larticle!
II. Larticle manque beaucoup de dtails sur la manire dimplmenter
certaines oprations!
III. Standard XML et XPath trs complexes.!
!
3) - 3me tape : optimisations (03/03-13/04)!

4) - 4me tape : tests et criture du rapport. (14/04-03/05)!

2 Prsentation de XPath !
2.1 XML vu comme un arbre!

Dans ce rapport, nous utilisons un modle de document XML simplifi comme suit.
Tous les objets de la section sont dfinis dans le cadre d'un document XML donn. Dans
notre modle de donnes, un document XML est un arbre. Soit dom l'ensemble de tous les
nuds dans cet arbre, nous utilisons les deux fonctions!
! !
firstchild, nextsibling: dom dom { nil }"
pour reprsenter l'arbre. firstchild renvoie le premier fils d'un nud (s'il y a des fils,
cest--dire, si le nud n'est pas une feuille), et autrement nil. Si n1,. . . , nk sont les fils
d'un nud dans cet ordre, nextsibling (ni) = ni +1 et nextsibling(nk) = nil. Nous
dfinissons les fonctions firstchild-1 et nextsibling-1 comme les inverses des deux
premires fonctions, o nil est renvoy si aucun inverse existe pour un nud donn.!
Chaque noeud a un identifiant unique. Nous allons reprsenter le document XML de
lintroduction comme un arbre, voir ci-dessous :!
regions
1
asia
america
country
lang
11
europe
12
country
name capital lang
country
10
name capital
13
lang
14
15
name capital
2.2 XPath!
XPath utilise des expressions de chemin pour slectionner des ensembles de nuds
dans un document XML. Les noeuds sont choisis en valuant la requte pas pas: !
Reprenons la requte !
/descendant::country[child::capital and ancestor::asia]/child::name!
Le tableau suivant indique les expressions de chemin et des descriptions :!

Path Expression
Description
descendant
Cest un axe de XPath, cest--dire parcours en profondeur
country
Cest un noeud avec tiquette country.
[]
Les descriptions entre crochet sont des conditions
child
C'est un axe de XPath, il envoie le fils de noeud courant
ancestor
C'est un axe de XPath, il envoie les anctres de noeud courant
[child::capital and Filtre le rsultat prcdant et choisit ceux qui ont un fils avec
ancestor::asia]
tiquette capital et ceux qui ont un anctre avec tiquette asia
Donc le rsultat de chaque tape est :!
/descendant::country :
<country lang="Standard Chinese">!
! !
<name>China</name>!
! !
<capital>Beijing</capital>!
! !
</country>!
! !
<country lang="Franais">!
! !
<name>France</name>!
! !
<capital>Paris</capital>!
! !
</country>!
! !
<country lang="Anglais">!
! !
<name>United States</name>!
! !
<capital>Tokyo</capital>!
</country>!
!!
[child::capital and ancestor::asia] :!

! !
<country lang="Standard Chinese">!
! !
<name>China</name>!
! !
<capital>Beijing</capital>!
! !
</country>!
/descendant::country[child::capital and ancestor::asia]/child::name : !

! !
<name>China</name>!

2.3 Ralisation en OCaml!

!
La bibliothque Tatoo sur laquelle on se base fournit un module darbre:!
Naive_tree:!
type node = {
tag : QName.t;
preorder : int;
mutable kind : Tree.NodeKind.t;
mutable data : string;
mutable first_child : node;
mutable next_sibling : node;
mutable parent: node;
}
type t = {
root : node;
size : int;
by_preorder : node array;
}
let first_child _ n = n.first_child

let next_sibling _ n = n.next_sibling
et une reprsentation des requtes XPath:

type axis =
|
|
|
|
|
|
|
|
Self
Child
Descendant of bool
FollowingSibling
Parent
Ancestor of bool
PrecedingSibling
Preceding
Following
type path = single_path list

and single_path = Absolute of step list | Relative of step list
and step = axis * test * expr list
and expr =
| Number of [ `Int of int | `Float of float ]
| String of string
| Fun_call of QName.t * expr list
| Path of path
| Binop of expr * binop * expr
| Unop of unop * expr
Jai rutilis ces modules tel quel dans mon code.

3 Algorithme de Gottlob, Koch et Pichler !
3.1 Prsentation de lalgorithme!

On considrons la requte:!
/child::a /descendant::b [child::c / descendant::d or not (preceding::*)]!
Lalgorithme traduit la requte dans larbre dvaluation (QueryTree) suivant:!
descendant
T(b)
parent
child
T(a)
T(c)
Start
not
dom
ancestor
following
T(d)
! Supposons quon a un fichier XML trs simple :!

<#document><a><c/><d/><e><f/></e></a> </#document>!
qui correspond larbre:!
#document
a
b
c
e
d
On value le QueryTree par un parcours rcursif en profondeur dabord!

10
Start : <#document><a><c/><d/><e><f/></e></a></#document>!
child(Start) : <a><c/><d/><e><f/></e></a>!
Tag(a) : <a><c/><d/><e><f/></e></a>!
Inter(child(Start), Tag(a)) : <a><c/><d/><e><f/></e></a>!
descendant(child(Start) Tag(a)) : <c/><d/>!
!
<c/>!
<d/>!
<e><f/></e>!
<f/>!
Tag(b) : <c/><d/>!
descendant(child(Start) Tag(a)) Tag(b) : <c/><d/> -!
Tag(d) : <d/>!
ancestor(Tag(d)) : <c/><d/> !
!
<a><c/><d/><e><f/></e></a>!
<#document><a><c/><d/><e><f/></e></a></#document>!
Tag(c) : <c/>!
Tag(c) ancestor(Tag(d)) : !
parent(Tag(c) ancestor(Tag(d))) : -!
Tag(*) : <a><c/><d/><e><f/></e></a>!
!
<c/><d/>!
<c/>!
<d/>!
<e><f/></e>!
<f/>!
following(Tag(*)) : <d/>!
!
<e><f/></e>!
<f/>!
Dom : <#document><a><c/><d/><e><f/></e></a></#document>!
!
<a><c/><d/><e><f/></e></a>!
<c/><d/>!
<c/>!
<d/>!
<e><f/></e>!
<f/>!
Dom - following(Tag(*)) : !
!
<c/>!

11
<c/><d/>!
<a><c/><d/><e><f/></e></a>!
<#document><a><c/><d/><e><f/></e></a></#document>-!
:!
!
<c/>!
<c/><d/>!
<a><c/><d/><e><f/></e></a>!
<#document><a><c/><d/><e><f/></e></a></#document>-!
:!
!
<c/><d/>!
donc le rsultat de lvaluation : <c/><d/>.!

Lefficacit de lalgorithme repose sur deux aspects cl :!
-
Traduire une requte XPath de taille |Q| en un QueryTree de taille |Q|!
Evaluer le QueryTree de taille |Q| en faisant au plus |D| oprations par noeud
du QueryTree.!
3.2 Algorithme de traduction de XPath vers QueryTree!
La traduction est donne dans larticle par un ensemble dquations rcursives:!
S ::t[e] (N0)
:=
(N0) T (t) 1e
S /::t[e] (N0)
:=
({root}) T (t) 1e
S /::t[e] (N0)
:=
(S(N0)) T (t) 1e
S ::t[e]
:=
-1(T (t) 1e)
S ::t[e]/
:=
-1(S T (t) 1e)
S /
:=
dom
(S)
root
1 e1 and e2
:=
1 e1 1 e2
1 e1 or e2
:=
1 e1 1 e2
1 not(e)
:=
dom - 1
:=
o N0 est un ensemble de nuds du rsultat courant. Initialement N0 ne contient que la

racine. Un requte $ value comme S $ (N0).!
Il nous a suffit de dfinir un type de donnes pour le QueryTree et une fonction
rcursive de traduction qui simule les quations:!
!
!

12
type QueryTree_desc = Binop of op * QueryTree * QueryTree

| Axis of Xpath.Ast.axis * QueryTree
| Start
| Dom
| Tag of QNameSet.t * Tree.NodeKind.t
and op = Union | Inter | Diff
and QueryTree = {
mutable desc : QueryTree_desc;
mutable id : int;
mutable hash : int;
}
let compile_xpath p = match p with

| [] -> assert false
| [p] -> compile_single_path p
| p::r -> List.fold_left (fun acc p -> Binop (Union , acc,
compile_single_path p )) (compile_single_path p) r
let rec compile_single_path p =

let open Xpath.Ast in
match p with
| Absolute p | Relative p -> compile_step_list (List.rev p)
and compile_step_list p =
match p with
| [] -> Start
| (a,(test,kind),el) :: r ->
let qtree = compile_step_list r in
let res = Binop ( Inter, Axis (a,qtree),Tag (test,kind) ) in
List.fold_left (fun acc e ->
Binop(Inter, acc, compile_expr e)) res el
Les champs id et hash du type queryTree sont utilis pour une optimisation que lon
prsente dans la section 3.4.1. !
tant donn une requte Q, elle peut tre rcrite en une expression algbrique E sur
les oprations , , , '-', et Tag(*) en utilisant la fonction S en temps O (|Q|).!
3.3 Evaluation du QueryTree en temps O(|D|*|Q|)!
Le code principal dvaluation du QueryTree est donn ci-dessous:!
Paramtres: larbre xml [tree], un QueryTree [qt], un noeud dpart [s]!
Retour: lensemble de noeuds correspondent au qt!
Fonction: eval_QueryTree

13
let rec eval_QueryTree tree start q =

match q with
| Start -> start
| Dom -> all_nodes tree
| Tag (t,k) -> element_by_tag tree t k
| Axis (a,q1) -> let ls = eval_QueryTree tree start q1 in
eval_axis tree ls a
| Binop (op,q1,q2)-> begin
let ls1 = eval_QueryTree tree start q1 in
let ls2 = eval_QueryTree tree start q2 in
match op with
| Union -> union_list tree ls1 ls2
| Inter -> inter_list tree ls1 ls2
| Diff -> diff_list tree ls1 ls2
end
Pour valuer le QueryTree en temps O(|D|*|Q|), if faut !

a) valuer les oprateurs , , '-', et Tag(*) en temps O(|D|).!
b) valuer les axes en temps O(|D|).!
3.3.1 Evaluation des oprateurs en temps O(|D|)!

Il nous a suffit dcrire les fonctions rcursives pour faire lunion, lintersection et la
diffrence de deux listes de noeuds tries sans doublon. Pour Tag(X) on effectue un
parcours pour collecter tous les noeuds ayant ltiquette X. Le code partiel :
let rec union_list t l1 l2 =
match l1,l2 with
| [],l2 -> l2
| l1, [] -> l1
| h1::ll1, h2::ll2 -> if (comp_node t h2 h1) then h2 :: (union_list t l1
ll2)
else if (comp_node t h1 h2) then h1::(union_list t ll1 l2)
else h1 ::(union_list t ll1 ll2)
o la fonction comp_node envoie true quand le noeud h1 apparait avant le noeud h2

dans le document, et false sinon.!
3.3.2 Evaluation des axes XPath!

Les axes XPath : self, child, parent, descendant, ancestor, descendant-or-self, ancestor-orself, following, preceding, following-sibling et preceding-sibling sont les relations binaires
dom*dom. On dfinit self := {x, x | x dom}. Les autres axes sont dfinis par les relations
primitives , firstchild et nextsibling, comme suite :!
child := firstchild.nextsibling*
parent := (nextsibling -1 )* . firstchild -1

14
descendant := firstchild.(firstchild nextsibling)*

ancestor := (firstchild -1 nextsibling -1)*.firstchild -1
descendant := descendant self
ancestor-or-self := ancestor self
following := ancestor-or-self.nextsibling.nextsibling*.descendant-or-self
preceding := ancestor-or-self.nextsibling -1.(nextsibling -1)*.descendant-or-self
following-sibling := nextsibling.nextsibling*
preceding-sibling := (nextsibling -1)*.nextsibling -1
Larticle donne la fonction ci-dessous pour valuer les axes mis sous cette forme :!
fonction eval(R1 Rn)*(S) begin!
! S := S;!
! while (il y a un lment x dans S) do!
! !
ajoute {Ri(x) | 1 i n, Ri(x) Nil, Ri(x) S} la fin de S;!
! return S;!
! end; !
fonction eval (S) := evalE() (S).!
fonction eval self (S) := S.!
fonction eval e1.e2 (S) := eval e2 (eval e1(S))!
fonction evalR (S) := { R(x) | x S}.!
fonction eval12 (S) := eval1 (S) eval2 (S).!
o S dom est un ensemble de noeuds dun document XML, e1 et e2 sont des
expressions rgulires, R, R1, , Rn sont des relations primitives, 1 et 2 sont des axes, et
est un axe autre que self.!
Selon les rgles prcdentes, maintenant on va raliser la fonction . On dfini h
(type de Hashtbl) et q (type de Queue) pour stocker les donnes pendant le processus de
la fonction . Dans ce cas , h est quivalent de S, q permet dvaluer les Ri dans lordre
corresponds dans h. On choisi la structure de Queue car il est FIFO. A la fin, on transmet h
type de List tri afin de maintenir linterface unifie. Le code dtaill dans le tableau cidessous :!

15
let rec eval_star tree ls lr =

let h = Hashtbl.create 17 in
let q = Queue.create () in
List.iter ( fun e -> Queue.add e q ) ls;
while not (Queue.is_empty q ) do
let n = Queue.pop q in
if not (Hashtbl.mem h n) then begin
Hashtbl.add h n ();
List.iter ( fun r -> let m = eval_relation tree r n in
if m != Naive_tree.nil && not (Hashtbl.mem h m ) then begin
Queue.add m q; end
) lr
end
done;
let l = Hashtbl.fold (fun k _ acc -> k::acc) h [] in
List.sort (compare_node tree) l
Grace la fonction eval_star, nous pouvons raliser la fonction eval_axis trs

simplement. Dans cette fonction eval_move correspond eval prsent plus haut. Les
codes partiels:
let rec eval_axis tree ls a =
match a with
Self -> ls
| Child -> let lfc = eval_move tree ls Firstchild in
eval_star tree lfc [Nextsibling]
| Descendant c -> let lfc = eval_move tree ls Firstchild in
let ls2 = eval_star tree lfc [Firstchild;Nextsibling] in
if not c then ls2
else union_list tree ls2 ls
Cependant, pour garder le rsultat dans lordre et sans doublons, on a du utiliser la

fonction List.sort, ce qui ajoute la complexit O(log(|D|)). Donc maintenant on a
lvaluation daxe en temps O(|D|*log(|D|)), jai implment 2 optimisations pour
garantir une complexit O(|D|) et viter les calculs superflus en pratique.!
3.4 Optimisations !
3.4.1 Hash consing!
Etant donn une requte (par exemple /child::a [child::c/descendant::b or

child::a/descendant::b]),
son arbre de QueryTree est comme suit. Remarquons quil y a

16
deux fois T(b) ancestor et T(a). !
T(a)
child
parent
parent
Start
ancestor
T(c)
ancestor
T(a)
T(b)
T(b)
En fait dans des requtes ralistes il y a souvent des portions de QueryTree qui se
rptent.!
Lide est de donner un numro chaque lment de larbre de QueryTree. Si
deux lments ont la mme signification, ils ont la mme numro. Voir la figure cidessous, cest un arbre de QueryTree avec identificateur. La deuxime apparition de T(a) a
numro 2 aussi, pareil pour T(b) ancestor. On cre donc une reprsentation de larbre
sous forme de DAG avec partage maximal.!
T(a)
child
1
12
11
parent 8
parent 10
Start
T(c)
6
ancestor
5
T(a)
ancestor
T(b)
T(b)
Lide est de stocker les rsultats de lvaluation intermdiaires du QueryTree

17
dans une table de hachage. Avant dvaluer un noeud du QueryTree, nous le cherchons
dans le table de hachage, sil existe, nous retournons directement le rsultat. Sinon nous
stockons le rsultat dans le table. Dautre part, afin dutiliser une table de hachage plus
approprie, Nous allons dfinir notre propre fonction de hachage la place de Hashtable
standard. Les codes partiels sont ci-dessous:!
let rec hash q =
if q.hash != -1 then q.hash
else match q.desc with
Dom -> 1
| Start -> 3
| Tag(s,_) -> 5 + 17*QNameSet.hash s
| Axis(a,q) -> 7 + 17 * Hashtbl.hash a + 23* hash q
| Binop(op,q1,q2) -> 11 + 17* Hashtbl.hash op + 23* hash q1 + 27*
hash q2
!
3.4.2 Utilisation des bitvectors pour enlever les tris intermdiaires!
Souvenons nous que nous avons utilis la fonction standard List.sort pour garder
les noeuds dans un ordre du document dans la fonction eval_axis, a ajoute une
complexit de O(log|D|), donc maintenant notre algorithme a la complexit O (|D|*|Q|
*log(|D|)), ce qui est mieux que lalgorithme naf mais pas optimal. Nous voulons la
complexit O (|D|*|Q|) et viter les doublons. Nous devons prserver lordre pendant
lvaluation dun axe. Pour raliser a, nous allons crire des fonctions ddies pour
chaque axe la place de la fonction gnrique eval_star et utiliser un bitvector pour
stocker les noeuds intermdiaires . Le code extrait est:
let get_descendant tree v =
let rec aux n acc =
if n == Naive_tree.nil then acc
else let n1 = Naive_tree.first_child tree n in
let j = Naive_tree.preorder tree n in
Bitvector.set acc j true;
incr node_compteur;
let acc1 = aux n1 acc in
let n2 = Naive_tree.next_sibling tree n in
aux n2 acc1
in
let v0 = Bitvector.create (Naive_tree.size tree) in
for i = 0 to (Bitvector.length v)-1 do
if Bitvector.get v i then
let n = Naive_tree.by_preorder tree i in
let n1 = Naive_tree.first_child tree n in
let _ = aux n1 v0 in ()
done;
v0
18
Lordre de noeud dans un arbre correspond une position dans le bitvector. Nous
mettons un lment de bitvector 1 si et seulement si le noeud correspondant est dans le
rsultat valu. Grace au bitvector, les rsultats valus par laxe sont toujours ordonns,
nous avons vit de renverser chaque fois le rsultat et vit de fusionner deux listes
tries que nous avons vu dans lexemples prcdentes. De plus un bitvector une taille de
O (|D|). Nous allons comparer le rsultat defficacit en diffrents moyens dans la
prochaine section. !

19
4 Exprience !
Dans cette section, nous allons dabord tester la correction du programme. Ensuite,
nous allons valuer son efficacit. Mon programme est crit entirement en OCaml (628
lignes) et est maintenu avec le systme de version Git.!
4.1 Correction!
Nous avons test notre programme sur un jeu de test du W3C[1]. La figure cidessous est une capture dcran dexcution de mon programme. Si le rsultat est OK,
mon programme renvoie les noeuds attendus, sinon le script affiche Problem.!
Comme on le voit, tous les rsultats sont OK, cest--dire que mon programme
renvoi des rsultats corrects.

20
4.2 Lefficacit!
Dans le tableau suivant, nous allons voir les diffrences entre les rsultats de
lvaluation non optimis et de lvaluation optimise. Jai test par un fichier XML avec
1151 nombres de noeuds. Jai compar des nombres de noeuds traverses et les temps
dexcution. videmment, lvaluation non optimise prend beaucoup plus de temps que
lvaluation optimise. On remarque que les 2 optimisations (Hash consing & bitvector)
sajoutent. Comme chaque fonction List.sort ajoute une complexit de O (log (|D|)),
souvenons nous que nous avons remplac la fonction List.sort par des fonctions
ddies(voir 3.4.2). Dautre part, nous avons minimis larbre de QueryTree, et stock les
rsultats dvaluation dans notre propre table de hachage, donc quand nous rencontrons
un noeud du QueryTree valu, nous renvoyons directement le rsultat. Cest--dire si
larbre de QueryTree avait la rplication, nous valuerions moins de noeuds, sinon deux
moyens de lvaluation valuent de mme noeuds. Du coups, mon programme est
efficace.!
Query
valuation
non optimise
optimis par
hash consing
noeu
ds
temps!
(ms)
noeu
ds
temps!
(ms)
temps!
(ms)
A1 /site/closed_auctions/closed_auction/
annotation/description/text/keyword
271
16,3600
271
0,3381
4839,1 0,2282
7170,2
A2 //closed_auction//keyword
6540 10,7250 5385
0,5250
2042,9 0,1891
5672,6
A3 /site/closed_auctions/closed_auction//
keyword
1950 10,4599 1950
0,3080
3395,7 0,1469
7122,1
A4 /site/closed_auctions/
closed_auction[annotation/description/
text/keyword]/date
1376 15,3980 1376
0,4649
3312,0 0,2508
6139,2
A5 /site/closed_auctions/
closed_auction[descendant::keyword]/
date
1364 10,7541 1364
0,2539
4235,3 0,1721
6247,4
A6 /site/people/person[profile/gender and
profile/age]/name
2342 17,4220 1187
0,3679
4735,8 0,2251
7740,8
A7 /site/people/person[phone or
homepage]/name
2365 14,5671 1210
0,3512
4147,9 0,1950
7469,3
A8 /site/people/person[address and
(phone or homepage) and (creditcard or
profile)]/name
5818 22,5239 1198
0,4640
4854,7 0,2680
8405,0

gain
de
temps!
(%)
optimi gain de
s par temps!
bitvect (%)
or
21
Query
valuation
non optimise
optimis par
hash consing
noeu
ds
noeu
ds
temps!
(ms)
temps!
(ms)
B1 /site/regions/*/item[parent::namerica or
parent::samerica]/name
2834 16,3491 1679
0,3741
4370,5 0,2000
8173,2
B2 //keyword/ancestor::listitem/text/
keyword
4930 14,0209 4914
0,4940
2838,2 0,2222
6309,9
B3 /site/open_auctions/open_auction/
bidder[following-sibling::bidder]
1337 10,0980 1322
0,2210
4568,9 0,2060
4902,1
B4 /site/open_auctions/open_auction/
bidder[preceding-sibling::bidder]
1346 11,1518 1331
0,2258
4939,2 0,2060
5413,6
B5 /site/regions/*/item[following::item]/
name
4613 15,0800 3447
0,4759
3168,8 0,2851
5288,5
B6 /site/regions/*/item[preceding::item]/
name
5235 16,1939 4069
0,4768
3396,1 0,2620
6180,3
B7 //person[profile/@income]/name
5785 13,6461 5785
1,0698
1275,6 0,1740
7840,5
B8 /site/open_auctions/
open_auction[bidder and not(bidder/
preceding-sibling::bidder)]/interval
4778 17,6282 2423
0,2151
8197,1 0,1860
9479,3
open_auction[(not(bidder/
following::bidder) or not(bidder/
preceding::bidder)) or (bidder/
following::bidder and bidder/
preceding::bidder)]/interval
24315 43,6721 8632
0,6270
6964,8 0,3169 13782,9
open_auction[(not(bidder/
following::bidder) or not(bidder/
preceding::bidder)) and (bidder/
following::bidder and bidder/
preceding::bidder)]/interval
23108 45,2900 7425
0,4830
9376,1 0,2630 17222,1
B11 //open_auction/bidder/../bidder/../
bidder/../interval
8385 18,2562 4890
0,6151
2967,9 0,2570
7103,2
B12 //item/@id/../@id/../@id/../@id/../
name
10134 22,0189 5487
0,5519
3989,4 0,2489
8846,2
B13 //keyword/ancestor::parlist/
descendant::keyword/ancestor::parlist/
descendant::keyword/ancestor::parlist/
descendant::keyword
5703 18,1561 5635
0,5469
3319,6 0,2880
6304,0
temps!
(ms)
gain
de
temps!
(%)
optimi gain de
s par temps!
bitvect (%)
or
Pour expliquer la relation entre la taille de QueryTree et le temps dexcution, nous

avons fait trois digrammes selon diffrentes tailles de fichiers XML. On voit que la
22
premire indique la relation est linaire, comme nous lavons prvu.!
temps
dexcution (ms)
requete sur la taille du fichier de 1151

0,3
0,225
0,15
0,075
0
12,5
25
37,5
50
taille de QueryTree
!
temps dexcution (ms)
requete sur la taille du fichier de 254301 noeuds

90
B13
67,5
45
22,5
0
12,5
25
37,5
50
taille de QueryTree
!
requete sur la taille du fichier de 2535588 noeuds
temps dexcution (ms)
6000
4500
3000
1500
0
B13
12,5
25
37,5
taille de QueryTree
50
Le deuxime et le troisime rsultats ne sont pas linaires, ce qui nous permet de

trouver un bug dans le code de bitvector. Aprs correction du bug, le temps pour B13
redevient linaire.

23
5 Conclusion!
Pendant mon stage, jai tudi larticle [Efficient Algorithms for Processing XPath
Queries] [2], appris lalgorithme sur larticle et russi implmenter cet algorithme en
temps O(|D|*|Q|) en OCaml.!
Grace ce stage, jai tout dabord approfondi la connaissance de programmation
fonctionnelle, jai appris beaucoup de techniques de programmation, par exemple
lutilisation de fonction auxiliaire, la rcursion terminale, etc. Jai aussi approfondi la
connaissance sur les algorithmes que jai indiqu dans ce rapport. Pour raliser ces
algorithmes, jai lu beaucoup de fois larticle, jai fait des dessins par pas aider
comprendre. Ensuite, ce que minfluence beaucoup, cest que comment on construit un
gros projet de petit petit, surtout lanalyse structural de programme. Si lalgorithme
serait lme de programme, la structure est le squelette de programme. De plus, grce
Kim Nguyen, jai reconnait le processus doptimisation. Aprs la premire optimisation, il
me donne lautre lide doptimisation, et nous vrifions si a marche mieux ou pas, et la
suite Dans nos efforts, le programme marche plus en plus efficacement. Enfin, jai appris
lutilisation de quelques outils comme git, cela rend mon travail plus facile et efficace.!
Par la suite, je vais continuer optimiser mon programme, en particulier essayer de
diminuer la consommation en mmoire.!
!
!

24
6 Bibliographie !
[1] World Wide Web Consortium. XPath Recommendation.
http://www.w3c.org/TR/xpath/.
[2] Georg Gottlob, Christoph Koch, Reinhard Pichler.Efficient Algorithms for Processing
XPath Queries 2002

25

Rapport de Ter Version Final Final

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Rapport de Ter Version Final Final

Hochgeladen von

Copyright:

Verfügbare Formate

!!

Algorithme efficace pour le

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

2 Prsentation de XPath !.............................................................................................................7!

3 Algorithme de Gottlob, Koch et Pichler !..............................................................................10!

3.4 Optimisations !...............................................................................................................................16!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

1.1 XPath et XML!

Lvaluation slectionne dabord les descendants partir de la racine, puis ne garde

1.2 Problme de lvaluation efficace!

3) - 3me tape : optimisations (03/03-13/04)!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

2.1 XML vu comme un arbre!

firstchild, nextsibling: dom dom { nil }"

name capital lang

Le tableau suivant indique les expressions de chemin et des descriptions :!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

Cest un axe de XPath, cest--dire parcours en profondeur

Cest un noeud avec tiquette country.

Les descriptions entre crochet sont des conditions

C'est un axe de XPath, il envoie le fils de noeud courant

C'est un axe de XPath, il envoie les anctres de noeud courant

<country lang="Standard Chinese">!

[child::capital and ancestor::asia] :!

<country lang="Standard Chinese">!

/descendant::country[child::capital and ancestor::asia]/child::name : !

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

2.3 Ralisation en OCaml!

La bibliothque Tatoo sur laquelle on se base fournit un module darbre:!

let first_child _ n = n.first_child

et une reprsentation des requtes XPath:

type path = single_path list

Jai rutilis ces modules tel quel dans mon code.

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

3 Algorithme de Gottlob, Koch et Pichler !

3.1 Prsentation de lalgorithme!

Lalgorithme traduit la requte dans larbre dvaluation (QueryTree) suivant:!

! Supposons quon a un fichier XML trs simple :!

On value le QueryTree par un parcours rcursif en profondeur dabord!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

donc le rsultat de lvaluation : <b><c/><d/></b>.!

Traduire une requte XPath de taille |Q| en un QueryTree de taille |Q|!

-1(T (t) 1e)

-1(S T (t) 1e)

o N0 est un ensemble de nuds du rsultat courant. Initialement N0 ne contient que la

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

type QueryTree_desc = Binop of op * QueryTree * QueryTree

let compile_xpath p = match p with

let rec compile_single_path p =

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

let rec eval_QueryTree tree start q =

Pour valuer le QueryTree en temps O(|D|*|Q|), if faut !

3.3.1 Evaluation des oprateurs en temps O(|D|)!

o la fonction comp_node envoie true quand le noeud h1 apparait avant le noeud h2

3.3.2 Evaluation des axes XPath!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

descendant := firstchild.(firstchild nextsibling)*

ajoute {Ri(x) | 1 i n, Ri(x) Nil, Ri(x) S} la fin de S;!

ALGORITHME EFFICACE POUR LE TRAITEMENT DES REQUTES XPATH!

let rec eval_star tree ls lr =