Présentation des codes de mise à jour (SQLXML 4.0)

Article
05/07/2013

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 Transact-SQL OPENXML.

La fonction OPENXML modifie une base de données en fragmentant le document XML existant et en fournissant un ensemble de lignes qui peut être passé à 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 particulièrement approprié partout où les fournisseurs d'ensembles de lignes, tels qu'une table, peuvent apparaître comme 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 un 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, possède les informations nécessaires pour mapper des éléments et des 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.

[!REMARQUE]

Cette documentation suppose une connaissance suffisante des modèles et de la prise en charge des schémas de mappage dans SQL Server. Pour plus d'informations, consultez Introduction aux schémas XSD annotés (SQLXML 4.0). Pour les applications héritées qui utilisent XDR, consultez Schémas XDR annotés (déconseillés dans SQLXML 4.0).

Espace de noms requis dans le code de mise à jour

Les mots clés dans un code de mise à jour, tels que <sync>, <before> et <after>, existent dans l'espace de noms urn:schemas-microsoft-com:xml-updategram. Le préfixe d'espace de noms employé est arbitraire. Dans cette documentation, le préfixe updg dénote l'espace de noms updategram.

Vérification de la syntaxe

Un code de mise à jour est un modèle avec des blocs <sync>, <before> et <after> qui forment la syntaxe du code de mise à jour. Le code ci-dessous illustre cette syntaxe dans 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 ci-dessous décrivent le rôle de chacun de ces blocs :

<before>
Identifie l'état existant (également appelé « état before ») de l'instance de l'enregistrement.
<after>
Identifie le nouvel état qu'auront les données après modification.
<sync>
Contient les blocs <before> et <after>. Un bloc <sync> peut contenir plusieurs jeux de blocs <before> et <after>. S'il existe plusieurs jeux de blocs <before> et <after> , ces blocs (même s'ils sont vides) doivent être spécifiés sous forme de paires. De plus, un code de mise jour peut comporter plusieurs blocs <sync>. Chaque bloc <sync> est une unité de transaction (ce qui signifie que, dans le bloc <sync>, soit tout est fait, soit rien n'est fait). Si vous spécifiez plusieurs blocs <sync> dans un code de mise à jour, l'échec d'un bloc <sync> n'affecte pas les autres blocs <sync> .

Les opérations effectuées par le code de mise à jour (suppression, insertion ou mise à jour d'une instance de l'enregistrement) dépendent du contenu des blocs <before> et <after> :

Si une instance de l'enregistrement apparaît uniquement dans le bloc <before> sans instance correspondante dans le bloc <after>, le code de mise à jour effectue une opération de suppression.
Si une instance de l'enregistrement apparaît uniquement dans le bloc <after> sans instance correspondante dans le bloc <before> , l'opération correspond à une insertion.
Si une instance de l'enregistrement apparaît dans le bloc <before> et qu'il existe une instance correspondante dans le bloc <after>, l'opération correspond à une mise à jour. Dans ce cas, le code de mise à jour met à jour l'instance de l'enregistrement aux valeurs spécifiées dans le bloc <after> .

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 utilise par défaut un mappage implicite (le mappage par défaut), dans lequel chaque élément du bloc <before> ou du bloc <after> est mappé à une table et l'élément ou l'attribut enfant de chaque élément est mappé à une colonne dans la base de données. Si vous spécifiez explicitement un schéma de mappage, les éléments et les attributs dans le code de mise à jour doivent correspondre aux éléments et aux attributs dans le 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 requérir de schéma de mappage. Dans ce cas, le code de mise à jour compte sur le schéma de mappage par défaut.

Le code de mise à jour ci-dessous illustre un mappage implicite. Dans cet exemple, le code de mise à jour insère un nouveau client dans la table Sales.Customer. Comme ce code de mise à jour utilise un mappage implicite, l'élément <Sales.Customer> est mappé à la table Sales.Customer, et les attributs CustomerID et SalesPersonID sont mappés aux colonnes correspondantes dans 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 qui seront mises à jour.

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

Comme un code de mise à jour est un modèle, le chemin d'accès spécifié pour le schéma de mappage dans le code de mise à jour est relatif à l'emplacement du fichier modèle (relatif à 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 (updategram) (SQLXML 4.0).

Mappage centré sur les éléments et mappage centré sur les attributs dans les codes de mise à jour

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 à des tables et les é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) sont mappés à des 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 désignent les propriétés de l'élément. Pour bénéficier d'un exemple, reportez-vous au code de mise à jour ci-dessous. L'élément <Person.Contact> contient les éléments enfants <FirstName> et <LastName>. Ces éléments enfants sont la propriété de l'élément <Person.Contact>.

Comme ce code de mise à jour ne spécifie pas de schéma de mappage, le code de mise à jour utilise le mappage implicite, dans lequel 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 ci-dessous utilise le mappage centré sur les attributs. Dans cet exemple, l'élément <Person.Contact> est composé des attributs FirstName et LastName. Ces attributs sont la propriété 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 et 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 dans 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 du mappage centré sur les attributs

Vous pouvez spécifier une association du mappage centré sur les éléments et du mappage centré sur les attributs, comme l'illustre le code de mise à jour ci-dessous. Remarquez que l'élément <Person.Contact> contient à la fois un attribut et un élément enfant. Également, ce code de mise à jour s'appuie sur un 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 des caractères valides dans SQL Server mais non valides dans XML

Dans SQL Server, les noms des 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ù HHHH représente le code UCS-2 hexadécimal à quatre chiffres du caractère dans l'ordre du bit le plus significatif en premier. Selon ce schéma d'encodage, un espace est remplacé par x0020 (code hexadécimal à quatre chiffres d'un espace) ; par conséquent, le nom de la table [Order Details] dans SQL Server devient _x005B_Order_x0020_Details_x005D_ dans XML.

De la même façon, vous pouvez avoir à spécifier des noms d'éléments en trois parties, tels que <[database].[owner].[table]>. Comme les crochets ([ et ]) ne sont pas valides dans XML, vous devez spécifier <_x005B_database_x005D_._x005B_owner_x005D_._x005B_table_x005D_>, où _x005B_ correspond à l'encodage du crochet gauche ([) et _x005D_ à l'encodage du crochet droit (]).

Exécution de codes de mise à jour

Comme un code de mise à jour est un modèle, tous les mécanismes de traitement d'un modèle s'appliquent aux codes de mise à jour. Pour SQLXML 4.0, vous pouvez exécuter un code de mise à jour d'une des façons suivantes :

En le soumettant dans une commande ADO.
En le soumettant sous la forme d'une commande OLE DB.

Voir aussi

Référence

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

Partager via