Udostępnij przez

Określanie przy użyciu relacji sql:relationship (SQLXML 4.0)

Może być powiązane elementy w dokumencie XML.Elementy mogą być zagnieżdżane hierarchicznie i może być określony identyfikator, IDREF lub IDREFS relacje między elementami.

Na przykład w schematu XSD <Odbiorcy> element zawiera <Zamówienia> elementy podrzędność. Gdy schemat jest mapowany do bazy danych AdventureWorks <Odbiorcy> element jest mapowany do tabela Sales.Customer oraz <Zamówienia> element jest mapowany do tabela Sales.SalesOrderHeader. Te tabel podstawowych, Sales.Customer i Sales.SalesOrderHeader, są powiązane, ponieważ klienci składanie zamówień.Identyfikator klienta w tabela Sales.SalesOrderHeader jest klucz obcy, odnoszące się do klucz podstawowy IDKlienta w tabela Sales.Customer.Można ustanowić te relacje między mapowania elementów schematu przy użyciu sql:relationship adnotacja.

W adnotacjami schematu XSD sql:relationship adnotacji można zagnieździć elementów schematu hierarchicznie, w ramach klucz podstawowy i obcego klucza relacje między tabel, do którego mapować elementy. Określając sql:relationship adnotację, należy określić następujące czynności:

  • W tabela nadrzędnej (Sales.Customer) oraz podrzędność tabela (Sales.SalesOrderHeader).

  • kolumna lub kolumn, które tworzą relacje między tabele nadrzędne i podrzędność.Na przykład identyfikator klienta kolumna, która pojawia się w tabelach nadrzędnych i podrzędność.

Te informacje są używane do generowania odpowiednich hierarchii.

Aby zapewnić nazw tabel i informacje niezbędne łączyć, następujące atrybuty są określone w sql:relationship adnotacja. Te atrybuty są prawidłowe tylko w przypadku <SQL:Relationship> element:

  • Imię i nazwisko
    Określa unikatową nazwę relacji.

  • Parent
    Określa nadrzędnej relacji (tabela).Jest to atrybut opcjonalny; jeżeli nie określono atrybutu, nazwa tabela nadrzędnej są uzyskiwane z informacji znajdujących się w hierarchii podrzędność w dokumencie.Jeśli dwóch hierarchii nadrzędny podrzędność, które korzystają z jednego schematu <SQL:Relationship> ale elementy nadrzędne różne, nie zostanie określony atrybut obiektu nadrzędnego w <SQL:Relationship>. Informacje te są uzyskiwane z hierarchii w schemacie.

  • klucz nadrzędny
    Określa klucz nadrzędny obiektu nadrzędnego.Jeśli klucz nadrzędny składa się z wielu kolumn, wartości są określone spacji między nimi.Brak pozycyjne mapowania między wartości, które są określone dla wielokolumnowego klucza i odpowiadający mu klucz podrzędność.

  • Element podrzędność
    Określa, do relacji podrzędnej (tabela).

  • klucz podrzędność
    Określa klucz podrzędność w podrzędność, odnoszące się do klucza nadrzędnego w obiekcie nadrzędnym.Jeśli klucz podrzędność składa się z wielu atrybutów (kolumn), wartości klucza podrzędnego są określone spacji między nimi.Brak pozycyjne mapowania między wartości, które są określone dla wielokolumnowego klucz i odpowiadającego mu klucz nadrzędnego.

  • Funkcja odwrotna
    Ten atrybut określony w <SQL:Relationship> jest używana przez updategrams. Aby uzyskać więcej informacji zobacz Określanie sql:inverse atrybut na sql:relationship.

The sql:key-fields annotation must be specified in an element that contains a podrzędność element, that has a <sql:relationship> defined between the element and the podrzędność, and that does not provide the klucz podstawowy of the tabela specified in the parent element. Nawet jeśli nie określono schematu <SQL:Relationship>, należy określić sql:key-fields do uzyskania odpowiednich hierarchii. Aby uzyskać więcej informacji zobacz Identyfikowanie kolumny klucz przy użyciu sql:klucz-pola.

Aby uzyskać prawidłowe zagnieżdżenia w wyniku, zaleca się sql:key-fields zostały określone w wszystkich schematów.

Przykłady

Aby utworzyć próbek pracy przy użyciu poniższych przykładach, musi spełniać określone wymagania.Aby uzyskać więcej informacji zobaczWymagania dotyczące uruchamianie SQLXML przykłady.

A.Określanie adnotacji sql:relationship na element

Zawiera następujące adnotacjami schematu XSD <Odbiorcy> i <Zamówienia> elementy. The <Order> element is a podrzędność element of the <Customer> element.

