Transacciones en SQL

Hola profe aqui le presento la tarea de Transacciones en SQL.

bueno... ya se hizo costumbre empezar por la redaccion.

Transacciones en SQL confirmacion y revision(commit and rollback)

Primeramente una transaccion es un conjunto de operaciones que seran tratadas como una sola unidad (en SQL).

Las transacciones deben de cumplir con las 4 propiedades fundamentales conocidas como ACID (atomicidad, coherencia, asilamiento y durabilidad)

Una transaccion es una transferencia de dinero o informacion, por ejemplo yo doy(transferir) dinero y ellos me dan(transfieren) un carro por asi decirlo. Esto es una transaccion entre cliente y vendedor.

Transaccion commit

Esta marca el final de una transaccion correcta. Hace que todo lo que modificaste en la base de datos se aga permanente desde el inicio de su ejecucion, liberando recursos que estan en la base de datos mantenidos en la transaccion.

Transaccion rollback

Ahora rollback lo unico que hace es revertir una transaccion explicita o implicita asta el inicio de la misma.

Lo que dice wikipedia:

Una transacción en un sistema de gestión de bases de datos (SGBD), es un conjunto de órdenes que se ejecutan formando una unidad de trabajo, es decir, en forma indivisible o atómica.

Un SGBD se dice transaccional si es capaz de mantener la integridad de los datos, haciendo que estas transacciones no puedan finalizar en un estado intermedio. Cuando por alguna causa el sistema debe cancelar la transacción, empieza a deshacer las órdenes ejecutadas hasta dejar la base de datos en su estado inicial (llamado punto de integridad), como si la orden de la transacción nunca se hubiese realizado.

Para esto, el lenguaje de consulta de datos SQL (Structured query language), provee los mecanismos para especificar que un conjunto de acciones deben constituir una transacción.
BEGIN TRAN: Especifica que va a empezar una transacción.
COMMIT TRAN: Le indica al motor que puede considerar la transacción completada con éxito. ROLLBACK TRAN: Indica que se ha alcanzado un fallo y que debe restablecer la base al punto de integridad.

En un sistema ideal, las transacciones deberían garantizar todas las propiedades ACID; en la práctica, a veces alguna de estas propiedades se simplifica o debilita con vistas a obtener un mejor rendimiento.

Algo importante sobre las transacciones:

Una transaccion es importante en una base de datos ya que esta puede facilitar la comunicacion en la informacion, en la transaccion commit se evalua que no alla ningun error para poder dar seguimiento, y la transaccion rollback se encarga de restaurar la base de datos a su forma original en caso de que alla ocurrido un error en la transaccion. Esto es muy conveniente en el caso de seguridad, por que en una base de datos grande pueden ocurrir errores, pero gracias a esto el sistema puede ser capas de lidiar con estos errores por si solo.

Sintaxis de commit and rollback:

COMMIT { TRAN TRANSACTION } [ transaction_name @tran_name_variable ] ]
[ ; ]

----------------------------------------------------------------------------------------

ROLLBACK { TRAN TRANSACTION }
[ transaction_name @tran_name_variable
savepoint_name @savepoint_variable ]
[ ; ]


Ahora un ejemplo:

Un ejemplo
Trabajaremos con la base de datos Northwind en nuestros ejemplos.
Vamos a realizar una transacción que modifica el precio de dos productos de la base de datos.
USE NorthWind
DECLARE @Error int
--Declaramos una variable que utilizaremos para almacenar un posible código de error
BEGIN TRAN

--Iniciamos la transacción
UPDATE Products SET UnitPrice=20 WHERE ProductName =’Chai’
--Ejecutamos la primera sentencia
SET @Error=@@ERROR
--Si ocurre un error almacenamos su código en @Error
--y saltamos al trozo de código que deshara la transacción. Si, eso de ahí es un
--GOTO, el demonio de los programadores, pero no pasa nada por usarlo
--cuando es necesario
IF (@Error<>0) GOTO TratarError
--Si la primera sentencia se ejecuta con éxito, pasamos a la segunda
UPDATE Products SET UnitPrice=20 WHERE ProductName=’Chang’
SET @Error=@@ERROR
--Y si hay un error hacemos como antes
IF (@Error<>0) GOTO TratarError
--Si llegamos hasta aquí es que los dos UPDATE se han completado con
--éxito y podemos “guardar” la transacción en la base de datos
COMMIT TRAN
TratarError:
--Si ha ocurrido algún error llegamos hasta aquí
If @@Error<>0 THEN
BEGIN
PRINT ‘Ha ecorrido un error. Abortamos la transacción’
--Se lo comunicamos al usuario y deshacemos la transacción
--todo volverá a estar como si nada hubiera ocurrido
ROLLBACK TRAN

