Megosztás a következőn keresztül:

SequenceType-kifejezések (XQuery)

A következőkre vonatkozik:SQL Server

Az XQueryben az érték mindig egy sorozat. Az érték típusát szekvenciatípusnak nevezzük. A sorozattípus XQuery-kifejezés példányában használható. Az XQuery specifikációban leírt SequenceType szintaxist akkor használja a rendszer, ha egy XQuery-kifejezés egy típusára kell hivatkoznia.

Az atomtípus neve XQuery-kifejezésként is használható a öntöttben. Az SQL Serverben részben támogatott a és XQuery-kifejezésekként példánya.

operátor példánya

A operátor példánya a megadott kifejezés értékének dinamikus vagy futásidejű típusának meghatározására használható. Például:

  
Expression instance of SequenceType[Occurrence indicator]

Vegye figyelembe, hogy a instance of operátor, a Occurrence indicatorhatározza meg a számosságot, az eredményként kapott sorozat elemeinek számát. Ha ez nincs megadva, a számosság 1 lesz. Az SQL Serverben csak a kérdőjel (?) előfordulásjelzője támogatott. A ? előfordulásjelző azt jelzi, hogy Expression nullát vagy egy elemet adhat vissza. Ha a ? előfordulásjelző meg van adva, instance of igaz értéket ad vissza, ha a Expression típus megfelel a megadott SequenceType, függetlenül attól, hogy Expression egyetlen vagy üres sorozatot ad vissza.

Ha a ? előfordulásjelző nincs megadva, sequence of csak akkor ad vissza Igaz értéket, ha a Expression típus megegyezik a megadott Type, és Expression egyetlentonnát ad vissza.

Megjegyzés A pluszjel (+) és a csillag (*) előfordulásjelzők nem támogatottak az SQL Serverben.

Az alábbi példák az XQuery operátor példányának használatát szemléltetik.

A példa

Az alábbi példa létrehoz egy xml- típusú változót, és egy lekérdezést határoz meg ellene. A lekérdezési kifejezés egy instance of operátort ad meg annak meghatározásához, hogy az első operandus által visszaadott érték dinamikus típusa megegyezik-e a második operandusban megadott típussal.

A következő lekérdezés igaz értéket ad vissza, mivel a 125-ös érték a megadott típusú példány, xs:egész szám:

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

A következő lekérdezés igaz értéket ad vissza, mert a /a[1] kifejezés által visszaadott érték az első operandusban egy elem:

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

Hasonlóképpen, instance of igaz értéket ad vissza a következő lekérdezésben, mivel az első kifejezésben szereplő kifejezés értéktípusa egy attribútum:

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

