1/31. I XQuery est un sur-ensemble de XPath 2.0, et utilise le même modèle. I On peut définir des fonctions, et utiliser toutes les fonctions 3/31

Transcription

1 ntroduction 1/31 2/31 ntroduction XQuery langage de requête pour XML Anne-Cécile Caron Master MAGE - SGBD 1er trimestre Langage déclaratif, composable, à la manière de SQL: une requête s applique sur une séquence d items et a pour résultat une séquence d items. XQuery n est pas un dialecte XML (contrairement à XSLT) XQuery est un sur-ensemble de XPath 2.0, et utilise le même modèle de données (séquences d items) Vous connaissez donc déjà une grande partie du langage. Typage de XML-Schema On peut définir des fonctions, et utiliser toutes les fonctions prédéfinies pour XPath. Les illustrations du cours proviennent du Livre XQuery, search across a variety of XML Data de Priscilla Walmsley, éditions O Reilly. ntroduction 3/31 4/31 Historique Premiers langages de requêtes pour données semi-structurées : , issus du monde universitaire. Working draft XQuery, XQuery 1.0, janvier 2007, seconde édition en décembre XQuery 3.0 (pas de version 2.0!) working draft au 13 décembre 2011, Recommendation depuis avril XPath 2.1 s appelle XPath 3.0 pour être synchronisé avec la numérotation XQuery. Requête Une requête est une expression, avec éventuellement des déclarations qui sont utilisées pour évaluer cette requête. On retrouve toutes les expressions XPath 2.0 : expressions de chemins, séquences, instructions complexes (for,if) expressions booléennes. Les expressions booléennes et conditionnelles sont étendues et contiennent des expressions XQuery (pas seulement XPath) Comme il faut définir la structure du résultat (pas seulement de l extraction comme avec XPath), on a besoin de constructeurs Expression FLWOR : extension de l expression for de XPath.

2 5/31 6/31 Expression FLWOR signifie For Let Where Order by Return On peut mettre autant de for et de let qu on veut, mais il faut au moins 1 for ou 1 let. for $x in Expr :la variable $x prend successivement chacune des valeurs des items de la séquence retournée par Expr let $x := Expr :la variable $x prend la valeur de la séquence retournée par Expr. On peut définir une clause for ou let avec plusieurs variables. for $i in (1, 2), $j in (3, 4) return ($i, $j) a pour résultat la séquence ( ) Expression FLWOR (suite) where Expr : on ne garde que les valuations des variables qui satisfont l expression en XQuery 3.0, clause group by. On s en passe en XQuery 1.0 en imbriquant les expressions FLWOR. order by permet de trier le résultat puisqu on trie les tuples de valeurs associés aux variables. Comme en SQL, on peut trier par ordre croissant (ascending) ou décroissant (descending). for $e in $employees order by $e/salary descending return $e/name return Expr : l expression est évaluée pour chaque tuple de valeurs associé aux variables, et les résultats de ces évaluations sont concaténés pour former la séquence résultat (comme si on avait l opérateur virgule). 7/31 8/31 Les séquences et itérations 1. for définit une itération, Dans cet exemple, pour tout $s dans la séquence (<one/>, <two/>, <three/>) : for $s in (<one/>, <two/>, <three/>) return <out>{$s}</out> -- a pour résultat <out><one/></out><out><two/></out><out><three/></out> 2. let définit une variable, ici $s vaut la séquence (<one/>, <two/>, <three/>) : let $s := (<one/>, <two/>, <three/>) return <out>{$s}</out> -- a pour résultat <out><one/><two/><three/></out> Quelques exemples d expressions FLWOR for $e in //eau where //bouteille/@ref_eau = $e/@id return {$e/nom_eau, $e/source/dept} -- renvoie : <nom_eau>cristalline</nom_eau> <dept>loiret</dept> <nom_eau>cristalline</nom_eau> <dept>alpes Maritimes</dept> <nom_eau>volvic</nom_eau> <dept>puy-de-d^ome</dept>

