Share via

SequenceType-expressies (XQuery)

van toepassing op:SQL Server-

In XQuery is een waarde altijd een reeks. Het type van de waarde wordt een reekstype genoemd. Het type reeks kan worden gebruikt in een exemplaar van XQuery-expressie. De syntaxis van SequenceType die in de XQuery-specificatie wordt beschreven, wordt gebruikt wanneer u naar een type in een XQuery-expressie moet verwijzen.

De naam van het atomische type kan ook worden gebruikt in de cast als XQuery-expressie. In SQL Server worden het exemplaar van en cast als XQuery-expressies op SequenceTypes gedeeltelijk ondersteund.

exemplaar van Operator

Het exemplaar van operator kan worden gebruikt om het dynamische, of runtime-type van de waarde van de opgegeven expressie te bepalen. Bijvoorbeeld:

  
Expression instance of SequenceType[Occurrence indicator]

Houd er rekening mee dat de operator instance of, de Occurrence indicator, de kardinaliteit, het aantal items in de resulterende reeks specificeert. Als dit niet is opgegeven, wordt ervan uitgegaan dat de kardinaliteit 1 is. In SQL Server wordt alleen het vraagteken (?) exemplaarindicator ondersteund. De ? exemplaarindicator geeft aan dat Expression nul of één item kan retourneren. Als de ? exemplaarindicator is opgegeven, retourneert instance of Waar wanneer het Expression type overeenkomt met de opgegeven SequenceType, ongeacht of Expression een singleton of een lege reeks retourneert.

Als de ? exemplaarindicator niet is opgegeven, retourneert sequence of alleen Waar wanneer het type Expression overeenkomt met de opgegeven Type en Expression een singleton retourneert.

Opmerking Het plusteken (+) en het sterretje (*) worden niet ondersteund in SQL Server.

In de volgende voorbeelden ziet u het gebruik van het exemplaar van de XQuery-operator.

Voorbeeld A

In het volgende voorbeeld wordt een xml- typevariabele gemaakt en wordt een query opgegeven. De queryexpressie geeft een instance of operator op om te bepalen of het dynamische type van de waarde die door de eerste operand wordt geretourneerd overeenkomt met het type dat is opgegeven in de tweede operand.

De volgende query retourneert True, omdat de 125-waarde een exemplaar van het opgegeven type is, xs:integer:

declare @x xml  
set @x=''  
select @x.query('125 instance of xs:integer')  
go

De volgende query retourneert True, omdat de waarde die wordt geretourneerd door de expressie /a[1], in de eerste operand een element is:

declare @x xml  
set @x='<a>1</a>'  
select @x.query('/a[1] instance of element()')  
go

Op dezelfde manier retourneert instance of Waar in de volgende query, omdat het waardetype van de expressie in de eerste expressie een kenmerk is:

declare @x xml  
set @x='<a attr1="x">1</a>'  
select @x.query('/a[1]/@attr1 instance of attribute()')  
go

