Aktualizowanie danych za pomocą XML Updategrams (SQLXML 4.0)

Aktualizuj istniejące dane, należy określić obie <before> i <after> bloków.Elementy określone w <before> i <after> opisują bloki żądane zmiany.Wierzchołki używa elementów, które są określone w <before> blok do identyfikowania istniejących rekordów w bazie danych.Odpowiednich elementów w <after> blok wskazują, jak powinna wyglądać rekordy po wykonaniu operacji aktualizacji.Z tej informacji tworzy wierzchołki instrukcja języka SQL , które odpowiadają <after> blok.Wierzchołki używa tej instrukcja aktualizacji bazy danych.

Jest to format wierzchołki operacji aktualizacji:

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
<updg:sync [mapping-schema="SampleSchema.xml"]  >
   <updg:before>
      <ElementName [updg:id="value"] .../>
      [<ElementName [updg:id="value"] .../> ... ]
   </updg:before>
   <updg:after>
      <ElementName [updg:id="value"] ... />
      [<ElementName [updg:id="value"] .../> ...]
   </updg:after>
</updg:sync>
</ROOT>

• <updg:before>
  Elementy w <before> blok zidentyfikować istniejące rekordy w tabelach bazy danych.

• <updg:after>
  Elementy w <after> blok opisują, jak rekordy określone w <before> blok powinna wyglądać po zastosowaniu aktualizacji.

mapping-schema Atrybut identyfikuje schematu mapowania używane przez wierzchołki.Jeśli wierzchołki Określa schemat mapowanie nazwy elementów i atrybut określone w <before> i <after> bloków muszą odpowiadać nazwom w schemacie.Schemat mapowania mapuje te element lub atrybut nazwy tabela bazy danych i kolumna nazwy.

Jeśli wierzchołki nie określono schematu, updategam używa domyślnego mapowania.Domyślnego mapowania, <ElementName> określonych w mapach wierzchołki do tabela bazy danych i podrzędność elementów lub atrybutów mapy do kolumny bazy danych.

Element <before> blok musi być zgodna z tylko jeden wiersz tabela w bazie danych.Jeśli element wielu wierszy tabela odpowiada lub nie pasuje do dowolnego wiersza tabela, wierzchołki zwraca błąd i anuluje cały <sync> blok.

Wierzchołki można dołączyć wiele <sync> bloków.Każdy <sync> Blok jest traktowany jako transakcja.Każdy <sync> blok może mieć wiele <before> i <after> bloków.Na przykład, jeśli są aktualizowane dwa istniejące rekordy, można określić dwa <before> i <after> par, jeden dla każdego rekordu jest aktualizowane.

Za pomocą atrybutu updg:id

Gdy elementy są określone w <before> i <after> bloki, użyj updg:id atrybut do oznaczenia wierszy w <before> i <after> bloków.Logiki przetwarzania używa tych informacji do ustalenia, co rejestrować w <before> zablokować pary z co rejestrować w <after> blok.

updg:id Atrybut nie jest konieczne (chociaż jest to zalecane), jeśli istnieje jednej z następujących:

• Elementy w schemacie określonego mapowania mają sql:key-fields atrybut zdefiniowane na nich.

• Istnieje jeden lub więcej określonych podano wartość dla pole klucz w diagramach aktualizacji.

Jeśli jest albo przypadek wierzchołki używa klucz kolumn, które są określone w sql:key-fields z parą elementów w <before> i <after> bloków.

Jeśli mapowanie schematu nie identyfikuje kolumna klucz (przy użyciu sql:key-fields) lub wierzchołki aktualizuje wartość kolumna klucz, należy określić updg:id.

Rekordy, które są zidentyfikowane w <before> i <after> bloków nie muszą być w tej samej kolejności.updg:id Atrybut wymusza skojarzenie między elementami, które są określone w <before> i <after> bloków.

Jeśli określisz jeden element w <before> blok i tylko jeden element odpowiednich w <after> blokować za pomocą updg:id jest to konieczne.Jednak zaleca się określenie updg:id Mimo to uniknąć niejednoznaczności.

