XPath, XQuery

Dan VODISLAV

Université de Cergy-Pontoise
 Plan

• XPath
– Expressions de chemin
– Axes, filtres et prédicats
– Fonctions XPath

• XQuery
– Modèle de données
– Expressions simples et complexes
– Expressions de chemin XPath 2.0
– Construction de noeuds
– Expressions FLOWR

2
 XPath
• Langage de sélection d’un ensemble de nœuds dans un document XML
– Utilise des expressions de chemin pour désigner des nœuds dans l’arbre
– Les expressions XPath sont utilisées dans d’autres langages: XSLT, XQuery, …
• Une expression de chemin XPath
– S’évalue en fonction d’un nœud contexte
– Désigne un ou plusieurs chemins dans l’arbre du document à partir du nœud
contexte
– A pour résultat un ensemble de nœuds de l’arbre (qui se situent au bout des
chemins)
• Types de nœuds
– Document, Element, Attribute, Text, Comment, ProcessingInstruction
• XPath offre aussi des expressions littérales (texte, numérique, booléen)
• Ex: 1 + 2

3
 Syntaxe XPath

• Expression de chemin: suite d’étapes

[/]étape1/étape2/…/étapen

• Idée: chaque étape successive détermine un ensemble de nœuds à partir du

nœud contexte
– Le reste du chemin utilise chacun des nœuds désignés par l’étape précédente
comme nœud contexte pour la suite de l’évaluation
• Étape = axe::filtre[prédicat1]…[prédicatn]
Exemple: child::B[position()=1] (abréviation: B[1])
• Axe: optionnel (par défaut child)
– Spécifie un ensemble des nœuds par rapport au nœud contexte + un ordre
• Filtre: obligatoire, décrit le sous-ensemble de nœuds de l’axe retenu
• Prédicats: optionnels, décrivent les conditions à satisfaire par les nœuds
– Combinés par l’opérateur "ET" logique

4
 Axes XPath

• Douze types d’axes