In het volgende voorbeeld retourneert de expressie, data(/a[1], een atomische waarde die is getypt als xdt:untypedAtomic. Daarom retourneert de instance of Waar.

declare @x xml  
set @x='<a>1</a>'  
select @x.query('data(/a[1]) instance of xdt:untypedAtomic')  
go

In de volgende query retourneert de expressie, data(/a[1]/@attrA, een niet-getypte atomische waarde. Daarom retourneert de instance of Waar.

declare @x xml  
set @x='<a attrA="X">1</a>'  
select @x.query('data(/a[1]/@attrA) instance of xdt:untypedAtomic')  
go

Voorbeeld B

In dit voorbeeld voert u een query uit op een getypte XML-kolom in de AdventureWorks-voorbeelddatabase. De XML-schemaverzameling die is gekoppeld aan de kolom waarop een query wordt uitgevoerd, bevat de gegevens over typen.

In de expressie retourneert data() de getypte waarde van het kenmerk ProductModelID waarvan het type xs:string is volgens het schema dat aan de kolom is gekoppeld. Daarom retourneert de instance of Waar.

SELECT CatalogDescription.query('  
   declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
   data(/PD:ProductDescription[1]/@ProductModelID) instance of xs:string  
') as Result  
FROM Production.ProductModel  
WHERE ProductModelID = 19

Zie Typed XML vergelijken met niet-getypte XML-voor meer informatie.

De volgende query's gebruiken de Booleaanse instance of-expressie om te bepalen of het kenmerk LocationID van het type xs:integer is:

SELECT Instructions.query('  
   declare namespace AWMI="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelManuInstructions";  
   /AWMI:root[1]/AWMI:Location[1]/@LocationID instance of attribute(LocationID,xs:integer)  
') as Result  
FROM Production.ProductModel  
WHERE ProductModelID=7

De volgende query wordt opgegeven voor de XML-kolom CatalogDescription. De VERZAMELING XML-schema's die aan deze kolom zijn gekoppeld, biedt typgegevens.

De query gebruikt de element(ElementName, ElementType?)-test in de instance of-expressie om te controleren of de /PD:ProductDescription[1] een elementknooppunt van een specifieke naam en type retourneert.

SELECT CatalogDescription.query('  
     declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
     /PD:ProductDescription[1] instance of element(PD:ProductDescription, PD:ProductDescription?)  
    ') as Result  
FROM  Production.ProductModel  
where ProductModelID=19

De query retourneert Waar.

Voorbeeld C

Wanneer u samenvoegtypen gebruikt, heeft de instance of-expressie in SQL Server een beperking: met name wanneer het type element of kenmerk een samenvoegtype is, kan instance of mogelijk niet het exacte type bepalen. Daarom retourneert een query Onwaar, tenzij de atomische typen die in het SequenceType worden gebruikt, het hoogste bovenliggende element van het werkelijke type van de expressie in de simpleType-hiërarchie zijn. Dat wil gezegd: de atomische typen die zijn opgegeven in het SequenceType moeten een direct onderliggend element van anySimpleType zijn. Zie Type Casting Rules in XQueryvoor meer informatie over de typehiërarchie.

In het volgende queryvoorbeeld wordt het volgende uitgevoerd:

  • Maak een XML-schemaverzameling met een samenvoegtype, zoals een geheel getal of tekenreekstype, dat hierin is gedefinieerd.

  • Declareer een getypte xml- variabele met behulp van de XML-schemaverzameling.

  • Wijs een xml-voorbeeldexemplaren toe aan de variabele.

  • Voer een query uit op de variabele om het instance of gedrag te illustreren bij het omgaan met een samenvoegtype.

Dit is de query:

CREATE XML SCHEMA COLLECTION MyTestSchema AS '  
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="http://ns" xmlns:ns="http://ns">  
<simpleType name="MyUnionType">  
<union memberTypes="integer string"/>  
</simpleType>  
<element name="TestElement" type="ns:MyUnionType"/>  
</schema>'  
Go

De volgende query retourneert False, omdat het SequenceType dat is opgegeven in de instance of-expressie niet het hoogste bovenliggende element is van het werkelijke type van de opgegeven expressie. Dat wil gezegd, de waarde van de <TestElement> een geheel getal is. Het hoogste bovenliggende element is xs:decimal. Het is echter niet opgegeven als de tweede operand voor de operator instance of.

SET QUOTED_IDENTIFIER ON  
DECLARE @var XML(MyTestSchema)  
  
SET @var = '<TestElement xmlns="http://ns">123</TestElement>'  
  
SELECT @var.query('declare namespace ns="http://ns"   
   data(/ns:TestElement[1]) instance of xs:integer')  
go

Omdat het hoogste bovenliggende element van xs:integer xs:decimal is, retourneert de query Waar als u de query wijzigt en xs:decimal opgeeft als het SequenceType in de query.

SET QUOTED_IDENTIFIER ON  
DECLARE @var XML(MyTestSchema)  
SET @var = '<TestElement xmlns="http://ns">123</TestElement>'  
SELECT @var.query('declare namespace ns="http://ns"     
   data(/ns:TestElement[1]) instance of xs:decimal')  
go

Voorbeeld D

In dit voorbeeld maakt u eerst een XML-schemaverzameling en gebruikt u deze om een xml- variabele te typen. De getypte xml- variabele wordt vervolgens opgevraagd om de instance of-functionaliteit te illustreren.

De volgende XML-schemaverzameling definieert een eenvoudig type, myType en een element, <root>, van het type myType:

drop xml schema collection SC  
go  
CREATE XML SCHEMA COLLECTION SC AS '  
<schema xmlns="http://www.w3.org/2001/XMLSchema" targetNamespace="myNS" xmlns:ns="myNS"  
xmlns:s="https://schemas.microsoft.com/sqlserver/2004/sqltypes">  
      <import namespace="https://schemas.microsoft.com/sqlserver/2004/sqltypes"/>  
      <simpleType name="myType">  
           <restriction base="s:varchar">  
                  <maxLength value="20"/>  
            </restriction>  
      </simpleType>  
      <element name="root" type="ns:myType"/>  
</schema>'  
Go

Maak nu een getypte xml- variabele en voer een query uit:

DECLARE @var XML(SC)  
SET @var = '<root xmlns="myNS">My data</root>'  
SELECT @var.query('declare namespace sqltypes = "https://schemas.microsoft.com/sqlserver/2004/sqltypes";  
declare namespace ns="myNS";   
   data(/ns:root[1]) instance of ns:myType')  
go

Omdat myType-type is afgeleid door beperking van een varchar-type dat is gedefinieerd in het sqltypes-schema, retourneert instance of ook Waar.

DECLARE @var XML(SC)  
SET @var = '<root xmlns="myNS">My data</root>'  
SELECT @var.query('declare namespace sqltypes = "https://schemas.microsoft.com/sqlserver/2004/sqltypes";  
declare namespace ns="myNS";   
data(/ns:root[1]) instance of sqltypes:varchar?')  
go

Voorbeeld E

In het volgende voorbeeld haalt de expressie een van de waarden van het kenmerk IDREFS op en gebruikt instance of om te bepalen of de waarde van het type IDREF is. In het voorbeeld wordt het volgende uitgevoerd:

  • Hiermee maakt u een XML-schemaverzameling waarin het <Customer>-element een kenmerk OrderList IDREFS-type heeft en het <Order> element een kenmerk OrderID ID-type heeft.

  • Hiermee maakt u een getypte xml- variabele en wijst u er een voorbeeld-XML-exemplaar aan toe.

  • Hiermee geeft u een query op voor de variabele. De query-expressie haalt de eerste order-id-waarde op uit het typekenmerk OrderList IDREFS van de eerste <Customer>. De opgehaalde waarde is idREF-type. Daarom retourneert instance of Waar.

create xml schema collection SC as  
'<schema xmlns="http://www.w3.org/2001/XMLSchema" xmlns:Customers="Customers" targetNamespace="Customers">  
            <element name="Customers" type="Customers:CustomersType"/>  
            <complexType name="CustomersType">  
                        <sequence>  
                            <element name="Customer" type="Customers:CustomerType" minOccurs="0" maxOccurs="unbounded" />  
                        </sequence>  
            </complexType>  
             <complexType name="OrderType">  
                <sequence minOccurs="0" maxOccurs="unbounded">  
                            <choice>  
                                <element name="OrderValue" type="integer" minOccurs="0" maxOccurs="unbounded"/>  
                            </choice>  
                </sequence>                                             
                <attribute name="OrderID" type="ID" />  
            </complexType>  
  
            <complexType name="CustomerType">  
                <sequence minOccurs="0" maxOccurs="unbounded">  
                            <choice>  
                                <element name="spouse" type="string" minOccurs="0" maxOccurs="unbounded"/>  
                                <element name="Order" type="Customers:OrderType" minOccurs="0" maxOccurs="unbounded"/>  
                            </choice>  
                </sequence>                                             
                <attribute name="CustomerID" type="string" />  
                <attribute name="OrderList" type="IDREFS" />  
            </complexType>  
 </schema>'  
go  
declare @x xml(SC)  
set @x='<CustOrders:Customers xmlns:CustOrders="Customers">  
                <Customer CustomerID="C1" OrderList="OrderA OrderB"  >  
                              <spouse>Jenny</spouse>  
                                <Order OrderID="OrderA"><OrderValue>11</OrderValue></Order>  
                                <Order OrderID="OrderB"><OrderValue>22</OrderValue></Order>  
  
                </Customer>  
                <Customer CustomerID="C2" OrderList="OrderC OrderD" >  
                                <spouse>John</spouse>  
                                <Order OrderID="OrderC"><OrderValue>33</OrderValue></Order>  
                                <Order OrderID="OrderD"><OrderValue>44</OrderValue></Order>  
  
                        </Customer>  
                <Customer CustomerID="C3"  OrderList="OrderE OrderF" >  
                                <spouse>Jane</spouse>  
                                <Order OrderID="OrderE"><OrderValue>55</OrderValue></Order>  
                                <Order OrderID="OrderF"><OrderValue>55</OrderValue></Order>  
                </Customer>  
                <Customer CustomerID="C4"  OrderList="OrderG"  >  
                                <spouse>Tim</spouse>  
                                <Order OrderID="OrderG"><OrderValue>66</OrderValue></Order>  
                        </Customer>  
                <Customer CustomerID="C5"  >  
                </Customer>  
                <Customer CustomerID="C6" >  
                </Customer>  
                <Customer CustomerID="C7"  >  
                </Customer>  
</CustOrders:Customers>'  
  
select @x.query(' declare namespace CustOrders="Customers";   
 data(CustOrders:Customers/Customer[1]/@OrderList)[1] instance of xs:IDREF ? ') as XML_result

Implementatiebeperkingen

Dit zijn de beperkingen:

  • De schema-element() en schemakenmerk() reekstypen worden niet ondersteund voor vergelijking met de operator instance of.

  • Volledige reeksen, bijvoorbeeld (1,2) instance of xs:integer*, worden niet ondersteund.

  • Wanneer u een vorm gebruikt van het element() reekstype waarmee een typenaam wordt opgegeven, zoals element(ElementName, TypeName), moet het type worden gekwalificeerd met een vraagteken (?). element(Title, xs:string?) geeft bijvoorbeeld aan dat het element null kan zijn. SQL Server biedt geen ondersteuning voor runtimedetectie van de eigenschap xsi:nil met behulp van instance of.

  • Als de waarde in Expression afkomstig is van een element of kenmerk dat als samenvoeging is getypt, kan SQL Server alleen het primitieve, niet afgeleide type identificeren waaruit het type van de waarde is afgeleid. Als <e1> bijvoorbeeld is gedefinieerd voor een statisch type (xs:integer | xs:string), retourneert het volgende Onwaar.

    data(<e1>123</e1>) instance of xs:integer

    data(<e1>123</e1>) instance of xs:decimal retourneert echter Waar.

  • Voor de verwerkingsinstructie() en documentknooppunt() reekstypen zijn alleen formulieren zonder argumenten toegestaan. processing-instruction() is bijvoorbeeld toegestaan, maar processing-instruction('abc') is niet toegestaan.

cast as Operator

De cast als expressie kan worden gebruikt om een waarde te converteren naar een specifiek gegevenstype. Bijvoorbeeld:

  
Expression cast as  AtomicType?

In SQL Server is het vraagteken (?) vereist na de AtomicType. Zoals in de volgende query wordt weergegeven, converteert "2" cast as xs:integer? de tekenreekswaarde bijvoorbeeld naar een geheel getal:

declare @x xml  
set @x=''  
select @x.query('"2" cast as xs:integer?')

In de volgende query retourneert data() de getypte waarde van het kenmerk ProductModelID, een tekenreekstype. De cast as operator converteert de waarde naar xs:integer.

WITH XMLNAMESPACES ('https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription' AS PD)  
SELECT CatalogDescription.query('  
   data(/PD:ProductDescription[1]/@ProductModelID) cast as xs:integer?  
') as Result  
FROM Production.ProductModel  
WHERE ProductModelID = 19

Het expliciete gebruik van data() is niet vereist in deze query. De cast as-expressie voert impliciete atomen uit op de invoerexpressie.

Constructorfuncties

U kunt de constructorfuncties van het atomische type gebruiken. In plaats van bijvoorbeeld de operator cast as te gebruiken, "2" cast as xs:integer?, kunt u de xs:integer() constructorfunctie gebruiken, zoals in het volgende voorbeeld:

declare @x xml  
set @x=''  
select @x.query('xs:integer("2")')

In het volgende voorbeeld wordt een xs:date-waarde geretourneerd die gelijk is aan 2000-01-01Z.

declare @x xml  
set @x=''  
select @x.query('xs:date("2000-01-01Z")')

U kunt ook constructors gebruiken voor de door de gebruiker gedefinieerde atomische typen. Als de XML-schemaverzameling die is gekoppeld aan het XML-gegevenstype bijvoorbeeld een eenvoudig type definieert, kan een myType() constructor worden gebruikt om een waarde van dat type te retourneren.

Implementatiebeperkingen

  • De XQuery-expressies typeswitch, castableen worden niet ondersteund.

  • cast als vereist een vraagteken (?) na het atomische type.

  • xs:QName wordt niet ondersteund als type voor cast-conversie. Gebruik in plaats daarvan uitgevouwen QName-.

  • xs:date, xs:timeen xs:datetime een tijdzone vereisen die wordt aangegeven door een Z.

    De volgende query mislukt omdat er geen tijdzone is opgegeven.

    DECLARE @var XML  
SET @var = ''  
SELECT @var.query(' <a>{xs:date("2002-05-25")}</a>')  
go

    Door de Z-tijdzone-indicator toe te voegen aan de waarde, werkt de query.

    DECLARE @var XML  
SET @var = ''  
SELECT @var.query(' <a>{xs:date("2002-05-25Z")}</a>')  
go

    Dit is het resultaat:

    <a>2002-05-25Z</a>

Zie ook

XQuery-expressies
Type System (XQuery)

  • Last updated on