END

Como se puede ver para cada sentencia que se ejecuta miramos si se ha producido o no un
error, y si detectamos un error ejecutamos el bloque de código que deshace la transacción.
Hay una interpretación incorrecta en cuanto al funcionamiento de las transacciones que esta
bastante extendida. Mucha gente cree que si tenemos varias sentencias dentro de una
transacción y una de ellas falla, la transacción se aborta en su totalidad.
¡Nada más lejos de la realidad!
Si tenemos dos sentencias dentro de una transacción.

USE NorthWind
BEGIN TRAN
UPDATE Products SET UnitPrice=20 WHERE ProductName=’Chang’
UPDATE Products SET UnitPrice=20 WHERE ProductName=’Chang’

COMMIT TRAN
Estas dos sentencias se ejecutarán como una sola. Si por ejemplo en medio de la transacción
(después del primer update y antes del segundo) hay un corte de electricidad, cuando el SQL
Server se recupere se encontrará en medio de una transacción y, o bien la termina o bien la
deshace, pero no se quedará a medias.
El error está en pensar que si la ejecución de la primera sentencia da un error se cancelará la
transacción. El SQL Server sólo se preocupa de ejecutar las sentencias, no de averiguar si lo
hacen correctamente o si la lógica de la transacción es correcta. Eso es cosa nuestra.
Por eso en el ejemplo que tenemos más arriba para cada sentencia de nuestro conjunto
averiguamos si se ha producido un error y si es así actuamos en consecuencia cancelando
toda la operación.
Transacciones anidadas
Otra de las posibilidades que nos ofrece el SQL Server es utilizar transacciones anidadas.
Esto quiere decir que podemos tener transacciones dentro de transacciones, es decir,
podemos empezar una nueva transacción sin haber terminado la anterior.

Asociada a esta idea de anidamiento existe una variable global @@TRANCOUNT que tiene
valor 0 si no existe ningún nivel de anidamiento, 1 si hay una transacción anidada, 2 si estamos
en el segundo nivel de anidamiento… y así sucesivamente.
La dificultad de trabajar con transacciones anidadas está en el comportamiento que tienen
ahora las sentencias ‘COMMIT TRAN’ y ‘ROLLBACK TRAN’

ROLLBACK TRAN: Dentro de una transacción anidada esta sentencia deshace todas
las transacciones internas hasta la instrucción BEGIN TRANSACTION más externa.
COMMIT TRAN: Dentro de una transacción anidada esta sentencia únicamente reduce
en 1 el valor de @@TRANCOUNT, pero no “finaliza” ninguna transacción ni “guarda” los
cambios. En el caso en el que @@TRANCOUNT=1 (cuando estamos en la última transacción)
COMMIT TRAN hace que todas las modificaciones efectuadas sobre los datos desde el inicio
de la transacción sean parte permanente de la base de datos, libera los recursos mantenidos
por la conexión y reduce @@TRANCOUNT a 0.

Quizás estos dos gráficos nos ayuden a entender el comportamiento de estas
sentencias cuando hay varios niveles de anidamiento
Comportamiento del COMMIT TRAN
Comportamiento de ROLLBACK TRAN
COMMIT TRA N
COMMIT TRA N
COMMIT TRA N
COMMIT TRA N
BEG IN TRA N
BEG IN TRA N
BEG IN TRA N
BEG IN TRA N
@ @ TRA N COU N T
0
1
2
3
4

Como siempre un ejemplo es lo mejor para entender como funciona.
CREATE TABLE Test (Columna int)
GO
BEGIN TRAN TranExterna -- @@TRANCOUNT ahora es 1
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
INSERT INTO Test VALUES (1)
BEGIN TRAN TranInterna1 -- @@TRANCOUNT ahora es 2.
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
INSERT INTO Test VALUES (2)
BEGIN TRAN TranInterna2 -- @@TRANCOUNT ahora es 3.
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
INSERT INTO Test VALUES (3)
COMMIT TRAN TranInterna2 -- Reduce @@TRANCOUNT a 2.

-- Pero no se guarda nada en la base de datos.
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
COMMIT TRAN TranInterna1 -- Reduce @@TRANCOUNT a 1.

-- Pero no se guarda nada en la base de datos.
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
COMMIT TRAN TranExterna -- Reduce @@TRANCOUNT a 0.