– child (axe par défaut): enfants directs du nœud contexte
– parent (..): nœud parent
– attribute (@): nœuds attribut du nœud contexte
– descendant (//): nœuds descendants du nœud contexte
– descendant-or-self: descendants, y compris le nœud contexte
– ancestor: nœuds ancêtres du nœud contexte
– ancestor-or-self: ancêtres, y compris le nœud contexte
– following: nœuds suivants dans l’ordre du document
– following-sibling: frères suivants dans l’ordre du document
– preceding: nœuds précédents dans l’ordre du document
– preceding-sibling: frères précédents dans l’ordre du document
– self (.): le nœud contexte lui-même

• Attributs: seul l’axe attribute désigne des nœuds attribut !

5
 Filtres et prédicats

• Filtres: deux façons de filtrer les nœuds d’un axe:

– Par leur nom
• Pour les nœuds qui ont un nom (Element, Attribute, ProcessingInstruction)
– Par leur type
• text(), comment(), processing-instruction()
• * : nœuds de type élément ou attribut
• node() : tous les types de nœud

• Prédicat: tests connectés par les opérateurs logiques "ET" et "OU"

– Négation: par la fonction not()
• Test = expression booléenne élémentaire: comparaison, fonction booléenne
– Expression de chemin convertie en booléen
• Ensemble de nœuds: false si l’ensemble est vide, sinon true
• Numérique: false si 0 ou NaN (« not a number »), sinon true
• Chaînes de caractères: false si chaîne vide, sinon true

6
 Fonctions XPath

• Pour nœuds
– count(expr): nombre de nœuds dans l’ensemble produit par l’expression
– name(): nom du nœud contexte
• Pour chaînes de caractères
– concat(ch1, ch2, …): concaténation
– contains(ch1, ch2): vérifie si ch1 contient ch2
– substring(ch, pos, l): extrait la sous-chaîne de ch de longueur l, commençant à la
position pos (les positions démarrent à 1)
– string-length(ch): longueur de la chaîne
• Pour booléens
– true(), false(): les valeurs vrai/faux
– not(expr): négation de l’expression logique
• Pour numériques
– sum(expr): somme des valeurs des nœuds produits par l’expression
– avg(expr): moyenne des valeurs des nœuds produits par l’expression

7
 Exemples

• D
• D/text()
• descendant::node()
• ..
• following::node()
• preceding-sibling::node()
• //@att1
• /A//D
• /comment()
• ../*
• /A/B//text()[1]
• /A//text()[1]
• //B[@att1="a2"]/D
• /A/B[last()]
• //B[count(D)>1]
• /A/C[not(D)]
• /A[B[D="Texte1"]/@att1]/C/@att2
8
 XQuery

• Langage de requêtes pour bases de données XML

– Langage fonctionnel typé, sans effets de bord

• Modèle de données XDM basé sur des séquences ordonnées

– Valeur = séquence ordonnée (liste) d’items
– Item = nœud (tout type DOM) ou valeur atomique
• Document, élément, attribut, texte, … + valeurs atomiques de différents types
– Chaque nœud et chaque valeur atomique a un type (XML Schema)
– Résultat de requête XQuery = valeur = séquence d'items

valeur item
*
item noeud valeur atomique

9
 Séquences

• Pas de distinction entre item et séquence de longueur 1

– Ex: 39 = (39)

• Une séquence peut contenir des valeurs hétérogènes

– Ex: (39, "toto", <toto/>)

• Pas de séquences imbriquées

– Ex: (39, (1, 2), "toto", <toto/>) = (39, 1, 2, "toto", <toto/>)

• Une séquence peut être vide

– Ex: ()

• L’ordre est important

– Ex: (1, 2) ≠ (2, 1)

10
 Expressions XQuery simples

• Valeurs atomiques littérales (des types simples XML Schema)

Ex: 39, "toto", 3.9, etc.
• Nœuds XML sous forme littérale
Ex: <film annee="2007">
<titre>La môme</titre>
</film>
• Valeurs obtenues par des constructeurs simples
Ex: true(), false(), date("2006-12-08")
• Collections de documents, documents
– document(uri-document)
retourne un item de type nœud Document
– collection(uri-collection)
retourne une séquence de nœuds Document
Ex: document("biblio.xml"), collection("cinema/films")
• Séquences construites
Ex: (1, 2, 3, 4, 5), 1 to 5, (1 to 3, 4, 5)
• Variables
– Nom précédé du signe $ ($x, $toto, etc.) + valeur (séquence d'items)

11
 Expressions XQuery complexes

• Expressions de chemin (XPath 2.0)

– Toute expression produisant une séquence de nœuds peut être une étape

• Expressions FLWOR avec définition de variables

• Tests (If-Then-Return-Else-Return)
• Fonctions prédéfinies et fonctions utilisateur
• Mélange de littéraux et d'expressions complexes
– Chaque expression doit être placée entre {} pour qu'elle soit évaluée
Ex. <comedies>
{document("films.xml")//film[@genre="comedie"]}
</comedies>

12
 Exemple

• Document bib.xml
<bib>
<book title="Comprendre XSLT">
<author><la>Amann</la><fi>B.</fi></author>
<author><la>Rigaux</la><fi>P.</fi></author>
<publisher>O’Reilly</publisher>
<price>28.95</price>
</book>
<book year="2001" title="Spatial Databases">
<author><la>Rigaux</la><fi>P.</fi></author>
<author><la>Scholl</la><fi>M.</fi></author>
<author><la>Voisard</la><fi>A.</fi></author>
<publisher>Morgan Kaufmann Publishers</publisher>
<price>35.00</price>
</book>
<book year="2000" title="Data on the Web">
<author><la>Abiteboul</la><fi>S.</fi></author>
<author><la>Buneman</la><fi>P.</fi></author>
<author><la>Suciu</la><fi>D.</fi></author>
<publisher>Morgan Kaufmann Publishers</publisher>
<price>39.95</price>
</book>
</bib>

13
 Expressions de chemin

• XPath 2.0
– Modèle XDM, basé sur des séquences, au lieu d'ensembles de nœuds
– Utilisation de tous les types XML Schema
– Étape: toute expression qui retourne une séquence de nœuds
– Nouveaux opérateurs (for, if, some, every), utilisation de variables
• Exemples
– document("bib.xml")/bib//book[1]/publisher
• L’éditeur du premier livre
– document("bib.xml")//(book union author union publisher)
• tous les livres, auteurs et éditeurs
– document("bib.xml")//book/(* except price)
• pour chaque livre tous les éléments fils sauf le prix.
– document("bib.xml")//book[every $a in author satisfies
contains($a/la,'a')]
• tous les livres dont tous les auteurs ont la lettre ’a’ dans leur nom de famille

14
 Construction de nœuds XML

• Cas 1: nom connu, contenu construit par une expression

– Requête:
<auteurs>
{ document("bib.xml")//book[2]/author/la }
</auteurs>
– Résultat:
<auteurs>
<la>Rigaux</la>
<la>Scholl</la>
<la>Voisard</la>
</auteurs>

• La requête fait partie d’un document XML, le résultat est

transformé en fragment XML

15
 Construction de nœuds XML (suite)

• Cas 2: le nom et le contenu sont calculés

– Constructeurs d’élément et d’attribut
• element { expr-nom } { expr-contenu }
• attribute { expr-nom } { expr-contenu }

– Requête:
element { document("bib.xml")//book[1]/name(@*[1]) } {
attribute { document("bib.xml")//book[1]/name(*[3]) }
{ document("bib.xml")//book[1]/*[3] }
}

– Résultat:

<title publisher="O’Reilly"/>

16
 Expressions FLOWR

• Une expression FLOWR ("flower")

– Itère sur des séquences (for)
– Définit des variables (let)
– Trie les résultats (order by)
– Applique des filtres (where)
– Construit et retourne un résultat (return)
• Itération : for $var in exp
– Affecte la variable $var successivement avec chaque item dans la
séquence retournée par exp
– Exemple:
for $a in document("bib.xml")//book[price<30]/author
return $a
– Résultat:
<author><la>Amann</la><fi>B.</fi></author>
<author><la>Rigaux</la><fi>P.</fi></author>

17
 Affectation d’ensembles: let

• let $var := exp

– affecte à la variable $var la séquence entière retournée par exp

• Requête:
for $b in document("bib.xml")//book[1]
let $al := $b/author
return <livre nb_auteurs="{count($al)}">
{ $al }
</livre>

• Résultat:
<livre nb_auteurs="2">
<author><la>Amann</la><fi>B.</fi></author>
<author><la>Rigaux</la><fi>P.</fi></author>
</livre>

18
 Sélection : where

• where exp
– permet de filtrer le résultat par rapport au résultat booléen de l’expression
exp

• Requête:
<livre>
{ for $a in document("bib.xml")//book
where $a/author[1]/la = "Abiteboul"
return $a/@title
}
</livre>

• Résultat:
<livre title="Data on the Web"/>

19
 Trier : order by

• expr1 order by expr2 (ascending | descending)?

– trier les éléments de la séquence retournée par l’expression expr1 selon
les valeurs retournées par expr2
• Requête:
<livres>
{ for $b in document("bib.xml")//book
order by $b/@year
return <livre> { $b/@title, $b/@year } </livre>
}
</livres>

• Résultat:
<livres>
<livre title="Comprendre XSLT"/>
<livre title="Data on the Web" year="2000"/>
<livre title="Spatial Databases" year="2001"/>
</livres>

20
 Tests: if-then-else

• Requête:
<livres>
{ for $b in document("bib.xml")//book
where $b/author/la = "Rigaux"
return if ($b/@year > 2000)
then <livre recent="true"> {$b/@title}
</livre>
else <livre> {$b/@title} </livre>
}
</livres>

• Résultat:
<livres>
<livre title="Comprendre XSLT"/>
<livre recent="true" title="Spatial Databases"/>
</livres>

21
 Quantification

• some $var in expr1 satisfies expr2

– il existe au moins un noeud retourné par l’expression expr1 qui satisfait
l’expression expr2 (quantification existentielle).
• every $var in expr1 satisfies expr2
– tous les nœuds retournés par l’expression expr1 satisfont l’expression expr2
(quantification universelle)
• Requête:
for $a in document("bib.xml")//author
where every $b
in document("bib.xml")//book[author/la = $a/la]
satisfies $b/publisher="Morgan Kaufmann Publishers"
return string($a/la)

• Résultat:
Scholl, Voisard, Abiteboul, Buneman, Suciu

22