3 9/31 10 / 31 Requête équivalente à celle du transparent précédent : for $e in //eau where (some $b in //bouteille satisfies $e/@id = $b/@ref_eau) return {$e/nom_eau, $e/source/dept} Pour la version suivante, on a 5 résultats (donc doublons), car 5 éléments bouteille : for $b in //bouteille let $e := //eau[@id = $b/@ref_eau] return {$e/nom_eau, $e/source/dept} Enfin, pour cette dernière version, on a 3 éléments triés selon le département : for $e in //eau where //bouteille/@ref_eau = $e/@id order by $e/source/dept return {$e/nom_eau, $e/source/dept} Ajout d éléments ou d attributs On peut ajouter un élément en utilisant une balise XML ; C est ce que l on a fait avec l expression {$e/nom_eau, $e/source/dept} Dans un constructeur, tout ce qui n est pas entre { } apparaît tel quel. sans mettre explicitement de nom d élément, on peut aussi utiliser une expression qui a pour résultat un élément (ou une séquence d éléments) comme $e/nom_eau. Si une expression a pour évaluation un attribut, alors cet attribut est ajouté à l élément qui contient l expression. On peut définir des éléments ou attributs dont le nom et le contenu sont calculés, en utilisant les constructeurs element ou attribute 11 / / 31 Exemple : génération d HTML Tableau HTML à partir du fichier XML décrivant des eaux minérales. <table> <thead> <th>eau</th><th>source</th> </thead> <tbody> { for $eau in //eau return } </tbody> </table> <td> {$eau/nom_eau/text()} </td> <td> {$eau/source/nom_source/text(),,$eau/source/dept/text()} </td> <table> <thead> <th>eau</th><th>source</th> </thead> <tbody> <td>cristalline</td> <td>st-cyr la Source Loiret</td> <td>cristalline</td> <td>aurèle Alpes Maritimes</td> <td>volvic</td> <td>volvic Puy-de-D^ome</td> <td>evian</td> <td>evian Haute-Savoie</td> </tbody> </table>

