Export (0) Print
Expand All
15 out of 19 rated this helpful - Rate this topic

Using OPENXML

SQL Server 2000

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.

Here are the steps:

  1. 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
    
  2. 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
    
  3. 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
    

See Also

sp_xml_preparedocument

sp_xml_removedocument

OPENXML

Writing XML Using OPENXML

Did you find this helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft. All rights reserved.