XQuery_2_

Document Sample
XQuery_2_ Powered By Docstoc
					                           Master MID
                   Modèle Intelligent et Décision




Présenté par:
Amel HALFAOUI
a_halfaoui@mail.univ-tlemcen.dz
 h_amel@hotmail.com
XPath est un langage d'interrogation des documents XML. Il permet de
sélectionner certaines parties d'un document XML : des sous-arbres, des
noeuds, des attributs, etc.
XPath est central dans le monde XML, il intervient comme brique de base dans
d'autres technologies XML :
     - XML Schémas (expression des contraintes d'unicité et de clefs),
     - les transformations XSLT,
     - XQuery
     - XLink
     - XPointer, etc.
noeud courant : c'est le nœud où l'on part, n'importe quel noeud peut jour
ce rôle. À partir de là, on considère trois éléments qui constituent une
etape:
 - un axe : la direction dans laquelle on se dirige à partir du noeud courant
 (vers le père, vers les fils, vers les frères de gauche, etc.) ;
 - un filtre : le type de noeuds qui nous intéresse dans l'axe choisi (des
 noeuds quelconques, des éléments quelconques ou un élément précis,
 des commentaires, etc.) ;
 - un prédicat optionnel : des conditions supplémentaires pour
 sélectionner des noeuds parmi ceux retenus par le filtre dans l'axe.

                    axe::filtre[prédicat]
L'enchaînement de plusieurs étapes constitue une chemin XPath :


   axe1::filtre1[prédicat1]/axe2::filtre2[prédicat2]

   Exemple concret :

   parent::*/child::node()[position()=2]



Si le chemin commence par un /, il s'agit d'un chemin absolu, c'est-à-dire prenant
son origine à la racine du document et non pas au noeud courant.

 Il est possible de faire une disjonction de requêtes XPath avec le signe | ; on
 obtient alors l'union des deux ensembles de noeuds correspondants.
      1 Les axes

•self : le noeud courant lui-même ;
•child : les enfants du noeud courant ;
•descendant, descendant-or-self : tous les descendants du noeud courant ;
•parent : le père du noeud courant ;
•ancestor, ancestor-or-self : les ancêtres du noeud courant ;
•attribute : les attributs du noeud courant ;
•preceding, following : les noeuds, précédants ou suivants, du noeud
courant, dans l'ordre de lecture du document ;
•preceding-sibling, following-sibling : les frères, précédant ou suivant, le
noeud courant ;
•namespace : les espaces de noms.
      2 Les Filtres



• node() : tous les noeuds ;
• text() : les noeuds textuels ;
• * : tous les éléments ;
• nom : les éléments portant ce nom ;
• comment() : les noeuds commentaires ;
• processing-instruction('cible') : les noeuds instructions, seulement les
instructions cible si cet argument est fourni.
    3 Les prédicats

Ils prennent la forme de tests que les noeuds sélectionnés devront vérifier.
Ces tests peuvent impliquer des fonctions ou de nouveaux chemins
XPath.



  child::toto[contains(text(),'coucou') and position()=2]
  child::toto[contains(text(),'coucou')][position()=2]
Notation plus simple mais pas aussi expressive que la notation étendue.


       Syntaxe abrégée               Syntaxe étendue
       .                             self::node()
       toto                          child::toto
       ../toto                       parent::toto
       @titi                         attribute::titi
                                     /descendant-or-
       //toto
                                     self::node()/child::toto
                                     descendant-or-
       .//toto
                                     self::node()/child::toto
       toto[2]                       child::toto[position() = 2]
Des fonctions sur les chaînes de caractères et qui vont donc porter sur les
contenus textuels de noeuds :
• concat () : colle ensemble les chaînes de caractères passées en paramètres ;
• string-length () : la longueur de la chaîne fournie ;
• contains , starts-with, ends-with : tests d'appartenance d'une chaîne dans une
autre.
Des fonctions qui prennent en argument une requête XPath et vont donc porter sur
des ensembles de noeuds :
 • count () : le nombre de noeuds dans l'ensemble sélectionné par la requête ;
 • name (): le nom de l'élément courant.

Positions relatives et information locale position() : postion dans le
contexte
• number() : Nombre de positions possibles dans le contexte
• count() : Cardinalité d‟un « node-set »
• last() : Indicateur de derniere position
Selector                         Selected nodes
/                                Document root
//                               Any sub-path
*                                Any element
name                             Element of tag name
@*                               Any attribute
@name                            Attribute of name name
text()                           Any text node
processing-instruction(„name‟)   Processing instruction of given name

