<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="xsl/default.xml"?>
<xemmet xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<title>Aide mémoire: de SQL à XPath 1.0</title>
<author>
  <firstname>Frédéric</firstname>
  <surname>Desmoulins</surname>
</author>
<copyright>Ce site est copyleft 2003 Frédéric Desmoulins</copyright>
<xhtmlHead>
<script type="text/javascript" src= "http://www.fragbase.com//js/browser.js" />
<link rel="stylesheet" type="text/css" href="css/emmet.css" media="screen" />
  <link rel="stylesheet" type="text/css" href="css/code.css" media="print,screen" />
  <link rel="stylesheet" type="text/css" href="css/print.css" media="print" />
</xhtmlHead>
  
<xhtmlOption>
</xhtmlOption>

<object id="obj1" pos="left" type="menu">
  <name>Mots clés SQL</name>
  <item id="kw0" href="#avg">AVG</item>
  <item id="kw1" href="#count">COUNT</item>
  <item id="kw2" href="#distinct">DISTINCT</item>
  <item id="kw3" href="#from">FROM</item>
  <item id="kw4" href="#groupby">GROUP BY &amp; HAVING</item>
  <item id="kw5" href="#minmax">MIN/MAX</item>
  <item id="kw6" href="#orderby">ORDER BY</item>
  <item id="kw7" href="#select">SELECT</item>
  <item id="kw8" href="#sum">SUM</item>
  <item id="kw9" href="#where">WHERE</item>
</object>

<articles>
  <article>
    <title>Aide mémoire à la transition de SQL à XPath 1.0.</title>
    <icon src="image/s2x/draft.png" width="48" height="24" />
    <content>
<p>Cette documentation s'adresse à ceux qui connaissent le langage SQL mais qui débutent avec XSLT/XPath. Si vous savez comment, via une requête SQL, récuperer les informations de votre base de données mais que vous êtes face à une base de données XML, cette doc devrait vous aider.</p>
<p><strong>Note: </strong>Ce travail est en cours de rédaction. Si certaines parties manquent de clareté votre contribution est bienvenue. Malgré tous mes efforts des erreurs peuvent apparaître. Veuillez me les communiquer le cas échéant. N'hésitez pas non plus à m'envoyer vos commentaires.
</p>
<p style="margin-top: 1em;">Auteur: Frédéric Desmoulins &lt;fredericdesmoulins à altern point com&gt;<br />
Réf. Web: http://www.fragbase.com/sql2xpath.php<br />
Dernière modification: 03/04/2006<br />
Licence: GNU FDL 
</p>
    </content>
  </article>
  <article id="avg">
    <title>AVG</title>
    <content>
<p>XPath 1.0 ne dispose pas d'une fonction permettant de calculer une moyenne. Il faudra effectuer la somme (cf. <a href="#sum">sum</a>) puis la diviser par le nombre d'occurence (cf. <a href="#count">count</a>).
<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple : </strong>Calculer la moyenne des poids.<br />
<div class="codeContainer">SQL: SELECT AVG(poids) FROM PERSONNE</div>
<div class="codeContainer">XPath 1.0:
sum(/personnes/personne/poids)
div
count(/personnes/personne/poids)</div>
  </p>  
  </content>
  </article>
  <article id="count">
    <title>COUNT</title>
    <content>
<p>On utilise la fonction <code>count(nodes)</code> pour compter le nombre de noeud localisé par l'expression XPath <code>nodes</code>. On peut également obtenir le nombre d'élément contextuel via la fonction <code>last()</code>.<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple : </strong>Compter le nombre de personne.
  <div class="codeContainer">SQL: SELECT COUNT(*) FROM PERSONNE</div>
  <div class="codeContainer">XPath: count(/personnes/personne)</div>
</p>
    </content>
  </article>
  <article id="distinct">
    <title>DISTINCT</title>
    <content>
