Expressions de comparaison (XQuery)Comparison Expressions (XQuery)

CETTE RUBRIQUE S’APPLIQUE À :ouiSQL Server (à partir de la version 2008)nonAzure SQL DatabasenonAzure SQL Data Warehouse nonParallel Data Warehouse THIS TOPIC APPLIES TO:yesSQL Server (starting with 2008)noAzure SQL DatabasenoAzure SQL Data Warehouse noParallel Data Warehouse

XQuery fournit les types d'opérateurs de comparaison suivants :XQuery provides the following types of comparison operators:

  • Opérateurs de comparaison généraleGeneral comparison operators

  • Opérateurs de comparaisonValue comparison operators

  • Opérateurs de comparaison de nœudNode comparison operators

  • Opérateurs de comparaison de commande de nœudNode order comparison operators

Opérateurs de comparaison généraleGeneral Comparison Operators

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.General comparison operators can be used to compare atomic values, sequences, or any combination of the two.

Le tableau suivant énumère les opérateurs généraux.The general operators are defined in the following table.

OpérateurOperator DescriptionDescription
= Égal àEqual
!=!= Non égalNot equal
< Inférieur àLess than
> Supérieur àGreater than
<= Inférieur ou égal àLess than or equal to
>= Supérieur ou égal àGreater than or equal to

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.When you are comparing two sequences by using general comparison operators and a value exists in the second sequence that compares True to a value in the first sequence, the overall result is True. Dans le cas contraire, le résultat est False.Otherwise, it is False. Par exemple, (1, 2, 3) = (3, 4) est True car la valeur 3 apparaît dans les deux séquences.For example, (1, 2, 3) = (3, 4) is True, because the value 3 appears in both sequences.

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.The comparison expects that the values are of comparable types. Ces derniers sont d'ailleurs vérifiés de manière statique.Specifically, they are statically checked. En cas de comparaisons numériques, la promotion du type numérique peut se produire.For numeric comparisons, numeric type promotion can occur. 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.For example, if a decimal value of 10 is compared to a double value 1e1, the decimal value is changed to double. Sachez que cela peut entraîner des résultats erronés puisque les comparaisons double précision ne peuvent pas être exactes.Note that this can create inexact results, because double comparisons cannot be exact.

Si l'une des valeurs est non typée, elle est convertie dans le type de l'autre valeur.If one of the values is untyped, it is cast to the other value's type. Dans l'exemple suivant, la valeur 7 est traitée comme un entier.In the following example, value 7 is treated as an integer. Avant la comparaison, la valeur non typée de /a[1] est convertie en entier.Before being compared, the untyped value of /a[1] is converted to an integer. La comparaison des entiers renvoie la valeur True.The integer comparison returns 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.Conversely, if the untyped value is compared to a string or another untyped value, it will be cast to xs:string. Dans la requête suivante, la chaîne 6 est comparée à la chaîne "17".In the following query, string 6 is compared to string "17". La requête suivante renvoie la valeur False suite à la comparaison des chaînes.The following query returns False, because of the string comparison.

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.The following query returns small-size pictures of a product model from the product catalog provided in the AdventureWorks sample database. La requête compare une séquence de valeurs atomiques renvoyée par PD:ProductDescription/PD:Picture/PD:Size à une séquence singleton, "small".The query compares a sequence of atomic values returned by PD:ProductDescription/PD:Picture/PD:Size with a singleton sequence, "small". Si la comparaison est True, elle retourne le < image> élément.If the comparison is True, it returns the <Picture> element.

