Expressions de comparaison (XQuery)

S’applique à :SQL Server

XQuery fournit les types d'opérateurs de comparaison suivants :

• Opérateurs de comparaison générale

• Opérateurs de comparaison de valeurs

• Opérateurs de comparaison de nœuds

• Opérateurs de comparaison d’ordre de nœud

Opérateurs de comparaison généraux

Les opérateurs de comparaison générale peuvent être utilisés pour comparer des valeurs atomiques, des séquences ou une combinaison des deux.

Le tableau suivant énumère les opérateurs généraux.

Lorsque vous comparez deux séquences à l'aide des opérateurs de comparaison générale et qu'il existe, dans la deuxième séquence, une valeur qui compare True à une valeur de la première séquence, le résultat global est True. Dans le cas contraire, le résultat est False. Par exemple, (1, 2, 3) = (3, 4) est True car la valeur 3 apparaît dans les deux séquences.

declare @x xml  
set @x=''  
select @x.query('(1,2,3) = (3,4)')    

La comparaison s'attend à ce que les valeurs soient de types comparables. Ces derniers sont d'ailleurs vérifiés de manière statique. En cas de comparaisons numériques, la promotion du type numérique peut se produire. Par exemple, si une valeur décimale de 10 est comparée à une valeur double précision de 1e1, la valeur décimale est convertie en valeur double précision. Sachez que cela peut entraîner des résultats erronés puisque les comparaisons double précision ne peuvent pas être exactes.

Si l'une des valeurs est non typée, elle est convertie dans le type de l'autre valeur. Dans l'exemple suivant, la valeur 7 est traitée comme un entier. Avant la comparaison, la valeur non typée de /a[1] est convertie en entier. La comparaison des entiers renvoie la valeur True.

declare @x xml  
set @x='<a>6</a>'  
select @x.query('/a[1] < 7')  

Inversement, si la valeur non typée est comparée à une chaîne ou à une autre valeur non typée, elle sera convertie en xs:string. Dans la requête suivante, la chaîne 6 est comparée à la chaîne "17". La requête suivante renvoie la valeur False suite à la comparaison des chaînes.

declare @x xml  
set @x='<a>6</a>'  
select @x.query('/a[1] < "17"')  

La requête suivante renvoie les illustrations petit format d'un modèle de produit à partir du catalogue de produits fourni dans l'exemple de base de données AdventureWorks. La requête compare une séquence de valeurs atomiques renvoyée par PD:ProductDescription/PD:Picture/PD:Size à une séquence singleton, "small". Si la comparaison a la valeur True, elle renvoie l’élément <Picture> .