W schemacie sql:relationship Adnotacja jest określona na <Zamówienia> element podrzędność. Samą relację jest zdefiniowany w <xsd:appinfo> element.

The <relationship> element identifies CustomerID in the Sales.SalesOrderHeader tabela as a klucz obcy that refers to the CustomerID klucz podstawowy in the Sales.Customer tabela. W związku z tym pojawiają się jako element podrzędność tego zamówienia, które należą do nabywcy <Odbiorcy> 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" />
  </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>

Poprzedni schemat używa nazwanego relacji.Można także określić na relację bez nazwy.Wyniki są takie same.

Jest to poprawione schematu, w którym określono na relację bez nazwy:

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

Aby przetestować kwerendę XPath próbki względem schematu

  1. Skopiować powyższy kod schematu i wkleić go do pliku tekstowego.Zapisz plik jako sql relationship.xml.

  2. Skopiuj następujący poniżej szablon i wkleić go do pliku tekstowego.Zapisz plik jako relationshipT.xml sql w tym samym katalogu, w którym zapisano 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>

    To ścieżka do katalogu określonego dla mapowania schematu (sql-relationship.xml) jest względna w stosunku do katalogu, w którym są zapisywane w szablonie.Ścieżka bezwzględna również można określić, na przykład:

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

  3. Tworzenie i używanie skryptu testu 4.0 SQLXML (Sqlxml4test.vbs) do wykonać tego szablonu.

    Aby uzyskać więcej informacji zobacz Przy użyciu obiektu ADO w celu wykonać kwerendy SQLXML.

Poniżej znajduje się zestaw wyników:

<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.Określanie łańcuch relacji

W tym przykładzie założono, że następujący dokument XML przy użyciu danych z bazy danych AdventureWorks:

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

Dla każdego zamówienia w tabela Sales.SalesOrderHeader dokument XML ma jeden <Zamówienia> element. And each <Order> element has a list of <Product> child elements, one for each product requested in the order.

Aby określić schematu XSD generujące tej hierarchii, należy określić dwie relacje: OrderOD i ODProduct. Relacja OrderOD określa relacji nadrzędny podrzędność między tabelami Sales.SalesOrderHeader i Sales.SalesOrderDetail.Relacja ODProduct określa relację między tabelami Sales.SalesOrderDetail i Production.Product.

W schemacie następujące msdata:relationship Adnotacja na <Produkt> element określa dwie wartości: OrderOD i ODProduct. Kolejność, w którym te wartości są określane jest ważna.

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

Zamiast określać relacji o nazwie, można określić na anonimowe relację.W tym przypadek całą zawartość <adnotacji>... </Annotation>, który opisuje dwie relacje, są wyświetlane jako element podrzędność <Produkt>.

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

Aby przetestować kwerendę XPath próbki względem schematu

  1. Skopiować powyższy kod schematu i wkleić go do pliku tekstowego.Zapisz plik jako relationshipChain.xml.

  2. Skopiuj następujący poniżej szablon i wkleić go do pliku tekstowego.Zapisz plik jako relationshipChainT.xml w tym samym katalogu, w którym zapisano relationshipChain.xml.

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

    To ścieżka do katalogu określonego dla mapowania schematu (relationshipChain.xml) jest względna w stosunku do katalogu, w którym są zapisywane w szablonie.Ścieżka bezwzględna również można określić, na przykład:

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

  3. Tworzenie i używanie skryptu testu 4.0 SQLXML (Sqlxml4test.vbs) do wykonać tego szablonu.

    Aby uzyskać więcej informacji zobacz Przy użyciu obiektu ADO w celu wykonać kwerendy SQLXML.

Poniżej znajduje się zestaw wyników:

<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.Określanie relacji adnotacji na atrybut

Schemat w tym przykładzie obejmuje <Odbiorcy> element z <Identyfikator klienta> element podrzędność, a atrybut OrderIDList IDREFS typu. The <Customer> element maps to the Sales.Customer tabela in the AdventureWorks database. Domyślnie zakres tego mapowania zastosuje do wszystkich elementów podrzędność lub atrybutów, chyba że sql:relation określony na element podrzędność lub atrybut, w tym przypadek odpowiednią relację podstawowy klucz/klucz obcy należy zdefiniować przy użyciu <Relacja> element. Element podrzędność oraz atrybut, który określa innej tabela przy użyciu relation adnotację, należy również określić relationship adnotacja.

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

