Condividi tramite

Specificare le relazioni usando sql:relationship (SQLXML 4.0)

Gli elementi di un documento XML possono essere correlati. Gli elementi possono essere annidati in modo gerarchico e le relazioni ID, IDREF o IDREFS possono essere specificate tra gli elementi.

In uno schema XSD, ad esempio, un <elemento Customer> contiene <elementi figlio Order> . Quando lo schema viene mappato al database AdventureWorks, l'elemento Customer> esegue il< mapping alla tabella Sales.Customer e l'elemento <Order> viene mappato alla tabella Sales.SalesOrderHeader. Queste tabelle sottostanti, Sales.Customer e Sales.SalesOrderHeader, sono correlate perché i clienti eseguono ordini. CustomerID nella tabella Sales.SalesOrderHeader è una chiave esterna che fa riferimento alla chiave primaria CustomerID nella tabella Sales.Customer. È possibile stabilire queste relazioni tra gli elementi dello schema di mapping usando l'annotazione sql:relationship .

Nello schema XSD con annotazioni, l'annotazione sql:relationship viene usata per annidare gli elementi dello schema in modo gerarchico, in base alle relazioni tra chiave primaria e chiave esterna tra le tabelle sottostanti a cui vengono mappati gli elementi. Specificando l'annotazione sql:relationship , è necessario identificare quanto segue:

  • Tabella padre (Sales.Customer) e tabella figlio (Sales.SalesOrderHeader).

  • Colonna o colonne che compongono la relazione tra le tabelle padre e figlio. Ad esempio, la colonna CustomerID, visualizzata sia nelle tabelle padre che in quella figlio.

Queste informazioni vengono usate per generare la gerarchia corretta.

Per fornire i nomi delle tabelle e le informazioni di join necessarie, nell'annotazione sql:relationship vengono specificati gli attributi seguenti. Questi attributi sono validi solo con l'elemento <sql:relationship> :

Nome
Specifica il nome univoco della relazione.

Genitore
Specifica la relazione padre (tabella). Si tratta di un attributo facoltativo; se l'attributo non viene specificato, il nome della tabella padre viene ottenuto dalle informazioni nella gerarchia figlio del documento. Se lo schema specifica due gerarchie padre-figlio che usano la stessa <relazione sql:relationship> ma elementi padre diversi, non si specifica l'attributo padre in <sql:relationship>. Queste informazioni vengono ottenute dalla gerarchia nello schema.

parent-key
Specifica la chiave padre dell'elemento padre. Se la chiave padre è composta da più colonne, i valori vengono specificati con uno spazio tra di essi. Esiste un mapping posizionale tra i valori specificati per la chiave multicolumn e per la chiave figlio corrispondente.

figlio
Specifica la relazione figlio (tabella).

chiave figlio
Specifica la chiave figlio nel figlio che fa riferimento alla chiave padre nell'elemento padre. Se la chiave figlio è composta da più attributi (colonne), i valori della chiave figlio vengono specificati con uno spazio tra di essi. Esiste un mapping posizionale tra i valori specificati per la chiave multicolumn e per la chiave padre corrispondente.

Inverso
Questo attributo specificato in <sql:relationship> viene usato dagli updategram. Per altre informazioni, vedere Specifica dell'attributo sql:inverse in sql:relationship.

L'annotazione sql:key-fields deve essere specificata in un elemento che contiene un elemento figlio, con una <relazione> sql:defined tra l'elemento e l'elemento figlio e che non fornisce la chiave primaria della tabella specificata nell'elemento padre. Anche se lo schema non specifica <sql:relationship>, è necessario specificare sql:key-fields per produrre la gerarchia corretta. Per altre informazioni, vedere Identificazione delle colonne chiave tramite sql:key-fields.

Per produrre un annidamento corretto nel risultato, è consigliabile sql:key-fields specificare in tutti gli schemi.

Esempi

Per creare esempi reali utilizzando gli esempi seguenti, è necessario soddisfare alcuni requisiti. Per altre informazioni, vedere Requisiti per l'esecuzione di esempi SQLXML.

Un. Specifica dell'annotazione sql:relationship in un elemento

Lo schema XSD con annotazioni seguente include <gli elementi Customer> e <Order> . L'elemento <Order> è un elemento figlio dell'elemento <Customer> .

