Cours 3 - XPath - IUT Bayonne

o http://www.w3.org/XML/
XPath
XML Path Language
Sébastien Laborie
Sebastien.Laborie@iutbayonne.univ-­‐‑pau.fr
Christian Sallaberry
Christian.Sallaberry@univ-­‐‑pau.fr
Bibliographie
o http://www.w3schools.com/xpath/
o http://bibliotheques.univ-pau.fr/live/livreselectroniques/edition-ENI
o http://www.gchagnon.fr/cours/xml/index.html
o http://www.w3.org/TR/xpath-datamodel/
o http://www.w3.org/TR/xpath-full-text-10-use-cases/
2

XPath : présentation
http://www.w3schools.com/xpath/
XPath : présentation
• XPath est un langage déclaratif permettant de spécifier
des chemins dans une arborescence XML
• XPath est utilisé dans de nombreux dialectes XML :
o XSLT pour la transformation d’ensembles d’éléments
o XQuery pour l’interrogation d’ensembles d’éléments
o XLink et XPointer qui ne seront pas traités ici
3
4

XPath : données, environnement
• Le modèle définit sept types de nœuds :
o Nœud document
o Nœud élément
o Nœud espace de nom
o Nœud attribut
o Nœud texte
o Nœud instruction de traitement
o Nœud commentaire
XPath : données, environnement
• Exemple de nœuds du modèle :
o Nœud document
o Nœud élément
o Nœud espace de nom
o Nœud texte
o Nœud attribut
o Nœud instruction de traitement
o Nœud commentaire
Categorie =
« plat »
titre
« Poivrée de … »
image
Src = « http://… »
Auteur =
« Laborie »
racine
recette
commentaire
collection
« Très bon »
…
ingrédient
Nom = « céleri »
Qte = « 500 »
Unite = « g »
…
5
6

XPath : expressions
• Une expression Xpath peut être :
o Une expression primitive ;
• dont le résultat est un objet unique du modèle de donnée du document XML
o Une expression de chemin ;
• dont le résultat est une séquence de nœuds
o Une expression de séquence ;
• comme une expression de répétition, conditionnelle, de quantification ou booléenne
o Un mélange de tous ces types d’expressions.
XPath : expressions
• Une expression Xpath peut être une expression primitive
• Expression d’une valeur :
xs:float('5.24'); xs:date('2010-01-01'); xs:integer('5')
• Référencement d’une variable :
for $i in 1 to 5 return $i * $i
• Expression du contexte courant :
/collection/recette/titre[contains(.,'Salade')]
• Expression entre parenthèses :
2 * (3 + 2) ; 2 * 3 + 2
• Fonctions :
- Nombres : 2*3
- Chaînes : contains('bonjour','bon')
- Dates : xs:date('2012-01-03') - xs:date('2012-01-01')
Comment convertir une telle durée en entier ?
- Booléens : true and false
- Nœuds : /collection/count(recette)
http://www.w3.org/TR/2007/REC-xpath-functions-20070123/
7
8

XPath : expressions
• Une expression Xpath peut être une expression de
chemin formée de trois éléments :
o axe : direction dans laquelle s'effectue l'évaluation (noeud père, noeuds fils, ...) ;
o filtre : type de noeuds à retenir (noeuds quelconques, éléments précis,...) ;
o Prédicat : conditions (optionnelles) à vérifier par les noeuds retenus
• Ces trois éléments joints forment une étape XPath
• L’enchainement de plusieurs étape forme un chemin
XPath :
o Les étapes d’un chemin sont séparées par le caractère « / »
o Les prédicats sont exprimés entre « [] »
o Des disjonctions (choix) d’étapes sont spécifiées à l’aide du caractère « | »
XPath : expressions
• Un chemin XPath est de la forme :
o axe1::filtre1[predicat1]/axe2::filtre2[predicat2]
o axe1::filtre1[predicat1]/axe2::filtre2[predicat2]|axe3::filtre3[predicat3]
• Un chemin commençant par « / » est dit absolu, sinon il est
relatif (au contexte (nœud courant))
• En somme, une expression de chemin
o spécifie une traversée de l'arbre du document (un chemin) :
• depuis un nœud de départ
• … vers un ensemble de nœuds cibles
o a pour résultat
• un ensemble de nœuds
• ou une valeur numérique, booléenne ou alphanumérique
9
10

• Axes
• ancestor
XPath : chemins
self = nœud courant = contexte
XPath : chemins
self = nœud courant = contexte
11
12

• ancestor-or-self
• attribute
XPath : chemins
self = nœud courant = contexte
XPath : chemins
self = nœud courant = contexte
13
14

• child
XPath : chemins
self = nœud courant = contexte
• descendant
XPath : chemins
self = nœud courant = contexte
15
16

XPath : chemins
• descendant-or-self
• following
self = nœud courant = contexte
XPath : chemins
self = nœud courant = contexte
17
18

• following-sibling
XPath : chemins
self = nœud courant = contexte
• namespace
XPath : chemins
self = nœud courant = contexte
19
20

