Expressões SequenceType (XQuery)

O exemplo a seguir cria uma variável de tipo xml e especifica uma consulta em relação a ela. A expressão de consulta especifica um operador instance of para determinar se o tipo dinâmico do valor retornado pelo primeiro operando corresponde ao tipo especificado no segundo operando.

A consulta a seguir retorna True, pois o valor 125 é uma instância do tipo especificado, xs:integer:

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

A consulta a seguir retorna True, pois o valor retornado pela expressão, /a [1], no primeiro operando é um elemento:

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

Da mesma forma, instance of retorna True na consulta a seguir, pois o tipo de valor da expressão na primeira expressão é um atributo:

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

No exemplo a seguir, a expressão, data(/a[1], retorna um valor atômico que é digitado como xdt:untypedAtomic. Portanto, o instance of retorna True.

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

Na consulta a seguir, a expressão, data(/a[1]/@attrA, retorna um valor atômico não digitado. Portanto, o instance of retorna True.

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

Neste exemplo, você está consultando uma coluna XML tipada no banco de dados de exemplo AdventureWorks2008R2. A coleção de esquemas XML associada com a coluna que está sendo consultada fornece as informações digitadas.

Na expressão, data() retorna o valor digitado do atributo ProductModelID cujo tipo é xs:string de acordo com o esquema associado com a coluna. Portanto, o instance of retorna 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

Para obter mais informações, consulte XML digitado comparado com XML não digitado. Para obter informações sobre a coleção de esquemas XML associada com a coluna CatalogDescription, consulte Sobre a coluna xml ProductModel.CatalogDescription.

As seguintes consultas usama expressãoBooliana instance of para determinar se o atributo LocationID é do tipo 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

A consulta a seguir é especificada em relação à coluna XML CatalogDescription digitada. A coleção de esquemas XML associada com essa coluna fornece as informações digitadas. Para obter mais informações sobre a coleção de esquemas XML, consulte Sobre a coluna xml ProductModel.CatalogDescription.

A consulta usa o teste element(ElementName, ElementType?) na expressão instance of para verificar se o /PD:ProductDescription[1] retorna um nó de elemento de um nome e tipo específicos.

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 consulta retorna True.

Ao usar tipos de união, a expressão instance of no SQL Server tem uma limitação: especificamente, quando o tipo de um elemento ou atributo for um tipo de união, instance of pode não determinar o tipo exato. Por conseguinte, uma consulta retornará False, a menos que os tipos atômicos usados em SequenceType sejam o pai mais elevado do tipo real da expressão na hierarquia simpleType. Ou seja, os tipos atômicos especificados em SequenceType devem ser um filho direto de anySimpleType. Para obter informações sobre a hierarquia de tipos, consulte Regras de conversão de tipos em XQuery.

O próximo exemplo de consulta executa o seguinte:

• Crie uma coleção de esquemas XML com um tipo de união, como um inteiro ou tipo de cadeia de caracteres, definido nele.

• Declare uma variável xml digitada usando a coleção de esquemas XML.

• Atribua uma instância XML de amostra à variável.

• Consulte a variável para ilustrar o comportamento instance of ao lidar com um tipo de união.

Esta é a consulta:

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 consulta a seguir retorna False, pois o SequenceType especificado na expressão instance of não é o pai mais alto do tipo real da expressão especificada. Ou seja, o valor do <TestElement> é do tipo inteiro. O pai mais alto é xs:decimal. Porém, não é especificado como o segundo operando ao operador 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

Como o pai mais alto de xs:integer é xs:decimal, a consulta retornará True se você modificar a consulta e especificar xs:decimal como SequenceType na consulta.

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

Neste exemplo, você cria primeiro uma coleção de esquemas XML e a usa para digitar uma variável xml. A variável xml digitada é consultada para ilustrar a funcionalidade instance of.

A coleção de esquemas XML a seguir define um tipo simples, myType, e um elemento, <root>, do tipo 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

Agora, crie uma variável xml digitada e a consulte:

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

Como o tipo myType é derivado pela restrição de um tipo varchar definido no esquema sqltypes, instance of também retornará 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

No exemplo a seguir, a expressão recupera um dos valores do atributo IDREFS e usa instance of para determinar se o valor é do tipo IDREF. O exemplo executa o seguinte:

• Cria uma coleção de esquemas XML na qual o elemento <Customer> tem um atributo IDREFS do tipo OrderList e o elemento <Order> tem um atributo ID do tipo OrderID.

• Cria uma variável xml digitada e lhe atribui uma instância XML de exemplo.

• Especifica uma consulta em relação à variável. A expressão de consulta recupera o primeiro valor de ID de ordem do atributo de tipo OrderList IDRERS do primeiro <Customer>. O valor recuperado é do tipo IDREF. Portanto, instance of retorna 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

Estas são as limitações:

• Não é oferecido suporte para os tipos de sequência schema-element() e schema-attribute() para comparação com o operador instance of.

• Sequências completas, por exemplo, (1,2) instance of xs:integer*, não têm suporte.

• Quando você estiver usando um formulário do tipo de sequência element() que especifica um nome de tipo, como element(ElementName, TypeName), o tipo deve ser qualificado com um ponto de interrogação (?). Por exemplo, element(Title, xs:string?) indica que o elemento poderia ser nulo. O SQL Server não oferece suporte à detecção de tempo de execução da propriedade xsi:nil usando instance of.

• Se o valor na Expression vier de um elemento ou atributo digitado como uma união, o SQL Server pode identificar só o tipo primitivo, não derivado, do qual o tipo do valor foi derivado. Por exemplo, se <e1> for definido como tendo um tipo estático de (xs:integer | xs:string), o seguinte retornará False.

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

  Porém, data(<e1>123</e1>) instance of xs:decimal retornará True.

• Para os tipos de sequência processing-instruction() e document-node(), são permitidos somente formulários sem argumentos. Por exemplo, processing-instruction() é permitido, mas processing-instruction('abc') não é permitido.

Você pode usar as funções de construtor de tipo atômico. Por exemplo, em vez de usar o operador cast as, "2" cast as xs:integer?, você pode usar a função de construtor xs:integer(), como no exemplo a seguir:

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

O exemplo a seguir retorna um valor xs:date igual a 2000-01-01Z.

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

Você também pode usar construtores para os tipos atômicos definidos pelo usuário. Por exemplo, se a coleção de esquemas XML associada com o tipo de dados XML definir um tipo simples, um construtor myType() pode ser usado para retornar um valor desse tipo.

Limitações de implementação