Partilhar via

Especificação de Relações Usando sql:relationship (SQLXML 4.0)

Aplica-se a:SQL ServerBanco de Dados SQL do Azure

Os elementos num documento XML podem estar relacionados. Os elementos podem ser aninhados hierarquicamente, e podem ser especificadas relações ID, IDREF ou IDREFS entre os elementos.

Por exemplo, num esquema XSD, um <elemento Cliente> contém <elementos filhos de Ordem> . Quando o esquema é mapeado para a base de dados AdventureWorks, o <elemento Cliente> é mapeado para a tabela Sales.Customer e o <elemento Order> para a tabela Sales.OrderHeader. Estas tabelas subjacentes, Sales.Customer e Sales.SalesOrderHeader, estão relacionadas porque os clientes fazem encomendas. O CustomerID na tabela Sales.OrderHeader é uma chave estrangeira que se refere à chave primária CustomerID na tabela Sales.Customer. Pode estabelecer estas relações entre elementos de esquema de mapeamento usando a anotação sql:relationship .

No esquema XSD anotado, a anotação sql:relationship é usada para aninhar os elementos do esquema hierarquicamente, com base nas relações de chave primária e chave estrangeira entre as tabelas subjacentes para as quais os elementos correspondem. Ao especificar a anotação sql:relationship , deve identificar o seguinte:

  • A tabela principal (Sales.Customer) e a tabela filha (Sales.SalesOrderHeader).

  • A coluna ou colunas que compõem a relação entre as tabelas pai e filho. Por exemplo, a coluna CustomerID, que aparece tanto na tabela pai como na filha.

Esta informação é usada para gerar a hierarquia adequada.

Para fornecer os nomes das tabelas e a informação necessária de junção, os seguintes atributos são especificados na anotação sql:relationship . Estes atributos são válidos apenas com o <elemento sql:relationship> :

Nome
Especifica o nome único da relação.

Parente
Especifica a relação pai (tabela). Este é um atributo opcional; Se o atributo não for especificado, o nome da tabela pai é obtido a partir da informação na hierarquia filha do documento. Se o esquema especificar duas hierarquias pai-filho que usam o mesmo< sql:relation> mas elementos pais diferentes, não especifica o atributo pai em <sql:relationship>. Esta informação é obtida da hierarquia no esquema.

Chave-pai
Especifica a chave parental do pai. Se a chave-pai for composta por várias colunas, os valores são especificados com um espaço entre elas. Existe um mapeamento posicional entre os valores especificados para a chave multicoluna e para a chave filha correspondente.

Criança
Especifica a relação filho (tabela).

chave-criança
Especifica a chave filho no filho, referindo-se à chave-pai no pai. Se a chave filho for composta por múltiplos atributos (colunas), os valores da chave filho são especificados com um espaço entre eles. Existe um mapeamento posicional entre os valores especificados para a chave multicoluna e para a chave parental correspondente.

Inverso
Este atributo especificado em <sql:relation> é usado pelos updategrams. Para mais informações, veja Especificar o atributo sql:inverse em sql:relationship.

A anotação sql:key-fields deve ser especificada num elemento que contenha um elemento filho, que tenha uma <relação> sql:definida entre o elemento e o filho, e que não forneça a chave primária da tabela especificada no elemento pai. Mesmo que o esquema não especifique <sql:relationship>, deve especificar sql:key-fields para produzir a hierarquia adequada. Para mais informações, consulte Identificar Colunas-Chave usando sql:key-fields.

Para produzir um aninhamento adequado no resultado, recomenda-se que os campos sql:key sejam especificados em todos os esquemas.

Examples

Para criar exemplos funcionais usando os seguintes exemplos, deve cumprir certos requisitos. Para mais informações, consulte Requisitos para Executar Exemplos de SQLXML.

A. Especificar a anotação sql:relationship num elemento

O seguinte esquema XSD anotado inclui <elementos de Cliente> e <Encomenda> . O <elemento Order> é um elemento filho do <elemento Cliente> .

No esquema, a anotação sql:relationship é especificada no <elemento filho da Ordem> . A relação em si é definida no <elemento xsd:appinfo> .

