Expressões de caminho - Especificando o 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 teste de nó

• Qualificadores de etapa zero ou mais (opcional)

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

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

Uma condição de teste de nó pode incluir o seguinte:

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

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

Nome do nó como teste de nó

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

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

• Para outros eixos, se os nós selecionados pelo eixo podem conter nós de elemento, elemento é o tipo de nó principal para esse eixo.

Quando você especifica um nome de nó como um teste de nó, a etapa retorna os seguintes tipos de nós:

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

• Nós que têm o mesmo nome especificado no teste de nó.

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

child::ProductDescription   

Esta expressão de uma etapa especifica um eixo child e o nome do nó ProductDescription como o teste de nó. A expressão retorna apenas os nós que são do tipo de nó principal do eixo filho, nós de elemento e que têm ProductDescription como nome.

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

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> elemento filho do elemento><ProductDescription.

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

Ao especificar os nomes dos nós para testes de nó, você também pode usar o caractere curinga (*) para especificar o nome local de um nó ou para seu prefixo de namespace, conforme mostrado no exemplo a seguir:

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 teste de nó

Para consultar tipos de nó diferentes dos nós de elemento, use um teste de tipo de nó. Como mostrado na tabela a seguir, há quatro testes de tipo de nó disponíveis.

Se o tipo de nó, como text() ou comment() ..., for especificado como o teste de nó, a etapa apenas retornará nós do tipo especificado, independentemente do tipo de nó principal do eixo. Por exemplo, a expressão de caminho a seguir retorna apenas os filhos do 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 <Features> elemento filho do nó do elemento><ProductDescription.

Exemplos

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

Um. Resultados da especificação do nome do nó e do tipo de nó como testes de nó 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 diferentes expressões de caminho. Os resultados são entã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::*  
')  

Esta expressão solicita os nós do elemento descendente do nó do elemento <b>.

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

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

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

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

Esta expressão retorna o nó do elemento <b> e seus nós de elemento descendente. Ao retornar os nós descendentes, o tipo de nó primário do eixo descendente-ou-eu, 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 nome de nó. Em vez disso, você pode usar a função node(), como mostra esta 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 o eixo descendente ou próprio e node() como o teste de nó, 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 teste de nó

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

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

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 da consulta anterior:

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

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

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

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

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 teste de nó.

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 do nó. Assim, a consulta retorna todos os filhos do nó do elemento <Features> filho do nó do elemento <ProductDescription>.

A consulta a seguir é semelhante à consulta anterior, exceto que, juntamente com o caractere curinga, um namespace é especificado. Como resultado, todos os filhos do nó do elemento nesse namespace são retornados. Observe que o elemento <Features> 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, conforme 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  

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

C. Especificando o tipo de nó no teste de nó

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

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 consulta seguinte, é 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 duas primeiras etapas especificam um nome de nó como o teste de nó e a terceira etapa especifica um tipo de nó como o teste de nó.

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

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 elemento <ProductDescription>:

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 da consulta anterior:

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

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

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 consulta a seguir 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 teste de nó processing-instruction(). Nesse caso, a consulta retorna as instruções de processamento cujo valor do atributo name é 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

Seguem-se as limitações específicas

• Os testes de nó SequenceType estendidos não são suportados.

• processing-instruction(name) não é suportado. Em vez disso, coloque o nome entre aspas.