WITH XMLNAMESPACES ('https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription' AS PD)  
SELECT CatalogDescription.query('         
    for $P in /PD:ProductDescription/PD:Picture[PD:Size = "small"]         
    return $P') as Result         
FROM   Production.ProductModel         
WHERE  ProductModelID=19         

La requête suivante compare une séquence de numéros de téléphone dans <les éléments numériques> au littéral de chaîne « 112-111-1111 ». La requête compare la séquence des éléments numéro de téléphone de la colonne AdditionalContactInfo pour déterminer s'il existe dans le document un numéro de téléphone spécifique pour un client spécifique.

WITH XMLNAMESPACES (  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes' AS act,  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo' AS aci)  
  
SELECT AdditionalContactInfo.value('         
   /aci:AdditionalContactInfo//act:telephoneNumber/act:number = "112-111-1111"', 'nvarchar(10)') as Result         
FROM Person.Contact         
WHERE ContactID=1         

La requête renvoie la valeur True. ce qui indique que le numéro existe dans le document. La requête suivante est une version légèrement modifiée de la précédente. Dans cette requête, les valeurs de numéro de téléphone récupérées à partir du document sont comparées à une séquence de deux valeurs de numéro de téléphone. Si la comparaison a la valeur True, l’élément <number> est retourné.

WITH XMLNAMESPACES (  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes' AS act,  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactInfo' AS aci)  
  
SELECT AdditionalContactInfo.query('         
  if (/aci:AdditionalContactInfo//act:telephoneNumber/act:number = ("222-222-2222","112-111-1111"))         
  then          
     /aci:AdditionalContactInfo//act:telephoneNumber/act:number         
  else         
    ()') as Result         
FROM Person.Contact         
WHERE ContactID=1  
  

Voici le résultat obtenu :

\<act:number   
  xmlns:act="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">  
    111-111-1111  
\</act:number>  
\<act:number   
  xmlns:act="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes">  
    112-111-1111  
\</act:number>   

Opérateurs de comparaison de valeurs

Les opérateurs de comparaison de valeurs servent à comparer des valeurs atomiques. Notez que vous pouvez utiliser des opérateurs de comparaison générale à la place des opérateurs de comparaison de valeurs dans vos requêtes.

Le tableau suivant énumère les opérateurs de comparaison de valeurs.

Si les deux valeurs sont identiques selon l'opérateur choisi, l'expression renvoie la valeur True. Dans le cas contraire, elle retourne la valeur False. Si l'une des valeurs est une séquence vide, le résultat de l'expression est False.

Ces opérateurs fonctionnent uniquement sur des valeurs atomiques singleton. Autrement dit, vous ne pouvez pas spécifier une séquence en tant qu'opérande.

Par exemple, la requête suivante récupère les <éléments Picture> d’un modèle de produit dont la taille d’image est « petite » :

SELECT CatalogDescription.query('         
              declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";         
              for $P in /PD:ProductDescription/PD:Picture[PD:Size eq "small"]         
              return         
                    $P         
             ') as Result         
FROM Production.ProductModel         
WHERE ProductModelID=19         

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

• declare namespace définit le préfixe d'espace de noms qui est utilisé par la suite dans la requête.

• La <valeur de l’élément Size> est comparée à la valeur atomique spécifiée, « small ».

• Notez que, étant donné que les opérateurs de valeur fonctionnent uniquement sur des valeurs atomiques, la fonction data() est implicitement utilisée pour récupérer la valeur de nœud. Autrement dit, data($P/PD:Size) eq "small" donne le même résultat.

Voici le résultat obtenu :

\<PD:Picture   
  xmlns:PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription">  
  \<PD:Angle>front\</PD:Angle>  
  \<PD:Size>small\</PD:Size>  
  \<PD:ProductPhotoID>31\</PD:ProductPhotoID>  
\</PD:Picture>  

Notez que les règles de promotion de type sont identiques qu'il s'agisse d'opérateur de comparaison générale ou de valeurs. En outre, SQL Server utilise les mêmes règles de cast pour les valeurs non typées lors des comparaisons de valeurs que lors des comparaisons générales. En revanche, les règles de la spécification XQuery convertissent toujours la valeur non typée en xs:string lors des comparaisons de valeurs.

Opérateurs de comparaison de nœuds

L’opérateur de comparaison de nœuds , est, s’applique uniquement aux types de nœuds. Le résultat renvoyé indique si les deux nœuds transmis comme opérandes représentent le même nœud dans le document source. Cet opérateur renvoie la valeur True si les deux opérandes identifient le même nœud. Dans le cas contraire, il renvoie la valeur False.

La requête suivante vérifie que le poste de travail 10 est le premier dans le processus de fabrication d'un modèle de produit spécifique.

WITH XMLNAMESPACES ('https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions' AS AWMI)  
  
SELECT ProductModelID, Instructions.query('         
    if (  (//AWMI:root/AWMI:Location[@LocationID=10])[1]         
          is          
          (//AWMI:root/AWMI:Location[1])[1] )          
    then         
          <Result>equal</Result>         
    else         
          <Result>Not-equal</Result>         
         ') as Result         
FROM Production.ProductModel         
WHERE ProductModelID=7           

Voici le résultat obtenu :

ProductModelID       Result          
-------------- --------------------------  
7              <Result>equal</Result>      

Opérateurs de comparaison de l'ordre des nœuds

Les opérateurs de comparaison de l'ordre des nœuds comparent des paires de nœuds en fonction de la position qu'ils occupent dans un document.

Ces comparaisons sont faites en fonction de l'ordre du document :

• << : l’opérande 1 précède-t-il l’opérande 2 dans l’ordre du document.

• >> : l’opérande 1suit-il l’opérande 2 dans l’ordre du document.

La requête suivante renvoie la valeur True si la description du catalogue de produits contient l’élément <Warranty> qui apparaît avant l’élément <Maintenance> dans l’ordre de document pour un produit particulier.

WITH XMLNAMESPACES (  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription' AS PD,  
  'https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain' AS WM)  
  
SELECT CatalogDescription.value('  
     (/PD:ProductDescription/PD:Features/WM:Warranty)[1] <<   
           (/PD:ProductDescription/PD:Features/WM:Maintenance)[1]', 'nvarchar(10)') as Result  
FROM  Production.ProductModel  
where ProductModelID=19  

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

• La méthode value() du type de données xmlest utilisée dans la requête.

• Le résultat booléen de la requête est converti en nvarchar(10) et retourné.

• La requête renvoie la valeur True.

Voir aussi

Système de types (XQuery)
Expressions XQuery