Expressions de chemin : spécification de l’axe

  • Article

S’applique à :SQL Server

Une étape d'axe dans une expression de chemin d'accès inclut les composants suivants :

Pour plus d’informations, consultez Expressions de chemin (XQuery).

L’implémentation XQuery dans SQL Server prend en charge les étapes d’axe suivantes :

Axe Description
child Retourne l'enfant du nœud du contexte.
descendant Retourne tous les descendants du nœud du contexte.
parent Retourne le parent du nœud du contexte.
attribute Retourne les attributs du nœud du contexte.
soi-même Retourne le nœud du contexte lui-même.
descendant-or-self Retourne le nœud du contexte et tous ses descendants.

Tous ces axes, à l’exception de l’axe parent , sont des axes avant. L’axe parent est un axe inverse, car il effectue une recherche vers l’arrière dans la hiérarchie de documents. Par exemple, l'expression de chemin d'accès relative child::ProductDescription/child::Summary comprend deux étapes, chacune spécifiant un axe child. La première étape récupère les enfants de l’élément <ProductDescription> du nœud de contexte. Pour chaque <nœud d’élément ProductDescription> , la deuxième étape récupère les enfants du nœud d’élément <Summary> .

L'expression de chemin d'accès relative child::root/child::Location/attribute::LocationID comporte quant à elle trois étapes. Les deux premières définissent un axe child, et la troisième, un axe attribute. Lorsqu’elle est exécutée sur les documents XML d’instructions de fabrication dans la table Production.ProductModel , l’expression retourne l’attribut LocationID du <nœud d’élément Location> enfant de l’élément <racine> .

Exemples

Les exemples de requête de cette rubrique sont spécifiés par rapport aux colonnes de type xml dans la base de données AdventureWorks .

R. Spécification de l'axe enfant

Pour un modèle de produit spécifique, la requête suivante récupère les <enfants de nœud d’élément Features> du <nœud d’élément ProductDescription> à partir de la description du catalogue de produits stockée dans la Production.ProductModel table.

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
  /child::PD:ProductDescription/child::PD:Features')  
FROM Production.ProductModel  
WHERE ProductModelID=19

Notez les points suivants dans la requête précédente :

B. Définition des axes descendant et descendant-or-self

L'exemple ci-dessous utilise des axes descendant et descendant-or-self. La requête dans cet exemple est spécifiée par rapport à une variable de type xml . L'instance XML est simplifiée pour illustrer facilement la différence dans les résultats générés.

declare @x xml  
set @x='  
<a>  
 <b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
 </b>  
</a>'  
declare @y xml  
set @y = @x.query('  
  /child::a/child::b  
')  
select @y

Dans le résultat suivant, l'expression retourne l'enfant <b> du nœud d'élément <a> :

<b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
</b>

Dans cette expression, si vous spécifiez un axe descendant pour l'expression de chemin d'accès,

/child::a/child::b/descendant::*, vous demandez tous les descendants du nœud d’élément <b> .

L'astérisque (*) dans le test de nœud représente le nom du nœud comme un test de nœud. Par conséquent, le type de nœud principal de l'axe descendant, le nœud d'élément, détermine les types de nœuds retournés. En d'autres termes, l'expression retourne tous les nœuds d'élément. Les nœuds de texte sont retournés. Pour plus d’informations sur le type de nœud principal et sa relation avec le test de nœud, consultez la rubrique Spécification du test de nœud dans une étape d’expression de chemin d’accès .

Les nœuds <c> de l’élément et <d> sont retournés, comme indiqué dans le résultat suivant :

<c>text2  
     <d>text3</d>  
</c>  
<d>text3</d>

Si vous spécifiez un axe descendant-ou-auto au lieu de l’axe descendant, /child::a/child::b/descendant-or-self::* retourne le nœud de contexte, l’élément <b>et son descendant.

Voici le résultat obtenu :

<b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
</b>  
  
<c>text2  
     <d>text3</d>  
</c>  
  
<d>text3</d>

L’exemple de requête suivant sur la base de données AdventureWorks récupère tous les nœuds d’élément descendant de l’élément <Features> enfant de l’élément :<ProductDescription>

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
  /child::PD:ProductDescription/child::PD:Features/descendant::*  
')  
FROM  Production.ProductModel  
WHERE ProductModelID=19

C. Spécification de l'axe parent

La requête suivante retourne l’élément enfant de l’élément <ProductDescription> dans le document XML du catalogue de produits stocké dans la Production.ProductModel table.<Summary>

Cet exemple utilise l’axe parent pour revenir au parent de l’élément et récupérer l’élément <>Summaryenfant de l’élément.ProductDescription<><Feature>

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
  
/child::PD:ProductDescription/child::PD:Features/parent::PD:ProductDescription/child::PD:Summary  
')  
FROM   Production.ProductModel  
WHERE  ProductModelID=19

Dans cette requête, l'expression de chemin d'accès utilise l'axe parent. Vous pouvez la réécrire sans l'axe parent, comme ceci :

/child::PD:ProductDescription[child::PD:Features]/child::PD:Summary

L'exemple ci-dessous illustre un emploi plus utile de l'axe parent.

Chaque description de catalogue de modèles de produits stockée dans la colonne CatalogDescription de la table ProductModel a un <ProductDescription> élément qui a l’attribut et <Features> l’élément ProductModelID enfant, comme illustré dans le fragment suivant :

<ProductDescription ProductModelID="..." >  
  ...  
  <Features>  
    <Feature1>...</Feature1>  
    <Feature2>...</Feature2>  
   ...  
</ProductDescription>

La requête définit une variable itérateur, $f, dans l'instruction FLWOR afin de retourner l'enfant de l'élément <Features>. Pour plus d’informations, consultez Instruction et itération FLWOR (XQuery). Pour chaque fonctionnalité, la clause return construit du code XML au format suivant :

<Feature ProductModelID="...">...</Feature>  
<Feature ProductModelID="...">...</Feature>

Pour ajouter le ProductModelID pour chaque <Feature> élément, l’axe parent est spécifié :

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
  for $f in /child::PD:ProductDescription/child::PD:Features/child::*  
  return  
   <Feature  
     ProductModelID="{ ($f/parent::PD:Features/parent::PD:ProductDescription/attribute::ProductModelID)[1]}" >  
          { $f }  
   </Feature>  
')  
FROM  Production.ProductModel  
WHERE ProductModelID=19

Voici le résultat partiel :

<Feature ProductModelID="19">  
  <wm:Warranty   
   xmlns:wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain">  
    <wm:WarrantyPeriod>3 years</wm:WarrantyPeriod>  
    <wm:Description>parts and labor</wm:Description>  
  </wm:Warranty>  
</Feature>  
<Feature ProductModelID="19">  
  <wm:Maintenance   
   xmlns:wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain">  
    <wm:NoOfYears>10 years</wm:NoOfYears>  
    <wm:Description>maintenance contract available through your dealer   
                  or any AdventureWorks retail store.</wm:Description>  
  </wm:Maintenance>  
</Feature>  
<Feature ProductModelID="19">  
  <p1:wheel   
   xmlns:p1="https://www.adventure-works.com/schemas/OtherFeatures">  
      High performance wheels.  
  </p1:wheel>  
</Feature>

Notez que le prédicat [1] dans l'expression de chemin d'accès est ajouté pour garantir qu'une valeur singleton est retournée.