XPath Intro 1 Notation 2 Exemples 3 Utilisations de XPath 4 Conclusion et Evolutions

Intro XPath est une syntaxe (non XML) pour désigner une portion d'un document XML. Initialement créé pour fournir une syntaxe et une sémantique aux fonctions communes à XPointer et XSL, XPath a rapidement été adopté par les développeurs comme un petit langage d'interrogation.

XPath signifie XML Path Language : il utilise une syntaxe non-XML permettant de manière souple d'adresser (en pointant vers) différentes parties d'un document XML. Il sert également à tester la correspondance de nœuds dans un document avec un schéma donné. XPath est principalement utilisé dans XSLT. XPath utilise une notation à cheminement (comme dans les URLs) pour parcourir la structure hiérarchique d'un document XML. Il s'agit d'une syntaxe non XML, donc elle peut être employée dans des URI et des valeurs d'attribut XML.

1 Notation Une expression XPath caractéristique est un chemin de localisation constitué par une suite d'élements ou d'attributs séparés par une barre de fraction (« / »), ressemblant au chemin dans un système de fichiers. XPath fournit des fonctions intégrées, permet d'utiliser des variables, de définir des filtres et de spécifier des axes.

XPath : un langage pour interroger les fichiers XML La spécification XPath est assez simple: Des notions qui permettent de composer une expression qui localisera, dans le document XML, une simple valeur, ou un ensemble de nœuds. Une expression XPath définit un (ou une combinaison de) chemin de localisation. Un chemin est une représentation d’un parcours de l’arbre XML jusqu’à l’information désirée. Le parcours peut être absolu, c’est à dire qu’il part de la racine du document, ou relatif (un nœud sert de point de départ). Le chemin de localisation est composé d’une ou plusieurs étapes de localisation.

Chaque étape est découpée en trois parties : 1 - un axe, 2 - un test de nœud, 3 - et un ou plusieurs prédicats (que l’on peut schématiser par la syntaxe "axe::test[predicat]"). 1 - L’axe indique le type d'information qui sera sélectionnée, relativement au nœud courant ou depuis la racine. C’est-à-dire qu’il indique la direction dans laquelle on va démarrer le parcours: les axes fils, descendant, parent, ancêtre, voisin, espace de noms, attribut permettent de sélectionner un premier sous-ensemble de nœuds. Par exemple, child:: est la syntaxe non-abrégée de l'axe des enfants du nœud courant. Dans beaucoup d'expressions XPath, quand l'axe n'est pas précisé, il s'agit implicitement de l'axe des enfants (child::). Un autre axe largement utilisé est celui des attributs, représenté avec le caractère 'arobase' ("@").

2 - Un nœud de test définit les éléments ou attributs à désigner 2 - Un nœud de test définit les éléments ou attributs à désigner. Le test de nœud diminue le précédent résultat en ne sélectionnant que les nœuds qui répondent positivement au test. Par exemple /descendant::personne est un chemin de localisation qui ne contient qu’une seule étape de localisation. Elle part de la racine (chemin absolu commençant par un /), utilise l’axe descendant pour ne sélectionner que les nœuds situés sous la racine, et applique une nouvelle restriction à cet ensemble, en ne gardant que les éléments dont le nom de balise est "personne".

3 - La troisième et dernière partie de l’étape de localisation permet de raffiner une nouvelle fois en appliquant des prédicats: Les prédicats sont des expressions plus complexes ; ils sont utilisés pour filtrer ou exclure certains nœuds. Les prédicats sont écrits entre crochets (« [ », « ] »):par exemple : le premier nœud de l’ensemble, celui qui contient un attribut nom valant «dupond"(/descendant::personne[@nom="dupond"]), etc.…Le caractère / permet d’enchaîner plusieurs étapes de localisation.

Cette technologie peut devenir rapidement compliquée Cette technologie peut devenir rapidement compliquée. C’est la raison pour laquelle, XPath définit une notation abrégée pour certains noms d’axe et pour certains tests (.. pour l’axe parent, @ pour l’axe attribut, personne[1] pour personne[position()=1] , etc.…). Ainsi, l’expression : /descendant::personne[position()=1]/descendant-or-self:: node()/child::voiture[attribute::couleur="rouge"] peut s’écrire de façon plus concise : //personne[2]//voiture[@couleur="rouge"]

Enfin, une panoplie de fonctions manipulant les ensembles de nœuds, les chaînes de caractères, les nombres ou encore les booléens complète les concepts évoqués précédemment. XPath offre donc un moyen de concentrer dans une seule expression un parcours simple ou extrêmement complexe de l’arbre XML, permettant de localiser les données recherchées. Cependant, certaines requêtes restent impossibles à formuler. XPath 2 (document de travail du W3C proche du statut de recommandation) apportera alors une solution à ce problème marginal.

Considérons le document XML suivant : 2 Exemples Considérons le document XML suivant : <?xml version="1.0"?> <racine> <journal nom=« lemonde" site=« www.lemonde.fr"> <article nom="XPath" /> </journal> </racine>