Przykłady

Przed użyciem przykłady wierzchołki Uwaga:

• Większość przykładów Użyj domyślnego mapowania (Brak mapowania schematu jest określona w diagramach aktualizacji).Więcej przykładów updategrams korzystające z mapowania schematów, zobacz Określanie adnotacjami schematu mapowanie w diagramach aktualizacji (SQLXML 4.0).

Większość przykładów używania AdventureWorks2008R2 przykładowej bazy danych.

A.Aktualizowanie rekordu

Wierzchołki następujące aktualizacje nazwisko pracownika Stępień w tabela Person.Person w AdventureWorks2008R2 bazy danych.Wierzchołki nie określono żadnych mapowanie schematu; Dlatego wierzchołki używa domyślnego mapowania.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
<updg:sync >
<updg:before>
   <Person.Person BusinessEntityID="1" />
</updg:before>
<updg:after>
   <Person.Person LastName="Fuller" />
</updg:after>
</updg:sync>
</ROOT>

Rekord opisane w <before> Blok reprezentuje bieżący rekord w bazie danych.Wierzchołki wykorzystuje wszystkie wartości kolumna określone w <before> blok do wyszukiwania rekordów.W tym wierzchołki <before> blok zapewnia tylko kolumna BusinessEntityID; Dlatego wierzchołki używa tylko wartości wyszukiwania dla rekordu.Gdyby dodać do tego blok wartość LastName, wierzchołki użyje wartości zarówno BusinessEntityID, jak i nazwisko wyszukiwania.

W tym wierzchołki <after> blok zapewnia wartość kolumna Nazwisko, ponieważ jest to tylko wartość, który został zmieniony.

Aby przetestować wierzchołki

1. Skopiuj szablon wierzchołki powyżej i wkleić go do pliku tekstowego.Zapisz plik jako UpdateLastName.xml.

2. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

B.Aktualizowanie wielu rekordów przy użyciu atrybut updg:id

W tym przykładzie wierzchołki wykonuje dwie aktualizacje w tabela HumanResources.Shift w AdventureWorks2008R2 bazy danych:

• Zmienia nazwę oryginalnego shift dzień, który rozpoczyna się od 7:00 AM z "Dzień" do "Wcześnie rano".

• Wstawia nowy shift o nazwie "Late Morning" które rozpoczyna się od 10:00 AM.

W diagramach aktualizacji updg:id atrybut tworzy skojarzenia między elementami w <before> i <after> bloków.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
  <updg:sync >
    <updg:before>
       <HumanResources.Shift updg:id="x" Name="Day" />
    </updg:before>
    <updg:after>
      <HumanResources.Shift updg:id="y" Name="Late Morning" 
                            StartTime="1900-01-01 10:00:00.000"
                            EndTime="1900-01-01 18:00:00.000"
                            ModifiedDate="2004-06-01 00:00:00.000"/>
      <HumanResources.Shift updg:id="x" Name="Early Morning" />
    </updg:after>
  </updg:sync>
</ROOT>

Ogłoszenia updg:id pierwsze wystąpienie par atrybut <HumanResources.Shift> element w <before> Blok z drugiego wystąpienia <HumanResources.Shift> element w <after> bloku.

Aby przetestować wierzchołki

1. Skopiuj szablon wierzchołki powyżej i wkleić go do pliku tekstowego.Zapisz plik jako UpdateMultipleRecords.xml.

2. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

C.Określanie wielu <przed> i <po> bloków

Aby uniknąć niejednoznaczności, można pisać wierzchołki w przykładzie b przy użyciu wielu <before> i <after> par blok.Określanie <before> i <after> par jest jednym ze sposobów określania wielu aktualizacji przy minimalnej ilości nieporozumień.Ponadto jeśli każda z <before> i <after> bloków określić co najwyżej jeden element, nie trzeba używać updg:id atrybut.

Ostrzeżenie

Tworząc pary, <after> tag musi natychmiast wykonaj odpowiednie <before> tag.