O <elemento de relação> identifica o CustomerID na tabela Sales.OrderHeader como uma chave estrangeira que se refere à chave primária CustomerID na tabela Sales.Customer. Assim, as encomendas que pertencem a um cliente aparecem como um elemento filho desse <elemento Cliente> .

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
<xsd:annotation>  
  <xsd:appinfo>  
    <sql:relationship name="CustOrders"  
          parent="Sales.Customer"  
          parent-key="CustomerID"  
          child="Sales.SalesOrderHeader"  
          child-key="CustomerID" />  
  </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="Customer" sql:relation="Sales.Customer" type="CustomerType" />  
   <xsd:complexType name="CustomerType" >  
     <xsd:sequence>  
        <xsd:element name="Order"   
                     sql:relation="Sales.SalesOrderHeader"  
                    sql:relationship="CustOrders" >  
           <xsd:complexType>  
              <xsd:attribute name="SalesOrderID" type="xsd:integer" />  
              <xsd:attribute name="CustomerID" type="xsd:string" />  
           </xsd:complexType>  
        </xsd:element>  
     </xsd:sequence>  
        <xsd:attribute name="CustomerID"   type="xsd:string" />   
    </xsd:complexType>  
  
</xsd:schema>

O esquema anterior utiliza uma relação nomeada. Também pode especificar uma relação não identificada. Os resultados são os mesmos.

Este é o esquema revisto em que uma relação sem nome é especificada:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
  
  <xsd:element name="Customer" sql:relation="Sales.Customer"  type="CustomerType" />  
   <xsd:complexType name="CustomerType" >  
     <xsd:sequence>  
        <xsd:element name="Order"   
                     sql:relation="Sales.SalesOrderHeader">  
           <xsd:annotation>  
            <xsd:appinfo>  
              <sql:relationship   
                parent="Sales.Customer"  
                parent-key="CustomerID"  
                child="Sales.SalesOrderHeader"  
                child-key="CustomerID" />  
            </xsd:appinfo>  
           </xsd:annotation>  
           <xsd:complexType>  
              <xsd:attribute name="SalesOrderID" type="xsd:integer" />  
              <xsd:attribute name="CustomerID" type="xsd:string" />  
           </xsd:complexType>  
        </xsd:element>  
     </xsd:sequence>  
        <xsd:attribute name="CustomerID"   type="xsd:string" />   
    </xsd:complexType>  
  
</xsd:schema>
Para testar uma consulta XPath de exemplo contra o esquema

  1. Copie o código do esquema acima e cole num ficheiro de texto. Guarde o ficheiro como sql-relationship.xml.

  2. Copie o modelo seguinte abaixo e cole-o num ficheiro de texto. Guarda o ficheiro como sql-relationshipT.xml no mesmo diretório onde guardaste sql-relationship.xml.

    <ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
    <sql:xpath-query mapping-schema="sql-relationship.xml">  
        /Customer[@CustomerID=1]  
    </sql:xpath-query>  
</ROOT>

    O caminho do diretório especificado para o esquema de mapeamento (sql-relationship.xml) é relativo ao diretório onde o modelo é guardado. Um caminho absoluto também pode ser especificado, por exemplo:

    mapping-schema="C:\MyDir\sql-relationship.xml"

  3. Crie e use o Script de Teste SQLXML 4.0 (Sqlxml4test.vbs) para executar o modelo.

    Para mais informações, consulte Utilização de ADO para Executar Consultas SQLXML.

Aqui está o conjunto de resultados:

<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">   
  <Customer CustomerID="1">   
    <Order OrderID="43860" CustomerID="1" />   
    <Order OrderID="44501" CustomerID="1" />   
    <Order OrderID="45283" CustomerID="1" />   
    <Order OrderID="46042" CustomerID="1" />   
  </Customer>   
</ROOT>

B. Especificação de uma cadeia de relações

Para este exemplo, assuma que pretende o seguinte documento XML usando dados obtidos da base de dados AdventureWorks:

<Order SalesOrderID="43659">  
  <Product Name="Mountain Bike Socks, M"/>   
  <Product Name="Sport-100 Helmet, Blue"/>  
  ...  
</Order>  
...

Para cada encomenda na tabela Sales.SalesOrderHeader, o documento XML tem um <elemento de Encomenda> . E cada <elemento da Ordem> tem uma lista de <elementos filhos do Produto> , um para cada produto solicitado na encomenda.