Aby przetestować kwerendę XPath próbki względem schematu

  1. Skopiować powyższy kod schematu i wkleić go do pliku tekstowego.Zapisz plik jako relacja na atrybut.xml.

  2. Skopiuj następujący szablon i wkleić go do pliku.Zapisz plik jako relacja na attributeT.xml w tym samym katalogu, w którym zapisano relacji na atrybut.xml.Nabywcę, identyfikator klienta 1 wybierane przez kwerendę, w szablonie.

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

    To ścieżka do katalogu określonego dla mapowania schematu (relacji na atrybut.xml) jest względna w stosunku do katalogu, w którym są zapisywane w szablonie.Ścieżka bezwzględna również można określić, na przykład:

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

  3. Tworzenie i używanie skryptu testu 4.0 SQLXML (Sqlxml4test.vbs) do wykonać tego szablonu.

    Aby uzyskać więcej informacji zobacz Przy użyciu obiektu ADO w celu wykonać kwerendy SQLXML.

Poniżej znajduje się zestaw wyników:

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

D.Określanie sql:relationship na wiele elementów

W tym przykładzie zawiera adnotacjami schematu XSD <Odbiorcy>, <Zamówienia>, a <OrderDetail> elementy.

The <Order> element is a child element of the <Customer> element.<sql:relationship> is specified on the <Order> child element; therefore, orders that belong to a customer appear as child elements of <Customer>.

The <Order> element includes the <OrderDetail> child element.<sql:relationship> is specified on <OrderDetail> child element, so the order details that pertain to an order appear as child elements of that <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>

Aby przetestować kwerendę XPath próbki względem schematu

  1. Skopiować powyższy kod schematu i wkleić go do pliku tekstowego.Zapisz plik jako relacji wielokrotności elements.xml.

  2. Skopiuj następujący szablon i wkleić go do pliku tekstowego.Zapisz plik jako relacja wiele elementsT.xml w tym samym katalogu, w którym zapisano relacji wielokrotności elements.xml.W szablonie zwraca informacje o zamówieniach nabywcy z IDKlienta 1 i 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>

    To ścieżka do katalogu określonego dla mapowania schematu (relacji — wiele elements.xml) jest względna w stosunku do katalogu, w którym są zapisywane w szablonie.Ścieżka bezwzględna również można określić, na przykład:

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

  3. Tworzenie i używanie skryptu testu 4.0 SQLXML (Sqlxml4test.vbs) do wykonać tego szablonu.

    Aby uzyskać więcej informacji zobacz Przy użyciu obiektu ADO w celu wykonać kwerendy SQLXML.

Poniżej znajduje się zestaw wyników:

<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.Określanie <SQL:Relationship> bez atrybut nadrzędny

Ten przykład ilustruje, określając <SQL:Relationship> bez nadrzędny atrybut. Załóżmy na przykład, istnieją następujące tabele pracownika:

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

The following XML view has the <Emp1> and <Emp2> elements mapping to the Sales.Emp1 and Sales.Emp2 tables:

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

W schemacie zarówno <Emp1> element i <Emp2> element jest typu EmpType. Typ EmpType w tym artykule opisano <Zamówienia> element podrzędność oraz odpowiadającego mu <SQL:Relationship>. W takim przypadek nie ma nie pojedynczego obiektu nadrzędnego, który może zostać zidentyfikowany w <SQL:Relationship> za pomocą nadrzędny atrybut. W takiej sytuacji nie zostanie określona nadrzędny atrybutu**<SQL:Relationship>**; nadrzędny atrybut informacje są uzyskiwane z hierarchii w schemacie.

Aby przetestować kwerendę XPath próbki względem schematu

  1. Utworzenie tych tabel w bazie danych 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. Dodaj ten przykładowych danych w tabelach:

    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. Skopiować powyższy kod schematu i wkleić go do pliku tekstowego.Zapisz plik jako noparent.xml relacji.

  4. Skopiuj następujący szablon i wkleić go do pliku tekstowego.Zapisz plik jako noparentT.xml relacji w tym samym katalogu, w którym zapisano noparent.xml relacji.Kwerendy w szablonie, powoduje zaznaczenie wszystkich <Emp1> elementy (w związku z tym nadrzędny jest Emp1).

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

    To ścieżka do katalogu określonego dla mapowania schematu (noparent.xml relacji) jest względna w stosunku do katalogu, w którym są zapisywane w szablonie.Ścieżka bezwzględna również można określić, na przykład:

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

  5. Tworzenie i używanie skryptu testu 4.0 SQLXML (Sqlxml4test.vbs) do wykonać tego szablonu.

    Aby uzyskać więcej informacji zobacz Przy użyciu obiektu ADO w celu wykonać kwerendy SQLXML.

W tym polu jest zestaw wyników częściowych:

<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