Transacciones en Transact SQL

Concepto de transaccion
Una transaccin es un conjunto de operaciones Transact SQL que se ejecutan como un nico bloque, es decir, si falla una operacin Transact SQL fallan todas. Si una transaccin tiene xito, todas las modificaciones de los datos realizadas durante la transaccin se confirman y se convierten en una parte permanente de la base de datos. Si una transaccin encuentra errores y debe cancelarse o revertirse, se borran todas las modificaciones de los datos. El ejemplo clsico de transaccin es una transferencia bancaria, en la que quitamos saldo a una cuenta y lo aadimos en otra. Si no somo capaces de abonar el dinero en la cuenta de destino, no debemos quitarlo de la cuenta de origen. SQL Server funciona por defecto con Transacciones de confirmacin automtica , es decir, cada instruccin individual es una transaccin y se confirma automticamente. Sobre el ejemplo anterior de la transferencia bancaria, un script debera realizar algo parecido a los siguiente:

DECLARE @importe DECIMAL(18,2), @CuentaOrigen VARCHAR(12), @CuentaDestino VARCHAR(12) /* Asignamos el importe de la transferencia * y las cuentas de origen y destino */ SET @importe = 50 SET @CuentaOrigen = '200700000001' SET @CuentaDestino = '200700000002'

/* Descontamos el importe de la cuenta origen */ UPDATE CUENTAS SET SALDO = SALDO - @importe WHERE NUMCUENTA = @CuentaOrigen

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen

/* Incrementamos el importe de la cuenta destino */ UPDATE CUENTAS SET SALDO = SALDO + @importe WHERE NUMCUENTA = @CuentaDestino

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino Esta forma de actuar seria erronea, ya que cada instruccin se ejecutaria y confirmara de forma independiente, por lo que un error dejara los datos erroneos en la base de datos ( y ese es el peor error que nos podemos encontrar! )

Transacciones implicitas y explicitas

Para agrupar varias sentencias Transact SQL en una nica transaccin, disponemos de los siguientes mtodos:

Transacciones explcitas
Cada transaccin se inicia explcitamente con la instruccin BEGIN TRANSACTION y se termina explcitamente con una instruccin COMMIT o ROLLBACK.

Transacciones implcitas

Se inicia automtivamente una nueva transaccin cuando se ejecuta una instruccin que realiza modificaciones en los datos, pero cada transaccin se completa explcitamente con una instruccin COMMIT o ROLLBACK. Para activar-desactivar el modo de transacciones implicitas debemos ejecutar la siguiente instruccin.

--Activamos el modo de transacciones implicitas SET IMPLICIT_TRANSACTIONS ON

--Desactivamos el modo de transacciones implicitas SET IMPLICIT_TRANSACTIONS OFF Cuando la opcin ANSI_DEFAULTS est establecida en ON, IMPLICIT_TRANSACTIONS tambin se establece en ON. El siguiente ejemplo muestra el script anterior haciendo uso de transacciones explicitas.

DECLARE @importe DECIMAL(18,2), @CuentaOrigen VARCHAR(12), @CuentaDestino VARCHAR(12)

/* Asignamos el importe de la transferencia * y las cuentas de origen y destino */ SET @importe = 50 SET @CuentaOrigen = '200700000002' SET @CuentaDestino = '200700000001'

BEGIN TRANSACTION -- O solo BEGIN TRAN BEGIN TRY /* Descontamos el importe de la cuenta origen */ UPDATE CUENTAS SET SALDO = SALDO - @importe WHERE NUMCUENTA = @CuentaOrigen

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen

/* Incrementamos el importe de la cuenta destino */ UPDATE CUENTAS SET SALDO = SALDO + @importe WHERE NUMCUENTA = @CuentaDestino

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR,

IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino

/* Confirmamos la transaccion*/ COMMIT TRANSACTION -- O solo COMMIT

END TRY BEGIN CATCH /* Hay un error, deshacemos los cambios*/ ROLLBACK TRANSACTION -- O solo ROLLBACK PRINT 'Se ha producido un error!' END CATCH

El siguiente ejemplo muestra el mismo script con transacciones implicitas.

SET IMPLICIT_TRANSACTIONS ON

DECLARE @importe DECIMAL(18,2), @CuentaOrigen VARCHAR(12), @CuentaDestino VARCHAR(12)

/* Asignamos el importe de la transferencia * y las cuentas de origen y destino */ SET @importe = 50 SET @CuentaOrigen = '200700000002' SET @CuentaDestino = '200700000001'

BEGIN TRY /* Descontamos el importe de la cuenta origen */ UPDATE CUENTAS SET SALDO = SALDO - @importe WHERE NUMCUENTA = @CuentaOrigen

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO + @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaOrigen

/* Incrementamos el importe de la cuenta destino */

UPDATE CUENTAS SET SALDO = SALDO + @importe WHERE NUMCUENTA = @CuentaDestino