W następujących wierzchołki pierwszego <before> i <after> para aktualizuje nazwę shift shift dzień.Druga para Wstawia nowy rekord shift.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
  <updg:sync >
    <updg:before>
       <HumanResources.Shift ShiftID="1" Name="Day" />
    </updg:before>
    <updg:after>
      <HumanResources.Shift Name="Early Morning" />
    </updg:after>
    <updg:before>
    </updg:before>
    <updg:after>
      <HumanResources.Shift Name="Late Morning" 
                            StartTime="1900-01-01 10:00:00.000"
                            EndTime="1900-01-01 18:00:00.000"
                            ModifiedDate="2004-06-01 00:00:00.000"/>
    </updg:after>
  </updg:sync>
</ROOT>

Aby przetestować wierzchołki

1. Skopiuj szablon wierzchołki powyżej i wkleić go do pliku tekstowego.Zapisz plik jako UpdateMultipleBeforeAfter.xml.

2. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

D.Określanie wielu <synchronizacji> bloków

Można określić wiele <sync> blokuje wierzchołki.Każdy <sync> Blok określona jest niezależną transakcji.

W następujących wierzchołki pierwszego <sync> blok aktualizacje rekordu w tabela Sales.Customer.Do celów uproszczenia wierzchołki określa tylko wartości wymaganej kolumna; wartość tożsamości (IDklienta) i wartości są aktualizowane (SalesPersonID).

Drugi <sync> blok dodaje dwa rekordy do tabela Sales.SalesOrderHeader.W tej tabela SalesOrderID jest typ tożsamości kolumna.Dlatego wierzchołki nie określono wartości SalesOrderID w każdym z <Sales.SalesOrderHeader> elementów.

Określanie wielu <sync> przydaje się bloki ponieważ jeśli drugi <sync> niepowodzenia blok (transakcję) do dodawania rekordów do tabela Sales.SalesOrderHeader pierwszy <sync> blok można nadal aktualizować rekord klienta w tabela Sales.Customer.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
  <updg:sync >
    <updg:before>
      <Sales.Customer CustomerID="1" SalesPersonID="280" />
    </updg:before>
    <updg:after>
      <Sales.Customer CustomerID="1" SalesPersonID="283" />
    </updg:after>
  </updg:sync>
  <updg:sync >
    <updg:before>
    </updg:before>
    <updg:after>
   <Sales.SalesOrderHeader 
             CustomerID="1"
             RevisionNumber="1"
             OrderDate="2004-07-01 00:00:00.000"
             DueDate="2004-07-13 00:00:00.000"
             OnlineOrderFlag="0"
             SalesPersonID="378"
             BillToAddressID="985"
             ShipToAddressID="985"
             ShipMethodID="5"
             SubTotal="24643.9362"
             TaxAmt="1971.5149"
             Freight="616.0984"
             rowguid="01010101-2222-3333-4444-556677889900"
             ModifiedDate="2004-07-08 00:00:00.000" />
   <Sales.SalesOrderHeader
             CustomerID="1"
             RevisionNumber="1"
             OrderDate="2004-07-01 00:00:00.000"
             DueDate="2004-07-13 00:00:00.000"
             OnlineOrderFlag="0"
             SalesPersonID="378"
             BillToAddressID="985"
             ShipToAddressID="985"
             ShipMethodID="5"
             SubTotal="1000.0000"
             TaxAmt="0.0000"
             Freight="0.0000"
             rowguid="10101010-2222-3333-4444-556677889900"
             ModifiedDate="2004-07-09 00:00:00.000" />
    </updg:after>
  </updg:sync>
</ROOT>

Aby przetestować wierzchołki

1. Skopiuj szablon wierzchołki powyżej i wkleić go do pliku tekstowego.Zapisz plik jako UpdateMultipleSyncs.xml.

2. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

E.Za pomocą schematu mapowania

W tym przykładzie wierzchołki Określa schemat mapowania za pomocą mapping-schema atrybut.(Brak domyślnego mapowania; oznacza to, że schemat mapowania zawiera niezbędne mapowanie elementów i atrybutów w diagramach aktualizacji bazy danych, tabel i kolumn.)