Nello schema l'annotazione sql:relationship viene specificata nell'elemento <figlio Order> . La relazione stessa viene definita nell'elemento <xsd:appinfo> .

L'elemento <di relazione> identifica CustomerID nella tabella Sales.SalesOrderHeader come chiave esterna che fa riferimento alla chiave primaria CustomerID nella tabella Sales.Customer. Di conseguenza, gli ordini che appartengono a un cliente vengono visualizzati come elemento figlio di tale <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>

Lo schema precedente usa una relazione denominata. È anche possibile specificare una relazione senza nome. I risultati sono uguali.

Questo è lo schema modificato in cui viene specificata una relazione senza nome:

<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>
Per testare una query Xpath di esempio sullo schema

  1. Copiare il codice dello schema precedente e incollarlo in un file di testo. Salvare il file come sql-relationship.xml.

  2. Copiare il modello seguente sotto e incollarlo in un file di testo. Salvare il file come sql-relationshipT.xml nella stessa directory in cui è stato salvato 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>

    Il percorso della directory specificato per lo schema di mapping (sql-relationship.xml) è relativo alla directory in cui viene salvato il modello. È possibile specificare anche un percorso assoluto, ad esempio:

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

  3. Creare e utilizzare lo script di test SQLXML 4.0 (Sqlxml4test.vbs) per eseguire il modello.

    Per altre informazioni, vedere Uso di ADO per eseguire query SQLXML.

Set di risultati:

<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. Specifica di una catena di relazioni

Per questo esempio, si supponga di voler usare il documento XML seguente usando i dati ottenuti dal database AdventureWorks:

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

Per ogni ordine nella tabella Sales.SalesOrderHeader, il documento XML ha un <elemento Order> . <Ogni elemento Order> ha un elenco di <elementi figlio Product>, uno per ogni prodotto richiesto nell'ordine.

Per specificare uno schema XSD che produrrà questa gerarchia, è necessario specificare due relazioni: OrderOD e ODProduct. La relazione OrderOD specifica la relazione padre-figlio tra le tabelle Sales.SalesOrderHeader e Sales.SalesOrderDetail. La relazione ODProduct specifica la relazione tra le tabelle Sales.SalesOrderDetail e Production.Product.

Nello schema seguente l'annotazione msdata:relationship nell'elemento <Product> specifica due valori: OrderOD e ODProduct. L'ordine in cui vengono specificati questi valori è 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>

Anziché specificare una relazione denominata, è possibile specificare una relazione anonima. In questo caso, l'intero contenuto dell'annotazione<>... </annotation>, che descrive le due relazioni, viene visualizzato come elemento figlio di <Product>.

<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>
Per testare una query Xpath di esempio sullo schema

  1. Copiare il codice dello schema precedente e incollarlo in un file di testo. Salvare il file come relationshipChain.xml.

  2. Copiare il modello seguente sotto e incollarlo in un file di testo. Salvare il file come relationshipChainT.xml nella stessa directory in cui è stato salvato relationshipChain.xml.

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

    Il percorso della directory specificato per lo schema di mapping (relationshipChain.xml) è relativo alla directory in cui viene salvato il modello. È possibile specificare anche un percorso assoluto, ad esempio:

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

  3. Creare e utilizzare lo script di test SQLXML 4.0 (Sqlxml4test.vbs) per eseguire il modello.

    Per altre informazioni, vedere Uso di ADO per eseguire query SQLXML.

Set di risultati:

<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. Specifica dell'annotazione della relazione in un attributo

Lo schema in questo esempio include un <elemento Customer> con un <elemento figlio CustomerID> e un attributo OrderIDList di tipo IDREFS. L'elemento <Customer> esegue il mapping alla tabella Sales.Customer nel database AdventureWorks. Per impostazione predefinita, l'ambito di questo mapping si applica a tutti gli elementi o gli attributi figlio, a meno che non sql:relation sia specificato nell'elemento figlio o nell'attributo, nel qual caso, la relazione chiave primaria/chiave esterna appropriata deve essere definita usando l'elemento <di relazione> . E l'elemento o l'attributo figlio, che specifica la tabella diversa usando l'annotazione relation , deve anche specificare l'annotazione relationship .

