Share via

Mise à jour de données à l'aide de codes de mise à jour (updategrams) XML (SQLXML 4.0)

  • Article

Lorsque vous mettez à jour des données existantes, vous devez spécifier à la fois les blocs <before> et <after>. Les éléments spécifiés dans les blocs <before> et <after> décrivent la modification désirée. Le code de mise à jour (updategram) utilise le ou les éléments spécifiés dans le bloc <before> pour identifier le ou les enregistrements existants dans la base de données. Le ou les éléments correspondants dans le bloc <after> indiquent à quoi les enregistrements doivent ressembler après l'exécution de l'opération de mise à jour. À partir de ces informations, le code de mise à jour (updategram) crée une instruction SQL qui correspond au bloc <after>. Le code de mise à jour (updategram) utilise ensuite cette instruction pour mettre à jour la base de données.

Voici le format du code de mise à jour (updategram) pour une opération de mise à jour :

<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>
    Les éléments du bloc <before> identifient les enregistrements existants dans les tables de base de données.

  • <updg:after>
    Les éléments du bloc <after> décrivent l'aspect des enregistrements spécifiés dans le bloc <before> une fois que les mises à jour sont appliquées.

L'attribut mapping-schema identifie le schéma de mappage à utiliser par le code de mise à jour (updategram). Si le code de mise à jour (updategram) spécifie un schéma de mappage, les noms d'éléments et d'attributs spécifiés dans les blocs <before> et <after> doivent correspondre aux noms du schéma. Le schéma de mappage mappe ces noms d'éléments ou d'attributs aux noms de tables et de colonnes de la base de données.

Si le code de mise à jour (updategram) ne spécifie pas de schéma, le mappage par défaut est utilisé. Dans le mappage par défaut, l'<ElementName> spécifié dans le code de mise à jour (updategram) est mappé à la table de la base de données alors que les attributs ou éléments enfants sont mappés aux colonnes de la base de données.

Un élément du bloc <before> doit correspondre à une seule ligne de table dans la base de données. Si l'élément correspond à plusieurs lignes de table ou s'il ne correspond à aucune d'entre elles, le code de mise à jour (updategram) retourne une erreur et annule l'intégralité du bloc <sync>.

Un code de mise à jour (updategram) peut inclure plusieurs blocs <sync>. Chaque bloc <sync> est traité comme une transaction. Chaque bloc <sync> peut avoir plusieurs blocs <before> et <after>. Par exemple, si vous mettez à jour deux des enregistrements existants, vous pouvez spécifier deux paires <before> et <after>, une pour chaque enregistrement mis à jour.

Utilisation de l'attribut updg:id

Lorsque plusieurs éléments sont spécifiés dans les blocs <before> et <after>, utilisez l'attribut updg:id pour marquer les lignes dans les blocs <before> et <after>. La logique de traitement utilise ces informations pour déterminer quel est l'enregistrement du bloc <before> qui correspond à un enregistrement du bloc <after>.