/* Registramos el movimiento */ INSERT INTO MOVIMIENTOS (IDCUENTA, SALDO_ANTERIOR, SALDO_POSTERIOR, IMPORTE, FXMOVIMIENTO) SELECT IDCUENTA, SALDO - @importe, SALDO, @importe, getdate() FROM CUENTAS WHERE NUMCUENTA = @CuentaDestino

/* Confirmamos la transaccion*/ COMMIT TRANSACTION -- O solo COMMIT END TRY BEGIN CATCH /* Hay un error, deshacemos los cambios*/ ROLLBACK TRANSACTION -- O solo ROLLBACK PRINT 'Se ha producido un error!' END CATCH

La transaccin sigue activa hasta que emita una instruccin COMMIT o ROLLBACK. Una vez que la primera transaccin se ha confirmado o revertido, se inicia automticamente una nueva transaccin la siguiente vez que la conexin ejecuta una instruccion para modificar datos.

La conexin contina generando transacciones implcitas hasta que se desactiva el modo de transacciones implcitas. Podemos verificar el nmero de transacciones activas a travs de @@TRANCOUNT.

SET IMPLICIT_TRANSACTIONS ON BEGIN TRY UPDATE CUENTAS SET FXALTA = FXALTA - 1 PRINT @@TRANCOUNT COMMIT END TRY BEGIN CATCH ROLLBACK PRINT 'Error' END CATCH Otro punto a tener en cuenta cuando trabajamos con transacciones son los bloqueos y el nivel de aislamiento. Podemos aprender ms sobre bloqueos y nivel de aislamiento en este articulo.

Transacciones anidadas.
Podemos anidar varias transacciones. Cuando anidamos varias transacciones la instruccin COMMIT afectar a la ltima transaccin abierta, pero ROLLBACK afectar a todas las transacciones abiertas. Un hecho a tener en cuenta, es que, si hacemos ROLLBACK de la transaccin superior se desharan tambin los cambios de todas las transacciones internas, aunque hayamos realizado COMMIT de ellas.

BEGIN TRAN

UPDATE EMPLEADOS SET NOMBRE = 'Devjoker'

WHERE ID=101

BEGIN TRAN

UPDATE EMPLEADOS SET APELLIDO1 = 'Devjoker.COM' WHERE ID=101

-- Este COMMIT solo afecta a la segunda transaccion. COMMIT

-- Este ROLLBACK afecta a las dos transacciones. ROLLBACK

Una consideracin a tener en cuanta cuando trabajamos con transacciones anidadas es la posibilidad de utilizar puntos de guardado o SAVEPOINTs.

Puntos de recuperacion (SavePoint).

Los puntos de recuperacin (SavePoints) permiten manejar las transacciones por pasos, pudiendo hacer rollbacks hasta un punto marcado por el savepoint y no por toda la transaccin. El siguiente ejemplo muestra como trabajar con puntos de recuperacin.

BEGIN TRAN

UPDATE EMPLEADOS

SET NOMBRE = 'Devjoker' WHERE ID=101

UPDATE EMPLEADOS SET APELLIDO1 = 'Devjoker.COM' WHERE ID=101

SAVE TRANSACTION P1 -- Guardamos la transaccion (Savepoint)

UPDATE EMPLEADOS SET APELLIDO1 = 'Otra cosa!' WHERE ID=101

-- Este ROLLBACK afecta solo a las instrucciones -- posteriores al savepoint P1. ROLLBACK TRANSACTION P1

-- Confirmamos la transaccion COMMIT