<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>
Per testare una query Xpath di esempio sullo schema

  1. Copiare il codice dello schema precedente e incollarlo in un file di testo. Salvare il file come relationship-on-attribute.xml.

  2. Copiare il modello seguente e incollarlo in un file. Salvare il file come relationship-on-attributeT.xml nella stessa directory in cui è stato salvato relationship-on-attribute.xml. La query nel modello seleziona un cliente con l'ID cliente 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>

    Il percorso della directory specificato per lo schema di mapping (relationship-on-attribute.xml) è relativo alla directory in cui viene salvato il modello. È possibile specificare anche un percorso assoluto, ad esempio:

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

  3. Creare e utilizzare lo script di test SQLXML 4.0 (Sqlxml4test.vbs) per eseguire il modello.

    Per altre informazioni, vedere Uso di ADO per eseguire query SQLXML.

Set di risultati:

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

D. Specifica di sql:relationship su più elementi

In questo esempio lo schema XSD con annotazioni contiene gli <elementi Customer>, <Order e OrderDetail>>.<

L'elemento <Order> è un elemento figlio dell'elemento <Customer> . <sql:relationship> viene specificato nell'elemento <figlio Order> , pertanto gli ordini che appartengono a un cliente vengono visualizzati come elementi figlio di <Customer>.

L'elemento <Order> include l'elemento <figlio OrderDetail> . <sql:relationship> viene specificato nell'elemento <figlio OrderDetail> , pertanto i dettagli dell'ordine relativi a un ordine vengono visualizzati come elementi figlio di tale <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>
Per testare una query Xpath di esempio sullo schema

  1. Copiare il codice dello schema precedente e incollarlo in un file di testo. Salvare il file come relationship-multiple-elements.xml.

  2. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file come relationship-multiple-elementsT.xml nella stessa directory in cui è stato salvato relationship-multiple-elements.xml. La query nel modello restituisce informazioni sugli ordini per un cliente con CustomerID 1 e SalesOrderID di 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>

    Il percorso della directory specificato per lo schema di mapping (relationship-multiple-elements.xml) è relativo alla directory in cui viene salvato il modello. È possibile specificare anche un percorso assoluto, ad esempio:

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

  3. Creare e utilizzare lo script di test SQLXML 4.0 (Sqlxml4test.vbs) per eseguire il modello.

    Per altre informazioni, vedere Uso di ADO per eseguire query SQLXML.

Set di risultati:

<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. Specifica dell'attributo <sql:relationship> senza l'attributo padre

Questo esempio illustra la specifica di <sql:relationship> senza l'attributo padre . Si supponga, ad esempio, di avere le tabelle dei dipendenti seguenti:

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

Nella visualizzazione XML seguente sono presenti gli <elementi Emp1> e<Emp2 mappati> alle tabelle 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>

Nello schema, sia l'elemento Emp1> che l'elemento<<Emp2> sono di tipo EmpType. Il tipo EmpType descrive un <elemento figlio Order> e l'oggetto sql:relationship> corrispondente<. In questo caso, non esiste un singolo elemento padre che può essere identificato in <sql:relationship> usando l'attributo padre . In questo caso, non si specifica l'attributo padre in <sql:relationship>. Le informazioni sull'attributo padre vengono ottenute dalla gerarchia nello schema.

Per testare una query Xpath di esempio sullo schema

  1. Creare queste tabelle nel database 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. Aggiungere questi dati di esempio nelle tabelle:

    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. Copiare il codice dello schema precedente e incollarlo in un file di testo. Salvare il file come relationship-noparent.xml.

  4. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file come relationship-noparentT.xml nella stessa directory in cui è stato salvato relationship-noparent.xml. La query nel modello seleziona tutti gli <elementi Emp1> , pertanto l'elemento padre è Emp1.

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

    Il percorso della directory specificato per lo schema di mapping (relationship-noparent.xml) è relativo alla directory in cui viene salvato il modello. È possibile specificare anche un percorso assoluto, ad esempio:

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

  5. Creare e utilizzare lo script di test SQLXML 4.0 (Sqlxml4test.vbs) per eseguire il modello.

    Per altre informazioni, vedere Uso di ADO per eseguire query SQLXML.

Ecco un set di risultati parziale:

<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