• parent
• preceding
XPath : chemins
self = nœud courant = contexte
XPath : chemins
self = nœud courant = contexte
21
22

• preceding-sibling
• self
XPath : chemins
self = nœud courant = contexte
XPath : chemins
self = nœud courant = contexte
23
24

• Axes : en résumé
XPath : chemins
o self : le nœud courant lui-même
o child, parent : les nœuds enfants, le nœud père
o descendant, descendant-or-self : les descendants, les
descendants ou lui-même
o ancestor, ancestor-or-self : les ancêtres, les ancêtres ou luimême
o preceding, following : les nœuds précédents ou suivants
o preceding-sibling, following-sibling : les nœuds frères précédents
ou les nœuds frères suivants
o attribute : les attributs du nœud courant
o namespace : les noeuds espace de noms du noeud contexte
self = nœud courant = contexte
XPath : chemins
• Axes : en exemple
? /child::node()
? /descendant::node()
? /descendant::text()
self = nœud courant = contexte
25
26

XPath : chemins
• Filtres : sélectionnent, parmi les nœuds de l’axe, ceux qui
correspondent à un type donné
o * : nœuds de l’axe ayant le même type que le type principal de
l’axe
? child::*
? attribute::*
o nom : nœuds de l’axe ayant le même type que le type principal de
l’axe et de nom nom
? ancestor::recette
? attribute::categorie
o node() : tout nœud de l’axe
o element() : tout nœud de l’axe de type element
? element(nom)
? element(nom, type)
? element(*,type)
XPath : chemins
• Filtres : sélectionnent, parmi les nœuds de l’axe, ceux qui
correspondent à un type donné
o attribute() : tout nœud de l’axe de type attribut
? attribute(nom)
? attribute(nom, type)
? attribute(*,type)
o text() : tout nœud de l’axe de type texte
o comment() : tout nœud de l’axe de type commentaire
o processing-instruction() : tout nœud de l’axe représentant une
instruction de traitement
o processing-instruction(nom) : tout nœud de l’axe représentant
une instruction de traitement de nom nom
27
28

XPath : chemins
• Axes et filtre : raccourcis
child peut être omis
descendant-or-self::node() peut être remplacé par //
element() peut être remplacé par *
attribute() peut être remplacé par @
self::node() peut être remplacé par .
parent::node() peut être remplacé par ..
XPath : exemples de chemin
29
30

XPath : exemples de chemin
XPath : exemples de chemin
• Axes & filtres
child::titre : les éléments titre enfants du nœud contextuel
child::* : tous les éléments enfants du nœud contextuel
child::text() : tous les nœuds textuels enfants du nœud contextuel
child::element() : tous les nœuds element enfants du nœud contextuel
child::node() : tous les enfants du nœud contextuel, quel que soit leur type
(élément ou autre)
attribute::categorie : l'attribut categorie du nœud contextuel
attribute::* : tous les attributs du nœud contextuel
descendant::ingredient : tous les descendants ingredient du nœud
contextuel
ancestor::recette : tous les ancêtres recette du nœud contextuel
ancestor-or-self::recette : tous les ancêtres recette du nœud contextuel et le
nœud contextuel lui-même si c'est un nœud recette
31
32

XPath : exemples de chemin
• Axes & filtres
descendant-or-self::ingredient : tous les descendants ingredient du nœud
contextuel et le nœud contextuel lui-même si c'est un nœud ingredient
self::ingredient : le nœud contextuel si c'est un élément ingredient et rien
dans le cas contraire
child::collection/descendant::titre : les descendants titre des éléments
collection enfants du nœud contextuel
child::*/child::preparation : tous les petits enfants preparation du nœud
contextuel
XPath : exemples de chemin
• Axes & filtres
? Les recettes
? Les titres des recettes
? Les noms des ingrédients des recettes
33
34