WITH XMLNAMESPACES ('http://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 < nombre> éléments à la chaîne littérale « 112-111-1111 ».The following query compares a sequence of telephone numbers in <number> elements to the string literal "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.The query compares the sequence of telephone number elements in the AdditionalContactInfo column to determine if a specific telephone number for a specific customer exists in the document.

WITH XMLNAMESPACES (  
  'http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes' AS act,  
  'http://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.The query returns True. ce qui indique que le numéro existe dans le document.This indicates that the number exists in the document. La requête suivante est une version légèrement modifiée de la précédente.The following query is a slightly modified version of the previous query. 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.In this query, the telephone number values retrieved from the document are compared to a sequence of two telephone number values. Si la comparaison est True, le < nombre> élément est renvoyé.If the comparison is True, the <number> element is returned.

WITH XMLNAMESPACES (  
  'http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ContactTypes' AS act,  
  'http://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 :This is the result:

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

Opérateurs de comparaison de valeursValue Comparison Operators

Les opérateurs de comparaison de valeurs servent à comparer des valeurs atomiques.Value comparison operators are used to compare atomic values. 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.Note that you can use general comparison operators instead of value comparison operators in your queries.

Le tableau suivant énumère les opérateurs de comparaison de valeurs.The value comparison operators are defined in the following table.

OpérateurOperator DescriptionDescription
eqeq Égal àEqual
nene Non égalNot equal
ltlt Inférieur àLess than
gtgt Supérieur àGreater than
lele Inférieur ou égal àLess than or equal to
gege Supérieur ou égal àGreater than or equal to

Si les deux valeurs sont identiques selon l'opérateur choisi, l'expression renvoie la valeur True.If the two values compare the same according to the chosen operator, the expression will return True. Dans le cas contraire, elle retourne la valeur False.Otherwise, it will return False. Si l'une des valeurs est une séquence vide, le résultat de l'expression est False.If either value is an empty sequence, the result of the expression is False.

Ces opérateurs fonctionnent uniquement sur des valeurs atomiques singleton.These operators work on singleton atomic values only. Autrement dit, vous ne pouvez pas spécifier une séquence en tant qu'opérande.That is, you cannot specify a sequence as one of the operands.

Par exemple, la requête suivante récupère <image > éléments pour un modèle de produit lorsque la taille de l’image est « petite :For example, the following query retrieves <Picture> elements for a product model where the picture size is "small:

SELECT CatalogDescription.query('         
              declare namespace PD="http://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 :Note the following from the previous query:

  • declare namespace définit le préfixe d'espace de noms qui est utilisé par la suite dans la requête.declare namespace defines the namespace prefix that is subsequently used in the query.

  • Le <taille > valeur de l’élément est comparée à la valeur atomique spécifiée, « petite ».The <Size> element value is compared with the specified atomic value, "small".

  • Étant donné que les opérateurs de valeur fonctionnent uniquement sur les valeurs atomiques, le data() fonction est implicitement utilisée pour récupérer la valeur du nœud.Note that because the value operators work only on atomic values, the data() function is implicitly used to retrieve the node value. Autrement dit, data($P/PD:Size) eq "small" donne le même résultat.That is, data($P/PD:Size) eq "small" produces the same result.

    Voici le résultat obtenu :This is the result:

\<PD:Picture   
  xmlns:PD="http://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.Note that the type promotion rules for value comparisons are the same as for general comparisons. De plus, SQL ServerSQL Server applique les mêmes règles de conversion pour les valeurs non typées au cours des comparaisons, qu'elles portent sur des valeurs ou soient générales.Also, SQL ServerSQL Server uses the same casting rules for untyped values during value comparisons as it uses during general comparisons. 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.In contrast, the rules in the XQuery specification always cast the untyped value to xs:string during value comparisons.

Opérateurs de comparaison de nœudsNode Comparison Operator

L’opérateur de comparaison de nœud, est, s’applique uniquement aux types de nœuds.The node comparison operator, is, applies only to node types. 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.The result it returns indicates whether two nodes passed in as operands represent the same node in the source document. Cet opérateur renvoie la valeur True si les deux opérandes identifient le même nœud.This operator returns True if the two operands are the same node. Dans le cas contraire, il renvoie la valeur False.Otherwise, it returns 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.The following query checks whether the work center location 10 is the first in the manufacturing process of a specific product model.

WITH XMLNAMESPACES ('http://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 :This is the result:

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

Opérateurs de comparaison de l'ordre des nœudsNode Order Comparison Operators

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.Node order comparison operators compare pairs of nodes, based on their positions in a document.

Ces comparaisons sont faites en fonction de l'ordre du document :These are the comparisons that are made, based on document order:

  • <<: Ne opérande 1 précéder opérande 2 dans l’ordre du document.<< : Does operand 1 precede operand 2 in the document order.

  • >>: Ne opérande 1 suivez opérande 2 dans l’ordre du document.>> : Does operand 1 follow operand 2 in the document order.

    La requête suivante retourne la valeur True si la description du catalogue produit le <garantie > élément apparaissant avant le <Maintenance > élément dans l’ordre des documents pour un produit particulier.The following query returns True if the product catalog description has the <Warranty> element appearing before the <Maintenance> element in the document order for a particular product.

WITH XMLNAMESPACES (  
  'http://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription' AS PD,  
  'http://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 :Note the following from the previous query:

  • Le value() méthode de la xmltype de données est utilisé dans la requête.The value() method of the xmldata type is used in the query.

  • Le résultat booléen de la requête est converti en nvarchar (10) et retourné.The Boolean result of the query is converted to nvarchar(10) and returned.

  • La requête renvoie la valeur True.The query returns True.

Voir aussiSee Also

Système de type ( XQuery ) Type System (XQuery)
Expressions XQueryXQuery Expressions