Vergelijkingsexpressies (XQuery)
van toepassing op:
SQL Server-
XQuery biedt de volgende typen vergelijkingsoperatoren:
Algemene vergelijkingsoperatoren
Operatoren voor waardevergelijking
Vergelijkingsoperatoren voor knooppunten
Vergelijkingsoperatoren voor knooppuntvolgorde
Algemene vergelijkingsoperatoren
Algemene vergelijkingsoperatoren kunnen worden gebruikt om atomische waarden, reeksen of een combinatie van de twee te vergelijken.
De algemene operators worden gedefinieerd in de volgende tabel.
| Bediener | Beschrijving |
|---|---|
| = | Gelijk |
| != | Niet gelijk aan |
| < | Kleiner dan |
| > | Groter dan |
| <= | Kleiner dan of gelijk aan |
| >= | Groter dan of gelijk aan |
Wanneer u twee reeksen vergelijkt met behulp van algemene vergelijkingsoperatoren en er een waarde bestaat in de tweede reeks die Waar vergelijkt met een waarde in de eerste reeks, is het algehele resultaat Waar. Anders is het Onwaar. (1, 2, 3) = (3, 4) is bijvoorbeeld Waar, omdat de waarde 3 in beide reeksen wordt weergegeven.
declare @x xml
set @x=''
select @x.query('(1,2,3) = (3,4)')
De vergelijking verwacht dat de waarden van vergelijkbare typen zijn. Ze worden statisch gecontroleerd. Voor numerieke vergelijkingen kan promotie van numerieke typen plaatsvinden. Als een decimale waarde van 10 bijvoorbeeld wordt vergeleken met een dubbele waarde 1e1, wordt de decimale waarde gewijzigd in dubbel. Houd er rekening mee dat dit onuitputtbare resultaten kan maken, omdat dubbele vergelijkingen niet exact kunnen zijn.
Als een van de waarden niet is getypt, wordt deze omgezet naar het type van de andere waarde. In het volgende voorbeeld wordt waarde 7 behandeld als een geheel getal. Voordat de waarde wordt vergeleken, wordt de niet-getypte waarde van /a[1] geconverteerd naar een geheel getal. De vergelijking van gehele getallen retourneert Waar.
declare @x xml
set @x='<a>6</a>'
select @x.query('/a[1] < 7')
Als de niet-getypte waarde wordt vergeleken met een tekenreeks of een andere niet-getypte waarde, wordt deze naar xs:string gecast. In de volgende query wordt tekenreeks 6 vergeleken met tekenreeks 17. De volgende query retourneert False vanwege de tekenreeksvergelijking.
declare @x xml
set @x='<a>6</a>'
select @x.query('/a[1] < "17"')
De volgende query retourneert kleine afbeeldingen van een productmodel uit de productcatalogus die is opgegeven in de AdventureWorks-voorbeelddatabase. De query vergelijkt een reeks atomische waarden die worden geretourneerd door PD:ProductDescription/PD:Picture/PD:Size met een singleton-reeks, 'klein'. Als de vergelijking Waar is, wordt het <afbeelding> element geretourneerd.
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
De volgende query vergelijkt een reeks telefoonnummers in <getal> elementen met de letterlijke tekenreeks "112-111-1111". De query vergelijkt de reeks telefoonnummerelementen in de kolom AdditionalContactInfo om te bepalen of een specifiek telefoonnummer voor een specifieke klant in het document bestaat.
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
De query retourneert Waar. Dit geeft aan dat het getal in het document bestaat. De volgende query is een enigszins gewijzigde versie van de vorige query. In deze query worden de telefoonnummerwaarden die zijn opgehaald uit het document vergeleken met een reeks van twee telefoonnummerwaarden. Als de vergelijking Waar is, wordt het <getal> element geretourneerd.
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
Dit is het resultaat:
\<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>
Operatoren voor waardevergelijking
Operatoren voor waardevergelijking worden gebruikt om atomische waarden te vergelijken. U kunt algemene vergelijkingsoperatoren gebruiken in plaats van waardevergelijkingsoperators in uw query's.
De operatoren voor waardevergelijking worden gedefinieerd in de volgende tabel.
| Bediener | Beschrijving |
|---|---|
| Eq | Gelijk |
| Ne | Niet gelijk aan |
| Lt | Kleiner dan |
| Gt | Groter dan |
| Le | Kleiner dan of gelijk aan |
| Ge | Groter dan of gelijk aan |
Als de twee waarden hetzelfde vergelijken volgens de gekozen operator, retourneert de expressie Waar. Anders wordt False geretourneerd. Als een van beide waarden een lege reeks is, is het resultaat van de expressie Onwaar.
Deze operators werken alleen voor atomische singletonwaarden. Dat wil gezegd, u kunt geen reeks opgeven als een van de operanden.
Met de volgende query worden bijvoorbeeld <Afbeelding> elementen opgehaald voor een productmodel waarin de afbeeldingsgrootte klein is:
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
Let op het volgende uit de vorige query:
declare namespacedefinieert het voorvoegsel van de naamruimte dat vervolgens in de query wordt gebruikt.De <Grootte> elementwaarde wordt vergeleken met de opgegeven atomische waarde, 'klein'.
Houd er rekening mee dat omdat de waardeoperators alleen op atomische waarden werken, de data() functie impliciet wordt gebruikt om de knooppuntwaarde op te halen. Dat wil gezegd,
data($P/PD:Size) eq "small"hetzelfde resultaat produceert.
Dit is het resultaat:
\<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>
Houd er rekening mee dat het type promotieregels voor waardevergelijkingen hetzelfde zijn als voor algemene vergelijkingen. Sql Server maakt ook gebruik van dezelfde cast-regels voor niet-getypte waarden tijdens waardevergelijkingen als tijdens algemene vergelijkingen. De regels in de XQuery-specificatie casten daarentegen altijd de niet-getypte waarde naar xs:string tijdens waardevergelijkingen.
Vergelijkingsoperator voor knooppunten
De vergelijkingsoperator voor knooppunten, is, is alleen van toepassing op knooppunttypen. Het resultaat dat wordt geretourneerd, geeft aan of twee knooppunten die zijn doorgegeven als operanden hetzelfde knooppunt in het brondocument vertegenwoordigen. Deze operator retourneert Waar als de twee operanden hetzelfde knooppunt zijn. Anders wordt false geretourneerd.
Met de volgende query wordt gecontroleerd of de locatie 10 van het werkcentrum de eerste is in het productieproces van een specifiek productmodel.
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
Dit is het resultaat:
ProductModelID Result
-------------- --------------------------
7 <Result>equal</Result>
Vergelijkingsoperatoren voor knooppuntvolgorde
Vergelijkingsoperatoren voor knooppuntvolgorde vergelijken paren van knooppunten op basis van hun posities in een document.
Dit zijn de vergelijkingen die worden gemaakt op basis van documentvolgorde:
<<: Gaat operand 1 vooraf aan operand 2 in de documentvolgorde.>>: Volgt operand 1operand 2 in de documentvolgorde.
De volgende query retourneert True als de beschrijving van de productcatalogus de <Garantie> element bevat dat wordt weergegeven vóór het element <Onderhoud> in de documentvolgorde voor een bepaald product.
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
Let op het volgende uit de vorige query:
De methode value() van het xml-gegevenstype wordt gebruikt in de query.
Het Booleaanse resultaat van de query wordt geconverteerd naar nvarchar(10) en geretourneerd.
De query retourneert Waar.