Para especificar um esquema XSD que produza esta hierarquia, deve especificar duas relações: OrderOD e ODProduct. A relação OrderOD especifica a relação pai-filho entre as tabelas Sales.SalesOrderHeader e Sales.SalesOrderDetail. A relação ODProduct especifica a relação entre as tabelas Sales.SalesOrderDetail e Production.Product (SalesOrderDetail).

No esquema seguinte, a anotação msdata:relationship no <elemento Product> especifica dois valores: OrderOD e ODProduct. A ordem em que estes valores são especificados é importante.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:msdata="urn:schemas-microsoft-com:mapping-schema">  
<xsd:annotation>  
  <xsd:appinfo>  
    <msdata:relationship name="OrderOD"  
          parent="Sales.SalesOrderHeader"  
          parent-key="SalesOrderID"  
          child="Sales.SalesOrderDetail"  
          child-key="SalesOrderID" />  
  
    <msdata:relationship name="ODProduct"  
          parent="Sales.SalesOrderDetail"  
          parent-key="ProductID"  
          child="Production.Product"  
          child-key="ProductID" />  
  </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="Order" msdata:relation="Sales.SalesOrderHeader"   
               msdata:key-fields="SalesOrderID" type="OrderType" />  
   <xsd:complexType name="OrderType" >  
     <xsd:sequence>  
        <xsd:element name="Product" msdata:relation="Production.Product"   
                     msdata:key-fields="ProductID"  
                     msdata:relationship="OrderOD ODProduct">  
          <xsd:complexType>  
             <xsd:attribute name="Name" type="xsd:string" />  
          </xsd:complexType>  
        </xsd:element>  
     </xsd:sequence>  
        <xsd:attribute name="SalesOrderID"   type="xsd:integer" />   
    </xsd:complexType>  
</xsd:schema>

Em vez de especificar uma relação nomeada, pode especificar uma relação anónima. Neste caso, todo o conteúdo da <anotação>... </anotação>, que descreve as duas relações, aparece como um elemento filho do <Produto>.

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:msdata="urn:schemas-microsoft-com:mapping-schema">  
  
  <xsd:element name="Order" msdata:relation="Sales.SalesOrderHeader"   
               msdata:key-fields="SalesOrderID" type="OrderType" />  
  
   <xsd:complexType name="OrderType" >  
     <xsd:sequence>  
        <xsd:element name="Product" msdata:relation="Production.Product"   
                     msdata:key-fields="ProductID" >  
         <xsd:annotation>  
          <xsd:appinfo>  
           <msdata:relationship   
               parent="Sales.SalesOrderHeader"  
               parent-key="SalesOrderID"  
               child="Sales.SalesOrderDetail"  
               child-key="SalesOrderID" />  
  
           <msdata:relationship   
               parent="Sales.SalesOrderDetail"  
               parent-key="ProductID"  
               child="Production.Product"  
               child-key="ProductID" />  
         </xsd:appinfo>  
       </xsd:annotation>  
       <xsd:complexType>  
          <xsd:attribute name="Name" type="xsd:string" />  
       </xsd:complexType>  
     </xsd:element>  
   </xsd:sequence>  
   <xsd:attribute name="SalesOrderID"   type="xsd:integer" />   
  </xsd:complexType>  
 </xsd:schema>
Para testar uma consulta XPath de exemplo contra o esquema

  1. Copie o código do esquema acima e cole num ficheiro de texto. Guarde o ficheiro como relationshipChain.xml.

  2. Copie o modelo seguinte abaixo e cole-o num ficheiro de texto. Guarda o ficheiro como relationshipChainT.xml no mesmo diretório onde guardaste relationshipChain.xml.

    <ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
    <sql:xpath-query mapping-schema="relationshipChain.xml">  
        /Order  
    </sql:xpath-query>  
</ROOT>

    O caminho do diretório especificado para o esquema de mapeamento (relationshipChain.xml) é relativo ao diretório onde o modelo é guardado. Um caminho absoluto também pode ser especificado, por exemplo:

    mapping-schema="C:\MyDir\relationshipChain.xml"

  3. Crie e use o Script de Teste SQLXML 4.0 (Sqlxml4test.vbs) para executar o modelo.

    Para mais informações, consulte Utilização de ADO para Executar Consultas SQLXML.