<p>Il n'y a pas fonction équivalente au DISTINCT de SQL dans les spécifications de XPath 1.0. Cependant il est  possible d'y remedier grâce au sélecteur d'axe. <em class="underlined">Séléctionner les noeuds distincts revient à séléctionner les noeuds qui n'ont pas de précédent - ou de suivant - `semblable'.</em><br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    taille <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;taille&gt;1.70&lt;/taille&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;taille&gt;1.7&lt;/taille&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;taille&gt;1.80&lt;/taille&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple 1 : </strong>Séléctionner les noms de personnes différents.
  <div class="codeContainer">SQL: SELECT DISTINCT nom FROM PERSONNE</div>
  <div class="codeContainer">XPath 1.0:
/personnes/personne[
  not(nom = preceding-sibling::personne/nom)
]/nom
<div style="text-align: center; margin: 1em 0 1em 0"><em style="color: red">ou</em></div>/personnes/personne[
  not(nom = following-sibling::personne/nom)
]/nom</div>
<strong>Exemple 2 : </strong>Séléctionner les tailles de personnes différentes.
  <div class="codeContainer">SQL: SELECT DISTINCT taille FROM PERSONNE</div>
  <div class="codeContainer">XPath 1.0:
/personnes/personne[
  not(number(taille) = preceding-sibling::personne/taille)
]/taille
<div style="text-align: center; margin: 1em 0 1em 0"><em style="color: red">ou</em></div>/personnes/personne[
  not(number(taille) = following-sibling::personne/taille)
]/taille</div>
<strong>Important: </strong>N'oubliez pas d'utiliser <code>number(node)</code> lorsque vous effectuez des comparaisons entre des nombres.<br /><br />
<strong>Note: </strong><code>sibling</code> éxige que les éléments précédent - ou suivant - aient le même élément parent que l'élément contextuel (l'axe parent). Dans notre exemple qui ne contient que des personnes on aurait pu tout aussi bien utiliser <code>preceding::nom</code> ou <code>following::nom</code>: Ce qui revient à rechercher les éléments 'nom' précédent ou suivant l'élément contextuel (Attention: XPath fait alors la séléction à l'intérieur comme à l'exterieur de l'axe parent !).
</p>
    </content>
  </article>
  <article id="from">
    <title>FROM</title>
    <content>
<p>Par défaut XPath parcourt les éléments appartenant au document XML courant (celui qui a été chargé par votre processeur XSLT ou bien celui qui est référencé dans votre document comme une feuille de style XSL). On peut néanmoins séléctionner des éléments appartenant à un autre document XML en le référençant - via une URI, un chemin absolu ou relatif de votre système de fichier - grâce à l'instruction <code>document('URI')</code>.<br />
<em>Il est également possible d'effectuer une sélection multiple en combinant des noeuds grâce à l'opérateur 'ou' représenté par: <code>|</code>.</em><br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple 1 : </strong>Sélectionner tous les éléments de type 'personne' dans le document situé à l'URL http://example.com/personnes.xml.
<div class="codeContainer">XPath:
document('http://example.com/personnes.xml')//personne</div>
<strong>Exemple 2 : </strong>Sélectionner tous les éléments de type 'personne' dans le document situé à l'URL http://example.com/personnes.xml avec ceux appartenant au document courant.
<div class="codeContainer">XPath:
document('http://example.com/personnes.xml')//personne | 
//personne</div>
</p>
    </content>
  </article>
  <article id="groupby">
    <title>GROUP BY &amp; HAVING</title>
    <content>
      <p>
        Le regroupement ne peut pas s'effectuer via XPath. Il faudra le faire via le langage manipulant vos expressions XPath (XSLT par exemple).<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
    taille <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
    &lt;taille&gt;1.70&lt;/taille&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
    &lt;taille&gt;1.70&lt;/taille&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
    &lt;taille&gt;1.80&lt;/taille&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple : </strong>Afficher le poids moyen en fonction des différentes tailles.<br />
<strong>Méthode XPath: </strong><br /><em class="underlined">
  a) Parcourir l'ensemble des tailles distinctes (cf. <a href="#distinct">distinct</a>)<br />
  b) A chaque taille nommée <em style="color: green">'t(i)'</em> provenant de (a), calculer la moyenne (cf. <a href="#avg">avg</a>) des poids du groupe définit par la règle <em style="color: green">'taille=t(i)'</em>.</em>
<div class="codeContainer">Sortie attendue:
&lt;moyennePoids taille="1.7"&gt;72.5&lt;/moyennePoids&gt;
&lt;moyennePoids taille="1.8"&gt;92&lt;/moyennePoids&gt;</div>
<div class="codeContainer">SQL: SELECT taille, AVG(poids) FROM PERSONNE GROUP BY taille;</div>
<div class="codeContainer">XSLT:
&lt;xsl:for-each select="
  /personnes/personne[
    not(number(taille)=preceding-sibling::personne/taille)
  ]/taille"&gt;
  &lt;moyennePoids taille="{number(.)}"&gt;
    &lt;xsl:value-of select="
      sum(/personnes/personne[number(taille)=current()]/poids) 
      div 
      count(/personnes/personne[number(taille)=current()])
    " /&gt;
  &lt;/moyennePoids&gt;
&lt;/xsl:for-each&gt;</div>
      </p>
    </content>
  </article>
  <article id="minmax">
    <title>MIN/MAX</title>
    <content><p>
XPath 1.0 ne propose pas de fonctions équivalentes aux MIN et MAX de SQL. Cependant il est  possible d'arriver au même résultat grâce au sélecteur d'axe. <em class="underlined">Séléctionner le noeud le plus 'petit'/'grand' revient à séléctionner le noeud qui n'a pas de précédent ni de suivant plus 'petit'/'grand'.</em><br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple 1 : </strong>Obtenir la ou les personnes ayant le poids le plus léger. 
  <div class="codeContainer">SQL:
SELECT * FROM PERSONNE WHERE poids IN (
  SELECT MIN(poids) FROM PERSONNE
)</div>
  <div class="codeContainer">XPath 1.0:
/personnes/personne[
  not(number(poids) &gt; (
    preceding-sibling::personne/poids | 
    following-sibling::personne/poids)
  )
]</div>
<strong>Exemple 2 : </strong>Obtenir la ou les personnes ayant le poids le plus lourd. 
  <div class="codeContainer">SQL:
SELECT * FROM PERSONNE WHERE poids IN (
  SELECT MAX(poids) FROM PERSONNE
)</div>
  <div class="codeContainer">XPath 1.0:
/personnes/personne[
  not(number(poids) &lt; (
    preceding-sibling::personne/poids | 
    following-sibling::personne/poids)
  )
]</div>
<strong>Note: </strong><code>sibling</code> éxige que les éléments précédent - ou suivant - aient le même élément parent que l'élément contextuel. Dans notre exemple qui ne contient que des personnes on aurait pu tout aussi bien utiliser <code>preceding::poids</code> et <code>following::poids</code>: Ce qui revient à rechercher les éléments 'poids' précédent ou suivant l'élément contextuel (Attention: XPath fait alors la séléction à l'intérieur comme à l'exterieur de l'axe parent !).</p>
    </content>
  </article>
  <article id="orderby">
    <title>ORDER BY</title>
    <content>
      <p>
        Le trie d'une séléction ne se fait pas via une expression XPath mais généralement grâce au langage manipulant XPath. Si l'on utilise XPath au travers d'XSLT on peut alors parcourir une séléction dans un ordre prédéfinit.<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple 1 : </strong>Parcourir les personnes dans l'ordre alphabétique de leur nom.
<div class="codeContainer">SQL: SELECT * FROM PERSONNE ORDER BY nom</div>
<div class="codeContainer">XSLT:
&lt;xsl:for-each select="/personnes/personne"&gt;
  &lt;xsl:sort select="nom" /&gt;
  &lt;!-- Implémentation --&gt;
&lt;/xsl:for-each&gt;
</div>
<strong>Exemple 2 : </strong>Parcourir les personnes du plus lourd au plus léger.
<div class="codeContainer">SQL: SELECT * FROM PERSONNE ORDER BY poids DESC</div>
<div class="codeContainer">XSLT:
&lt;xsl:for-each select="/personnes/personne"&gt;
  &lt;xsl:sort select="poids"
      data-type="number"
      order="descending" /&gt;
  &lt;!-- Implémentation --&gt;
&lt;/xsl:for-each&gt;
</div>
<strong>Important: </strong>N'oubliez pas d'utiliser <code>data-type="number"</code> lorsque vous classez des nombres.<br /><br />
      </p>
    </content>
  </article>
  <article id="select">
    <title>SELECT</title>
    <content>
<p>Pour sélectionner des noeuds dans l'arbre XML on définit le chemin (absolu ou relatif) de localisation. La localisation s'effectue comme celle que l'on utilise avec les shell UNIX: avec le charactère <code>/</code>.<br />
Pour parcourir l'arborescence à partir de la racine (chemin absolu) on commence l'expression XPath avec <code>/</code>, puis on descend dans l'arbre.
On peut également utiliser une autre technique qui consiste à indiquer l'element recherché précédé de <code>//</code>. Attention ce dernier moyen oblige votre processeur XPath à parcourir <em>tout</em> l'arbre sans considérer aucun axe (à eviter lorsque ce n'est pas nécessaire) !<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple : </strong>Séléctionner tous les éléments de type personne (donc tous les sous éléments et attributs de 'personne': nom, prénom, id).
<div class="codeContainer">SQL: SELECT * FROM PERSONNE</div>
<div class="codeContainer">XPath:
/personnes/personne
<div style="text-align: center;margin: 1em 0 1em 0"><em style="color: red">ou</em></div>//personne</div>
</p>
    </content>
  </article>
  <article id="sum">
    <title>SUM</title>
    <content>
<p>On utilise la fonction <code>sum(numberNodes)</code> pour effectuer la somme des noeuds localisés par l'expression XPath <code>numberNodes</code>. Si tous les noeuds ne sont pas des nombres, <code>NaN</code> (Not A Number) est retourné.<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple : </strong>Compter la somme du poids de chaque personne.
  <div class="codeContainer">SQL: SELECT SUM(poids) FROM PERSONNE</div>
  <div class="codeContainer">XPath: sum(/personnes/personne/poids)</div>
</p>
    </content>
  </article>
  <article id="where">
    <title>WHERE</title>
    <content>
<p>Pour sélectionner des éléments en applicant une ou plusieurs conditions on utilise des crochets contenant le ou les tests <code>['condition']</code>.<br />
Les prédicats s'appliquent sur les noeuds définis par le chemin précédent les crochets ou, par défaut, sur les noeuds contextuels. On peut combiner les tests en utilisant <code>and</code> et/ou <code>or</code> dans la même paire de crochet.<br /><br />
<div style="float: left;">
<div class="dbContainer">
  <div class="tableName">PERSONNE</div>
  <div>
    <span class="pKey">id</span> <span class="fieldType">(unsigned int)</span><br />
    nom <span class="fieldType">(varchar 256)</span><br />
    prenom <span class="fieldType">(varchar 256)</span><br />
    poids <span class="fieldType">(unsigned float)</span><br />
  </div>
</div>
<div class="codeContainer">&lt;personnes&gt;
  &lt;personne id="1"&gt;
    &lt;nom&gt;Dupont&lt;/nom&gt;
    &lt;prenom&gt;Michel&lt;/prenom&gt;
    &lt;poids&gt;77&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="2"&gt;
    &lt;nom&gt;Durand&lt;/nom&gt;
    &lt;prenom&gt;Paul&lt;/prenom&gt;
    &lt;poids&gt;68&lt;/poids&gt;
  &lt;/personne&gt;
  &lt;personne id="3"&gt;
    &lt;nom&gt;Clavier&lt;/nom&gt;
    &lt;prenom&gt;George&lt;/prenom&gt;
    &lt;poids&gt;92&lt;/poids&gt;
  &lt;/personne&gt;
&lt;/personnes&gt;</div>
</div>
<strong>Exemple 1 : </strong>Séléctionner tous les éléments de type personne qui ont un nom commençant par un 'D'.
<div class="codeContainer">SQL: SELECT * FROM PERSONNE WHERE nom like 'D%'</div>
<div class="codeContainer">XPath: /personnes/personne[starts-with(nom, 'D')]</div>
<strong>Exemple 2 : </strong>Séléctionner les poids des personnes qui sont supérieurs à 70 et qui ont un nom commençant par un 'D'.
<div class="codeContainer">SQL: SELECT poids FROM PERSONNE WHERE poids&gt;70 AND nom like 'D%'</div>
<div class="codeContainer">XPath:
/personnes/personne[
  number(poids) &gt; 70 and starts-with(nom, 'D')
]/poids 
<div style="text-align: center;margin: 1em 0 1em 0"><em style="color: red">ou</em></div>/personnes/personne[
  starts-with(nom, 'D')
]/poids[number(.) &gt; 70]</div>
</p>
    </content>
  </article>
</articles>
</xemmet>