comment()                        Any comment node
node()                           Any node
id(„value‟)                      Element of id value
Exemple :
Exemple :
Exemple
Exemple (Prédicat)
Exemple :
Exemple :
Requêtes primitives sur SGML (Standard Generalized
Markup Language)
���� 1998: propositions XQL et XML-QL
���� 1999: création du XML Query WG (Working Group)
���� Juin 2001: XQuery 1.0 WD (Working Draft)
���� Buts du XML Query WG
– Modèle de données pour les documents XML
– Des opérateurs de requêtes pour ce modèle de données
– Un langage de requêtes basé sur ces opérateurs de
requêtes
Document XML généré à partir d‟une base de données
���� Requêtes sur sur le document XML:
– «Filtrage de données XML»
– Création de sous-structures de données XML (résultat.xml)
���� XQuery est un langage de requêtes fonctionnel où la
requête est représentée sous la forme d‟une expression.
���� Basé sur OQL, SQL, XML-QL, XPath.
���� Compatible avec la syntaxe XML
          XQUERY



Requête             Recherche
  sql              d'information




          Structure
          d'arbres
Expression de cheminement (XPATH): /a//b[c = 5]
 Constructeur d‟élément: <a> ... </a>
 Expressions FLWR: FOR ... LET ... WHERE ... RETURN
 Opérateurs et Fonctions: x + y, -z
 Expressions conditionnelles: IF ... THEN ... ELSE
 Conditions «Some» et «Every»: EVERY var IN expr
SATISFIES expr
 Variables et constantes : $x, 5
 Trie: expr SORTBY (expr ASCENDING , ... )
      1 Expression Xpath


Toute expression de chemin XPath est une requête valide appelée requête XPath .
Une telle requete peut etre appliquée a un document (URI) ou à une collection de
documents (Forêt)

       Noms de tous les restaurants :

           collection(“Restaurants”)/Restaurant/Nom/text()

           collection(“Restaurants”)/Restaurant/Nom
<Guide region="exotique" version="2.0">
           <Restaurant type="indhou" categorie="**">
                       <Nom>Le passage Brady</Nom>
                       <Adresse>
                                  <No>43</No>
                                  <Rue>Faubourg Saint- Denis</Rue>
                                  <Ville>Paris 10</Ville>
                       </Adresse>
                       <Telephone>0142112310</Telephone>
           </Restaurant>
           <Restaurant type="thibetain" categorie="**">
                       <Nom>Le Lhassa</Nom>
                       <Adresse>
                                  <No>13</No>
                                  <Rue>Montagne Sainte-Genevieve</Rue>
                                  <Ville>Paris 5</Ville>
                       </Adresse>
                       <Telephone>0144122112</Telephone>
                       <Manager>Dicky</Manager>
           </Restaurant>
           <Epicerie type="egyptienne">
                       <Nom>Le Caire</Nom>
                       <Telephone>0146134582</Telephone>
                       <Manager>Ali Moussa</Manager>
                       <Specialite>falavel</Specialite>
           </Epicerie>
</Guide>
<Guide region="normandie" version="2.0">
           <Restaurant type="francais" categorie="***">
                     <Nom>Le Grand Hotel</Nom>
                     <Adresse>
                                 <Rue>Promenade M. Proust</Rue>
                                 <Ville>Cabourg</Ville>
                     </Adresse>
                     <Prix menu="midi">200</Prix>
                     <Prix menu="soir">300</Prix>
           </Restaurant>
           <Restaurant type="francais" categorie="**">
                     <Nom>L‟absinthe</Nom>
                     <Adresse>
                                 <No>10</No>
                                 <Rue>Quai Quarantaine</Rue>
                                 <Ville>Honfleur</Ville>
                     </Adresse>
                     <Prix menu="midi">150</Prix>
                     <Prix menu="soir">250</Prix>
                     <Telephone>0234142189</Telephone>
                     <Specialite>Fruits de Mer</Specialite>
           </Restaurant>
</Guide>
BD Guide


BD XML = forêt de documents XML
 Schéma de BD = Schéma XML si existant
 - Guide de données :
   - Schéma faible généré à partir d‟un ensemble de documents par union des
  arbres de structure décrivant tous les cheminements possibles dans la
  collection et par typage des données en texte
 - Schéma plus flexible que schéma relationnel
<Repertoire>
           <Hotel categorie="***">
                      <Nom>California</Nom>
                      <Adresse>
                                  <Num>32</Num>
                                  <Rue>Rue des Ecoles</Rue>
                                  <Code>75005</Code>
                                  <Ville>Paris</Ville>
                      </Adresse>
                      <Commentaire>Charmant hotel pres du centre</Commentaire>
                      <Prix>150</Prix>
           </Hotel>
                      <Hotel categorie="***">
                      <Nom>Le Saint Simon</Nom>
                      <Adresse>
                                  <No>32</No>
                                  <Rue>Rue Saint Simon</Rue>
                                  <Code>75005</Code>
                                  <Ville>Paris</Ville>
                      </Adresse>
                      <Commentaire>Proche restaurant celebre</Commentaire>
                      <Prix>300</Prix>
           </Hotel>
