Introduction
En cours de finalisation auprès du W3C, la spécification XML Query décrit un "langage souple de balises, capable de marquer le conteneur d'informations en provenance de diverses sources de données, dont les documents structurés ou semi-structurés, les bases de données relationnelles et les archives d'objets". En bref, XML-Query sert à traiter des données XML (et assimilées).
XML-Query, ou XQuery, répond donc à un besoin: celui de lancer des requêtes sur des sources de données XML, étant donné le nombre maintenant énorme de données enregistrées, échangées et présentées via XML. Le langage a donc été conçu pour permettre des requêtes précises facilement compréhensibles, tout en étant suffisemment souple pour permettre d'accéder à un grand nombre de types de sources d'informations XML, dont les bases de données et les documents.
XQuery est un dérivé de Quilt, qui lui-même empruntait de nombreuses fonctionnalités de XPath 1.0, XQL, XML-QL, SQL et OQL. Plus directement, XQuery est un dérivé de XPath 2.0, les deux langages ayant de fait beaucoup de similarités.

Les bases de XQuery
L'élement de base du langage XQuery est l'expression. Tout en XQuery est une expression qui renvoi une valeur. Un programme ou script XQuery n'est rien d'autre qu'une expression, avec en option des fonctions ou définitions. Le langage reconnait de nombreuses sortes d'expressions qui peuvent être construites à partir de mots-clés, de symboles ou d'opérandes.
XQuery est un langage fonctionnel où chaque requête est une expression. Il existe sept types d'expressions: expression de chemin, constructeurs d'éléments, expressions FLWR, expressions mettant en jeu des opérateurs et des fonctions, expressions conditionnelles, et expressions qui testent ou modifient les types de données. Ces diverses expressions peuvent être utilisées soit directement, soit dans des blocs emboîtés.

Expressions de chemin
Elles sont basées sur la synthaxe de XPath, le standard XML pour décrire des "chemins" dans un document XML:

pour trouver tous les titres de chapitres dans un document livres.xml:
document("livres.xml")//chapitre/titre

pour trouver tous les livres publiés par Addison-Wesley après 1991:
document("biblio.xml")//livre[editeur = "Addison-Wesley" AND @annee > "1991"]

Constructeurs d'éléments
Utilisés quand une requête doit créer de nouveaux éléments. Les accolades { } permettent de placer une expression au sein d'un constructeur.

Génère un élement <livre> dont un sous élément est <titre> et qui contient l'attribut "année":
<livre>
  { $b/@annee }
  { $b/titre }
</livre>

La variable $b est rattachée à une autre partie de la requête. Quand l'ensemble de la requête est lancée, le constructeur ci-dessus donnera un résultat sous la forme suivante:

<livre annee="2002">
  <titre>ActionScript for Flash MX: The Definitive Guide</title>
</livre>

Expressions FLWR
Prononcée "flower", une expression FLWR (For, Let, Where, Return) est similaire à la construction SELECT-FROM-WHERE de SQL (avec qui elle partage certaines capacités), et compose le squelette de l'expression XQuery. Une expression FLWR est composée de :
- une clause FOR: attache une ou plusieurs variables à une séquence de valeurs renvoyées par une autre expression (généralement une expression de chemin), et boucle dans les valeurs.
- clause LET: attache aussi une ou plusieurs variables à une séquence, mais sans itération.
- clause WHERE: contient un ou plusieurs prédicats qui filtrent ou limitent le jeu de noeuds générés par les clauses FOR/LET.
- clause RETURN: génère le résultat de l'expression FLWR. Elle contient généralement un ou plusieurs éléments constructeurs et/ou des références à des variables, et est executée une fois pour chaque noeud renvoyé par les clauses FOR/LET/WHERE.

<resultats>
  {
  FOR $t IN distinct(document("prix.xml")/prix/livre/titre)
  LET $p := avg(document("prix.xml")/prix/livre[titre=$t]/prix)
  WHERE (document("biblio/xml")/livre[titre=$t]/editeur) = "Addison-Wesley"
  RETURN
    <resultat>
      { $t }
      <moy>
        { $p }
      </moy>
    </resultat>
  }
