Introduction aux codes de mise à jour (SQLXML 4.0)

Vous pouvez modifier (insérer, mettre à jour ou supprimer) une base de données dans Microsoft SQL Server à partir d’un document XML existant à l’aide d’un code de mise à jour ou de la fonction OPENXML Transact-SQL.

La fonction OPENXML modifie une base de données en déchiquetant le document XML existant et en fournissant un ensemble de lignes qui peut être transmis à une instruction INSERT, UPDATE ou DELETE. Avec OPENXML, les opérations sont effectuées directement sur les tables de base de données. Par conséquent, OPENXML est le plus approprié partout où les fournisseurs d’ensembles de lignes, tels qu’une table, peuvent apparaître en tant que source.

Comme OPENXML, un code de mise à jour vous permet d’insérer, de mettre à jour ou de supprimer des données dans la base de données ; toutefois, un code de mise à jour fonctionne sur les vues XML fournies par le schéma XSD annoté (ou XDR) ; Par exemple, les mises à jour sont appliquées à la vue XML fournie par le schéma de mappage. Le schéma de mappage, à son tour, contient les informations nécessaires pour mapper les éléments et attributs XML aux tables et colonnes de base de données correspondantes. Le code de mise à jour utilise ces informations de mappage pour mettre à jour les tables et colonnes de base de données.

Espaces de noms requis dans le code de mise à jour

Les mots clés d’un code de mise à jour, tels que <la synchronisation>, <avant> et <après>, existent dans l’espace urn:schemas-microsoft-com:xml-updategram de noms. Le préfixe d’espace de noms que vous utilisez est arbitraire. Dans cette documentation, le updg préfixe désigne l’espace updategram de noms.

Révision de la syntaxe

Un code de mise à jour est un modèle avec <synchronisation>, <avant> et <après> des blocs qui forment la syntaxe du code de mise à jour. Le code suivant montre cette syntaxe sous sa forme la plus simple :

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

Les définitions suivantes décrivent le rôle de chacun de ces blocs :

<avant>
Identifie l’état existant (également appelé « état avant ») de l’instance d’enregistrement.

<après>
Identifie le nouvel état dans lequel les données doivent être modifiées.

<Synchronisation>
Contient les <blocs avant> et <après> . Un <bloc de synchronisation> peut contenir plusieurs ensembles de <blocs avant> et <après> . S’il existe plusieurs ensembles de <blocs avant> et <après> , ces blocs (même s’ils sont vides) doivent être spécifiés en tant que paires. En outre, un code de mise à jour peut avoir plusieurs <blocs de synchronisation> . Chaque <bloc de synchronisation> est une unité de transaction (ce qui signifie que tout ce qui se trouve dans le <bloc de synchronisation> est terminé ou que rien n’est fait). Si vous spécifiez plusieurs <blocs de synchronisation> dans un code de mise à jour, l’échec d’un <bloc de synchronisation> n’affecte pas les autres <blocs de synchronisation> .

Si un code de mise à jour supprime, insère ou met à jour une instance d’enregistrement dépend du contenu des <blocs avant> et <après> :

• Si une instance d’enregistrement apparaît uniquement dans le <bloc avant> sans instance correspondante dans le <bloc après> , le code de mise à jour effectue une opération de suppression.

• Si une instance d’enregistrement apparaît uniquement dans le <bloc après> sans instance correspondante dans le <bloc précédent> , il s’agit d’une opération d’insertion.

• Si une instance d’enregistrement apparaît dans le <bloc avant> et a une instance correspondante dans le <bloc après> , il s’agit d’une opération de mise à jour. Dans ce cas, le code de mise à jour met à jour l’instance d’enregistrement sur les valeurs spécifiées dans le <bloc après> .

Spécification d’un schéma de mappage dans le code de mise à jour

Dans un code de mise à jour, l’abstraction XML fournie par un schéma de mappage (les schémas XSD et XDR sont pris en charge) peut être implicite ou explicite (autrement dit, un code de mise à jour peut fonctionner avec ou sans schéma de mappage spécifié). Si vous ne spécifiez pas de schéma de mappage, le code de mise à jour suppose un mappage implicite (mappage par défaut), où chaque élément du <bloc avant> ou <après> est mappé à une table et l’élément enfant ou l’attribut de chaque élément est mappé à une colonne de la base de données. Si vous spécifiez explicitement un schéma de mappage, les éléments et les attributs du code de mise à jour doivent correspondre aux éléments et attributs du schéma de mappage.

Mappage implicite (par défaut)

Dans la plupart des cas, un code de mise à jour qui effectue des mises à jour simples peut ne pas nécessiter de schéma de mappage. Dans ce cas, le code de mise à jour s’appuie sur le schéma de mappage par défaut.

Le code de mise à jour suivant illustre le mappage implicite. Dans cet exemple, le code de mise à jour insère un nouveau client dans la table Sales.Customer. Étant donné que ce code de mise à jour utilise le mappage implicite, l’élément <Sales.Customer> est mappé à la table Sales.Customer, et les attributs CustomerID et SalesPersonID correspondent aux colonnes correspondantes de la table Sales.Customer.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">  
<updg:sync >  
<updg:before>  
</updg:before>  
<updg:after>  
    <Sales.Customer CustomerID="1" SalesPersonID="277" />  
    </updg:after>  