Elementy i atrybuty określonych w diagramach aktualizacji można znaleźć elementy i atrybuty w schemacie mapowania.

Następującego schematu XSD mapowanie ma <Customer>, <Order>, i <OD> elementów, które są mapowane na Sales.Customer, Sales.SalesOrderHeader i Sales.SalesOrderDetail tabel w bazie danych.

<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="CustomerOrder"
          parent="Sales.Customer"
          parent-key="CustomerID"
          child="Sales.SalesOrderHeader"
          child-key="CustomerID" />

    <sql:relationship name="OrderOD"
          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="CustomerOrder" >
           <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="OD" 
                             sql:relation="Sales.SalesOrderDetail"
                             sql:relationship="OrderOD" >
                 <xsd:complexType>
                  <xsd:attribute name="SalesOrderID" type="xsd:integer" />
                  <xsd:attribute name="ProductID" type="xsd:integer" />
                  <xsd:attribute name="UnitPrice" type="xsd:decimal" />
                  <xsd:attribute name="OrderQty" type="xsd:integer" />
                  <xsd:attribute name="UnitPriceDiscount" type="xsd:decimal" /> 
                 </xsd:complexType>
                </xsd:element>
              </xsd:sequence>
              <xsd:attribute name="CustomerID" type="xsd:string" />
              <xsd:attribute name="SalesOrderID" type="xsd:integer" />
              <xsd:attribute name="OrderDate" type="xsd:date" />
           </xsd:complexType>
        </xsd:element>
      </xsd:sequence>
      <xsd:attribute name="CustomerID"   type="xsd:string" /> 
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

To mapowanie schematu (UpdategramMappingSchema.xml) jest określony w następujących wierzchołki.Wierzchołki dodaje element szczegółów zamówienia w tabela Sales.SalesOrderDetail dla określonego zamówienia.Wierzchołki zawiera zagnieżdżone elementy: <OD> element zagnieżdżony <Order> elementu.klucz podstawowy/ Relacji klucz obcy między tymi dwoma elementami jest określona w schemacie mapowania.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
  <updg:sync mapping-schema="UpdategramMappingSchema.xml" >
    <updg:before>
       <Order SalesOrderID="43659" />
    </updg:before>
    <updg:after>
      <Order SalesOrderID="43659" >
          <OD ProductID="776" UnitPrice="2329.0000"
              OrderQty="2" UnitPriceDiscount="0.0" />
      </Order>
    </updg:after>
  </updg:sync>
</ROOT>

Aby przetestować wierzchołki

1. Powyższy schemat mapowanie skopiować i wkleić go do pliku tekstowego.Zapisz plik jako UpdategramMappingSchema.xml.

2. Skopiuj szablon wierzchołki powyżej i wkleić go do pliku tekstowego.Zapisz plik jako UpdateWithMappingSchema.xml w tym samym folderze, co zostało użyte do zapisania mapowanie schematu (UpdategramMappingSchema.xml).

3. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

Więcej przykładów updategrams korzystające z mapowania schematów, zobacz Określanie adnotacjami schematu mapowanie w diagramach aktualizacji (SQLXML 4.0).

F.Za pomocą schematu mapowania atrybutów IDREFS

Ten przykład ilustruje, jak updategrams pomocą IDREFS atrybuty w schemacie mapowanie aktualizować rekordy w wielu tabelach.Na przykład załóżmy, że baza danych składa się z następujących tabel:

• Student (StudentID, LastName)

• Kurs (CourseID, CourseName)

• Rejestracji (StudentID, CourseID)

Ponieważ student może włączyć w wiele kursów i kurs może mieć wiele studentów, trzecią tabela, włączyćmeni tabela jest zobowiązany do reprezentowania tej relacji M:N.