Using OPENXML
SQL Server 2000 11 out of 21 rated this helpful - Rate this topic 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, seeOPENXML. 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 (attributecentric 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 inSchemaDeclaration. 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 ---------VINET LILAS ContactName -------------------Paul Henriot 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 elementcentric 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 ---------VINET LILAS ContactName -------------------Paul Henriot 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 elementcentric 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. rowpatternidentifies 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 elementcentric 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 ---------VINET LILAS ContactName -------------------Paul Henriot 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 inSchemaDeclaration. In SchemaDeclaration (in the WITH clause), the rowset column names, oid and amount, match the corresponding XML attribute names. Therefore, theColPattern parameter is not specified. For the comment column in the rowset, the XPath function (text()) is specified as ColPattern. This overwrites theattribute-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 ----O1 O2 O3 O4 amount ----------3.5 13.4 100.0 10000.0 comment ----------------------------NULL Customer was very satisfied Happy Customer. 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 ----O1 O2 O3 O4 date --------------------------1996-01-20 00:00:00.000 1997-04-30 00:00:00.000 1999-07-14 00:00:00.000 1996-01-20 00:00:00.000 amount ---------3.5 13.4 100.0 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 ----------11 42 72 Qty ----------12 10 3 OID ------10248 10248 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 theattendedBy 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: 2. DROP TABLE CourseAttendance 3. DROP TABLE Students 4. DROP TABLE Courses 5. GO 6. CREATE TABLE Students( 7. id varchar(5) primary key, 8. name varchar(30) 9. ) 10. GO 11. CREATE TABLE Courses( 12. id varchar(5) primary key, 13. name varchar(30), 14. taughtBy varchar(5) 15. ) 16. GO 17. CREATE TABLE CourseAttendance( 18. id varchar(5) references Courses(id), 19. attendedBy varchar(5) references Students(id), 20. constraint CourseAttendance_PK primary key (id, attendedBy) 21. )

22. go 23. Create these stored procedures: 24. DROP PROCEDURE f_idrefs 25. GO 26. CREATE PROCEDURE f_idrefs 27. @t varchar(500), 28. @idtab varchar(50), 29. @id varchar(5) 30. AS 31. DECLARE @sp int 32. DECLARE @att varchar(5) 33. SET @sp = 0 34. WHILE (LEN(@t) > 0) 35. BEGIN 36. SET @sp = CHARINDEX(' ', @t+ ' ') 37. SET @att = LEFT(@t, @sp-1) 38. EXEC('INSERT INTO '+@idtab+' VALUES ('''+@id+''', '''+@att+''')') 39. SET @t = SUBSTRING(@t+ ' ', @sp+1, LEN(@t)+1-@sp) 40. END 41. Go 42. 43. DROP PROCEDURE fill_idrefs 44. GO 45. CREATE PROCEDURE fill_idrefs 46. @xmldoc int, 47. @xpath varchar(100), 48. @from varchar(50), 49. @to varchar(50), 50. @idtable varchar(100) 51. AS 52. DECLARE @t varchar(500) 53. DECLARE @id varchar(5) 54. 55. /* Temporary Edge table */ 56. SELECT * 57. INTO #TempEdge 58. FROM OPENXML(@xmldoc, @xpath) 59. 60. DECLARE fillidrefs_cursor CURSOR FOR 61. SELECT CAST(iv.text AS nvarchar(200)) AS id, 62. CAST(av.text AS nvarchar(4000)) AS refs 63. FROM #TempEdge c, #TempEdge i, 64. #TempEdge iv, #TempEdge a, #TempEdge av 65. WHERE c.id = i.parentid 66. AND UPPER(i.localname) = UPPER(@from) 67. AND i.id = iv.parentid 68. AND c.id = a.parentid 69. AND UPPER(a.localname) = UPPER(@to) 70. AND a.id = av.parentid 71. 72. OPEN fillidrefs_cursor 73. FETCH NEXT FROM fillidrefs_cursor INTO @id, @t 74. WHILE (@@FETCH_STATUS <> -1) 75. BEGIN 76. IF (@@FETCH_STATUS <> -2) 77. BEGIN

78. execute f_idrefs @t, @idtable, @id 79. END 80. FETCH NEXT FROM fillidrefs_cursor INTO @id, @t 81. END 82. CLOSE fillidrefs_cursor 83. DEALLOCATE fillidrefs_cursor 84. Go 85. This is the sample document that is shredded and the data is stored in the preceding tables. 86. DECLARE @h int 87. EXECUTE sp_xml_preparedocument @h OUTPUT, ' 88. <Data> 89. <Student id = "s1" name = "Student1" attends = "c1 c3 c6" /> 90. <Student id = "s2" name = "Student2" attends = "c2 c4" /> 91. <Student id = "s3" name = "Student3" attends = "c2 c4 c6" /> 92. <Student id = "s4" name = "Student4" attends = "c1 c3 c5" /> 93. <Student id = "s5" name = "Student5" attends = "c1 c3 c5 c6" /> 94. <Student id = "s6" name = "Student6" /> 95. 96. <Class id = "c1" name = "Intro to Programming" 97. attendedBy = "s1 s4 s5" /> 98. <Class id = "c2" name = "Databases" 99. attendedBy = "s2 s3" /> 100. <Class id = "c3" name = "Operating Systems" 101. attendedBy = "s1 s4 s5" /> 102. <Class id = "c4" name = "Networks" attendedBy = "s2 s3" /> 103. <Class id = "c5" name = "Algorithms and Graphs" 104. attendedBy = "s4 s5"/> 105. <Class id = "c6" name = "Power and Pragmatism" 106. attendedBy = "s1 s3 s5" /> 107. </Data>' 108. 109. INSERT INTO Students SELECT * FROM OPENXML(@h, '//Student') WITH Students 110. 111. INSERT INTO Courses SELECT * FROM OPENXML(@h, '//Class') WITH Courses 112. /* Using the edge table */ 113. EXECUTE fill_idrefs @h, '//Class', 'id', 'attendedby', 'CourseAttendance' 114. 115. SELECT * FROM Students 116. SELECT * FROM Courses 117. SELECT * FROM CourseAttendance 118. EXECUTE sp_xml_removedocument @h