</updg:sync>  
</ROOT>  

Mappage explicite

Si vous spécifiez un schéma de mappage (XSD ou XDR), le code de mise à jour utilise le schéma pour déterminer les tables et colonnes de base de données à mettre à jour.

Si le code de mise à jour effectue une mise à jour complexe (par exemple, l’insertion d’enregistrements dans plusieurs tables en fonction de la relation parent-enfant spécifiée dans le schéma de mappage), vous devez fournir explicitement le schéma de mappage à l’aide de l’attribut mapping-schema sur lequel le code de mise à jour s’exécute.

Étant donné qu’un code de mise à jour est un modèle, le chemin spécifié pour le schéma de mappage dans le code de mise à jour est relatif à l’emplacement du fichier de modèle (par rapport à l’emplacement où le code de mise à jour est stocké). Pour plus d’informations, consultez Spécification d’un schéma de mappage annoté dans un code de mise à jour (SQLXML 4.0) .

Mappage centré sur les éléments et centré sur les attributs dans updategrams

Avec le mappage par défaut (lorsque le schéma de mappage n’est pas spécifié dans le code de mise à jour), les éléments de code de mise à jour sont mappés aux tables et aux éléments enfants (dans le cas du mappage centré sur les éléments) et les attributs (dans le cas du mappage centré sur les attributs) mappés aux colonnes.

Mappage centré sur les éléments

Dans un code de mise à jour centré sur les éléments, un élément contient des éléments enfants qui indiquent les propriétés de l’élément. Par exemple, reportez-vous au code de mise à jour suivant. L’élément <Person.Contact> contient les éléments enfants **<FirstName>**et <LastName> . Ces éléments enfants sont des propriétés de l’élément <Person.Contact> .

Étant donné que ce code de mise à jour ne spécifie pas de schéma de mappage, le code de mise à jour utilise un mappage implicite, où l’élément <Person.Contact> est mappé à la table Person.Contact et à ses éléments enfants sont mappés aux colonnes FirstName et LastName.

<ROOT xmlns:updg="urn:schemas-microsoft-com:xml-updategram">  
<updg:sync >  
  <updg:after>  
    <Person.Contact>  
       <FirstName>Catherine</FirstName>  
       <LastName>Abel</LastName>  
    </Person.Contact>  
  </updg:after>  
</updg:sync>  
</ROOT>  

Mappage centré sur les attributs

Dans un mappage centré sur les attributs, les éléments ont des attributs. Le code de mise à jour suivant utilise le mappage centré sur les attributs. Dans cet exemple, l’élément <Person.Contact> se compose des attributs FirstName et LastName . Ces attributs sont les propriétés de l’élément <Person.Contact> . Comme dans l’exemple précédent, ce code de mise à jour ne spécifie aucun schéma de mappage. Il s’appuie donc sur le mappage implicite pour mapper l’élément <Person.Contact> à la table Person.Contact et les attributs de l’élément aux colonnes respectives de la table.

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

Utilisation du mappage centré sur les éléments et centré sur les attributs

Vous pouvez spécifier un mélange de mappage centré sur les éléments et centré sur les attributs, comme indiqué dans le code de mise à jour suivant. Notez que l’élément Person.Contact> contient à la< fois un attribut et un élément enfant. En outre, ce code de mise à jour s’appuie sur le mappage implicite. Ainsi, l’attribut FirstName et l’élément <enfant LastName> sont mappés aux colonnes correspondantes dans la table Person.Contact.

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

Utilisation de caractères valides dans SQL Server mais non valides dans XML

Dans SQL Server, les noms de tables peuvent inclure un espace. Toutefois, ce type de nom de table n’est pas valide dans XML.

Pour encoder des caractères qui sont des identificateurs SQL Server valides, mais qui ne sont pas des identificateurs XML valides, utilisez « __xHHHH__ » comme valeur d’encodage, où HHHHH représente le code HEXAdécimal UCS-2 à quatre chiffres pour le caractère dans le premier ordre de bits le plus significatif. À l’aide de ce schéma d’encodage, un caractère d’espace est remplacé par x0020 (code hexadécimal à quatre chiffres pour un caractère d’espace) ; ainsi, le nom de la table [Détails de l’ordre] dans SQL Server devient _x005B_Order_x0020_Details_x005D_ en XML.

De même, vous devrez peut-être spécifier des noms d’éléments en trois parties, tels que <[base de données].[ propriétaire]. [table]>. Étant donné que les caractères de crochet ([ et ]) ne sont pas valides en XML, vous devez le spécifier comme <_x005B_database_x005D_._x005B_owner_x005D_._x005B_table_x005D_>, où _x005B_ est l’encodage du crochet gauche ([) et _x005D_ est l’encodage du crochet droit (]).

Exécution de tableaux de mise à jour

Étant donné qu’un code de mise à jour est un modèle, tous les mécanismes de traitement d’un modèle s’appliquent au code de mise à jour. Pour SQLXML 4.0, vous pouvez exécuter un code de mise à jour de l’une des manières suivantes :

• En l’envoyant dans une commande ADO.

• En l’envoyant en tant que commande OLE DB.

Voir aussi

Considérations relatives à la sécurité du code de mise à jour (SQLXML 4.0)