Expressões de Caminho – Especificar Teste de Nó

Aplica-se a:SQL Server

Uma etapa de eixo em uma expressão de caminho inclui os seguintes componentes:

• Um eixo

• Um node test

• Zero ou mais qualificadores de etapa (opcional)

Para obter mais informações, consulte Expressões de caminho (XQuery).

Um node test é uma condição e é o segundo componente da etapa de eixo em uma expressão de caminho. Todos os nós selecionados por uma etapa devem satisfazer essa condição. Para a expressão de caminho, /child::ProductDescription, o node test é ProductDescription. Essa etapa recupera somente os filhos do nó de elemento cujo nome é ProductDescription.

Uma condição de node test pode incluir o seguinte:

• Um nome de nó. Só são retornados nós do tipo de nó principal com o nome especificado.

• Um tipo de nó. Só são retornados nós do tipo especificado.

Nome de nó como node test

Ao especificar um nome de nó como um node test em uma etapa de expressão de caminho, você deve entender o conceito de tipo de nó principal. Todo eixo, filho, pai ou atributo, tem um tipo de nó principal. Por exemplo:

• Um eixo de atributo só pode conter atributos. Portanto, o nó de atributo é o tipo de nó principal do eixo de atributo.

• Para outros eixos, se os nós selecionados pelo eixo puderem conter nós de elemento, o elemento será o tipo de nó principal.

Quando você especificar um nome de nó como um node test, a etapa retornará os seguintes tipos de nós:

• Nós que são o tipo de nó principal do eixo.

• Nós que têm o mesmo nome, conforme especificado no node test.

Por exemplo, considere a seguinte expressão de caminho:

child::ProductDescription   

Essa expressão de uma etapa especifica um eixo child e o nome de nó ProductDescription como o node test. A expressão retorna apenas nós que são do tipo de nó principal do eixo filho, nós de elemento e os que tenham ProductDescription como nome.

A expressão de caminho, /child::PD:ProductDescription/child::PD:Features/descendant::*, tem três etapas. Tais etapas especificam os eixos filho e descendente. Em cada etapa, o nome de nó é especificado como o node test. O caractere curinga (*) na terceira etapa indica todos os nós do tipo de nó de principal para o eixo descendente. O tipo de nó principal do eixo determina o tipo de nó selecionado e os filtros de nome de nó que os nós selecionaram.

Como resultado, quando essa expressão é executada em documentos XML do catálogo de produtos na tabela ProductModel , ela recupera todos os filhos do nó do <elemento Features> filho do <elemento ProductDescription> .

A expressão de caminho, /child::PD:ProductDescription/attribute::ProductModelID, é composta por duas etapas. Ambas as etapas especificam um nome de nó como o node test. Além disso, a segunda etapa usa o eixo de atributo. Como resultado, cada etapa seleciona nós do tipo de nó principal de seu eixo com o nome especificado como o node test. Portanto, a expressão retorna o nó de atributo ProductModelID do nó do <elemento ProductDescription> .

Ao especificar os nomes de nós para node tests, você também pode usar o caractere curinga (*) para especificar o nome local de um nó ou para seu prefixo de namespace, como mostrado no seguinte exemplo:

declare @x xml  
set @x = '  
<greeting xmlns="ns1">  
   <salutation>hello</salutation>  
</greeting>  
<greeting xmlns="ns2">  
   <salutation>welcome</salutation>  
</greeting>  
<farewell xmlns="ns1" />'  
select @x.query('//*:greeting')  
select @x.query('declare namespace ns="ns1"; /ns:*')  

Tipo de nó como node test

Para consultar os tipos de nó que não sejam os nós de elemento, use um teste do tipo de nó. Como mostrado na tabela a seguir, há quatro testes do tipo de nó disponíveis.

Se o tipo de nó, como text() ou comment()..., for especificado como o node test, a etapa apenas retornará nós de tipo especificado, independentemente do tipo de nó principal do eixo. Por exemplo, a seguinte expressão de caminho retorna apenas os filhos de nó de comentário do nó de contexto:

child::comment()  

Da mesma forma, /child::ProductDescription/child::Features/child::comment() recupera os filhos do nó de comentário do <filho do nó do elemento Features> do nó do <elemento ProductDescription> .

Exemplos

Os exemplos a seguir comparam nome de nó e tipo de nó.

a. Resultados da especificação do nome de nó e do tipo de nó como node tests em uma expressão de caminho

No exemplo a seguir, um documento XML simples é atribuído a uma variável de tipo xml . O documento é consultado usando expressões de caminho diferentes. Os resultados são comparados.

declare @x xml  
set @x='  
<a>  
 <b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
 </b>  