Aqui está o conjunto de resultados:

<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">   
  <Order SalesOrderID="43659">  
    <Product Name="Mountain Bike Socks, M" />   
    <Product Name="Sport-100 Helmet, Blue" />   
    <Product Name="AWC Logo Cap" />   
    <Product Name="Long-Sleeve Logo Jersey, M" />   
    <Product Name="Long-Sleeve Logo Jersey, XL" />   
    ...  
  </Order>  
  ...  
</ROOT>

C. Especificar a anotação de relação num atributo

O esquema neste exemplo inclui um <elemento Customer> com um <elemento filho CustomerID> e um atributo OrderIDList do tipo IDREFS. O <elemento Cliente> corresponde à tabela Sales.Customer na base de dados AdventureWorks. Por defeito, o âmbito deste mapeamento aplica-se a todos os elementos ou atributos filhos, a menos que sql:relation seja especificado no elemento ou atributo filho, caso em que a relação apropriada entre chave primária e chave estrangeira deve ser definida usando o <elemento de relação> . E o elemento filho ou atributo, que especifica a tabela diferente usando a anotação de relação , também deve especificar a anotação de relação .

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
<xsd:annotation>  
  <xsd:appinfo>  
    <sql:relationship name="CustOrders"  
          parent="Sales.Customer"  
          parent-key="CustomerID"  
          child="Sales.SalesOrderHeader"  
          child-key="CustomerID" />  
     </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="Customer" sql:relation="Sales.Customer" type="CustomerType" />  
   <xsd:complexType name="CustomerType" >  
     <xsd:sequence>  
        <xsd:element name="CustomerID"   type="xsd:string" />   
     </xsd:sequence>  
     <xsd:attribute name="OrderIDList"   
                     type="xsd:IDREFS"   
                     sql:relation="Sales.SalesOrderHeader"   
                     sql:field="SalesOrderID"  
                     sql:relationship="CustOrders" >  
        </xsd:attribute>  
    </xsd:complexType>  
</xsd:schema>
Para testar uma consulta XPath de exemplo contra o esquema

  1. Copie o código do esquema acima e cole num ficheiro de texto. Guarde o ficheiro como relationship-on-attribute.xml.

  2. Copie o modelo seguinte e cole-o num ficheiro. Guarda o ficheiro como relationship-on-attributeT.xml no mesmo diretório onde guardaste relationship-on-attribute.xml. A consulta no modelo seleciona um cliente com o CustomerID de 1.

    <ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
  <sql:xpath-query mapping-schema="relationship-on-attribute.xml">  
    /Customer[CustomerID=1]  
  </sql:xpath-query>  
</ROOT>

    O caminho do diretório especificado para o esquema de mapeamento (relationship-on-attribute.xml) é relativo ao diretório onde o modelo é guardado. Um caminho absoluto também pode ser especificado, por exemplo:

    mapping-schema="C:\MyDir\relationship-on-attribute.xml"

  3. Crie e use o Script de Teste SQLXML 4.0 (Sqlxml4test.vbs) para executar o modelo.

    Para mais informações, consulte Utilização de ADO para Executar Consultas SQLXML.

Aqui está o conjunto de resultados:

<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">   
  <Customer OrderIDList="43860 44501 45283 46042">  
    <CustomerID>1</CustomerID>   
  </Customer>  
</ROOT>

D. Especificação de sql:relationship em múltiplos elementos

Neste exemplo, o esquema XSD anotado contém os <elementos Customer>, <Order> e <OrderDetail> .

O <elemento Order> é um elemento filho do <elemento Cliente> . <sql:relationship> é especificado no <elemento filho da Ordem> ; portanto, as ordens que pertencem a um cliente aparecem como elementos filhos do <Cliente>.

