Partilhar via

Especificando relações usando sql:relationship (SQLXML 4.0)

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

Por exemplo, em um esquema XSD, um <elemento Customer> contém <elementos filho order> . Quando o esquema é mapeado para o banco de dados AdventureWorks, o <elemento Customer> é mapeado para a tabela Sales.Customer e o <elemento Order> é mapeado para a tabela Sales.SalesOrderHeader. Essas tabelas subjacentes, Sales.Customer e Sales.SalesOrderHeader, estão relacionadas porque os clientes fazem pedidos. A CustomerID na tabela Sales.SalesOrderHeader é uma chave estrangeira que se refere à chave primária CustomerID na tabela Sales.Customer. Você pode estabelecer essas relações entre os elementos de esquema de mapeamento usando a sql:relationship anotação.

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

  • A tabela pai (Sales.Customer) e a tabela filho (Sales.SalesOrderHeader).

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

Essas informações são usadas para gerar a hierarquia adequada.

Para fornecer os nomes de tabela e as informações de junção necessárias, os atributos a seguir são especificados na sql:relationship anotação. Esses atributos são válidos apenas com o <elemento sql:relationship> :

Nome
Especifica o nome exclusivo da relação.

pai
Especifica a relação pai (tabela). Esse é um atributo opcional; se o atributo não for especificado, o nome da tabela pai será obtido das informações na hierarquia filho no documento. Se o esquema especificar duas hierarquias pai-filho que usam o mesmo <sql:relationship> , mas elementos pai diferentes, você não especifica o atributo pai em <sql:relationship>. Essas informações são obtidas da hierarquia no esquema.

chave pai
Especifica a chave pai do pai. Se a chave pai for composta por várias colunas, os valores serão especificados com um espaço entre elas. Há um mapeamento posicional entre os valores especificados para a chave multicolumn e para a chave filho correspondente.

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

chave filho
Especifica a chave filho no filho que se refere à chave pai no pai. Se a chave filho for composta por vários atributos (colunas), os valores de chave filho serão especificados com um espaço entre eles. Há um mapeamento posicional entre os valores especificados para a chave multicolumn e para a chave pai correspondente.

Inverso
Esse atributo especificado em <sql:relationship> é usado por updategramas. Para obter mais informações, consulte Especificando o atributo sql:inverse em sql:relationship.

A sql:key-fields anotação deve ser especificada em um elemento que contém um elemento filho, que tem uma <relação> sql:definida entre o elemento e o filho e que não fornece a chave primária da tabela especificada no elemento pai. Mesmo que o esquema não especifique <sql:relationship>, você deve especificar sql:key-fields para produzir a hierarquia adequada. Para obter mais informações, consulte Identificar colunas de chave usando sql:key-fields.

Para produzir aninhamento adequado no resultado, é recomendável que sql:key-fields sejam especificados em todos os esquemas.

Exemplos

Para criar exemplos de funcionamento usando os exemplos a seguir, é necessário atender a determinados requisitos. Para obter mais informações, consulte Requisitos para executar exemplos de SQLXML.

Um. Especificando a anotação sql:relationship em um elemento

O esquema XSD anotado a seguir inclui <elementos cliente> e <pedido> . O <elemento Order> é um elemento filho do <elemento Customer> .

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

O <elemento de relação> identifica CustomerID na tabela Sales.SalesOrderHeader como uma chave estrangeira que se refere à chave primária CustomerID na tabela Sales.Customer. Portanto, os pedidos que pertencem a um cliente aparecem como um elemento filho desse <elemento Customer> .

<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 usa uma relação nomeada. Você também pode especificar uma relação sem nome. Os resultados são iguais.

Esse é o esquema revisado no qual 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 com relação ao esquema

  1. Copie o código de esquema acima e cole-o em um arquivo de texto. Salve o arquivo como sql-relationship.xml.

  2. Copie o modelo a seguir e cole-o em um arquivo de texto. Salve o arquivo como sql-relationshipT.xml no mesmo diretório em que você salvou 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 em que o modelo é salvo. Também é possível especificar um caminho absoluto, 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 obter mais informações, consulte Como usar o ADO para executar consultas SQLXML.

Este é 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. Especificando uma cadeia de relacionamentos

Para este exemplo, suponha que você queira o seguinte documento XML usando dados obtidos do banco de dados AdventureWorks:

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

Para cada pedido na tabela Sales.SalesOrderHeader, o documento XML tem um <elemento Order> . E cada <elemento Order> tem uma lista de elementos filho do< produto>, um para cada produto solicitado na ordem.