Expression XPath Résultat / sélectionne un nœud "fictif", dit root element, qui englobe tout le document sauf <?xml version="1.0"?> /root sélectionne le nœud vide, puisqu'il n'y a pas d'élément "root" (mais "racine") //article sélectionne tous les éléments "article" du document où qu'ils soient /racine/journal sélectionne l'unique élément « journal" puisqu'il est ici le seul fils de "racine" portant ce nom //article[@nom="XPath"] sélectionne tous les éléments "article" du document où qu'ils soient, dont l'attribut "nom" contient le text "XPath"

Toutes ces expressions XPath sont absolues, c'est-à-dire qu'elles donnent le même résultat quel que soit le contexte. Les expressions suivantes sont relatives. Si le contexte courant est l'unique élément « journal", elles donnent : Expression XPath Résultat article sélectionne l'élément "article" racine ne sélectionne rien, vu le contexte ../racine sélectionne l'élément "racine", puisqu'il est parent de l'élément courant Le résultat de ces sélections dépendra de la nature de la tâche. - en affichage : ce sera la valeur textuelle, propre à chaque type d'élément, qui apparaîtra. Si plusieurs nœuds sont sélectionnés, comme pour //article, seul le premier est concerné. - en sélection, il se comportera comme un pointeur sur lequel d'autres requêtes XPath pourront être effectuées.

3 Utilisations de XPath XPath est toujours utilisé comme langage de requêtes dans les bases de données XML, en général en concurrence avec XQuery. XPath est utilisé comme langage d'expression des règles dans Schematron , et partiellement aussi dans XML Schema. XPath peut être utilisé depuis la ligne de commande, ici avec la commande xpath qui vient du module Perl XML::XPath. Ici, on cherche les URL des articles dans un flux de syndication Atom : $ xpath -e '//link[@rel="alternate"]/@href' feed.atom Autre exemple, avec xfind pour chercher des fichiers (XML servant à modéliser les attributs du fichier) : $ ./find -xpath '/bin/*[@size > /bin/bash/@size]' /bin/ipv6calc /bin/rpm

Exemples Exemple 1 La base de la syntaxe XPATH est semblable à celle de l'adressage du système de fichiers. Si le chemin commence par '/', alors il représente un chemin absolu vers l'élément requis.

/AAA Equivalent à /child::AAA Sélectionne l'élément racine AAA      <AAA>           <BBB/>           <CCC/>           <BBB/>           <BBB/>           <DDD>                <BBB/>           </DDD>           <CCC/>      </AAA>

/AAA/CCC Equivalent à /child::AAA/child::CCC Sélectionne tous les éléments CCC qui sont enfants de l'élément racine AAA <AAA>           <BBB/>           <CCC/>           <BBB/>           <BBB/>           <DDD>                <BBB/>           </DDD>           <CCC/>      </AAA>

/AAA/DDD/BBB Sélectionne tous les éléments BBB qui sont enfants de DDD, qui sont enfants de l'élément racine AAA    <AAA>           <BBB/>           <CCC/>           <BBB/>           <BBB/>           <DDD>                <BBB/>           </DDD>           <CCC/>      </AAA>

Exemple 2 Si le chemin commence par '//', alors tous les éléments du document qui correspondent au critère qui suit sont sélectionnés.

//BBB Sélectionne tous les éléments BBB      <AAA>           <BBB/>           <CCC/>           <BBB/>           <DDD>                <BBB/>           </DDD>           <CCC>                <DDD>                     <BBB/>                     <BBB/>                </DDD>           </CCC>      </AAA>

//DDD/BBB Sélectionne tous les éléments BBB qu sont enfants de DDD      <AAA>           <BBB/>           <CCC/>           <BBB/>           <DDD>                <BBB/>           </DDD>           <CCC>                <DDD>                     <BBB/>                     <BBB/>                </DDD>           </CCC>      </AAA>

Exemple 3 L'étoile * sélectionne tous les éléments localisés par ce qui la précède dans le chemin

