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

Article
04/26/2023

S’applique à :SQL Server Azure SQL Database

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.

Notes

Cette documentation suppose que vous êtes familiarisé avec les modèles et la prise en charge des schémas de mappage dans SQL Server. Pour plus d’informations, consultez Présentation des 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 <la synchronisation>, <avant> et <après>, 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 indique l’espace de noms updategram .

Vérification de la syntaxe

Un code de mise à jour est un modèle avec <des blocs de synchronisation>, <avant> et <après> 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 :

<Avant>
Identifie l'état existant (également appelé « état before ») de l'instance de l'enregistrement.

<Après>
Identifie le nouvel état qu'auront les données après modification.

<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 effectué 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> .

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

Si un enregistrement instance apparaît uniquement dans le <bloc avant> sans instance correspondant dans le <bloc après>, le code de mise à jour effectue une opération de suppression.
Si un enregistrement instance apparaît uniquement dans le <bloc après> sans instance correspondant dans le <bloc avant>, il s’agit d’une opération d’insertion.
Si un enregistrement instance 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’enregistrement instance aux 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 (le 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 mappe à une colonne de 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. Étant donné que 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 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 qui seront mises à jour.

Si le code de mise à jour effectue une mise à jour complexe (par exemple, en insérant des 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 à l’aide de 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 (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 aux tables et les éléments enfants (dans le cas d’un mappage centré sur les éléments) et les attributs (dans le cas d’un 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 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 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 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> 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 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. Notez 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 de table peuvent inclure un espace. Toutefois, ce type de nom de table n'est pas valide dans XML.

Pour encoder des caractères qui sont valides SQL Server identificateurs, mais qui ne sont pas des identificateurs XML valides, utilisez « __xHHHH__ » comme valeur d’encodage, où HHHH signifie le code hexadécimal UCS-2 à quatre chiffres pour le caractère dans l’ordre d’encodage 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 la commande] 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 entre crochets ([ et ]) ne sont pas valides dans XML, vous devez le spécifier comme <_x005B_database_x005D_._x005B_owner_x005D_._x005B_table_x005D_>, où _x005B_ est l’encodage pour le crochet gauche ([) et _x005D_ est l’encodage pour le 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

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

Share via