-- Se lleva a cabo la transacción externa y todo lo que conlleva.
SELECT ‘El nivel de anidamiento es’, @@TRANCOUNT
SELECT * FROM Test

Por cierto que lo de usar nombre para las transacciones es por claridad, puesto que COMMIT
TRAN como ya hemos dicho solamente reduce en 1 el valor de @@TRANCOUNT.
Veamos ahora un ejemplo de transacción anidada con ROLLBACK TRAN

BEGIN TRAN TranExterna -- @@TRANCOUNT ahora es 1
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (1)
BEGIN TRAN TranInterna1 -- @@TRANCOUNT ahora es 2.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (2)
BEGIN TRAN TranInterna2 -- @@TRANCOUNT ahora es 3.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (3)
ROLLBA CK TRA N
BEG IN TRA N
BEG IN TRA N
BEG IN TRA N
@ @ TRA N COU N T
BEG IN TRA N
0
1
2
3
4

ROLLBACK TRAN --@@TRANCOUNT es 0 y se deshace

--la transacción externa y todas las internas
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
SELECT * FROM Test

En este caso no se inserta nada puesto que el ROLLBACK TRAN deshace todas las
transacciones dentro de nuestro anidamiento hasta la transacción más externa y además hace
@@TRANCOUNT=0

¿Supone este funcionamiento asimétrico del COMMIT y del ROLLBACK un problema?
Pues la verdad es que no. La manera de tratar las transacciones por el SQL Server es la que
nos permite programar de manera natural los anidamientos.
De todos modos, si queremos ir un poco más lejos hay una cuarta sentencia para trabajar con
transacciones: SAVE TRAN

SAVE TRAN
Esta sentencia crea un punto de almacenamiento dentro de una transacción. Esta marca sirve
para deshacer una transacción en curso sólo hasta ese punto. Por supuesto nuestra
transacción debe continuar y terminar con un COMMIN TRAN (o los que hagan falta) para que
todo se guarde o con un ROLLBACK TRAN para volver al estado previo al primer BEGIN
TRAN.

BEGIN TRAN TranExterna -- @@TRANCOUNT ahora es 1
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (1)
BEGIN TRAN TranInterna1 -- @@TRANCOUNT ahora es 2.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (2)
SAVE TRAN Guadada
BEGIN TRAN TranInterna2 -- @@TRANCOUNT ahora es 3.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
INSERT INTO Test VALUES (3)
ROLLBACK TRAN Guadada -- se deshace lo hecho el punto guardado.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT

--Ahora podemos decidir si la transacción se lleva a cabo

--o se deshace completamente

--Para deshacerla un ROLLBACK bastará como hemos visto

--Pero para guardar la transacción hace falta reducir @@TRANCOUNT a 0
COMMIT TRAN TranInterna1 -- Reduce @@TRANCOUNT a 2.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
COMMIT TRAN TranInterna1 -- Reduce @@TRANCOUNT a 1.

-- Pero no se guarda nada en la base de datos.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
COMMIT TRAN TranExterna -- Reduce @@TRANCOUNT a 0.

-- Se lleva a cabo la transacción externa y todo lo que conlleva.
SELECT 'El nivel de anidamiento es',@@TRANCOUNT
SELECT * FROM Test

Si no ponemos el nombre del punto salvado con SAVE TRAN al hacer un ROLLBACK TRAN
se deshace la transacción más externa y @@TRANCOUNT se pone a 0.
Como podemos ver el uso de transacciones no es complicado, e incluso las transacciones
anidadas si se tratan con cuidado son fáciles de manejar. Como siempre si hay alguna duda la
mejor fuente de ejemplos y soluciones son los BOL del SQL Server.

Bueno con esto termino el tema de Transacciones.

A continuacion las Referencias

Para el ejemplo y algunas definiciones use esta pagina:

http://74.125.95.104/search?q=cache:6WZHp7IYuKoJ:www.willydev.net/descargas/transaccionsql.pdf+transacciones+en+sql&hl=es&ct=clnk&cd=6&gl=mx

Como elemento de apoyo use esta pagina que es de wikipedia:

http://es.wikipedia.org/wiki/Transacci%C3%B3n_(base_de_datos)

Y por ultimo en lo que me base para la definicion y sintaxis de commit and rollback:

Para commit:
http://technet.microsoft.com/es-es/library/ms190295.aspx

Para rollback:
http://msdn.microsoft.com/es-es/library/ms181299.aspx

bueno ya le paro por que ya tengo unos cuantos dias sin dormir.

thank for you attention.

chao!!!

sikno `-´