Para especificar um esquema XSD que produzirá essa hierarquia, você 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.

No esquema a seguir, a msdata:relationship anotação no <elemento Product> especifica dois valores: OrderOD e ODProduct. A ordem na qual esses 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, você pode especificar uma relação anônima. Nesse caso, todo o conteúdo da <anotação>... </annotation>, que descreve as duas relações, aparecem 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 com relação ao esquema

  1. Copie o código de esquema acima e cole-o em um arquivo de texto. Salve o arquivo como relationshipChain.xml.

  2. Copie o modelo a seguir e cole-o em um arquivo de texto. Salve o arquivo como relationshipChainT.xml no mesmo diretório em que você salvou 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 em que o modelo é salvo. Também é possível especificar um caminho absoluto, 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 obter mais informações, consulte Como usar o ADO para executar consultas SQLXML.

Este é 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. Especificando a anotação de relação em um atributo

O esquema neste exemplo inclui um <elemento Customer> com um <elemento filho CustomerID> e um atributo OrderIDList do tipo IDREFS. O <elemento Cliente> é mapeado para a tabela Sales.Customer no banco de dados AdventureWorks. Por padrão, o escopo desse mapeamento se aplica a todos os elementos ou atributos sql:relation filho, a menos que seja especificado no elemento filho ou atributo, nesse caso, a relação chave primária/chave estrangeira apropriada deve ser definida usando o elemento de <relação> . E o elemento filho ou atributo, que especifica a tabela diferente usando a relation anotação, também deve especificar a relationship anotaçã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 com relação ao esquema

  1. Copie o código de esquema acima e cole-o em um arquivo de texto. Salve o arquivo como relationship-on-attribute.xml.

  2. Copie o modelo a seguir e cole-o em um arquivo. Salve o arquivo como relationship-on-attributeT.xml no mesmo diretório em que você salvou 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 em que o modelo é salvo. Também é possível especificar um caminho absoluto, 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 obter mais informações, consulte Como usar o ADO para executar consultas SQLXML.

Este é 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. Especificando sql:relationship em vários elementos

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

O <elemento Order> é um elemento filho do <elemento Customer> . <sql:relationship> é especificado no <elemento Filho order> ; portanto, os pedidos que pertencem a um cliente aparecem como elementos filho do <Cliente>.

O <elemento Order> inclui o <elemento filho OrderDetail> . <sql:relationship> é especificado no <elemento filho OrderDetail> , portanto, os detalhes da ordem que pertencem a uma ordem aparecem como elementos filho desse <elemento Order> .

<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 com relação ao esquema

  1. Copie o código de esquema acima e cole-o em um arquivo de texto. Salve o arquivo como relationship-multiple-elements.xml.

  2. Copie o modelo a seguir e cole-o em um arquivo de texto. Salve o arquivo como relationship-multiple-elementsT.xml no mesmo diretório em que você salvou relationship-multiple-elements.xml. A consulta no modelo retorna informações de pedido para um cliente com a CustomerID de 1 e 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 em que o modelo é salvo. Também é possível especificar um caminho absoluto, 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 obter mais informações, consulte Como usar o ADO para executar consultas SQLXML.

Este é 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. Especificando o <sql:relationship> sem o atributo pai

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

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

A exibição XML a seguir tem o <mapeamento de elementos Emp1> e <Emp2> 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, o elemento Emp1> e o< elementoEmp2> são do tipo .<EmpType O tipo EmpType descreve um <elemento filho Order> e a relação> sql:correspondente<. Nesse caso, não há nenhum pai único que possa ser identificado no <sql:relationship> usando o atributo pai . Nessa situação, você não especifica o atributo pai em <sql:relationship>; as informações de atributo pai são obtidas da hierarquia no esquema.

Para testar uma consulta XPath de exemplo com relação ao esquema

  1. Crie estas tabelas no banco de dados AdventureWorks:

    USE AdventureWorks  
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 este exemplo de dados 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 de esquema acima e cole-o em um arquivo de texto. Salve o arquivo como relationship-noparent.xml.

  4. Copie o modelo a seguir e cole-o em um arquivo de texto. Salve o arquivo como relationship-noparentT.xml no mesmo diretório em que você salvou relationship-noparent.xml. A consulta no modelo 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 em que o modelo é salvo. Também é possível especificar um caminho absoluto, 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 obter mais informações, consulte Como usar o ADO para executar consultas SQLXML.

Aqui está um conjunto de resultados parcial:

<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