Definizione di relazioni tramite sql:relationship (SQLXML 4.0)

  • Articolo

Si applica a: SQL Server database SQL di Azure

Gli elementi in un documento XML possono essere correlati. È possibile nidificare gerarchicamente gli elementi e specificare relazioni ID, IDREF o IDREFS 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 in quanto i clienti effettuano ordini. L'elemento 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 costituiscono la relazione tra le tabelle padre e figlio, ad esempio la colonna CustomerID, visualizzata sia nella tabella padre che nella tabella figlio.

Queste informazioni vengono utilizzate per generare la gerarchia appropriata.

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

Nome
Specifica il nome univoco della relazione,

Parent
Specifica la relazione padre (tabella). Si tratta di un attributo facoltativo. Se non è specificato, il nome della tabella padre viene ottenuto dalle informazioni presenti nella gerarchia padre-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 è costituita da più colonne, i valori vengono specificati con uno spazio tra l'uno e l'altro. Tra i valori specificati per la chiave multicolonna e la chiave figlio corrispondente viene applicato un mapping posizionale.

Bambino
Specifica la relazione figlio (tabella).

chiave figlio
Specifica la chiave figlio nell'elemento figlio che fa riferimento alla chiave padre nell'elemento padre. Se la chiave figlio è costituita da più attributi (colonne), i valori di chiave figlio vengono specificati con uno spazio tra l'uno e l'altro. Tra i valori specificati per la chiave multicolonna e la chiave padre corrispondente viene applicato un mapping posizionale.

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:relationship> definita 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 specificare sql:key-fields 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.

R. 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 utilizza una relazione denominata. È inoltre possibile specificare una relazione priva di nome. I risultati sono identici.

Di seguito viene fornito lo schema corretto in cui è specificata una relazione priva di 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 con il nome sql-relationship.xml.

  2. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file con il nome sql-relationshipT.xml nella stessa directory in cui è stato salvato il file 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 di directory specificato per lo schema di mapping (sql-relationship.xml) è relativo alla directory in cui è 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. Definizione di una catena di relazioni

Per questo esempio, si supponga di voler fare in modo che il documento XML seguente utilizzi dati ottenuti dal database di 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 definire 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 sono elencati gli attributi è 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 con il nome relationshipChain.xml.

  2. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file con il nome relationshipChainT.xml nella stessa directory in cui è stato salvato il file 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 di directory specificato per lo schema di mapping (relationshipChain.xml) è relativo alla directory in cui è 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. Definizione dell'annotazione sql:relationship 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 venga specificato sql:relation 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 relazione , deve anche specificare l'annotazione della relazione .

<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 con il nome relationship-on-attribute.xml.

  2. Copiare il modello seguente e incollarlo in un file. Salvare il file con il nome relationship-on-attributeT.xml nella stessa directory in cui è stato salvato il file relationship-on-attribute.xml. La query nel modello seleziona un cliente con CustomerID 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 di directory specificato per lo schema di mapping (relationship-on-attribute.xml) è relativo alla directory in cui è 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 in 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 con il nome relationship-multiple-elements.xml.

  2. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file con il nome relationship-multiple-elementsT.xml nella stessa directory in cui è stato salvato il file relationship-multiple-elements.xml. La query nel modello restituisce informazioni sull'ordine per un cliente con CustomerID 1 e SalesOrderID 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 di directory specificato per lo schema di mapping (relationship-multiple-elements.xml) è relativo alla directory in cui è 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 disporre delle tabelle relative ai 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 il corrispondente< sql:relationship.> 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 le tabelle seguenti nel database 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. Aggiungere i dati di esempio seguenti 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 con il nome relationship-noparent.xml.

  4. Copiare il modello seguente e incollarlo in un file di testo. Salvare il file con il nome relationship-noparentT.xml nella stessa directory in cui è stato salvato il file 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 di directory specificato per lo schema di mapping (relationship-noparent.xml) è relativo alla directory in cui è 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.

Di seguito viene fornito 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>