4 13 / / 31 Exemple d utilisation des constructeurs element et attribute Sur l exemple ci-dessous, les noms des éléments et attributs sont en dur : element bouteille { attribute ref_eau {"e1"}, element codebarre { " " }, element volume {"150" } } -- est équivalent à <bouteille ref_eau="e1"> <codebarre> </codebarre> <volume>150</volume> </bouteille> Sur l exemple suivant, le nom de l élément est fabriqué à l exécution de la requête : return element {fn:node-name($b)} {$b/@*, 2 * fn:data($b/volume)} -- si $b a pour valeur <bouteille ref_eau="e3"> <codebarre> </codebarre> <volume>50</volume> </bouteille> -- alors le résultat de cette expression est l élément : <bouteille ref_eau="e3">100</bouteille> 15 / / 31 Les fonctions l existe quelques fonctions en XQuery, et on retrouve en particulier les fonctions de groupes utilisées en SQL : count : compte le nombre d items dans la séquence min : donne la plus petite valeur de la séquence. La séquence doit donc contenir des items valeur atomiques de types qui peuvent être comparés (string, date, nombres,...) max : donne la plus grande valeur de la séquence. Même contrainte d utilisation que min. avg : donne la moyenne des valeurs de la séquence. ça fonctionne pour des valeurs numériques, des valeurs de type xs:yearmonthduration ou xs:daytimeduration. sum : donne la somme des valeurs de la séquence. Même contrainte d utilisation que avg. Exemple : utilisation de count on ne conserve que les eaux dont on a au moins 2 bouteilles <eaux>{ for $e in //eau let $b := //bouteille[@ref_eau = $e/@id] where count($b) >= 2 return {$e/*} <nb-bouteilles>{count($b)}</nb-bouteilles> }</eaux> <eaux> <nom_eau>cristalline</nom_eau>... et tous les autres sous-éléments de cet élément eau... <nb-bouteilles>2</nb-bouteilles>... et d autres éléments eau dont on a au moins 2 bouteilles... </eaux>

5 17 / / 31 Le typage XQuery est un langage fortement typé, qui manipule des séquences d items. On vient de voir que les fonctions prédéfinies ne s appliquent pas sur tous les types Soit le document interrogé a un schéma, qui permet de connaître les types des données Soit on fait des conversions explicites en utilisant les types XML-schema : let $s := sum(//bouteille/xs:integer(volume)) return $s Soit la fonction applique des conversions implicites : let $s := sum(//bouteille/volume) return $s Dans cet exemple, chaque élément volume est converti en une valeur atomique de type nombre (contenu de l élément). Les comparaisons l existe 3 sortes de comparaisons en XQuery. 1. Comparaison de valeurs : eq, ne, lt, le, gt, ge. 2. Comparaison générale : =,!=, <, <=, >, >=. Quantification existentielle. 3. Comparaison de noeuds : is, <<, >> 4. Pour tous ces opérateurs de comparaison, si l un des deux opérandes vaut () alors la comparaison vaut (). 19 / / 31 Comparaison de valeurs Les opérateurs sont eq, ne, lt, le, gt, ge. chaque opérande doit être une séquence de longueur au plus 1, et on convertit chaque opérande en valeur atomique typée Si les types des opérandes sont compatibles, la comparaison vaut true si la valeur du premier opérande est (égale, di érente, inférieure, inférieure ou égale, supérieure, supérieure ou égal) à la valeur du second opérande, elle vaut false sinon. //nom_eau eq "Volvic" --> retourne une erreur car le premier opérande contient plus qu un élément for $s in //nom_eau return $s eq "Volvic" --> false false true false //bouteille[xs:integer(volume) gt 50] --> la conversion explicite est obligatoire, en l absence d un schéma indiquant le type de la valeur. Comparaison générale Les opérateurs sont =,!=, <, <=, >, >=. chaque opérande est une séquence, et on convertit les opérandes en séquences de valeurs atomiques la comparaison générale vaut true ssi il existe un item dans la première séquence et un item dans la seconde séquence pour lesquels la comparaison de valeur est vraie. //nom_eau = "Volvic" --> true car il existe un nom d eau qui a pour valeur "Volvic" //bouteille[volume > 50] --> ici une conversion implicite est appliquée //eau[@id = //bouteille/@ref_eau] --> les éléments eau tels qu il existe une bouteille contenant cette eau. Pour chaque eau, la comparaison est faite avec l opérande de gauche contenant 1 noeud attribut, l opérande de droite en contenant 5.

6 21 / / 31 Comparaison de noeuds Les opérateurs sont is, <<, >>. chaque opérande est soit un noeud soit la séquence vide. si les deux opérandes sont des noeuds, la comparaison avec is vaut true si ces deux noeuds sont les mêmes (identité). la comparaison avec << ( >>) vauttrue si l opérande à gauche de l opérateur est avant (après) l opérande de droite dans l ordre du document. <a>3</a> is <a>3</a> --> false (alors que c est vrai pour eq et =) //eau[1] is //eau[@id="e1"] --> true //eau[1] << //eau[3] --> true Définir des fonctions le nom de la fonction est qualifié par un espace de noms ; les fonctions prédéfinies sont dans l espace de nom qui est l espace par défaut pour les fonctions. Chaque paramètre est défini sous la forme $var as type Le type du résultat est facultatif, mais fortement conseillé! external signifie que c est une fonction définie dans une librairie spécifique, liée par exemple à une implémentation particulière de XQuery 23 / / 31 Exemple declare function local:discountprice( $price as xs:decimal?, $discount as xs:decimal?, $maxdiscountpct as xs:integer?) as xs:decimal? { let $maxdiscount := ($price * $maxdiscountpct) div 100, $actualdiscount := min(($maxdiscount, $discount)) return ($price - $actualdiscount) }; local:discountprice(20,(),10) --> retourne autre exemple d utilisation : for $prod in //product return <price>{ local:discountprice($prod/price, $prod/discount, 15) }</price> Retour sur les types des séquences on a vu que l on pouvait utiliser les types de XML-schema. Par exemple xs:decimal représente un singleton contenant un nombre décimal. On peut utiliser des types génériques. En particulier : item() node() empty-sequence() text() On peut définir des cardinalités. Par exemple : une séquence de 0 ou 1 nombre décimal : xs:decimal? une séquence de 0, 1 ou plusieurs entiers : xs:integer* une séquence d au moins 1 item : item()+ l opérateur instance of permet de tester si une expression est d un type donné. Par exemple (3, 4, 5) instance of xs:integer* est vrai.

7 25 / / 31 Les Ce sont des URs. ls permettent d utiliser di érents vocabulaires sans ambiguité de nommage. Dans un document XML, on définit des préfixes qui correspondent aux di érents namespace utilisés : <cat:catalog xmlns:cat=" xmlns:prod=" <cat:number>1446</cat:number> <prod:product> <prod:number>563</prod:number> <prod:name prod:language="en">floppy Sun Hat</prod:name> </prod:product> </cat:catalog> l peut y avoir 1 namespace sans préfixe, appelé namespace par défaut. Les et XQuery l existe des préfixes déclarés implicitement par l évaluateur XQuery : On peut déclarer d autres namespaces explicitement Di culté : ne pas confondre les namespaces des documents en entrée et ceux des documents en sortie. 27 / / 31 Espaces de noms dans une requête XQuery Les documents en entrée contiennent des éléments et attributs qui appartiennent à des La requête peut construire des éléments/attributs qui appartiennent à des Les fonctions déclarées ou appelées dans une requête ont des noms qualifiés Les types utilisés dans une requête (par exemple pour la signature des fonctions) ont des noms qualifiés les types définis par l utilisateur appartiennent à l espace de noms cible du schéma où ils ont été définis. les types prédéfinis sont dans l espace de nom XML Schema, par convention le préfixe est xs Exemple 1 Requête sur le document page 25 : <report xmlns=" xmlns:cat=" xmlns:prod=" { for $product in doc("prod_ns.xml")/prod:product return <linetem> {$product/prod:number} {$product/prod:name} </linetem> } </report> Résultat : <report xmlns:prod=" xmlns:cat=" xmlns=" <linetem> <prod:number>563</prod:number> <prod:name language="en">floppy Sun Hat</prod:name> </linetem> </report>

8 Structure complète d une requête 29 / / 31 Exemple 2 Requête : declare default element namespace " declare namespace cat = " declare namespace prod = " <report> { for $product in doc("prod_ns.xml")/prod:product return <linetem> {$product/prod:number} {$product/prod:name} </linetem> } </report> Résultat : <report xmlns=" <linetem> <prod:number xmlns:prod=" <prod:name xmlns:prod=" language="en">floppy Su </linetem> </report> Structure complète d une requête Une requête contient un prologue qui permet de déclarer des, des fonctions, de donner des instructions à l évaluateur, d importer des schémas, des modules,... xquery version "1.0" encoding "UTF-8"; declare default element namespace " declare namespace ord = " import module " at " un corps qui consiste en une expression (qui peut être une séquence d expressions séparées par des,) Structure complète d une requête 31 / 31 Module La définition d une requête va donc se faire avec un module principal, qui contient un prologue et un corps de requête et éventuellement des modules bibliothèques, qui ne contiennent chacun qu un prologue, i.e. principalement des déclarations de fonctions. Un module bibliothèque commence par une déclaration de module : module namespace <prefix> = "<namespace-name>" ; -- par exemple: module namespace strings = " Pour utiliser un module bibliothèque, il su tdel importer: -- par exemple import module namespace strings = " at "