Expressions de chemin : spécification de l’axe

S'applique à : SQL Server

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

• Axe

• Un test de nœud

• Zéro ou plusieurs qualificateurs d’étape (facultatif)

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

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

Tous ces axes, à l’exception de l’axe parent , sont des axes avant. L’axe parent est un axe inverse, car il 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 é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 des 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 de 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 du 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 :

• La query() méthode du type de données xml spécifie l’expression de chemin d’accès.

• Les deux étapes de cette expression définissent un axe child et les noms des nœuds, ProductDescription et Features en tant que tests de nœuds. Pour plus d’informations sur les tests de nœud, consultez Spécification du test de nœud dans une étape d’expression de chemin d’accès.

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 de 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 Spécification du test de nœud dans une rubrique Étape d’expression de chemin d’accès.

Les nœuds d’élément <c> 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 descendants 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’enfant d’élément 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’enfant <>Summaryde 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 du catalogue de modèles de produit 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 indiqué 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 l’instruction et l’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 l’élément 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.