Using OPENXML
The examples in this topic show how OPENXML is used in creating a rowset view of an XML document. For information about the syntax of OPENXML, see OPENXML. The examples show all aspects of OPENXML except specifying metaproperties in OPENXML. For more information about specifying metaproperties in OPENXML, see Specifying Metaproperties in OPENXML.
Examples
In retrieving the data, rowpattern is used to identify the nodes in the XML document that determine the rows. rowpattern is expressed in the XPath pattern language used in the MSXML XPath implementation. For example, if the pattern ends in an element or an attribute, a row is created for each element or attribute node selected by rowpattern.
The flags value provides default mapping. In the SchemaDeclaration, if no ColPattern is specified, the mapping specified in flags is assumed. The flags value is ignored if ColPattern is specified in SchemaDeclaration. The specified ColPattern determines the mapping (attribute-centric or element-centric) and also the behavior in dealing with overflow and unconsumed data.
A. Execute a simple SELECT statement with OPENXML
The XML document in this example consists of the <Customer>, <Order>, and <OrderDetail> elements. The OPENXML statement retrieves customer information in a two-column rowset (CustomerID and ContactName) from the XML document.
First, the sp_xml_preparedocument stored procedure is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/ROOT/Customer) identifies the <Customer> nodes to process.
- The flags parameter value is set to 1 indicating attribute-centric mapping. As a result, the XML attributes map to the columns in the rowset defined in SchemaDeclaration.
- In SchemaDeclaration (in the WITH clause), the specified ColName values match the corresponding XML attribute names. Therefore, the ColPattern parameter is not specified in SchemaDeclaration.
And then, the SELECT statement retrieves all the columns in the rowset provided by OPENXML.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" ContactName="Paul Henriot">
<Order OrderID="10248" CustomerID="VINET" EmployeeID="5"
OrderDate="1996-07-04T00:00:00">
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" ContactName="Carlos Gonzlez">
<Order OrderID="10283" CustomerID="LILAS" EmployeeID="3"
OrderDate="1996-08-16T00:00:00">
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer',1)
WITH (CustomerID varchar(10),
ContactName varchar(20))
EXEC sp_xml_removedocument @idoc
This is the result:
CustomerID ContactName
---------- --------------------
VINET Paul Henriot
LILAS Carlos Gonzlez
If the same SELECT statement is executed with flags set to 2, indicating element-centric mapping, because <Customer> elements do not have any subelements, the values of CustomerID and ContactName for both the customers are returned as NULL.
If in the XML document, the <CustomerID> and <ContactName> are subelements, the element-centric mapping retrieves the values.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer>
<CustomerID>VINET</CustomerID>
<ContactName>Paul Henriot</ContactName>
<Order OrderID="10248" CustomerID="VINET" EmployeeID="5" OrderDate="1996-07-04T00:00:00">
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer>
<CustomerID>LILAS</CustomerID>
<ContactName>Carlos Gonzlez</ContactName>
<Order OrderID="10283" CustomerID="LILAS" EmployeeID="3" OrderDate="1996-08-16T00:00:00">
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer',2)
WITH (CustomerID varchar(10),
ContactName varchar(20))
EXEC sp_xml_removedocument @idoc
This is the result:
CustomerID ContactName
---------- --------------------
VINET Paul Henriot
LILAS Carlos Gonzlez
B. Specify ColPattern for mapping between rowset columns and the XML attributes/elements
This example shows how the XPath pattern is specified in the optional ColPattern parameter to provide mapping between rowset columns and the XML attributes (and elements).
The XML document in this example consists of the <Customer>, <Order>, and <OrderDetail> elements. The OPENXML statement retrieves customer and order information as a rowset (CustomerID, OrderDate, ProdID, and Qty) from the XML document.
First, the sp_xml_preparedocument stored procedure is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/ROOT/Customer/Order/OrderDetail) identifies the <OrderDetail> nodes to process.
- For illustration purposes, the flags parameter value is set to 2 indicating element-centric mapping. However, the mapping specified in ColPattern overwrites this mapping (the XPath pattern specified in ColPattern maps the columns in the rowset to attributes thus resulting in an attribute-centric mapping).
In SchemaDeclaration (in the WITH clause), ColPattern is also specified with the ColName and ColType parameters. The optional ColPattern is the XPath pattern specified to indicate:
- The OrderID, CustomerID, and OrderDate columns in the rowset map to the attributes of the parent of the nodes identified by rowpattern. rowpattern identifies the <OrderDetail> nodes. Therefore, the CustomerID and OrderDate columns map to CustomerID and OrderDate attributes of the <Order> element.
- The ProdID and Qty columns in the rowset map to the ProductID and Quantity attributes of the nodes identified in rowpattern.
And then the SELECT statement retrieves all the columns in the rowset provided by OPENXML.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" ContactName="Paul Henriot">
<Order OrderID="10248" CustomerID="VINET" EmployeeID="5"
OrderDate="1996-07-04T00:00:00">
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" ContactName="Carlos Gonzlez">
<Order OrderID="10283" CustomerID="LILAS" EmployeeID="3"
OrderDate="1996-08-16T00:00:00">
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT stmt using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer/Order/OrderDetail',2)
WITH (OrderID int '../@OrderID',
CustomerID varchar(10) '../@CustomerID',
OrderDate datetime '../@OrderDate',
ProdID int '@ProductID',
Qty int '@Quantity')
This is the result:
OrderID CustomerID OrderDate ProdID Qty
-------------------------------------------------------------
10248 VINET 1996-07-04 00:00:00.000 11 12
10248 VINET 1996-07-04 00:00:00.000 42 10
10283 LILAS 1996-08-16 00:00:00.000 72 3
The XPath pattern specified as ColPattern can also be specified to map the XML elements to the rowset columns (resulting in element-centric mapping). In the following example, the XML document <CustomerID> and <OrderDate> are subelements of <Orders> element. Because ColPattern overwrites the mapping specified in flags parameter, the flags parameter is not specified in OPENXML.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" ContactName="Paul Henriot">
<Order EmployeeID="5" >
<OrderID>10248</OrderID>
<CustomerID>VINET</CustomerID>
<OrderDate>1996-07-04T00:00:00</OrderDate>
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" ContactName="Carlos Gonzlez">
<Order EmployeeID="3" >
<OrderID>10283</OrderID>
<CustomerID>LILAS</CustomerID>
<OrderDate>1996-08-16T00:00:00</OrderDate>
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT stmt using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer/Order/OrderDetail')
WITH (CustomerID varchar(10) '../CustomerID',
OrderDate datetime '../OrderDate',
ProdID int '@ProductID',
Qty int '@Quantity')
EXEC sp_xml_removedocument @idoc
C. Combining attribute-centric and element-centric mapping
In this example, the flags parameter is set to 3, indicating that both attribute-centric and element-centric mapping is to be applied. In this case, the attribute-centric mapping is applied first, and then element-centric mapping is applied for all the columns not yet dealt with.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" >
<ContactName>Paul Henriot</ContactName>
<Order OrderID="10248" CustomerID="VINET" EmployeeID="5"
OrderDate="1996-07-04T00:00:00">
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" >
<ContactName>Carlos Gonzlez</ContactName>
<Order OrderID="10283" CustomerID="LILAS" EmployeeID="3"
OrderDate="1996-08-16T00:00:00">
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer',3)
WITH (CustomerID varchar(10),
ContactName varchar(20))
EXEC sp_xml_removedocument @idoc
This is the result
CustomerID ContactName
---------- --------------------
VINET Paul Henriot
LILAS Carlos Gonzlez
The attribute-centric mapping is applied for CustomerID. There is no ContactName attribute in the <Customers> element; therefore, element-centric mapping is applied.
D. Specify text() XPath function as ColPattern
The XML document in this example consists of the <Customer> and <Order> elements. The OPENXML statement retrieves a rowset consisting of the oid attribute from the <Order> element, the ID of the parent of the node (identified by rowpattern), and the leaf-value string of the element content.
First, the sp_xml_preparedocument stored procedure is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/root/Customer/Order) identifies the <Order> nodes to process.
- The flags parameter value is set to 1, indicating attribute-centric mapping. As a result, the XML attributes map to the rowset columns defined in SchemaDeclaration.
- In SchemaDeclaration (in the WITH clause), the rowset column names, oid and amount, match the corresponding XML attribute names. Therefore, the ColPattern parameter is not specified. For the comment column in the rowset, the XPath function (text()) is specified as ColPattern. This overwrites the attribute-centric mapping specified in flags, and the column contains the leaf-value string of the element content.
And then, the SELECT statement retrieves all the columns in the rowset provided by OPENXML.
DECLARE @idoc int
DECLARE @doc varchar(1000)
--sample XML document
SET @doc ='
<root>
<Customer cid= "C1" name="Janine" city="Issaquah">
<Order oid="O1" date="1/20/1996" amount="3.5" />
<Order oid="O2" date="4/30/1997" amount="13.4">Customer was very satisfied
</Order>
</Customer>
<Customer cid="C2" name="Ursula" city="Oelde" >
<Order oid="O3" date="7/14/1999" amount="100" note="Wrap it blue
white red">
<Urgency>Important</Urgency>
Happy Customer.
</Order>
<Order oid="O4" date="1/20/1996" amount="10000"/>
</Customer>
</root>
'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/root/Customer/Order', 1)
WITH (oid char(5),
amount float,
comment ntext 'text()')
EXEC sp_xml_removedocument @idoc
This is the result:
oid amount comment
----- ----------- -----------------------------
O1 3.5 NULL
O2 13.4 Customer was very satisfied
O3 100.0 Happy Customer.
O4 10000.0 NULL
E. Specify TableName in the WITH clause
This example specifies TableName in the WITH clause instead of SchemaDeclaration in the WITH clause. This is useful if you have a table with the structure you want and no column patterns (ColPattern parameter) are required.
The XML document in this example consists of the <Customer> and <Order> elements. The OPENXML statement retrieves order information in a three-column rowset (oid, date, and amount) from the XML document.
First, the sp_xml_preparedocument stored procedure is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/root/Customer/Order) identifies the <Order> nodes to process.
- There is no SchemaDeclaration in the WITH clause. Instead, a table name is specified. Therefore, the table schema is used as the rowset schema.
- The flags parameter value is set to 1, indicating attribute-centric mapping. Therefore, attributes of the elements (identified by rowpattern) map to the rowset columns with the same name.
And then the SELECT statement retrieves all the columns in the rowset provided by OPENXML.
-- Create a test table. This table schema is used by OPENXML as the
-- rowset schema.
CREATE TABLE T1(oid char(5), date datetime, amount float)
DECLARE @idoc int
DECLARE @doc varchar(1000)
-- Sample XML document
SET @doc ='
<root>
<Customer cid= "C1" name="Janine" city="Issaquah">
<Order oid="O1" date="1/20/1996" amount="3.5" />
<Order oid="O2" date="4/30/1997" amount="13.4">Customer was very
satisfied</Order>
</Customer>
<Customer cid="C2" name="Ursula" city="Oelde" >
<Order oid="O3" date="7/14/1999" amount="100" note="Wrap it blue
white red">
<Urgency>Important</Urgency>
</Order>
<Order oid="O4" date="1/20/1996" amount="10000"/>
</Customer>
</root>
'
--Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/root/Customer/Order', 1)
WITH T1
EXEC sp_xml_removedocument @idoc
This is the result:
oid date amount
----- --------------------------- ----------
O1 1996-01-20 00:00:00.000 3.5
O2 1997-04-30 00:00:00.000 13.4
O3 1999-07-14 00:00:00.000 100.0
O4 1996-01-20 00:00:00.000 10000.0
F. Obtain the result in an edge table format
In this example, the WITH clause is not specified in the OPENXML statement. As a result, the rowset generated by OPENXML has an edge table format. The SELECT statement returns all the columns in the edge table.
The sample XML document in the example consists of the <Customer>, <Order>, and <OrderDetail> elements.
First, the sp_xml_preparedocument stored procedure is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/ROOT/Customer) identifies the <Customer> nodes to process.
- The WITH clause is not provided; therefore, OPENXML returns the rowset in an edge table format.
And then the SELECT statement retrieves all the columns in the edge table.
DECLARE @idoc int
DECLARE @doc varchar(1000)
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" ContactName="Paul Henriot">
<Order CustomerID="VINET" EmployeeID="5" OrderDate=
"1996-07-04T00:00:00">
<OrderDetail OrderID="10248" ProductID="11" Quantity="12"/>
<OrderDetail OrderID="10248" ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" ContactName="Carlos Gonzlez">
<Order CustomerID="LILAS" EmployeeID="3" OrderDate=
"1996-08-16T00:00:00">
<OrderDetail OrderID="10283" ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
--Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT statement using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer')
EXEC sp_xml_removedocument @idoc
The result is returned as an edge table. You can write queries against the edge table to obtain information:
- The following query returns the number of Customer nodes in the document. Because the WITH clause is not specified, OPENXML returns an edge table. The SELECT statement queries the edge table.
SELECT count(*) FROM OPENXML(@idoc, '/') WHERE localname = 'Customer' - This query returns local names of XML nodes of element type.
SELECT distinct localname FROM OPENXML(@idoc, '/') WHERE nodetype = 1 ORDER BY localname
G. Specify rowpattern ending with an attribute
The XML document in this example consists of the <Customer>, <Order>, and <OrderDetail> elements. The OPENXML statement retrieves order details information in a three-column rowset (ProductID, Quantity, and OrderID) from the XML document.
First, the sp_xml_preparedocument is called to obtain a document handle. This document handle is passed to OPENXML.
In the OPENXML statement:
- rowpattern (/ROOT/Customer/Order/OrderDetail/@ProductID) ends with an XML attribute (ProductID). In the resulting rowset, a row is created for each attribute node selected in the XML document.
- In this example, the flags parameter is not specified. Instead, the mappings are specified by the ColPattern parameter.
In SchemaDeclaration (in the WITH clause), ColPattern is also specified with the ColName and ColType parameters. The optional ColPattern is the XPath pattern specified to indicate:
- The XPath pattern (.) specified as ColPattern for the ProdID column in the rowset identifies the context node (current node). As per the rowpattern specified, it is the ProductID attribute of the <OrderDetail> element.
- The ColPattern, ../@Quantity, specified for the Qty column in the rowset identifies the Quantity attribute of the parent (<OrderDetail>) node of the context node (<ProductID>).
- Similarly, the ColPattern, ../../@OrderID, specified for the OID column in the rowset identifies the OrderID attribute of the parent (<Order>) of the parent (<OrderDetail>) node of the context node (<ProductID>).
And then, the SELECT statement retrieves all the columns in the rowset provided by OPENXML.
DECLARE @idoc int
DECLARE @doc varchar(1000)
--Sample XML document
SET @doc ='
<ROOT>
<Customer CustomerID="VINET" ContactName="Paul Henriot">
<Order OrderID="10248" CustomerID="VINET" EmployeeID="5" OrderDate=
"1996-07-04T00:00:00">
<OrderDetail ProductID="11" Quantity="12"/>
<OrderDetail ProductID="42" Quantity="10"/>
</Order>
</Customer>
<Customer CustomerID="LILAS" ContactName="Carlos Gonzlez">
<Order OrderID="10283" CustomerID="LILAS" EmployeeID="3" OrderDate=
"1996-08-16T00:00:00">
<OrderDetail ProductID="72" Quantity="3"/>
</Order>
</Customer>
</ROOT>'
-- Create an internal representation of the XML document.
EXEC sp_xml_preparedocument @idoc OUTPUT, @doc
-- Execute a SELECT stmt using OPENXML rowset provider.
SELECT *
FROM OPENXML (@idoc, '/ROOT/Customer/Order/OrderDetail/@ProductID')
WITH ( ProdID int '.',
Qty int '../@Quantity',
OID int '../../@OrderID')
EXEC sp_xml_removedocument @idoc
This is the result:
ProdID Qty OID
----------- ----------- -------
11 12 10248
42 10 10248
72 3 10283
H. Specify an XML document with multiple text nodes
If you have multiple text nodes in an XML document, a SELECT statement with a ColPattern (text()) returns only the first text node instead of all. For example:
DECLARE @h int
EXEC sp_xml_preparedocument @h OUTPUT,
N'
<root xmlns:a="urn:1">
<a:Elem abar="asdf">
T<a>a</a>U
</a:Elem>
</root>',
'<ns xmlns:b="urn:1" />'
SELECT * FROM openxml(@h, '/root/b:Elem')
WITH (Col1 varchar(20) 'text()')
The SELECT statement returns T as the result (and not TaU)
I. Retrieve individual values from multivalued attributes
An XML document can have attributes that are multivalued. For example the IDREFS attribute can be multivalued. In an XML document, the multivalued attribute values are specified as a string with the values separated by a space. In the following XML document, the attends attribute of the <Student> element and the attendedBy attribute of <Class> are multivalued. Retrieving individual values from a multivalued XML attribute and storing each value in a separate row in the database requires additional work. This example shows the process.
This sample XML document consists of the following elements:
- <Student>
Consists of id (student ID), name, and attends attributes. The attends attribute is a multivalued attribute.
- <Class>
Consists of id (class ID), name, and attendedBy attributes. The attendedBy attribute is a multivalued attribute.
This attends attribute in <Student> and the attendedBy attribute in <Class> represent a m:n relationship between Student and Class tables. A student can take many classes and a class can have many students.
Assume you want to shred this document and save it in the database as follows:
- Save the <Student> data in the Students table.
- Save the <Class> data in the Courses table.
- Save he m:n relationship data (between Student and Class) in the CourseAttendence table. Additional work is required to extract the values. To retrieve this information and store it in the table, use these stored procedures:
- Insert_Idrefs_Values
Inserts the values of course ID and student ID in the CourseAttendence table.
- Extract_idrefs_values
Extracts the individual student IDs from each <Course> element. An edge table is used to retrieve these values.
- Insert_Idrefs_Values
Here are the steps:
- Create the following tables:
DROP TABLE CourseAttendance DROP TABLE Students DROP TABLE Courses GO CREATE TABLE Students( id varchar(5) primary key, name varchar(30) ) GO CREATE TABLE Courses( id varchar(5) primary key, name varchar(30), taughtBy varchar(5) ) GO CREATE TABLE CourseAttendance( id varchar(5) references Courses(id), attendedBy varchar(5) references Students(id), constraint CourseAttendance_PK primary key (id, attendedBy) ) go - Create these stored procedures:
DROP PROCEDURE f_idrefs GO CREATE PROCEDURE f_idrefs @t varchar(500), @idtab varchar(50), @id varchar(5) AS DECLARE @sp int DECLARE @att varchar(5) SET @sp = 0 WHILE (LEN(@t) > 0) BEGIN SET @sp = CHARINDEX(' ', @t+ ' ') SET @att = LEFT(@t, @sp-1) EXEC('INSERT INTO '+@idtab+' VALUES ('''+@id+''', '''+@att+''')') SET @t = SUBSTRING(@t+ ' ', @sp+1, LEN(@t)+1-@sp) END Go DROP PROCEDURE fill_idrefs GO CREATE PROCEDURE fill_idrefs @xmldoc int, @xpath varchar(100), @from varchar(50), @to varchar(50), @idtable varchar(100) AS DECLARE @t varchar(500) DECLARE @id varchar(5) /* Temporary Edge table */ SELECT * INTO #TempEdge FROM OPENXML(@xmldoc, @xpath) DECLARE fillidrefs_cursor CURSOR FOR SELECT CAST(iv.text AS nvarchar(200)) AS id, CAST(av.text AS nvarchar(4000)) AS refs FROM #TempEdge c, #TempEdge i, #TempEdge iv, #TempEdge a, #TempEdge av WHERE c.id = i.parentid AND UPPER(i.localname) = UPPER(@from) AND i.id = iv.parentid AND c.id = a.parentid AND UPPER(a.localname) = UPPER(@to) AND a.id = av.parentid OPEN fillidrefs_cursor FETCH NEXT FROM fillidrefs_cursor INTO @id, @t WHILE (@@FETCH_STATUS <> -1) BEGIN IF (@@FETCH_STATUS <> -2) BEGIN execute f_idrefs @t, @idtable, @id END FETCH NEXT FROM fillidrefs_cursor INTO @id, @t END CLOSE fillidrefs_cursor DEALLOCATE fillidrefs_cursor Go - This is the sample document that is shredded and the data is stored in the preceding tables.
DECLARE @h int EXECUTE sp_xml_preparedocument @h OUTPUT, ' <Data> <Student id = "s1" name = "Student1" attends = "c1 c3 c6" /> <Student id = "s2" name = "Student2" attends = "c2 c4" /> <Student id = "s3" name = "Student3" attends = "c2 c4 c6" /> <Student id = "s4" name = "Student4" attends = "c1 c3 c5" /> <Student id = "s5" name = "Student5" attends = "c1 c3 c5 c6" /> <Student id = "s6" name = "Student6" /> <Class id = "c1" name = "Intro to Programming" attendedBy = "s1 s4 s5" /> <Class id = "c2" name = "Databases" attendedBy = "s2 s3" /> <Class id = "c3" name = "Operating Systems" attendedBy = "s1 s4 s5" /> <Class id = "c4" name = "Networks" attendedBy = "s2 s3" /> <Class id = "c5" name = "Algorithms and Graphs" attendedBy = "s4 s5"/> <Class id = "c6" name = "Power and Pragmatism" attendedBy = "s1 s3 s5" /> </Data>' INSERT INTO Students SELECT * FROM OPENXML(@h, '//Student') WITH Students INSERT INTO Courses SELECT * FROM OPENXML(@h, '//Class') WITH Courses /* Using the edge table */ EXECUTE fill_idrefs @h, '//Class', 'id', 'attendedby', 'CourseAttendance' SELECT * FROM Students SELECT * FROM Courses SELECT * FROM CourseAttendance EXECUTE sp_xml_removedocument @h