Następującego schematu XSD mapowanie zapewnia widok XML tabel za pomocą <studentów>, <kursu>, i <rejestracji> elementów.IDREFS atrybuty w schemacie mapowanie określić relację między tymi elementami.StudentIDList atrybutu na <kursu> element jest IDREFS atrybut typu, który odwołuje się do kolumna StudentID w tabela rejestracji.Podobnie EnrolledIn atrybutu na <studentów> element jest IDREFS atrybut typu, który odwołuje się do kolumna CourseID w tabela rejestracji.

<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="StudentEnrollment"
          parent="Student"
          parent-key="StudentID"
          child="Enrollment"
          child-key="StudentID" />

    <sql:relationship name="CourseEnrollment"
          parent="Course"
          parent-key="CourseID"
          child="Enrollment"
          child-key="CourseID" />
  </xsd:appinfo>
</xsd:annotation>

  <xsd:element name="Course" sql:relation="Course" 
                             sql:key-fields="CourseID" >
    <xsd:complexType>
    <xsd:attribute name="CourseID"  type="xsd:string" /> 
    <xsd:attribute name="CourseName"   type="xsd:string" /> 
    <xsd:attribute name="StudentIDList" sql:relation="Enrollment"
                 sql:field="StudentID"
                 sql:relationship="CourseEnrollment" 
                                     type="xsd:IDREFS" />

    </xsd:complexType>
  </xsd:element>
  <xsd:element name="Student" sql:relation="Student" >
    <xsd:complexType>
    <xsd:attribute name="StudentID"  type="xsd:string" /> 
    <xsd:attribute name="LastName"   type="xsd:string" /> 
    <xsd:attribute name="EnrolledIn" sql:relation="Enrollment"
                 sql:field="CourseID"
                 sql:relationship="StudentEnrollment" 
                                     type="xsd:IDREFS" />
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

W każdym przypadku, gdy określenie tego schematu w diagramach aktualizacji i wstawiania rekordu tabela kursu, wierzchołki Wstawia nowy rekord kursu w tabela Kurs.Jeśli określisz jeden lub więcej nowych studentów identyfikatorów dla atrybut StudentIDList, wierzchołki również wstawia rekordu w tabela rejestracji dla każdego nowego studentów.Wierzchołki zapewnia, że nie duplikaty zostaną dodane do tabela rejestracji.

Aby przetestować wierzchołki

1. Tworzenie tych tabel w bazie danych, która jest określona w wirtualnego katalogu głównego:

   CREATE TABLE Student(StudentID varchar(10) primary key, 
                        LastName varchar(25))
   CREATE TABLE Course(CourseID varchar(10) primary key, 
                       CourseName varchar(25))
   CREATE TABLE Enrollment(StudentID varchar(10) 
                                     references Student(StudentID),
                          CourseID varchar(10) 
                                     references Course(CourseID))
   

2. Dodać przykładowe dane:

   INSERT INTO Student VALUES ('S1','Davoli')
   INSERT INTO Student VALUES ('S2','Fuller')
   
   INSERT INTO Course VALUES  ('CS101', 'C Programming')
   INSERT INTO Course VALUES  ('CS102', 'Understanding XML')
   
   INSERT INTO Enrollment VALUES ('S1', 'CS101')
   INSERT INTO Enrollment VALUES ('S1', 'CS102')
   

3. Powyższy schemat mapowanie skopiować i wkleić go do pliku tekstowego.Zapisz plik jako SampleSchema.xml.

4. Zapisz wierzchołki (SampleUpdategram) w tym samym folderze, używany do zapisywania mapowanie schematu w poprzednim kroku.(Ta wierzchołki spadnie studentów z StudentID = "1" z kursu CS102.)

   <ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
     <updg:sync mapping-schema="SampleSchema.xml" >
       <updg:before>
           <Student updg:id="x" StudentID="S1" LastName="Davolio"
                                EnrolledIn="CS101 CS102" />
       </updg:before>
       <updg:after >
           <Student updg:id="x" StudentID="S1" LastName="Davolio"
                                EnrolledIn="CS101" />
       </updg:after>
     </updg:sync>
   </ROOT>
   

5. Tworzenie i używanie wierzchołki wykonać skryptu testu 4.0 SQLXML (Sqlxml4test.vbs).

   Aby uzyskać więcej informacji, zobacz Przy użyciu ADO SQLXML wykonanie kwerendy 4.0.

