Delen via

Relaties specificeren met sql:relationship (SQLXML 4.0)

Van toepassing op:SQL ServerAzure SQL Database

De elementen in een XML-document kunnen gerelateerd zijn. De elementen kunnen hiërarchisch genest worden, en ID-, IDREF- of IDREFS-relaties kunnen tussen de elementen worden gespecificeerd.

Bijvoorbeeld, in een XSD-schema bevat <een Customer-element Order-kindelementen>.>< Wanneer het schema wordt toegewezen aan de AdventureWorks-database, wordt het <Customer-element> gekoppeld aan de Sales.Customer-tabel en het <Order-element> aan de Sales.SalesOrderHeader-tabel. Deze onderliggende tabellen, Sales.Customer en Sales.SalesOrderHeader, zijn gerelateerd omdat klanten bestellingen plaatsen. De CustomerID in de Sales.SalesOrderHeader-tabel is een vreemde sleutel die verwijst naar de primaire CustomerID-sleutel in de Sales.Customer-tabel. Je kunt deze relaties tussen mapping schema-elementen vaststellen door gebruik te maken van de sql: relationship-annotatie.

In het geannoteerde XSD-schema wordt de sql:relationship-annotatie gebruikt om de schema-elementen hiërarchisch te nesten, op basis van primaire sleutel- en vreemde sleutelrelaties tussen de onderliggende tabellen waaraan de elementen worden gekoppeld. Bij het specificeren van de sql: relationship-annotatie moet je het volgende identificeren:

  • De hoofdtabel (Sales.Customer) en de kind-tabel (Sales.SalesOrderHeader).

  • De kolom of kolommen die de relatie vormen tussen de ouder- en kindtabellen. Bijvoorbeeld de kolom CustomerID, die zowel in de ouder- als kindtabellen voorkomt.

Deze informatie wordt gebruikt om de juiste hiërarchie te genereren.

Om de tabelnamen en de benodigde join-informatie te verkrijgen, worden de volgende attributen gespecificeerd in de sql: relationship-annotatie. Deze attributen zijn alleen geldig met het <sql:relationship-element> :

Naam
Specificeert de unieke naam van de relatie.

Parent
Specificeert de ouderrelatie (tabel). Dit is een optioneel attribuut; Als het attribuut niet is gespecificeerd, wordt de naam van de ouder-tabel verkregen uit informatie in de kindhiërarchie in het document. Als het schema twee ouder-kindhiërarchieën specificeert die dezelfde <sql:relationship> gebruiken maar verschillende ouder-elementen, specificeer je het ouderattribuut niet in <sql:relationship>. Deze informatie wordt verkregen uit de hiërarchie in het schema.

Oudersleutel
Specificeert de oudersleutel van de ouder. Als de oudersleutel uit meerdere kolommen bestaat, worden waarden gespecificeerd met een ruimte ertussen. Er is een positionele mapping tussen de waarden die zijn gespecificeerd voor de multikolomsleutel en voor de bijbehorende kindsleutel.

onderliggende
Specificeert de kindrelatie (tabel).

Kindsleutel
Specificeert de kindsleutel in het kind, verwijzend naar de parent-key in ouder. Als de kindsleutel uit meerdere attributen (kolommen) bestaat, worden de kindsleutelwaarden gespecificeerd met een ruimte ertussen. Er is een positionele mapping tussen de waarden die zijn gespecificeerd voor de meerkolomsleutel en voor de bijbehorende oudersleutel.

Omgekeerd
Dit attribuut dat op <sql:relationship> is gespecificeerd, wordt gebruikt door updategrams. Voor meer informatie, zie Specificering van het sql:inverse Attribuut op sql:relationship.

De sql:key-fields annotatie moet worden gespecificeerd in een element dat een kind-element bevat, dat een <sql:relatie> heeft tussen het element en het kind, en dat niet de primaire sleutel van de tabel die in het ouder-element is gespecificeerd, oplevert. Zelfs als het schema sql:relationship> niet specificeert<, moet je sql:key-fields specificeren om de juiste hiërarchie te produceren. Voor meer informatie, zie Sleutelkolommen identificeren door gebruik te maken van sql:key-fields.

Om een juiste genesing in het resultaat te bereiken, wordt aanbevolen dat sql:key-fields in alle schema's worden gespecificeerd.

Voorbeelden

Om werkmonsters te maken met de volgende voorbeelden, moet je aan bepaalde eisen voldoen. Voor meer informatie, zie Vereisten voor het uitvoeren van SQLXML-voorbeelden.

Eén. Het specificeren van de sql:relationship-annotatie op een element

Het volgende geannoteerde XSD-schema bevat <Klant-> en <Order-elementen> . Het <Order-element> is een kind-element van het <Customer-element> .