L'attribut updg:id n'est pas nécessaire (bien qu'il soit recommandé) si l'un ou l'autre des cas de figure se présente :

  • L'attribut sql:key-fields est défini sur les éléments du schéma de mappage spécifié.

  • Il existe une ou plusieurs valeurs spécifiques fournies pour le ou les champs clés dans le code de mise à jour (updategram).

Quel que soit le cas de figure, le code de mise à jour (updategram) utilise les colonnes clés spécifiées dans sql:key-fields pour assortir les éléments dans les blocs <before> et <after>.

Si le schéma de mappage n'identifie pas de colonnes clés (via sql:key-fields) ou si le code de mise à jour (updategram) met à jour une valeur de colonne clé, vous devez spécifier updg:id.

Les enregistrements identifiés dans les blocs <before> et <after> n'ont pas à être dans le même ordre. L'attribut updg:id force l'association entre les éléments spécifiés dans les blocs <before> et <after>.

Si vous spécifiez un élément dans le bloc <before> et un seul élément correspondant dans le bloc <after>, l'utilisation de updg:id n'est pas nécessaire. Toutefois, il est recommandé de spécifier quand même updg:id pour éviter toute ambiguïté.

Exemples

Avant d'utiliser les exemples de code de mise à jour (updategram), notez les points suivants :

  • La plupart des exemples utilisent le mappage par défaut (en d'autres termes, aucun schéma de mappage n'est spécifié dans le code de mise à jour (updategram)). Pour obtenir des exemples supplémentaires de code de mise à jour (updategram) qui utilisent des schémas de mappage, consultez Spécification d'un schéma de mappage annoté dans un code de mise à jour (updategram) (SQLXML 4.0).

  • La plupart des exemples sont basés sur l'exemple de base de données AdventureWorks. Toutes les mises à jour sont appliquées aux tables de cette base de données. Vous pouvez restaurer la base de données AdventureWorks.

A.Mise à jour d'un enregistrement

Le code de mise à jour (updategram) suivant met à jour le nom de famille d'un employé en le remplaçant par Fuller dans la table Person.Contact de la base de données AdventureWorks. Le code de mise à jour (updategram) ne spécifie pas de schéma de mappage ; par conséquent, le mappage par défaut est utilisé.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">
<updg:sync >
<updg:before>
   <Person.Contact ContactID="1" />
</updg:before>
<updg:after>
   <Person.Contact LastName="Abel-Achong" />
</updg:after>
</updg:sync>
</ROOT>

L'enregistrement décrit dans le bloc <before> représente l'enregistrement actif dans la base de données. Le code de mise à jour (updategram) utilise toutes les valeurs de colonne spécifiées dans le bloc <before> pour rechercher l'enregistrement. Dans ce code de mise à jour (updategram), le bloc <before> fournit uniquement la colonne ContactID ; par conséquent, le code de mise à jour (updategram) utilise uniquement la valeur pour rechercher l'enregistrement. Si vous deviez ajouter la valeur de LastName à ce bloc, le code de mise à jour (updategram) utiliserait à la fois les valeurs de ContactID et de LastName pour effectuer la recherche.

Dans ce code de mise à jour (updategram), le bloc <after> fournit uniquement la valeur de la colonne LastName, car c'est la seule valeur modifiée.

Pour tester le code de mise à jour

  1. Copiez le modèle de code de mise à jour (updategram) ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdateLastName.xml.

  2. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

B.Mise à jour de plusieurs enregistrements à l'aide de l'attribut updg:id

Dans cet exemple, le code de mise à jour (updategram) effectue deux mises à jour sur la table HumanResources.Shift de la base de données AdventureWorks :

  • Il modifie le nom de l'équipe de jour d'origine qui commence à 7 h 09 en remplaçant « Day » par « Early Morning ».

  • Il insère une nouvelle équipe nommée « Late Morning » qui commence à 10 h 00.

Dans le code de mise à jour (updategram), l'attribut updg:id crée des associations entre les éléments des blocs <before> et <after>.

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

Notez que l'attribut updg:id associe la première instance de l'élément <HumanResources.Shift> dans le bloc <before> à la seconde instance de l'élément <HumanResources.Shift> dans le bloc <after>.

Pour tester le code de mise à jour

  1. Copiez le modèle de code de mise à jour (updategram) ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdateMultipleRecords.xml.

  2. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

C.Spécification de plusieurs blocs <before> et <after>

Pour éviter toute ambiguïté, vous pouvez écrire le code de mise à jour (updategram) de l'exemple B en utilisant plusieurs paires de blocs <before> et <after>. La spécification de paires <before> et <after> est une façon d'indiquer plusieurs mises à jour en réduisant au minimum les risques de confusion. En outre, si chacun des blocs <before> et <after> spécifie un élément tout au plus, vous n'avez pas à utiliser l'attribut updg:id.

[!REMARQUE]

Pour former une paire, la balise <after> doit suivre immédiatement sa balise <before> correspondante.

Dans le code de mise à jour (updategram) suivant, la première paire <before> et <after> met à jour le nom de l'équipe de jour. La seconde paire insère un nouvel enregistrement d'équipe.

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

Pour tester le code de mise à jour

  1. Copiez le modèle de code de mise à jour (updategram) ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdateMultipleBeforeAfter.xml.

  2. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

D.Spécification de plusieurs blocs <sync>

Vous pouvez spécifier plusieurs blocs <sync> dans un code de mise à jour (updategram). Chaque bloc <sync> spécifié est une transaction indépendante.

Dans le code de mise à jour (updategram) suivant, le premier bloc <sync> met à jour un enregistrement dans la table Sales.Customer. Pour des raisons de simplicité, le code de mise à jour (updategram) spécifie uniquement les valeurs de colonne requises, la valeur d'identité (CustomerID) et la valeur mise à jour (SalesPersonID).

Le second bloc <sync> ajoute deux enregistrements à la table Sales.SalesOrderHeader. Pour cette table, SalesOrderID est une colonne de type IDENTITY. Par conséquent, le code de mise à jour (updategram) ne spécifie pas la valeur de SalesOrderID dans chacun des éléments <Sales.SalesOrderHeader>.

La spécification de plusieurs blocs <sync> est utile, car si le second bloc <sync> (une transaction) ne peut pas ajouter d'enregistrements à la table Sales.SalesOrderHeader, le premier bloc <sync> peut toujours mettre à jour l'enregistrement de client dans la table 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"
             ContactID="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"
             ContactID="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>

Pour tester le code de mise à jour

  1. Copiez le modèle de code de mise à jour (updategram) ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdateMultipleSyncs.xml.

  2. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

E.Utilisation d'un schéma de mappage

Dans cet exemple, le code de mise à jour (updategram) spécifie un schéma de mappage à l'aide de l'attribut mapping-schema. (Il n'y a aucun mappage par défaut ; en d'autres termes, le schéma de mappage fournit le mappage nécessaire des éléments et attributs du code de mise à jour (updategram) aux tables et colonnes de la base de données.)

Les éléments et attributs spécifiés dans le code de mise à jour (updategram) font référence aux éléments et attributs du schéma de mappage.

Le schéma de mappage XSD suivant comprend les éléments <Customer>, <Order> et <OD>, qui sont mappés aux tables Sales.Customer, Sales.SalesOrderHeader et Sales.SalesOrderDetail dans la base de données.

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

Ce schéma de mappage (UpdategramMappingSchema.xml) est spécifié dans le code de mise à jour (updategram) suivant. Le code de mise à jour (updategram) ajoute un article dans la table Sales.SalesOrderDetail pour une commande spécifique. Le code de mise à jour (updategram) inclut des éléments imbriqués : un élément <OD> imbriqué dans un élément <Order>. La relation clé primaire/clé étrangère entre ces deux éléments est spécifiée dans le schéma de mappage.

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

Pour tester le code de mise à jour

  1. Copiez le schéma de mappage ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdategramMappingSchema.xml.

  2. Copiez le modèle de code de mise à jour (updategram) ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom UpdateWithMappingSchema.xml dans le même dossier que celui utilisé pour l'enregistrement du schéma de mappage (UpdategramMappingSchema.xml).

  3. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

Pour obtenir des exemples supplémentaires de code de mise à jour (updategram) qui utilisent des schémas de mappage, consultez Spécification d'un schéma de mappage annoté dans un code de mise à jour (updategram) (SQLXML 4.0).

F.Utilisation d'un schéma de mappage avec les attributs IDREFS

Cet exemple montre comment les codes de mise à jour (updategrams) utilisent les attributs IDREFS du schéma de mappage pour mettre à jour des enregistrements dans plusieurs tables. Pour cet exemple, supposez que la base de données comporte les tables suivantes :

  • Student(StudentID, LastName)

  • Course(CourseID, CourseName)

  • Enrollment(StudentID, CourseID)

Dans la mesure où un étudiant peut s'inscrire à de nombreux cours et comme un cours peut avoir de nombreux étudiants, la troisième table, la table Enrollment, est requise pour représenter cette relation M:N.

Le schéma de mappage XSD suivant fournit une vue XML des tables à l'aide des éléments <Student>, <Course> et <Enrollment>. Les attributs IDREFS du schéma de mappage spécifient la relation entre ces éléments. L'attribut StudentIDList sur l'élément <Course> est un attribut de type IDREFS qui fait référence à la colonne StudentID de la table Enrollment. De même, l'attribut EnrolledIn sur l'élément <Student> est un attribut de type IDREFS qui fait référence à la colonne CourseID de la table Enrollment.

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

Chaque fois que vous spécifiez ce schéma dans un code de mise à jour (updategram) et que vous insérez un enregistrement dans la table Course, le code de mise à jour (updategram) insère un nouvel enregistrement de cours dans la table Course. Si vous spécifiez un ou plusieurs nouveaux ID d'étudiants pour l'attribut StudentIDList, le code de mise à jour (updategram) insère également un enregistrement dans la table Enrollment pour chaque nouvel étudiant. Le code de mise à jour (updategram) s'assure qu'aucun doublon n'est ajouté à la table Enrollment.

Pour tester le code de mise à jour

  1. Créez ces tables dans la base de données spécifiée dans la racine virtuelle :

    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. Ajoutez ces exemples de données :

    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. Copiez le schéma de mappage ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom SampleSchema.xml.

  4. Enregistrez le code de mise à jour (SampleUpdategram) dans le même dossier que celui utilisé pour l'enregistrement du schéma de mappage à l'étape précédente. (Ce code de mise à jour (updategram) supprime un étudiant pour lequel StudentID="1" dans le cours 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. Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le code de mise à jour (updategram).

    Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.

  6. Enregistrez et exécutez le code de mise à jour (updategram) suivant, comme décrit dans les étapes précédentes. Le code de mise à jour (updategram) rajoute l'étudiant pour lequel StudentID="1" dans le cours CS102 en insérant un enregistrement dans la table Enrollment.

    <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. Enregistrez et exécutez le code de mise à jour (updategram) suivant, comme décrit dans les étapes précédentes. Ce code de mise à jour (updategram) insère trois nouveaux étudiants et les inscrit au cours CS101. À nouveau, la relation IDREFS insère des enregistrements dans la table Enrollment.

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

Voici le schéma XDR équivalent :

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

Pour obtenir des exemples supplémentaires de code de mise à jour (updategram) qui utilisent des schémas de mappage, consultez Spécification d'un schéma de mappage annoté dans un code de mise à jour (updategram) (SQLXML 4.0).

Voir aussi

Référence

Considérations de sécurité relatives au code de mise à jour (updategram) (SQLXML 4.0)