6. Zapisz i wykonać następujące wierzchołki opisane w poprzednich krokach.Wierzchołki dodaje studentów z StudentID = "1" Powrót do kursu CS102 przez dodanie rekordu w tabela rejestracji.

   <ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
     <updg:sync mapping-schema="SampleSchema.xml" >
       <updg:before>
           <Student updg:id="x" StudentID="S1" LastName="Davolio"
                                EnrolledIn="CS101" />
       </updg:before>
       <updg:after >
           <Student updg:id="x" StudentID="S1" LastName="Davolio"
                                EnrolledIn="CS101 CS102" />
       </updg:after>
     </updg:sync>
   </ROOT>
   

7. Zapisz i wykonać tego dalej wierzchołki opisane w poprzednich krokach.Wierzchołki to wstawienie trzech nowych studentów i rejestruje je w toku CS101.Ponownie relacji IDREFS wstawia rekordy w tabela rejestracji.

   <ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
     <updg:sync mapping-schema="SampleSchema.xml" >
       <updg:before>
          <Course updg:id="y" CourseID="CS101" 
                              CourseName="C Programming" />
       </updg:before>
       <updg:after >
          <Student updg:id="x1" StudentID="S3" LastName="Leverling" />
          <Student updg:id="x2" StudentID="S4" LastName="Pecock" />
          <Student updg:id="x3" StudentID="S5" LastName="Buchanan" />
          <Course updg:id="y" CourseID="CS101"
                              CourseName="C Programming"
                              StudentIDList="S3 S4 S5" />
       </updg:after>
     </updg:sync>
   </ROOT>
   

Jest to równoważne schematu XDR:

<?xml version="1.0" ?>
<Schema xmlns="urn:schemas-microsoft-com:xml-data"
        xmlns:dt="urn:schemas-microsoft-com:datatypes"
        xmlns:sql="urn:schemas-microsoft-com:xml-sql">
  <ElementType name="Enrollment" sql:relation="Enrollment" sql:key-fields="StudentID CourseID">
    <AttributeType name="StudentID" dt:type="id" />
    <AttributeType name="CourseID" dt:type="id" />

    <attribute type="StudentID" />
    <attribute type="CourseID" />
  </ElementType>
  <ElementType name="Course" sql:relation="Course" sql:key-fields="CourseID">
    <AttributeType name="CourseID" dt:type="id" />
    <AttributeType name="CourseName" />
 
    <attribute type="CourseID" />
    <attribute type="CourseName" />

    <AttributeType name="StudentIDList" dt:type="idrefs" />
    <attribute type="StudentIDList" sql:relation="Enrollment" sql:field="StudentID" >
        <sql:relationship
                key-relation="Course"
                key="CourseID"
                foreign-relation="Enrollment"
                foreign-key="CourseID" />
    </attribute>

  </ElementType>
  <ElementType name="Student" sql:relation="Student">
    <AttributeType name="StudentID" dt:type="id" />
     <AttributeType name="LastName" />

    <attribute type="StudentID" />
    <attribute type="LastName" />

    <AttributeType name="EnrolledIn" dt:type="idrefs" />
    <attribute type="EnrolledIn" sql:relation="Enrollment" sql:field="CourseID" >
        <sql:relationship
                key-relation="Student"
                key="StudentID"
                foreign-relation="Enrollment"
                foreign-key="StudentID" />
    </attribute>

    <element type="Enrollment" sql:relation="Enrollment" >
        <sql:relationship key-relation="Student"
                          key="StudentID"
                          foreign-relation="Enrollment"
                          foreign-key="StudentID" />
    </element>
  </ElementType>

</Schema>

Więcej przykładów updategrams korzystające z mapowania schematów, zobacz Określanie adnotacjami schematu mapowanie w diagramach aktualizacji (SQLXML 4.0).

Zobacz także

Odwołanie

Zagadnienia dotyczące zabezpieczeń wierzchołki (SQLXML 4.0)