</a>'  
select @x.query('  
/child::a/child::b/descendant::*  
')  

Essa expressão solicita os nós de elemento descendentes do nó de elemento <b>.

O asterisco (*) no node test indica um caractere curinga para o nome de nó. O eixo descendente tem o nó de elemento como seu tipo de nó primário. Portanto, a expressão retorna todos os nós de elemento descendentes do nó de elemento <b>. Ou seja, são retornados os nós de elemento <c> e <d>, como mostrado no seguinte resultado:

<c>text2  
     <d>text3</d>  
</c>  
<d>text3</d>  

Se você especificar um eixo descendente ou independente em vez de especificar um eixo descendente, o nó de contexto será retornado, além de seus descendentes:

/child::a/child::b/descendant-or-self::*  

Essa expressão retorna o nó de elemento <b> e seus nós de elemento descendentes. Ao retornar os nós descendentes, o tipo de nó primário do eixo descendente ou independente, o tipo de nó de elemento, determina que tipo de nós são retornados.

Este é o resultado:

<b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
</b>  
  
<c>text2  
     <d>text3</d>  
</c>  
  
<d>text3</d>   

A expressão anterior usava um caractere curinga como um nome de nó. Em vez disso, você pode usar a função node(), como mostrado nesta expressão:

/child::a/child::b/descendant::node()  

Como node() é um tipo de nó, você receberá todos os nós do eixo descendente. Este é o resultado:

text1  
<c>text2  
     <d>text3</d>  
</c>  
text2  
<d>text3</d>  
text3  

Novamente, se você especificar eixo descendente ou independente e node() como o node test, receberá todos os descendentes, elementos e nós de texto, e também o nó de contexto, o elemento <b>.

<b>text1  
   <c>text2  
     <d>text3</d>  
   </c>  
</b>  
text1  
<c>text2  
     <d>text3</d>  
</c>  
text2  
<d>text3</d>  
text3  

B. Especificando um nome de nó no node test

O exemplo a seguir especifica um nome de nó como o node test em todas as expressões de caminho. Como resultado, todas as expressões retornam nós do tipo de nó principal do eixo que tem o nome de nó especificado no node test.

A expressão de consulta a seguir retorna o <Warranty> elemento do documento XML do catálogo de produtos armazenado na Production.ProductModel tabela:

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::PD:Features/child::wm:Warranty  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Observe o seguinte na consulta anterior:

• A palavra-chave namespace no prólogo do XQuery define um prefixo usado no corpo da consulta. Para obter mais informações, sobre o prólogo XQuery, consulte Prólogo do XQuery .

• Todas as três etapas na expressão de caminho especificam o eixo filho e um nome de nó como o node test.

• A parte do qualificador de etapa opcional da etapa de eixo não é especificada nas etapas da expressão.

A consulta retorna os <Warranty> filhos do <Features> elemento filho do <ProductDescription> elemento.

Este é o resultado:

<wm:Warranty xmlns:wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain">  
  <wm:WarrantyPeriod>3 years</wm:WarrantyPeriod>  
  <wm:Description>parts and labor</wm:Description>  
</wm:Warranty>     

Na consulta a seguir, a expressão de caminho especifica um caractere curinga (*) em um node test.

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::PD:Features/child::*  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

O caractere curinga é especificado para o nome de nó. Portanto, a consulta retorna todos os filhos do nó de elemento do <Features> filho do nó do elemento do nó do <ProductDescription> elemento.

A consulta a seguir é semelhante à consulta anterior, exceto que junto com o caractere curinga, é especificado um namespace. Como resultado, são retornados todos os filhos do nó de elemento nesse namespace. Observe que o <Features> elemento pode conter elementos de namespaces diferentes.

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::PD:Features/child::wm:*  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Você pode usar o caractere curinga como um prefixo de namespace, como mostrado nesta consulta:

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::PD:Features/child::*:Maintenance  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Essa consulta retorna os filhos do <Maintenance> nó de elemento em todos os namespaces do documento XML do catálogo de produtos.

C. Especificando o tipo de nó no node test

O exemplo a seguir especifica um tipo de nó como o node test em todas as expressões de caminho. Como resultado, todas as expressões retornam nós do tipo especificado no node test.

Na consulta a seguir, a expressão de caminho especifica um tipo de nó em sua terceira etapa:

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::PD:Features/child::text()  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Na próxima consulta, é especificado o seguinte:

• A expressão de caminho tem três etapas separadas por uma barra (/).

• Cada uma dessas etapas especifica um eixo filho.

• As primeiras duas etapas especificam um nome de nó como o node test, e a terceira etapa especifica um tipo de nó como o node test.

• A expressão retorna filhos de nó de texto do <Features> filho do elemento do nó do <ProductDescription> elemento.

Apenas um nó de texto é retornado. Este é o resultado:

These are the product highlights.   

A consulta a seguir retorna os filhos do nó de comentário do <ProductDescription> elemento :

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::PD:ProductDescription/child::comment()  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Observe o seguinte na consulta anterior:

• A segunda etapa especifica um tipo de nó como o node test.

• Como resultado, a expressão retorna os filhos do nó de comentário dos nós de <ProductDescription> elemento.

Este é o resultado:

<!-- add one or more of these elements... one for each specific product in this product model -->  
<!-- add any tags in <specifications> -->      

A seguinte consulta recupera os nós de instrução de processamento de nível superior:

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::processing-instruction()  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Este é o resultado:

<?xml-stylesheet href="ProductDescription.xsl" type="text/xsl"?>   

Você pode passar um parâmetro literal de cadeia de caracteres para o node test processing-instruction(). Nesse caso, a consulta retorna as instruções de processamento cujo valor do atributo de nome é o literal de cadeia de caracteres especificado no argumento.

SELECT CatalogDescription.query('  
declare namespace PD="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelDescription";  
declare namespace wm="https://schemas.microsoft.com/sqlserver/2004/07/adventure-works/ProductModelWarrAndMain";  
 /child::processing-instruction("xml-stylesheet")  
')  
FROM Production.ProductModel  
WHERE ProductModelID=19  

Limitações de implementação

A seguir, são apresentadas as limitações específicas

• Não é oferecido suporte aos node tests SequenceType estendidos.

• Não é oferecido suporte a processing-instruction(name). Em vez disso, insira o nome entre aspas.