O <elemento Order> inclui o <elemento filho OrderDetail> . <sql:relation> é especificado no <elemento filho OrderDetail> , pelo que os detalhes de ordem que dizem respeito a uma ordem aparecem como elementos filhos desse <elemento de Ordem> .

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
<xsd:annotation>  
  <xsd:appinfo>  
    <sql:relationship name="CustOrders"  
        parent="Sales.Customer"  
        parent-key="CustomerID"  
        child="Sales.SalesOrderHeader"  
        child-key="CustomerID" />  
  
    <sql:relationship name="OrderOrderDetail"  
        parent="Sales.SalesOrderHeader"  
        parent-key="SalesOrderID"  
        child="Sales.SalesOrderDetail"  
        child-key="SalesOrderID" />  
  </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="Customer" sql:relation="Sales.Customer" >  
   <xsd:complexType>  
     <xsd:sequence>  
        <xsd:element name="Order" sql:relation="Sales.SalesOrderHeader"    
              sql:relationship="CustOrders" maxOccurs="unbounded" >  
          <xsd:complexType>  
              <xsd:sequence>  
                <xsd:element name="OrderDetail"   
                             sql:relation="Sales.SalesOrderDetail"   
                             sql:relationship="OrderOrderDetail"   
                             maxOccurs="unbounded" >  
                  <xsd:complexType>  
                    <xsd:attribute name="SalesOrderID" type="xsd:integer" />  
                    <xsd:attribute name="ProductID" type="xsd:string" />  
                    <xsd:attribute name="OrderQty" type="xsd:integer" />  
                  </xsd:complexType>  
                </xsd:element>  
              </xsd:sequence>  
              <xsd:attribute name="SalesOrderID" type="xsd:integer" />  
              <xsd:attribute name="OrderDate" type="xsd:date" />  
              <xsd:attribute name="CustomerID" type="xsd:string" />  
          </xsd:complexType>  
        </xsd:element>  
      </xsd:sequence>  
      <xsd:attribute name="CustomerID" type="xsd:string" />  
     </xsd:complexType>  
  </xsd:element>  
</xsd:schema>
Para testar uma consulta XPath de exemplo contra o esquema

  1. Copie o código do esquema acima e cole num ficheiro de texto. Guarde o ficheiro como relationship-multiple-elements.xml.

  2. Copie o modelo seguinte e cole-o num ficheiro de texto. Guarda o ficheiro como relationship-multiple-elementsT.xml no mesmo diretório onde guardaste relationship-multiple-elements.xml. A consulta no modelo devolve informações de encomenda para um cliente com o CustomerID de 1 e o SalesOrderID de 43860.

    <ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
  <sql:xpath-query mapping-schema="relationship-multiple-elements.xml">  
    /Customer[@CustomerID=1]/Order[@SalesOrderID=43860]  
  </sql:xpath-query>  
</ROOT>

    O caminho do diretório especificado para o esquema de mapeamento (relationship-multiple-elements.xml) é relativo ao diretório onde o modelo é guardado. Um caminho absoluto também pode ser especificado, por exemplo:

    mapping-schema="C:\MyDir\relationship-multiple-elements.xml"

  3. Crie e use o Script de Teste SQLXML 4.0 (Sqlxml4test.vbs) para executar o modelo.

    Para mais informações, consulte Utilização de ADO para Executar Consultas SQLXML.

Aqui está o conjunto de resultados:

<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
  <Order SalesOrderID="43860" OrderDate="2001-08-01" CustomerID="1">  
     <OrderDetail SalesOrderID="43860" ProductID="761" OrderQty="2" />   
     <OrderDetail SalesOrderID="43860" ProductID="770" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="758" OrderQty="2" />   
     <OrderDetail SalesOrderID="43860" ProductID="765" OrderQty="2" />   
     <OrderDetail SalesOrderID="43860" ProductID="732" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="762" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="738" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="768" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="753" OrderQty="2" />   
     <OrderDetail SalesOrderID="43860" ProductID="729" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="763" OrderQty="1" />   
     <OrderDetail SalesOrderID="43860" ProductID="756" OrderQty="1" />   
  </Order>  
</ROOT>

E. Especificar a <relação sql:> sem o atributo pai

Este exemplo ilustra a especificação da <relação> sql:sem o atributo pai. Por exemplo, suponha que tem as seguintes tabelas de funcionários:

Emp1(SalesPersonID, FirstName, LastName, ReportsTo)  
Emp2(SalesPersonID, FirstName, LastName, ReportsTo)

A seguinte vista XML tem os <elementos Emp1> e <Emp2> mapeados para as tabelas Sales.Emp1 e Sales.Emp2:

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"  
            xmlns:sql="urn:schemas-microsoft-com:mapping-schema">  