</resultats>

En plus des fonctions internes, XQuery fournit un mécanisme permettent à l'utilisateur de créer ses propres fonctions.

Expressions conditionnelles
XQuery autorise l'utilisation des expressions IF/THEN/ELSE:

<utilisateur>
  { $u/numero }
  { $u/nom }
  {
  IF (empty($b))
  THEN <status>inactif</status>
  ELSE <status>actif</status>
  }
</utilsateur>

Expressions quantifiées
Ce terme décrit SOME et EVERY. Avec SOME, il est possible de déterminer si au moins un noeud d'un bloc de noeuds correspond à un prédicat. L'expression EVERY permet quant à elle de tester si tous les noeuds d'un bloc correspondent à un prédicat.

Le code suivant fait la liste des utilisateurs ayant parié sur tous les jeux:
<parieur>
  {
  FOR $u IN document("utilisateur.xml")//utilisateur_tuple
  WHERE
    EVERY $item IN document("jeux.xml")//jeu_tuple SATISFIES SOME $b IN document("paris.xml")//pari_tuple SATISFIES ($jeu/numjeu = $b/numjeu AND $u/numutilisateur = $b/numutilisateur)
  RETURN
    $u/nom
  }
</parieur>

Expressions servant à tester ou modifier des types de données
XQuery utilise à la fois les types de données standards (basés sur le système de typage de XML Schema: nombres, booléens, chaînes, dates, temps, durées...) et les types de données utilisateur. Les expressions INSTANCEOF et TYPESWITCH/CASE sont utilisées pour tester si une occurence est d'une type donné.

Constantes et variables
Constantes et variables sont les expressions les plus basiques de XQuery. Les constantes prennent la forme de représentations littérales de valeurs:
"Journal du Net"
42
true
"2002-11-04"

La requête suivante affiche le client dont le numéro est 3715:
let $numclient := "3715"
return document("clients.xml")//client[numclient=$numclient]

Dans cet exemple, "3715" est la constante, et $numclient la variable.

Opérateurs
On retrouve dans XQuery les même opérateurs que dans les autres langages.

Les opérateur arithmétiques:
let $prix := document("commande.xml")//achat[numachat='0021']/prix
let $quantite := document("commande.xml")//commande[@num='001']/achat/quantite
let $taux := document("commande.xml")//achat[numachat='0021']/taux
return
  <resultat>
    <prixunite> { $prix div $quantite } </prixunite>
    <taxe> { $prix * $taux } </taxe>
    <total> { $prix + $prix * $taux } </total>
  </resultat>

Les opérateurs de comparaison:
for $element in document("donnees.xml")//element
return
  <resultat>
    { $element/numElement }
    <niveau>
    { IF ( $element/prix >= 500 ) THEN 3 ELSE
      IF ( $element/prix >= 200 ) THEN 2 ELSE
      IF ( $element/prix <= 50 ) THEN 0 ELSE 1 }
    </niveau>
  </resultat>

Les opérateurs booléens
for $element in document("donnees.xml")//element
return
  <resultat>
    {$element/numElement}
    <niveau>
      { if ( $element/prix >= 500 and $element/prix < 10000 ) then 3 else
        if ( $element/prix >= 200 and $element/prix < 500 ) then 2 else
        if ( $element/prix <= 200 and $element/prix > 50 ) then 1 else 0 }
    </niveau>
  </result>

D'autres opérateurs existent, dont des moins "classiques", que nous ne couvrirons pas dans cet article.

XQuery est donc un langage puissant et élégant, qui permet au XML d'atteindre son plein potentiel dans la gestion de données en provenance de bases de données et autre documents au format XML. C'est un apport essentiel dans la vaste panoplie d'outils XML, qui se révèle de plus en plus nécessaire à mesure que la plupart des données du monde informatiques sont stockées dans ce langage. XQuery est particulièrement recommandé quand se fait sentir le besoin d'un outil puissant et pratique pour analyser ou générer du XML.