In het schema is de sql:relationship-annotatie gespecificeerd op het <Order-kindelement> . De relatie zelf wordt gedefinieerd in het <xsd:appinfo-element> .

Het <relatie-element> identificeert CustomerID in de Sales.SalesOrderHeader-tabel als een vreemde sleutel die verwijst naar de primaire CustomerID-sleutel in de Sales.Customer-tabel. Daarom verschijnen bestellingen die van een klant zijn als een kindelement van dat <klantelement> .

<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>

Het vorige schema gebruikt een benoemde relatie. Je kunt ook een naamloze relatie specificeren. De resultaten zijn hetzelfde.

Dit is het herziene schema waarin een naamloze relatie wordt gespecificeerd:

<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>
Om een voorbeeld van een XPath-query te testen tegen het schema

  1. Kopieer de bovenstaande schemacode en plak deze in een tekstbestand. Sla het bestand op als sql-relationship.xml.

  2. Kopieer het volgende sjabloon hieronder en plak het in een tekstbestand. Sla het bestand op als sql-relationshipT.xml in dezelfde map waar je sql-relationship.xmlhebt opgeslagen.

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

    Het directorypad dat voor het mappingschema (sql-relationship.xml) is gespecificeerd is relatief tot de map waar het sjabloon wordt opgeslagen. Een absoluut pad kan ook worden gespecificeerd, bijvoorbeeld:

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

  3. Maak het SQLXML 4.0 Test Script (Sqlxml4test.vbs) aan en gebruik het om het sjabloon uit te voeren.

    Voor meer informatie, zie Gebruik ADO om SQLXML-queries uit te voeren.

Dit is de resultatenset:

<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. Het specificeren van een relatieketen

Voor dit voorbeeld ga je ervan uit dat je het volgende XML-document wilt met gegevens verkregen uit de AdventureWorks-database:

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

Voor elke bestelling in de Sales.SalesOrderHeader-tabel heeft het XML-document één <Order-element> . En elk <Order-element> heeft een lijst van <Product-kindelementen> , één voor elk product dat in de order wordt gevraagd.

Om een XSD-schema te specificeren dat deze hiërarchie zal produceren, moet je twee relaties specificeren: OrderOD en ODProduct. De OrderOD-relatie specificeert de ouder-kindrelatie tussen de tabellen Sales.SalesOrderHeader en Sales.SalesOrderDetail. De ODProduct-relatie specificeert de relatie tussen de tabellen Sales.SalesOrderDetail en Production.Product.

In het volgende schema specificeert de msdata:relationship-annotatie op het <productelement> twee waarden: OrderOD en ODProduct. De volgorde waarin deze waarden worden gespecificeerd is belangrijk.

<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>

In plaats van een benoemde relatie te specificeren, kun je een anonieme relatie specificeren. In dit geval is de volledige inhoud van <de annotatie>... </annotatie>, die de twee relaties beschrijft, verschijnen als een kindelement van <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>
Om een voorbeeld van een XPath-query te testen tegen het schema

  1. Kopieer de bovenstaande schemacode en plak deze in een tekstbestand. Sla het bestand op als relationshipChain.xml.

  2. Kopieer het volgende sjabloon hieronder en plak het in een tekstbestand. Sla het bestand op als relationshipChainT.xml in dezelfde map waar je relationshipChain.xmlhebt opgeslagen.

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

    Het directorypad dat voor het mappingschema (relationshipChain.xml) is gespecificeerd is relatief tot de map waar het sjabloon wordt opgeslagen. Een absoluut pad kan ook worden gespecificeerd, bijvoorbeeld:

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

  3. Maak het SQLXML 4.0 Test Script (Sqlxml4test.vbs) aan en gebruik het om het sjabloon uit te voeren.

    Voor meer informatie, zie Gebruik ADO om SQLXML-queries uit te voeren.

Dit is de resultatenset:

<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. Het specificeren van de relatieannotatie op een attribuut

Het schema in dit voorbeeld bevat een <Customer-element> met een <CustomerID-kindelement> en een OrderIDList-attribuut van IDREFS-type. Het <Customer-element> wordt gekoppeld aan de Sales.Customer-tabel in de AdventureWorks-database. Standaard geldt de scope van deze mapping voor alle kindelementen of attributen, tenzij sql:relation is gespecificeerd op het kindelement of attribuut, in welk geval de juiste primaire sleutel/vreemde sleutel relatie met het <relatie-element> moet worden gedefinieerd. En het kindelement of attribuut, dat de verschillende tabel specificeert met de relatieannotatie, moet ook de relatieannotatie specificeren.