<xsd:annotation>  
  <xsd:appinfo>  
    <sql:relationship name="EmpOrders"  
          parent-key="SalesPersonID"  
          child="Sales.SalesOrderHeader"  
          child-key="SalesPersonID" />  
     </xsd:appinfo>  
</xsd:annotation>  
  
  <xsd:element name="Emp1" sql:relation="Sales.Emp1" type="EmpType" />  
  <xsd:element name="Emp2" sql:relation="Sales.Emp2" type="EmpType" />  
   <xsd:complexType name="EmpType" >  
     <xsd:sequence>  
        <xsd:element name="Order"   
                     sql:relation="Sales.SalesOrderHeader"   
                     sql:relationship="EmpOrders" >  
          <xsd:complexType>  
             <xsd:attribute name="SalesOrderID" type="xsd:integer" />  
             <xsd:attribute name="CustomerID" type="xsd:string" />  
          </xsd:complexType>  
        </xsd:element>  
     </xsd:sequence>  
        <xsd:attribute name="SalesPersonID"   type="xsd:integer" />   
        <xsd:attribute name="LastName"   type="xsd:string" />   
    </xsd:complexType>  
  
</xsd:schema>

No esquema, tanto o <elemento Emp1> como <o elemento Emp2> são do tipo EmpType. O tipo EmpType descreve um <elemento filho Order> e a correspondente <relação sql:>. Neste caso, não existe um único pai que possa ser identificado em <sql:relation> usando o atributo pai . Nesta situação, não se especifica o atributo pai em <sql:relationship>; a informação do atributo pai é obtida da hierarquia no esquema.

Para testar uma consulta XPath de exemplo contra o esquema

  1. Crie estas tabelas na base de dados AdventureWorks:

    USE AdventureWorks2022;
CREATE TABLE Sales.Emp1 (  
       SalesPersonID int primary key,   
       FirstName  varchar(20),   
       LastName   varchar(20),   
       ReportsTo int)  
Go  
CREATE TABLE Sales.Emp2 (  
       SalesPersonID int primary key,   
       FirstName  varchar(20),   
       LastName   varchar(20),   
       ReportsTo int)  
Go

  2. Adicione estes dados de exemplo nas tabelas:

    INSERT INTO Sales.Emp1 values (279, 'Nancy', 'Devolio',NULL)  
INSERT INTO Sales.Emp1 values (282, 'Andrew', 'Fuller',1)  
INSERT INTO Sales.Emp1 values (276, 'Janet', 'Leverling',1)  
INSERT INTO Sales.Emp2 values (277, 'Margaret', 'Peacock',3)  
INSERT INTO Sales.Emp2 values (283, 'Steven', 'Devolio',4)  
INSERT INTO Sales.Emp2 values (275, 'Nancy', 'Buchanan',5)  
INSERT INTO Sales.Emp2 values (281, 'Michael', 'Suyama',6)

  3. Copie o código do esquema acima e cole num ficheiro de texto. Guarde o ficheiro como relationship-noparent.xml.

  4. Copie o modelo seguinte e cole-o num ficheiro de texto. Guarda o ficheiro como relationship-noparentT.xml no mesmo diretório onde guardaste relationship-noparent.xml. A consulta no template seleciona todos os <elementos Emp1> (portanto, o pai é Emp1).

    <ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
    <sql:xpath-query mapping-schema="relationship-noparent.xml">  
        /Emp1  
    </sql:xpath-query>  
</ROOT>

    O caminho do diretório especificado para o esquema de mapeamento (relationship-noparent.xml) é relativo ao diretório onde o modelo é guardado. Um caminho absoluto também pode ser especificado, por exemplo:

    mapping-schema="C:\MyDir\relationship-noparent.xml"

  5. Crie e use o Script de Teste SQLXML 4.0 (Sqlxml4test.vbs) para executar o modelo.

    Para mais informações, consulte Utilização de ADO para Executar Consultas SQLXML.

Aqui está um conjunto parcial de resultados:

<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">  
<Emp1 SalesPersonID="276" LastName="Leverling">  
  <Order SalesOrderID="43663" CustomerID="510" />   
  <Order SalesOrderID="43666" CustomerID="511" />   
  <Order SalesOrderID="43859" CustomerID="259" />  
  ...  
</Emp1>
  • Last updated on