Wyrażenia SequenceType (XQuery)

Poniższy przykład tworzy xml wpisz zmienną i określa kwerenda na typie.Określa wyrażenie kwerendy instance of operator, aby ustalić, czy dynamiczne typ wartości zwracanej przez pierwszego operandu zgodny z typem określonym w drugi operand.

Następująca kwerenda zwraca True, ponieważ 125 wartość jest wystąpienie określonego typu xs:integer:

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

Następująca kwerenda zwraca wartość True, ponieważ wartość zwrócona przez wyrażenie, /a [1], w pierwszym argumentem jest elementem:

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

Podobnie instance of zwraca wartość True w następującej kwerendzie, ponieważ atrybut jest typ wartości wyrażenie pierwszego wyrażenie:

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

W poniższym przykładzie wyrażenie, data(/a[1], zwraca niepodzielny wartość, która jest wpisana jako xdt:untypedAtomic.Dlatego instance of zwraca wartość True.

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

W następującej kwerendzie wyrażenie, data(/a[1]/@attrA, zwraca bez niepodzielny wartości.Dlatego instance of zwraca wartość True.

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

W tym przykładzie wykonywana jest kwerenda maszynowy XML kolumna w AdventureWorks2008R2 przykładowej bazy danych.kolekcja schematu XML skojarzony z kolumna jest poszukiwanych zawiera wpisywania informacji.

W wyrażenie, data() zwraca wartość atrybut ProductModelID, którego typ jest xs:ciąg zgodnie ze schematem skojarzone z kolumna.Dlatego instance of zwraca wartość True.

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

Aby uzyskać więcej informacji, zobacz XML wpisywanych w porównaniu do pliku XML bez typu.Aby uzyskać informacje dotyczące kolekcja schematu XML skojarzony z kolumna CatalogDescription, zobacz Informacje o kolumnie xml ProductModel.CatalogDescription.

Następujące kwerendy użyj wartość logiczna instance of wyrażenie, czy atrybut LocationID jest typu xs:integer:

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

Określono następujące kwerendy przeciwko CatalogDescription wpisane XML kolumna.kolekcja schematu XML skojarzona kolumna ta zawiera informacje wpisywania.Aby uzyskać więcej informacji na temat kolekcja schematu XML, zobacz Informacje o kolumnie xml ProductModel.CatalogDescription.

W kwerendzie użyto element(ElementName, ElementType?) przetestować w instance of wyrażenie, aby sprawdzić, czy /PD:ProductDescription[1] zwraca węzeł elementu określonej nazwy i typu.

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

Kwerenda zwraca wartość True.

Podczas korzystania z typów Unii instance of wyrażenie w SQL Server ma ograniczenie: W szczególności, gdy typ element lub atrybut jest typu Unii instance of nie może określić dokładny typ.W związku z tym kwerenda zwróci FAŁSZ, chyba że niepodzielny typów używanych w SequenceType jest najwyższym nadrzędnym rzeczywisty typ wyrażenie w hierarchii simpleType.Oznacza to, że niepodzielny typów określonych w SequenceType musi być bezpośredni element podrzędność anySimpleType.Aby uzyskać informacje o hierarchii typów, zobacz Typ rzutowania reguł w XQuery.

W następnym przykładzie kwerendy wykonuje następujące czynności:

• Utworzyć kolekcja schematu XML typu Unii, takie jak liczba całkowita lub typu ciąg, określonego w nim.

• Zadeklarować maszynowy xml zmiennej przy użyciu kolekcja schematu XML.

• Przypisywanie przykładowy plik XML wystąpienie do zmiennej.

• Zmienna, aby zilustrować kwerendy instance of zachowanie podczas zajmowania się typu Unii.

To jest kwerenda:

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

Następująca kwerenda zwraca FAŁSZ, ponieważ SequenceType określone w instance of wyrażenie jest nie najwyższy nadrzędnego rzeczywisty typ określonego wyrażenia.Oznacza to, że wartość <TestElement> jest typu Liczba całkowita.Najwyższy nadrzędny jest xs:decimal.Jednakże nie jest określony jako drugi argument instance of operator.

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

Ponieważ nadrzędnego najwyższego xs:integer, xs:decimal, kwerenda będzie zwracać wartość PRAWDA jeśli zmodyfikować kwerendę i określić xs:decimal jako SequenceType w kwerendzie.

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

W tym przykładzie najpierw utworzyć kolekcja schematu XML i używać go do wpisz xml zmiennej.Pismo xml zmienna jest następnie proszeni o ilustrują instance of funkcji.

Następujące kolekcja schematu XML definiuje typ prosty, myType i elementu, <root>, z myType typu:

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

Teraz utworzyć maszynowy xml zmienną i jej kwerendy:

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

Ponieważ typ myType pochodzi przez ograniczenie typu varchar, który jest zdefiniowany w schemacie właściwości sqltypes, instance of także zwróci wartość True.

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

W poniższym przykładzie wyrażenie pobiera wartości atrybut IDREFS i używa instance of do ustalenia, czy wartość jest typu IDREF.Przykład wykonuje następujące czynności:

• Tworzy kolekcja schematu XML, w którym <Customer> element ma OrderList atrybut typu IDREFS oraz <Order> element ma IDZamówienia identyfikator atrybutu type.

• Tworzy maszynowy xml zmienną i przypisuje przykładowym kodzie XML wystąpienie do niej.

• Określa zapytanie zmiennej.Wyrażenie kwerendy pobiera pierwszą wartość Identyfikator zamówienia z OrderList IDRERS atrybut typu pierwszy <Customer>.Wartość pobierana jest typu IDREF.Dlatego instance of zwraca wartość True.

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

Są następujące ograniczenia:

• schema-element() i schema-attribute() sekwencji nie są obsługiwane dla porównania do instance of operator.

• Na przykład pełnej sekwencji, (1,2) instance of xs:integer*, nie są obsługiwane.

• W przypadku korzystania z formularza element() , który określa nazwę typu, takie jak typ sekwencji element(ElementName, TypeName), typ musi być kwalifikowany znakiem zapytania (?).For example, element(Title, xs:string?) indicates that the element might be null.SQL Server does not support run-time detection of the xsi:nil property by using instance of.

• Jeśli wartość w Expression pochodzi z element lub atrybut wpisana jako Unii, SQL Server można tylko identyfikować pierwotny, nie pochodzi, typ, z którego pochodzi typ wartości.Na przykład jeśli <e1> zdefiniowane do typu statycznego (xs:integer | xs:ciąg), następujące zwróci False.

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

  Jednakże data(<e1>123</e1>) instance of xs:decimal zwróci wartość True.

• Dla processing-instruction() i document-node() są dozwolone typy sekwencji tylko formularze bez argumentów.Na przykład processing-instruction() jest dozwolona, ale processing-instruction('abc') nie jest dozwolona.

Można użyć funkcji konstruktora typu niepodzielny.Na przykład, zamiast cast as operator, "2" cast as xs:integer?, można użyć xs:integer() funkcja konstruktora, jak w następującym przykładzie:

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

Poniższy przykład zwraca xs:data wartość równą 2000-01-01Z.

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

Za pomocą konstruktory niepodzielny typów zdefiniowanych przez użytkownika.Na przykład, jeśli kolekcja schematu XML skojarzony z typem danych XML definiuje typ prosty myType() Konstruktora służą do zwracają wartość tego typu.

Ograniczenia wdrażania