<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>
Om een voorbeeld van een XPath-query te testen tegen het schema

  1. Kopieer de bovenstaande schemacode en plak deze in een tekstbestand. Sla het bestand op als relationship-on-attribute.xml.

  2. Kopieer het volgende sjabloon en plak het in een bestand. Sla het bestand op als relationship-on-attributeT.xml in dezelfde map waar je relationship-on-attribute.xmlhebt opgeslagen. De query in de template selecteert een klant met CustomerID van 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>

    Het directorypad dat voor het mappingschema (relationship-on-attribute.xml) is gespecificeerd is relatief tot de map waar het sjabloon wordt opgeslagen. Een absoluut pad kan ook worden gespecificeerd, bijvoorbeeld:

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

  3. Maak het SQLXML 4.0 Test Script (Sqlxml4test.vbs) aan en gebruik het om het sjabloon uit te voeren.

    Voor meer informatie, zie Gebruik ADO om SQLXML-queries uit te voeren.

Dit is de resultatenset:

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

D. SQL:relatie specificeren op meerdere elementen

In dit voorbeeld bevat het geannoteerde XSD-schema de <elementen Customer>, <Order> en <OrderDetail> .

Het <Order-element> is een kind-element van het <Customer-element> . <sql:relationship> wordt gespecificeerd op het <Order-kindelement> ; daarom verschijnen orders die bij een klant horen als kindelementen van <Customer>.

Het <Order-element> bevat het <OrderDetail-kindelement> . <sql:relationship> wordt gespecificeerd op <het OrderDetail-kindelement> , dus de orderdetails die betrekking hebben op een order verschijnen als kindelementen van dat <Order-element> .

<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>
Om een voorbeeld van een XPath-query te testen tegen het schema

  1. Kopieer de bovenstaande schemacode en plak deze in een tekstbestand. Sla het bestand op als relationship-multiple-elements.xml.

  2. Kopieer het volgende sjabloon en plak het in een tekstbestand. Sla het bestand op als relationship-multiple-elementsT.xml in dezelfde map waar je relationship-multiple-elements.xmlhebt opgeslagen. De zoekopdracht in het sjabloon levert orderinformatie terug voor een klant met CustomerID 1 en 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>

    Het directorypad dat voor het mappingschema (relationship-multiple-elements.xml) is gespecificeerd is relatief tot de map waar het sjabloon wordt opgeslagen. Een absoluut pad kan ook worden gespecificeerd, bijvoorbeeld:

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

  3. Maak het SQLXML 4.0 Test Script (Sqlxml4test.vbs) aan en gebruik het om het sjabloon uit te voeren.

    Voor meer informatie, zie Gebruik ADO om SQLXML-queries uit te voeren.

Dit is de resultatenset:

<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. Het specificeren van de <sql:relationship> zonder het ouderattribuut

Dit voorbeeld illustreert het specificeren van de <sql:relationship> zonder het ouderattribuut . Stel bijvoorbeeld dat je de volgende personeelstabellen hebt:

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

De volgende XML-weergave heeft de <Emp1> - en <Emp2-elementen> gekoppeld aan de tabellen Sales.Emp1 en 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>

In het schema zijn zowel het Emp1-element> als het< Emp2-element >van het type EmpType<. Het type EmpType beschrijft een <Order-kindelement> en de bijbehorende <sql:relationship>. In dit geval is er geen enkele ouder die in sql:relationship> kan worden geïdentificeerd< door het ouderattribuut te gebruiken. In deze situatie specificeer je het ouderattribuut niet in <sql:relationship>; de informatie over het ouderattribuut wordt verkregen uit de hiërarchie in het schema.

Om een voorbeeld van een XPath-query te testen tegen het schema

  1. Maak deze tabellen aan in de AdventureWorks-database:

    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. Voeg deze voorbeeldgegevens toe aan de tabellen:

    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. Kopieer de bovenstaande schemacode en plak deze in een tekstbestand. Sla het bestand op als relationship-noparent.xml.

  4. Kopieer het volgende sjabloon en plak het in een tekstbestand. Sla het bestand op als relationship-noparentT.xml in dezelfde map waar je relationship-noparent.xmlhebt opgeslagen. De query in het sjabloon selecteert alle <Emp1-elementen> (dus is de ouder Emp1).

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

    Het directorypad dat voor het mappingschema (relationship-noparent.xml) is gespecificeerd is relatief tot de map waar het sjabloon wordt opgeslagen. Een absoluut pad kan ook worden gespecificeerd, bijvoorbeeld:

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

  5. Maak het SQLXML 4.0 Test Script (Sqlxml4test.vbs) aan en gebruik het om het sjabloon uit te voeren.

    Voor meer informatie, zie Gebruik ADO om SQLXML-queries uit te voeren.

Hier is een gedeeltelijke resultaatset:

<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