</Repertoire>
2- Expression FLWR

   for $var in <forêt> [, $var in <forêt>]...// itération
   let $var := <sous-arbre> // assignation
   where <condition> // élagage
   return <résultat> // construction
3- Sélection


  Lister le nom des restaurants de Cabourg:
   – collection(“Restaurants”)/Restaurant [Adresse/Ville= “Cabourg"] /Nom

   – <resultat>
    {for $R in collection("Restaurants")/Restaurant
    where $R/Adresse/Ville = “Cabourg”
    return {$R/Nom}}
    </resultat>
4- Jointure


  Lister le nom des Restaurants avec telephone dans la rue de l'Hôtel Lutecia:

   – for $R in collection(“guide ")/Restaurant,
          $H in collection(“repertoire")/Hotel
    where $H//Rue = $R//Rue
    and $H//Nom = "Le Lutecia"
    return
                    <Result>
                             {$R/Nom}
                             {$R/Téléphone}
                    </Result>
5- Utilisation du quantifieur some
 Donner les noms et adresses des restaurants ayant au moins un menu de
  prix supérieur à 50
  – for $R in collection (“guide”))/Restaurant
     where some $p in $R /menu/@prix satisfies (number($p )> 50)
     return
                   <Result>
                            {$R/Nom}
                            {$R/Téléphone}
                   </Result>

La quantification existentielle s‟effectue par défaut en Xquery donc la question
 précédente est équivalente à
 – for $R in collection (“guide”))/Restaurant
    where $R /menu/@prix > 50)
    return
                   <Result>
                             {$R/Nom}
                             {$R/Téléphone}
                   </Result>
6- Utilisation du quantifieur universel every
  Donner les noms et adresses des restaurants dont tous les menus sont de
   prix inférieur à 50
   – for $R in collection (“guide”))/Restaurant
      where every $p in $R /menu/@prix satisfies (number($p )< 50)
      return
                     <Result>
                              {$R/Nom}
                              {$R/Téléphone}
                     </Result>
7- Imbrication en where


  Adresses des hotels dans des villes ayant des restaurants trois étoiles

   – for $h in collection(“repertoire”)/Hotel
     where $h/Adresse/Ville in
       for $r in collection(“guide”)/Restaurant
       where $r/@categorie = "***"
       return {$r/Adresse/Ville/text()}
    return {$h/Adresse}
8- Agrégat simple


  Combien de restaurants y-a-t-il en collection ?

   let $R := collection(“guide”)/Restaurant
   return
      <NombreRestaurant > {count ($R)} </NombreRestaurant>
For vs let

       FOR $x IN collection(guide)/restaurant/nom
       RETURN <result> $x </result>

                   Returns:
                   <result> <nom>...</nom></result>
                   <result> <nom>...</nom></result>
                   <result> <nom>...</nom></result>

       Let $x IN collection(guide)/restaurant/nom
       RETURN <result> $x </result>
                   <result>
                            <nom>...</nom>
                             <nom>...</nom>
                             <nom>...</nom>
                   .</result>
9- Agrégat partitionné


  Lister le nom de chaque restaurant avec le prix moyens des menus proposés
   – for $r in collection(“guide”)//Restaurant
     let $a := collection(“guide”)// [Restaurant = $r]//Menu/@Prix
     return
     <resultat>
        {$r/Nom}
       <avgPrix>{AVG($a)}</avgPrix>
     </resultat>
10 - Recherche textuelle


  Lister les bons restaurants de Paris

   – for $r in collection(“guide”)//Restaurant
    where (contains ($r/Comments, “Bon”)
    or contains ($r/Comments, “Excellent”))
    and $r/Adresse/Ville = “Paris”
    return {$r/Nom}
11- Ordre


  Lister les bons restaurants de Paris par ordre alphabétique

   for $r in collection(“Restaurants”)//Restaurant
   where (contains($r/Comments, "Excellent”)
   or contains($r/Comments, "Good”))
   and $r/Adresse/Ville = “Paris”
   return {$r/Nom}
   orderby ($r/Nom descending)
Requête intégrée dans un document XML
  Construire un document avec en-tête, titre, liste restaurants peu
  chers, titre, liste restaurants chers

      <XML_document>
        <Very_Expensive_Restaurants>
             <Title>List of very expensive restaurants</Title>
           {for $r in collection("Restaurants”)//Restaurant
           where every $p in $r/Menu/@Prix satisfies ($p>100)
           return {$r}}
       </Very_Expensive_Restaurants>
       <Very_cheap_Restaurants>
          <Title>List of very inexpensive restaurants</Title>
           {for $r in collection(“Restaurants”)//Restaurant
           where some $p in $r/Menu/@Prix satisfies ($p<10)
           return {$r}}
        <Date>{date()}</Date>
        </Very_cheap_Restaurants>
      </XML_document>
Xupdate : support des mise à jour

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:182
posted:7/15/2011
language:French
pages:42