Spécification de relations à l'aide de sql:relationship (schéma XDR)
Important
Cette rubrique est fournie à titre de référence pour les applications héritées. Cette fonctionnalité ne fera plus l'objet d'aucun travail de développement. Évitez de l'utiliser dans vos nouveaux travaux de développement. Utilisez à la place des schémas XSD annotés pour créer des vues XML. Pour plus d'informations, consultez Introduction aux schémas XSD annotés (SQLXML 4.0). Vous pouvez convertir les schémas XDR annotés existants en schémas XSD. Pour plus d'informations, consultez Conversion de schémas XDR annotés en schémas XSD équivalents (SQLXML 4.0).
Les éléments d'un document XML peuvent être liés. Les éléments peuvent être imbriqués hiérarchiquement ; en outre, des relations ID, IDREF ou IDREFS peuvent être spécifiées entre les éléments.
Par exemple, dans un schéma XDR, un élément <Customer> contient des éléments enfants <Order>. L'élément <Customer> est mappé à une table qui contient les données des clients (telle que Sales.Customer dans la base de données AdventureWorks). L'élément <Order> est mappé à une table qui contient les données des commandes dans la même base de données (telle que Sales.SalesORderHeader). Ces tables sous-jacentes, Sales.Customer et Sales.SalesOrderHeader, sont liées car les clients passent des commandes. CustomerID dans la table Sales.SalesOrderHeader est une clé étrangère qui fait référence à la clé primaire CustomerID dans la table Sales.Customer. Vous pouvez établir ces relations entre les éléments du schéma de mappage en utilisant l'annotation <sql:relationship>.
Dans le schéma XDR annoté, l'annotation <sql:relationship> permet d'imbriquer hiérarchiquement les éléments du schéma en fonction des relations de clé primaire et de clé étrangère qui existent entre les tables sous-jacentes auxquelles les éléments sont mappés. En spécifiant l'annotation <sql:relationship>, vous devez identifier les éléments suivants :
la table primaire (Sales.Customer) et la table source contenant une clé étrangère (Sales.SalesOrderHeader) et
la condition de jointure nécessaire (CustomerID dans Sales.SalesOrderHeader est une clé étrangère qui fait référence à la clé primaire CustomerID dans la table Sales.Customer).
Ces informations sont utilisées pour générer la hiérarchie correcte (pour chaque élément <customer>, les éléments <order> associés apparaissent comme des éléments enfants).
Pour fournir les noms de tables et les informations de jointure nécessaires, les attributs suivants sont spécifiés avec l'annotation <sql:relationship>. Ces attributs sont valides uniquement avec l'élément sql:relationship :
key-relation
Spécifie la relation primaire (table).key
Spécifie la clé primaire du key-relation. Si la clé primaire est composée de plusieurs colonnes, les valeurs sont spécifiées en étant séparées par un espace. Il existe un mappage de position entre les valeurs spécifiées pour la clé multicolonne et pour la clé étrangère correspondante.foreign-relation
Spécifie la relation étrangère (table).foreign-key
Spécifie la clé étrangère dans le foreign-relation qui fait référence à key dans key-relation. Si la clé étrangère est composée de plusieurs attributs (colonnes), les valeurs de clé étrangère sont spécifiées en étant séparées par un espace. Il existe un mappage de position entre les valeurs spécifiées pour la clé multicolonne et pour la clé étrangère correspondante.
[!REMARQUE]
Vous devez vous assurer que les types de données Microsoft SQL Server de key et foreign-key sont tels qu'ils peuvent être convertis implicitement, si nécessaire.
La balise sql:relationship peut être ajoutée uniquement aux éléments <element> ou <attribute> dans un schéma annoté. Lorsque sql:relationship est spécifié sur un attribut, il devrait figurer un sql:relation et un sql:field spécifiés pour l'attribut pour garantir qu'une valeur unique est extraite (plusieurs attributs du même nom ne sont pas valides dans XML). Lorsque sql:relationship est spécifié sur un élément, la relation peut entraîner une valeur unique ou un jeu de valeurs.
La balise sql:relationship est utilisée pour spécifier une relation logique unique entre deux entités. Les attributs définissent les relations et les champs utilisés pour définir la relation logique. Plusieurs instances de sql:relationship peuvent être spécifiées dans un élément ou un attribut dans le schéma annoté, ce qui indique une relation complexe entre l'élément ou l'attribut et son élément contenu. Toutes les instances de sql:relationship sont utilisées ensemble pour définir la relation complexe.
Lorsque plusieurs instances de la balise sql:relationship sont spécifiées dans un élément ou un attribut, l'ordre dans lequel ils apparaissent est significatif.
L'annotation sql:key-fields doit être spécifiée dans un élément contenant un élément enfant et un sql:relationship, défini entre l'élément et l'enfant, qui ne fournit pas la clé primaire de la table spécifiée dans l'élément parent. Pour plus d'informations, consultez Identification de colonnes clés à l'aide de sql:key-fields (SQLXML 4.0). Pour produire une imbrication correcte dans le résultat, il est recommandé de spécifier sql:key-fields dans tous les schémas.
[!REMARQUE]
Dans le schéma de mappage, les valeurs relationnelles telles qu'un nom de table et un nom de colonne respectent la casse.
Exemples
Pour créer des exemples fonctionnels à l'aide des exemples suivants, vous devez respecter certaines conditions requises. Pour plus d'informations, consultez Configuration requise pour l'exécution des exemples SQLXML.
A. Spécifier sql:relationship sur un <élément>
Ce schéma XDR annoté inclut les éléments <Customer> et <Order>. L'élément <Order> est un élément enfant de l'élément <Customer>.
Dans le schéma, l'annotation sql:relationship est spécifiée sur l'élément enfant <Order>. L'annotation identifie CustomerID dans la table Sales.SalesOrderHeader en tant que clé étrangère faisant référence à la clé primaire CustomerID dans la table Sales.Customer. Par conséquent, les commandes appartenant à un client apparaissent en tant qu'élément enfant de cet élément <Customer>.
<?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="Order" sql:relation="Sales.SalesOrderHeader" >
<AttributeType name="CustomerID" />
<AttributeType name="SalesOrderID" />
<AttributeType name="OrderDate" />
<attribute type="CustomerID" />
<attribute type="SalesOrderID" />
<attribute type="OrderDate" />
</ElementType>
<ElementType name="Customer" sql:relation="Sales.Customer" >
<AttributeType name="CustomerID" />
<attribute type="CustomerID" />
<element type="Order" >
<sql:relationship
key-relation="Sales.Customer"
key="CustomerID"
foreign-key="CustomerID"
foreign-relation="Sales.SalesOrderHeader" />
</element>
</ElementType>
</Schema>
[!REMARQUE]
Dans le schéma de mappage, les valeurs relationnelles telles que le nom de table et le nom de colonne respectent la casse. Dans l'exemple précédent, Customers est la valeur de l'attribut sql:relation. La valeur de l'attribut key-relation correspondant doit également être Customers.
Pour tester un exemple de requête XPath sur le schéma
Copiez le code de schéma ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom sql-relationship-xdr.xml.
Copiez le modèle suivant et collez-le dans un fichier texte. Enregistrez le fichier sous le nom sql-relationship-xdrT.xml dans le répertoire où vous avez enregistré sql-relationship-xdr.xml. La requête dans le modèle sélectionne un client pour lequel CustomerID a la valeur 1.
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql"> <sql:xpath-query mapping-schema="sql-relationship-xdr.xml"> Customer[@CustomerID="1"] </sql:xpath-query> </ROOT>Le chemin d'accès au répertoire spécifié pour le schéma de mappage (sql-relationship-xdr.xml) est relatif au répertoire où le modèle est enregistré. Vous pouvez également spécifier un chemin d'accès absolu, par exemple :
mapping-schema="C:\SqlXmlTest\sql-relationship-xdr.xml"Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le modèle.
Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.
Voici le jeu de résultats partiel :
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<Customer CustomerID="1">
<Order CustomerID="1" SalesOrderID="43860" OrderDate="2001-08-01T00:00:00" />
<Order CustomerID="1" SalesOrderID="44501" OrderDate="2001-11-01T00:00:00" />
<Order CustomerID="1" SalesOrderID="45283" OrderDate="2002-02-01T00:00:00" />
<Order CustomerID="1" SalesOrderID="46042" OrderDate="2002-05-01T00:00:00" />
</Customer>
</ROOT>
B. Spécifier sql:relationship sur un <attribut> et créer des références de document à l'aide des attributs ID et IDREFS.
Dans cet exemple, les références de document locales sont spécifiées à l'aide des attributs ID et IDREFS. L'exemple de schéma XDR est composé d'un élément <Customer> mappé à la table Sales.Customer. Cet élément est composé d'un élément enfant <Order> qui est mappé à la table Sales.SalesOrderHeader.
Dans cet exemple, sql:relationship est spécifié deux fois :
sql:relationship est spécifié sur l'élément enfant <Order>. Par conséquent, les commandes appartenant à un client apparaîtront en tant qu'élément enfant de cet élément <Customer>.
sql:relationship est également spécifié sur l'attribut OrderIDList de l'élément <Customer>. Cet attribut est défini en tant que type IDREFS faisant référence à l'attribut SalesOrderID (attribut de type ID) de l'élément <Order>. Par conséquent, sql:relationship est requis. Dans ce cas, l'annotation sql:relationship permet à une liste de commandes appartenant à un client d'apparaître avec cet élément <Customer>.
Les attributs spécifiés comme IDREFS peuvent être utilisés pour faire référence aux attributs de type ID, ce qui permet d'établir des liens à l'intérieur du document.
Comme les nombres ne sont pas des valeurs ID valides (ils doivent être des jetons de nom), sql:id-prefix a été utilisé pour faire d'Order ID une valeur de chaîne. Pour plus d'informations, consultez Création d'attributs de type ID, IDREF et IDREFS valides à l'aide de sql:id-prefix (schéma 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="Order" sql:relation="Sales.SalesOrderHeader" >
<AttributeType name="SalesOrderID" dt:type="id" sql:id-prefix="Ord-" />
<AttributeType name="OrderDate" />
<attribute type="SalesOrderID" />
<attribute type="OrderDate" />
</ElementType>
<ElementType name="Customer" sql:relation="Sales.Customer">
<AttributeType name="CustomerID" />
<attribute type="CustomerID" />
<AttributeType name="OrderIDList" dt:type="idrefs"
sql:id-prefix="Ord-"/>
<attribute type="OrderIDList" sql:relation="Sales.SalesOrderHeader"
sql:field="SalesOrderID">
<sql:relationship
key-relation="Sales.Customer"
key="CustomerID"
foreign-relation="Sales.SalesOrderHeader"
foreign-key="CustomerID" />
</attribute>
<element type="Order">
<sql:relationship key-relation="Sales.Customer"
key="CustomerID"
foreign-relation="Sales.SalesOrderHeader"
foreign-key="CustomerID" />
</element>
</ElementType>
</Schema>
Pour tester un exemple de requête XPath sur le schéma
Copiez le code de schéma ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom idIdref-xdr.xml.
Copiez le modèle suivant et collez-le dans un fichier texte. Enregistrez ce fichier sous le nom idIdref-xdrT.xml dans le répertoire où vous avez enregistré idIdref-xdr.xml. La requête dans le modèle sélectionne un client pour lequel CustomerID a la valeur 1.
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql"> <sql:xpath-query mapping-schema="idIdref-xdr.xml"> Customer[@CustomerID="1"] </sql:xpath-query> </ROOT>Le chemin d'accès au répertoire spécifié pour le schéma de mappage (idIdref-xdr.xml) est relatif au répertoire dans lequel le modèle est enregistré. Vous pouvez également spécifier un chemin d'accès absolu, par exemple :
mapping-schema="C:\SqlXmlTest\idIdref-xdr.xml"Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le modèle.
Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.
Le jeu de résultats obtenu est le suivant :
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<Customer CustomerID="1"
OrderIDList="Ord-43860 Ord-44501 Ord-45283 Ord-46042">
<Order SalesOrderID="Ord-43860" OrderDate="2001-08-01T00:00:00" />
<Order SalesOrderID="Ord-44501" OrderDate="2001-11-01T00:00:00" />
<Order SalesOrderID="Ord-45283" OrderDate="2002-02-01T00:00:00" />
<Order SalesOrderID="Ord-46042" OrderDate="2002-05-01T00:00:00" />
</Customer>
</ROOT>
C. Spécifier sql:relationship sur plusieurs éléments
Dans cet exemple, le schéma XDR annoté est composé des éléments <Customer>, <Order> et <OD>.
L'élément <Order> est un élément enfant de l'élément <Customer>. sql:relationship est spécifié sur l'élément enfant <Order> afin que les commandes appartenant à un client apparaissent en tant qu'éléments enfants de <Customer>.
L'élément <Order> inclut l'élément enfant <OD>. sql:relationship est spécifié sur l'élément enfant <OD> afin que les détails de commande qui appartiennent à une commande apparaissent en tant qu'éléments enfants de cet élément <Order>.
<?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="OD" sql:relation="Sales.SalesOrderDetail" >
<AttributeType name="SalesOrderID" />
<AttributeType name="ProductID" />
<attribute type="SalesOrderID" />
<attribute type="ProductID" />
</ElementType>
<ElementType name="Order" sql:relation="Sales.SalesOrderHeader" >
<AttributeType name="CustomerID" />
<AttributeType name="SalesOrderID" />
<AttributeType name="OrderDate" />
<attribute type="CustomerID" />
<attribute type="SalesOrderID" />
<attribute type="OrderDate" />
<element type="OD" >
<sql:relationship
key-relation="Sales.SalesOrderHeader"
key="SalesOrderID"
foreign-key="SalesOrderID"
foreign-relation="Sales.SalesOrderDetail" />
</element>
</ElementType>
<ElementType name="Customer" sql:relation="Sales.Customer" >
<AttributeType name="CustomerID" />
<attribute type="CustomerID" />
<element type="Order" >
<sql:relationship
key-relation="Sales.Customer"
key="CustomerID"
foreign-key="CustomerID"
foreign-relation="Sales.SalesOrderHeader" />
</element>
</ElementType>
</Schema>
Pour tester un exemple de requête XPath sur le schéma
Copiez le code de schéma ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom sql-relationship-multi-xdr.xml.
Copiez le modèle suivant et collez-le dans un fichier texte. Enregistrez le fichier sous le nom sql-relationship-multi-xdrT.xml dans le répertoire où vous avez enregistré sql-relationship-multi-xdr.xml. La requête du modèle retourne des informations de commande pour un client pour lequel CustomerID a la valeur 1 et SalesOrderID a la valeur 43860.
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql"> <sql:xpath-query mapping-schema="sql-relationship-multi-xdr.xml"> /Customer[@CustomerID="1"]/Order[@SalesOrderID=43860] </sql:xpath-query> </ROOT>Le chemin d'accès au répertoire spécifié pour le schéma de mappage (sql-relationship-multi-xdr.xml) est relatif au répertoire où le modèle est enregistré. Vous pouvez également spécifier un chemin d'accès absolu, par exemple :
mapping-schema="C:\SqlXmlTest\sql-relationship-multi-xdr.xml"Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le modèle.
Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.
Le jeu de résultats obtenu est le suivant :
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<Order CustomerID="1" SalesOrderID="43860" OrderDate="2001-08-01T00:00:00">
<OD SalesOrderID="43860" ProductID="761" />
<OD SalesOrderID="43860" ProductID="770" />
<OD SalesOrderID="43860" ProductID="758" />
<OD SalesOrderID="43860" ProductID="765" />
<OD SalesOrderID="43860" ProductID="732" />
<OD SalesOrderID="43860" ProductID="762" />
<OD SalesOrderID="43860" ProductID="738" />
<OD SalesOrderID="43860" ProductID="768" />
<OD SalesOrderID="43860" ProductID="753" />
<OD SalesOrderID="43860" ProductID="729" />
<OD SalesOrderID="43860" ProductID="763" />
<OD SalesOrderID="43860" ProductID="756" />
</Order>
</ROOT>
D. Spécifier des relations indirectes
Dans cet exemple, le schéma XDR annoté est composé des éléments <Customer> et <OD>. La relation entre ces éléments est indirecte (la table Sales.Customer est associée à la table Sales.SalesOrderDetail par le biais de la table Sales.SalesOrderHeader). Pour associer un client aux détails de commande, la relation entre la table Sales.Customer et la table Sales.SalesOrderHeader doit être spécifiée en premier lieu. Ensuite, la relation entre les tables Sales.SalesOrderHeader et Sales.SalesOrderDetail doit être spécifiée.
Voici le schéma :
<?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="OD" sql:relation="Sales.SalesOrderDetail" >
<AttributeType name="SalesOrderID" />
<AttributeType name="ProductID" />
<AttributeType name="UnitPrice" />
<attribute type="SalesOrderID" />
<attribute type="ProductID" />
<attribute type="UnitPrice" />
</ElementType>
<ElementType name="Customer" sql:relation="Sales.Customer" >
<AttributeType name="CustomerID" />
<attribute type="CustomerID" />
<element type="OD" >
<sql:relationship
key-relation="Sales.Customer"
key="CustomerID"
foreign-relation="Sales.SalesOrderHeader"
foreign-key="CustomerID"/>
<sql:relationship
key-relation="Sales.SalesOrderHeader"
key="SalesOrderID"
foreign-relation="Sales.SalesOrderDetail"
foreign-key="SalesOrderID" />
</element>
</ElementType>
</Schema>
Pour tester un exemple de requête XPath sur le schéma
Copiez le code de schéma ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom indirect-relationship-xdr.xml.
Copiez le modèle suivant et collez-le dans un fichier texte. Enregistrez le fichier sous le nom indirect-relationship-xdrT.xml dans le répertoire où vous avez enregistré indirect-relationship-xdr.xml. La requête du modèle retourne des informations de commande pour un client pour lequel CustomerID a la valeur 1.
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql" > <sql:xpath-query mapping-schema="indirect-relationship-xdr.xml" > /Customer[@CustomerID="1"] </sql:xpath-query> </ROOT>Le chemin d'accès au répertoire spécifié pour le schéma de mappage (indirect-relationship-xdr.xml) est relatif au répertoire où le modèle est enregistré. Vous pouvez également spécifier un chemin d'accès absolu, par exemple :
mapping-schema="C:\SqlXmlTest\indirect-relationship-xdr.xml"Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le modèle.
Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.
Voici le résultat partiel :
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<Customer CustomerID="1">
<OD SalesOrderID="43860" ProductID="761" UnitPrice="503.3507" />
<OD SalesOrderID="43860" ProductID="770" UnitPrice="503.3507" />
<OD SalesOrderID="43860" ProductID="758" UnitPrice="1049.7528" />
<OD SalesOrderID="43860" ProductID="765" UnitPrice="503.3507" />
...
</Customer>
</ROOT>
E. Spécifier des relations de jointure à plusieurs clés
Pour spécifier une jointure à l'aide de sql:relationship, vous pouvez spécifier une jointure impliquant deux colonnes ou plus. Dans ce cas, les noms des colonnes pour key et foreign-key sont répertoriés à l'aide d'un espace.
Cet exemple suppose que ces deux tables existent dans une base de données temporaire (telle que tempdb) :
dbo.Cust (fname, lname)
dbo.Ord (OrderID, fname, lname)
Les colonnes fname et lname forment la clé primaire de la table Cust. OrderID est la clé primaire de la table Ord. Les colonnes fname et lname dans la table Ord sont les clés étrangères faisant référence à la clé primaire fname et lname de la table Cust.
Ce schéma est composé des éléments <Cust> et <Ord>. sql:relationship permet de les joindre.
<?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="Ord" sql:relation="Ord" >
<AttributeType name="OrderID" />
<attribute type="OrderID" />
</ElementType>
<ElementType name="Cust" sql:relation="Cust" >
<AttributeType name="fname" />
<AttributeType name="lname" />
<attribute type="fname" />
<attribute type="lname" />
<element type="Ord" >
<sql:relationship
key-relation="Cust"
key="fname lname"
foreign-relation="Ord"
foreign-key="fname lname"/>
</element>
</ElementType>
</Schema>
Pour tester un exemple de requête XPath sur le schéma
Créez les deux tables : Cust et Ord.
USE tempdb CREATE TABLE dbo.Cust( fname varchar(20), lname varchar(20) ) CREATE TABLE dbo.Ord ( OrderID int primary key, fname varchar(20), lname varchar(20) ) GOAjoutez les exemples de données suivants :
INSERT INTO Cust values ('Nancy', 'Davolio') INSERT INTO Cust values('Andrew', 'Fuller') INSERT INTO Ord values (1,'Nancy', 'Davolio') INSERT INTO Ord values (2,'Nancy', 'Davolio') INSERT INTO Ord values (3,'Andrew', 'Fuller')Copiez le code de schéma ci-dessus et collez-le dans un fichier texte. Enregistrez le fichier sous le nom multikey-join-xdr.xml.
Copiez le modèle suivant et collez-le dans un fichier texte. Enregistrez le fichier sous le nom multikey-join-xdrT.xml dans le même répertoire où vous avez enregistré multikey-join-xdr.xml. La requête dans le modèle retourne des informations sur les clients.
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql" > <sql:xpath-query mapping-schema="multikey-join-xdr.xml" > /Cust </sql:xpath-query> </ROOT>Le chemin d'accès au répertoire spécifié pour le schéma de mappage (multikey-join-xdr.xml) est relatif au répertoire où le modèle est enregistré. Vous pouvez également spécifier un chemin d'accès absolu, par exemple :
mapping-schema="C:\SqlXmlTest\multikey-join-xdr.xml"Créez et utilisez le script de test SQLXML 4.0 (Sqlxml4test.vbs) pour exécuter le modèle.
Pour plus d'informations, consultez Utilisation d'ADO pour exécuter des requêtes SQLXML 4.0.
Voici le résultat partiel :
<ROOT xmlns:sql="urn:schemas-microsoft-com:xml-sql">
<Cust fname="Andrew" lname="Fuller">
<Ord OrderID="3" />
</Cust>
<Cust fname="Nancy" lname="Davolio">
<Ord OrderID="1" />
<Ord OrderID="2" />
</Cust>
</ROOT>