A következő példában a data(/a[1]kifejezés egy xdt:untypedAtomic típusú atomi értéket ad vissza. Ezért a instance of igaz értéket ad vissza.

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

Az alábbi lekérdezésben a data(/a[1]/@attrAkifejezés egy nem beírt atomértéket ad vissza. Ezért a instance of igaz értéket ad vissza.

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

B példa

Ebben a példában egy beírt XML-oszlopot kérdez le az AdventureWorks mintaadatbázisban. A lekérdezett oszlophoz társított XML-sémagyűjtemény megadja a gépelési információkat.

A kifejezésben data() a ProductModelID attribútum beírt értékét adja vissza, amelynek típusa xs:sztring az oszlophoz társított séma szerint. Ezért a instance of igaz értéket ad vissza.

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

További információ: A gépelt XML és a nem beírt XMLösszehasonlítása.

A következő lekérdezések a logikai instance of kifejezéssel határozzák meg, hogy a LocationID attribútum xs:egész típusú-e:

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

Az alábbi lekérdezés a CatalogDescription típusú XML-oszlopon van megadva. Az oszlophoz társított XML-sémagyűjtemény gépelési információkat biztosít.

A lekérdezés a element(ElementName, ElementType?) kifejezés instance of tesztjének használatával ellenőrzi, hogy a /PD:ProductDescription[1] egy adott nevű és típusú elemcsomópontot ad vissza.

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

A lekérdezés igaz értéket ad vissza.

C példa

Egyesítő típusok használatakor az SQL Server instance of kifejezésének korlátozásai vannak: Ha egy elem vagy attribútum típusa egyesítő típusú, előfordulhat, hogy instance of nem határozza meg a pontos típust. Következésképpen a lekérdezés hamis értéket ad vissza, kivéve, ha a SequenceType-ban használt atomtípusok a simpleType hierarchia kifejezésének tényleges típusának legmagasabb szülője. Vagyis a SequenceType-ban megadott atomtípusoknak bármelySimpleType közvetlen gyermekének kell lenniük. A típushierarchiáról további információt az XQuery típuselosztó szabályai című témakörben talál.

A következő lekérdezési példa a következőket hajtja végre:

  • Hozzon létre egy olyan XML-sémagyűjteményt, amely egyesítő típusú, például egész vagy sztring típusú.

  • Deklaráljon egy beírt xml változót az XML-sémagyűjtemény használatával.

  • Rendeljen hozzá egy minta XML-példányt a változóhoz.

  • A változó lekérdezésével szemléltetheti a instance of viselkedését az egyesítő típus kezelésekor.

Ez a lekérdezés:

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

A következő lekérdezés hamis értéket ad vissza, mert a instance of kifejezésben megadott SequenceType nem a megadott kifejezés tényleges típusának legmagasabb szülője. Vagyis a <TestElement> értéke egész számtípus. A legmagasabb szülő az xs:decimális. A instance of operátor második operandusaként azonban nincs megadva.

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

Mivel az xs:egész szám legnagyobb szülője az xs:decimális, a lekérdezés Igaz értéket ad vissza, ha módosítja a lekérdezést, és xs:decimális értéket ad meg a lekérdezésBen a SequenceType értékként.

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

D példa

Ebben a példában először létrehoz egy XML-sémagyűjteményt, és egy xml- változó beírására használja. A beírt xml változó lekérdezve mutatja be a instance of funkciót.

Az alábbi XML-sémagyűjtemény a myType típusú egyszerű típust, a myType és egy <root>elemet definiálja:

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

Most hozzon létre egy beírt xml- változót, és kérdezze le:

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

Mivel a myType típus az sqltypes sémában definiált varchar-típusból származik, a instance of is Igaz értéket ad vissza.

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

E példa

A következő példában a kifejezés lekéri az IDREFS attribútum egyik értékét, és instance of használatával állapítja meg, hogy az érték IDREF típusú-e. A példa a következőket hajtja végre:

  • Létrehoz egy XML-sémagyűjteményt, amelyben a <Customer> elem OrderList IDREFS típusattribútummal rendelkezik, és a <Order> elem OrderID AZONOSÍTÓ típusú attribútummal rendelkezik.

  • Létrehoz egy beírt xml- változót, és hozzárendel hozzá egy XML-mintapéldányt.

  • Lekérdezést ad meg a változóhoz. A lekérdezési kifejezés lekéri az első rendelésazonosító értékét az első <Customer>OrderList IDREFS típusattribútumából. A beolvasott érték IDREF típusú. Ezért instance of igaz értéket ad vissza.

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

Megvalósítási korlátozások

Ezek a korlátozások:

  • A sémaelem() és sémaattribútum() sorozattípus nem támogatott az instance of operátorral való összehasonlításhoz.

  • A teljes sorozatok( például (1,2) instance of xs:integer*) nem támogatottak.

  • Ha az elem() típusnevet (például element(ElementName, TypeName)) meghatározó sorozattípust használ, a típusnak kérdőjellel (?) kell rendelkeznie. A element(Title, xs:string?) például azt jelzi, hogy az elem null értékű lehet. Az SQL Server nem támogatja a xsi:nil tulajdonság futásidejű észlelését instance ofhasználatával.

  • Ha a Expression értéke egy egyesítésként beírt elemből vagy attribútumból származik, az SQL Server csak azt a primitív, nem származtatott típust tudja azonosítani, amelyből az érték típusa származik. Ha például a <e1> statikus típusú (xs:egész | xs:sztring) értékre van definiálva, az alábbiak hamis értéket adnak vissza.

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

    A data(<e1>123</e1>) instance of xs:decimal azonban igaz értéket ad vissza.

  • A feldolgozási utasítás() és dokumentumcsomópont() sorozattípusok esetében csak argumentum nélküli űrlapok engedélyezettek. Például processing-instruction() engedélyezett, de processing-instruction('abc') nem.

öntött operátorként

A kifejezésként való megjelenítéssel egy értéket egy adott adattípussá alakíthat át. Például:

  
Expression cast as  AtomicType?

Az SQL Serverben a kérdőjelre (?) a AtomicTypeután van szükség. Az alábbi lekérdezésben látható módon például "2" cast as xs:integer? a sztring értékét egész számmá alakítja:

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

A következő lekérdezésben data() a ProductModelID attribútum beírt értékét adja vissza, egy sztringtípust. Az cast as operátor xs:egész számmá alakítja az értéket.

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

Ebben a lekérdezésben nem szükséges adatok() explicit használata. A cast as kifejezés implicit atomizálást végez a bemeneti kifejezésen.

Konstruktorfüggvények

Használhatja az atomtípus konstruktorfüggvényeket. A cast as operátor használata helyett például "2" cast as xs:integer?a xs:integer() konstruktorfüggvényt használhatja, ahogyan az alábbi példában is látható:

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

Az alábbi példa egy 2000-01-01Z értékkel egyenlő xs:date értéket ad vissza.

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

Konstruktorokat is használhat a felhasználó által definiált atomtípusokhoz. Ha például az XML-adattípushoz társított XML-sémagyűjtemény egy egyszerű típust határoz meg, egy myType() konstruktor használható az adott típusú érték visszaadására.

Megvalósítási korlátozások

  • Az XQuery-kifejezések typeswitch, öntöttés kezelése nem támogatott.

  • öntött elemhez kérdőjel (?) szükséges az atomtípus után.

  • xs:QName nem támogatott formázási típusként. Használja inkább kibővített QName.

  • xs:date, xs:timeés xs:datetime időzónát igényelnek, amelyet egy Z jelez.

    A következő lekérdezés meghiúsul, mert nincs megadva az időzóna.

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

    Ha hozzáadja a Z időzóna-jelzőt az értékhez, a lekérdezés működik.

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

    Ez az eredmény:

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

Lásd még:

XQuery-kifejezések
Type System (XQuery)

  • Last updated on