XPath : chemins
• Un prédicat est une expression logique entre
crochets [] retournant vrai ou faux
• Il existe quatre formes de prédicats :
o axe::filtre[numéro]
o axe::filtre[expression XPATH]
o axe::filtre[expression logique]
o prédicats composés
XPath : chemins
o axe::filtre[numéro]
Sélectionne les nœuds en fonction de leur position :
/collection/recette[position()=2]
/collection/recette[position()=2]/element()
/collection/recette[position()=2]/*
/collection/recette[position()=last()]
/collection/recette[last()]
/collection/recette[2]
35
36

XPath : chemins
o axe::filtre[expression XPATH]
Sélectionne les nœuds pour lesquels l’expression
XPATH renvoie un ensemble de nœuds non vide :
/collection/recette/titre[text()]
/collection/recette[image]/titre
/collection/recette[@categorie]/titre
Titres des recettes comportant une étape de
préparation dont la durée est stipulée ?
XPath : chemins
o axe::filtre[expression logique]
Sélectionne les nœuds pour lesquels l’expression logique
renvoie la valeur VRAI
L’expression logique peut comporter :
• des opérateurs mathématiques +, -, *, div, mod
• des opérateurs de comparaison binaires =, !=, =, unaire NOT
• des connecteurs logiques ET, OU
• des fonctions relatives à des objets de type nœud,
chaine de caractères, booléen, numérique, …
37
38

XPath : chemins
o axe::filtre[expression logique]
Fonctions XPath applicables aux nœuds :
• number count(ns)
• number position()
/collection/recette/titre[position()=1]
/collection/recette[position()=1] /titre
• number last()
/collection/recette/titre[last()]
/collection/recette[last()]/titre
• node-set id(o)
• …
XPath : chemins
o axe::filtre[expression logique]
n = number; s = string; o = object;
ns = node-set; ? = 0|1; * = 0, .., N
Fonctions XPath applicables aux chaines de caractères :
• string string(o?)
• string concat(s,s,s*)
• string substring(s,n,n?)
• string substring-before(s,s)
• string substring-after(s,s)
• boolean contains(s,s)
• boolean starts-with(s,s)
• number string-length(s?)
• …
n = number; s = string; o = object;
ns = node-set; ? = 0|1; * = 0, .., N
39
40

XPath : chemins
o axe::filtre[expression logique]
Fonctions XPath booléennes :
• boolean boolean(o)
boolean(5)
boolean("ttt")
boolean(/collection/recette[position()=1] /titre)
• boolean not(o)
• boolean true()
• boolean false()
• …
XPath : chemins
o axe::filtre[expression logique]
n = number; s = string; o = object;
ns = node-set; ? = 0|1; * = 0, .., N
Fonctions XPath applicables aux numériques :
• number number(o?)
• number sum(ns)
• number floor(n)
• number ceiling(n)
• number round(n)
• …
n = number; s = string; o = object;
ns = node-set; ? = 0|1; * = 0, .., N
41
42

XPath : exemples de chemin
• Axes, filtres & prédicats
child::recette[position()=1] : le premier enfant recette du nœud contextuel
child::recette[position()=last()] : le dernier enfant recette du nœud
contextuel
child::recette[position()=last()-1] : l'avant dernier enfant recette du nœud
contextuel
child::recette[position()>1] : tous les enfants recette du nœud contextuel
autres que le premier
following-sibling::recette[position()=1] : la prochaine recette cible du nœud
contextuel
preceding-sibling::recette[position()=1] : la précédent recette cible du
nœud contextuel
descendant::recette[position()=42] : le 42ième élément recette du
document
child::collection/child::recette[position()=2]/child:: ingredient[position()=3] :
le 3ième ingredient de la 2ième recette de l'élément collection
child::recette[attribute::categorie=‘entree’] : tous les enfants recette du
nœud contextuel qui ont un attribut categorie dont la valeur est entree
XPath : exemples de chemin
• Axes, filtres & prédicats
child::recette[attribute::categorie=‘entree'][position()=2] : le
2ième enfant recette du nœud contextuel qui a un attribut
categorie dont la valeur est entree
child::recette[position()=2][attribute::categorie =‘entree'] : le
2ième enfant recette du nœud contextuel si celui-là a un
attribut categorie de valeur entree
child::recette[child::titre='Salade de chèvres chauds'] : l'enfant
recette du nœud contextuel qui a un ou plusieurs enfants titre
avec un contenu textuel égal à Salade de chèvres chauds
/collection/child::recette/child::titre[contains(.,'Salade')] : ?
/collection/child::recette[child::titre] : ?
/collection/recette/child::*[self::titre or self::image] : ?
/collection/recette/child::*[self::ingredient or
self::preparation][position()=last()] : ?
43
44

XPath : exemples de chemin
• Axes, filtres & prédicats
o Les titres de toutes les recettes ?
o Les titres des recettes qui comptent plus de trois ingrédients ?
o Les recettes qui citent « autruche » dans le titre ?
o Toutes les recettes dans le détail ?
? /collection/recette/titre/text()[starts-with(., 'Po')]
? /collection/recette/titre[starts-with(., 'Po')]
? /collection/recette/*[@qte][position()
o Quantificateur existentiel
• some $i in (1,2,3,4) satisfies $i > 3
• //commande[some $p in ./detail/produit satisfies $p/@ref = "FEUTR-
BIC"]/@id
45
46

Exercices !
Recherche d’information
avec XPath
Exercice 1 : éditeur oXygen
• Editez un premier document XML et l’interroger
47
48

Exercice 1 : éditeur oXygen
• Editez un premier document XML et l’interroger
Exercice 1 : éditeur oXygen
• Editez un premier document XML et l’interroger
49
50

Exercice 2 : Oxygen & XPath
o Interroger le fichier gestion_commerciale.xml :
• Noms et prénoms des clients
• Clients qui ont des commandes
• Clients et nombre de commandes
• Clients qui ont plus de 2 commandes
• Clients qui n’ont pas de commande
• Désignation et prix des produits à plus de 10 euros
• Produits en rupture de stock (quantité en stock >2)
• Produits commandés
• Code des commandes comprenant plus de deux lignes de
commande
• Nombre total de bâtons de colle commandés
• Nombre de bâtons de colle en stock
• Nombre de commandes
51