/AAA/CCC/DDD/* Sélectionne tous les éléments inclus dans les éléments /AAA/CCC/DDD           <AAA>           <XXX>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </XXX>           <CCC>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </CCC>           <CCC>                <BBB>                     <BBB>                          <BBB/>                     </BBB>                </BBB>           </CCC>      </AAA>

/*/*/*/BBB Sélectionne tous les éléments BBB qui ont trois ancêtres      <AAA>           <XXX>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </XXX>           <CCC>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </CCC>           <CCC>                <BBB>                     <BBB>                          <BBB/>                     </BBB>                </BBB>           </CCC>      </AAA>

//* Sélectionne tous les éléments      <AAA>           <XXX>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </XXX>           <CCC>                <DDD>                     <BBB/>                     <BBB/>                     <EEE/>                     <FFF/>                </DDD>           </CCC>           <CCC>                <BBB>                     <BBB>                          <BBB/>                     </BBB>                </BBB>           </CCC>      </AAA>

Exemple 4 Une expression entre crochets peut spécifier plus précisément un élément. Un nombre entre crochets donne la position d'un élément dans le jeu sélectionné. La fonction last sélectionne le dernier élément du jeu

/AAA/BBB[1] Sélectionne le premier élément BBB, fils de l'élément racine AAA      <AAA>           <BBB/>           <BBB/>           <BBB/>           <BBB/>      </AAA>

/AAA/BBB[last()] Sélectionne le dernier élément BBB, fils de l'élément racine AAA      <AAA>           <BBB/>           <BBB/>           <BBB/>           <BBB/>      </AAA>

Exemple 5 Les attributs sont spécifiés par le préfixe @.

//@id Sélectionne tous les attributs id     <AAA>           <BBB id = "b1" />           <BBB id = "b2" />           <BBB name = "bbb"/>           <BBB/>      </AAA> //BBB[@id] Sélectionne tous BBB qui ont un attribut id      <AAA>           <BBB id = "b1"/>           <BBB id = "b2"/>           <BBB name = "bbb"/>           <BBB/>      </AAA>

//BBB[@name] //BBB[@*] Sélectionne tous BBB qui ont un attribut name      <AAA>           <BBB id = "b1"/>           <BBB id = "b2"/>           <BBB name = "bbb"/>           <BBB/>      </AAA> //BBB[@*] Sélectionne tous BBB qui ont un attribut      <AAA>           <BBB id = "b1"/>           <BBB id = "b2"/>           <BBB name = "bbb"/>           <BBB/>      </AAA>

Exemple 6 La fonction count() compte le nombre d'éléments sélectionnés.

//*[count(BBB)=2] Sélectionne les éléments ayant deux enfants BBB      <AAA>           <CCC>                <BBB/>                <BBB/>                <BBB/>           </CCC>           <DDD>                <BBB/>                <BBB/>           </DDD>           <EEE>                <CCC/>                <DDD/>           </EEE>      </AAA>

Exemple 7 La fonction name() retourne le nom de l'élément, la fonction start-with retourne vrai si la chaîne du premier argument commence par celle du deuxième et la fonction contains retourne vrai si la chaîne du premier argument contient celle du deuxième

//*[name()='BBB']   <AAA>           <BCC>                <BBB/>                <BBB/>                <BBB/>           </BCC>           <DDB>                <BBB/>                <BBB/>           </DDB>           <BEC>                <CCC/>                <DBD/>           </BEC>      </AAA> //*[starts-with(name(),'B')]      <AAA>           <BCC>                <BBB/>                <BBB/>                <BBB/>           </BCC>           <DDB>                <BBB/>                <BBB/>           </DDB>           <BEC>                <CCC/>                <DBD/>           </BEC>      </AAA> //*[contains(name(),'C')] <AAA>           <BCC>                <BBB/>                <BBB/>                <BBB/>           </BCC>           <DDB>                <BBB/>                <BBB/>           </DDB>           <BEC>                <CCC/>                <DBD/>           </BEC>      </AAA>

Exemple 8 La fonction string-length retourne le nombre de caractères dans une chaîne.

//*[string-length(name()) = 3]      <AAA>           <Q/>           <SSSS/>           <BB/>           <CCC/>           <DDDDDDDD/>           <EEEE/>      </AAA>

Exemple 9 Les axes ancestors, descendants, following, preceding et self partitionnent un document (ignorant les attributs et les noeuds d'espace de nom) : il ne se chevauchent pas et ensemble ils contiennent tous les noeuds d'un document

//GGG/ancestor::* //GGG/descendant::* //GGG/following::*      <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA> //GGG/descendant::*      <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA> //GGG/following::*   <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA>

//GGG/preceding::* //GGG/self::*      <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA> //GGG/self::*      <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA> //GGG/ancestor::* | //GGG/descendant::* | //GGG/following::* | //GGG/preceding::* | //GGG/self::*      <AAA>           <BBB>                <CCC/>                <ZZZ/>           </BBB>           <XXX>                <DDD>                     <EEE/>                     <FFF>                          <HHH/>                          <GGG>                               <JJJ>                                    <QQQ/>                               </JJJ>                               <JJJ/>                          </GGG>                          <HHH/>                     </FFF>                </DDD>           </XXX>           <CCC>                <DDD/>           </CCC>      </AAA>

4 Conclusion et Evolutions XPath offre donc un moyen de concentrer dans une seule expression un parcours simple ou extrêmement complexe de l’arbre XML, permettant de localiser les données recherchées. Cependant, certaines requêtes restent impossibles à formuler. XPath 2 (document de travail du W3C (World Wide Web Consortium) proche du statut de recommandation) apportera alors une solution à ce problème marginal. La syntaxe XPath a donc évolué pour devenir plus complète. La norme XPath 2.0, recommandation W3C depuis le 23 janvier 2007 est prévue pour être utilisée dans les langages XSLT 2.0 et XQuery 1.0, entre autres.