En tecnologías de base de datos,
un rollback es una operación que devuelve a la base de datos a algún estado
previo. Los Rollbacks son importantes para la integridad de la base de datos, a
causa de que significan que la base de datos puede ser restaurada a una copia
limpia incluso después de que se han realizado operaciones erróneas. Son
cruciales para la recuperación de crashes de un servidor de base de datos;
realizando rollback(devuelto) cualquier transacción que estuviera activa en el
tiempo del crash, la base de datos es restaurada a un estado consistente.
En SQL, ROLLBACK es un comando que causa que
todos los cambios de datos desde la última sentencia BEGIN WORK, o START
TRANSACTION sean descartados por el sistema de gestión de base de datos
relacional (RDBMS), para que el estado de los datos sea "rolled
back"(devuelto) a la forma en que estaba antes de que aquellos cambios
tuvieran lugar.
Una sentencia ROLLBACK también publicará
cualquier savepoint existente que pudiera estar en uso.
En muchos dialectos de SQL, ROLLBACKs son
específicos de la conexión. Esto significa que si se hicieron dos conexiones a
la misma base de datos, un ROLLBACK hecho sobre una conexión no afectará a
cualesquiera otras conexiones. Esto es vital para el buen funcionamiento de la
Concurrencia.
A funcionalidad de rollback está normalmente
implementada con un Log de transacciones, pero puede también estar implementada
mediante control de concurrencia.
Hacer un recovery en MySQL
Si queremos realizar una copia de seguridad desde entornos
Windows, deberemos utilizar la línea de comandos ("cmd"). Para abrir
la línea de comandos en Windows podemos ir al menú Inicio>Ejecutar, escribir
cmd y pulsar enter). Se nos abrir la línea de comandos de Windows. Ahora hemos
de situarnos en la carpeta donde tenemos instalados los binarios de MySQL por
ejemplo: c:\mysql\bin (esta ruta depende de donde instalaste MYSQL) y
escribimos el mismo comando que en linux:
mysqldump --opt -u nombredeusuario -p basededatos tabla1
> archivodebackup.txt
Recovery de una base
de datos InnoDB
Para una base de datos transaccional (de tipo InnoDB o BDB)
y de gran tamaño, se
puede utilizar este comando
mysqldump --opt -q --single-transaction -u nombredeusuario
-p basededatos tabla1 >
archivodebackup.txt
El parámetro -q es útil para bases de datos de gran tamaño.
mysql> CREATE TABLE innotest (campo INT NOT NULL
PRIMARY KEY) TYPE = InnoDB;
Query OK, 0 rows affected (0.10 sec)
mysql> INSERT INTO innotest VALUES(1);
Query OK, 1 row affected (0.08 sec)
mysql> INSERT INTO innotest VALUES(2);
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO innotest VALUES(3);
Query OK, 1 row affected (0.04 sec)
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
+-------+
3 rows in set (0.00 sec)
De
acuerdo, nada espectacular. Ahora veamos como usar transacciones.
mysql> BEGIN;
Query OK, 0 rows affected (0.01 sec)
mysql> INSERT INTO innotest VALUES(4);
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
| 4 |
+-------+
4 rows in set (0.00 sec)
Si en
este momento ejecutamos un ROLLBACK, la transacción no será completada, y los
cambios realizados sobre la tabla no tendrán efecto.
mysql> ROLLBACK;
Query OK, 0 rows affected (0.06 sec)
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
+-------+
3 rows in set (0.00 sec)
Ahora
vamos a ver que sucede si perdemos la conexión al servidor antes de que la
transacción sea completada.
mysql> BEGIN;
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO innotest VALUES(4);
Query OK, 1 row affected (0.00 sec)
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
| 4 |
+-------+
4 rows in set (0.00 sec)
mysql> EXIT;
Bye
Cuando
obtengamos de nuevo la conexión, podemos verificar que el registro no se
insertó, ya que la transacción no fue completada.
Welcome to the MySQL monitor. Commands end with ; or g.
Your MySQL connection id is 449 to server version:
4.0.13
Type 'help;' or 'h' for help. Type 'c' to clear the
buffer.
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
+-------+
3 rows in set (0.00 sec)
Ahora
vamos a repetir la sentencia INSERT ejecutada anteriormente, pero haremos un
COMMIT antes de perder la conexión al servidor al salir del monitor de MySQL.
mysql> BEGIN;
Query OK, 0 rows affected (0.00 sec)
mysql> INSERT INTO innotest VALUES(4);
Query OK, 1 row affected (0.00 sec)
mysql> COMMIT;
Query OK, 0 rows affected (0.02 sec)
mysql> EXIT;
Bye
Una vez
que hacemos un COMMIT, la transacción es completada, y todas las sentencias SQL
que han sido ejecutadas previamente afectan de manera permanente a las tablas
de la base de datos.
Welcome to the MySQL monitor. Commands end with ; or g.
Your MySQL connection id is 450 to server version:
4.0.13
Type 'help;' or 'h' for help. Type 'c' to clear the
buffer.
mysql> SELECT * FROM innotest;
+-------+
| campo |
+-------+
| 1 |
| 2 |
| 3 |
| 4 |
+-------+
4 rows in set (0.00 sec)
mysql> CREATE TABLE ventas(
-> id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
-> producto VARCHAR(30) NOT NULL,
-> cantidad TINYINT NOT NULL) TYPE = InnoDB;
Query OK, 0 rows affected (0.96 sec)
Insertamos un registro.
mysql> INSERT INTO ventas VALUES(0,'Gansito marinela',3);
Query OK, 1 row affected (0.16 sec)
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 3 |
+----+------------------+----------+
1 row in set (0.01 sec)
Ahora vamos a iniciar una
transacción con la sentencia BEGIN.
mysql> BEGIN;
Query OK, 0 rows affected (0.00 sec)
Actualizamos el registro.
mysql> UPDATE ventas SET cantidad=4 WHERE id=1;
Query OK, 1 row affected (0.07 sec)
Líneas correspondientes: 1 Cambiadas: 1 Avisos: 0
Verificamos que los cambios han
sucedido.
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 4 |
+----+------------------+----------+
1 row in set (0.00 sec)
Si queremos deshacer los
cambios, entonces ejecutamos un ROLLBACK.
mysql> ROLLBACK;
Query OK, 0 rows affected (0.06 sec)
Verificamos que se deshicieron
los cambios.
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 3 |
+----+------------------+----------+
1 row in set (0.00 sec)
Vamos a actualizar el registro
usando otra transacción.
mysql> BEGIN;
Query OK, 0 rows affected (0.00 sec)
mysql> UPDATE ventas SET cantidad=2 WHERE id=1;
Query OK, 1 row affected (0.00 sec)
Líneas correspondientes: 1 Cambiadas: 1 Avisos: 0
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 2 |
+----+------------------+----------+
1 row in set (0.00 sec)
Vamos a confirmar que deseamos
los cambios.
mysql> COMMIT;
Query OK, 0 rows affected (0.05 sec)
En este momento los cambios son
permanentes y definitivos.
mysql> SELECT * FROM ventas;
+----+------------------+----------+
| id | producto | cantidad |
+----+------------------+----------+
| 1 | Gansito marinela | 2 |
+----+------------------+----------+
1 row in set (0.00 sec)
Oracle
Declaraciones de control de
transacciones gestionar los cambios realizados por las sentencias DML.
¿Qué es una transacción?
Una transacción es un conjunto de
sentencias SQL de Oracle, que traten como una sola unidad. Es decir, todos los
estados deben llevar a cabo con éxito o ninguna de las sentencias se ejecutan
debería.
Para el control de las transacciones
de Oracle no hace permanente instrucciones DML a menos que lo cometió. Si no
confirmar la transacción y que se apague o se bloquea el sistema entonces la
transacción es respaldada rollo.
Declaraciones TCL disponibles en
Oracle son
COMMIT: Hacer cambios realizados
en la transacción permanente.
ROLLBACK: Revertir el estado de
la base de datos para el último punto de confirmación.
SAVEPOINT: Se utiliza para
especificar un punto en operación a la que más tarde puede revertir.
COMMIT
Para que los cambios realizados
en un número de transacción permanente la sentencia COMMIT.
La sintaxis de la sentencia
COMMIT es
COMMIT [WORK] [COMENTARIO 'tu
comentario "];
De trabajo es opcional.
COMENTARIO también es opcional,
especifique esta opción si desea identificar la transacción en DBA_2PC_PENDING
diccionario de datos.
Ejemplo
insertar en emp (empno, Ename,
sal) valores (101, 'Abid', 2300);
cometerlo;
ROLLBACK
Para deshacer los cambios realizados en una
transacción de dar rollback comunicado. Rollback restaurar el estado de la base
de datos para el último punto de confirmación.
Ejemplo:
eliminar de emp;
rollback / * deshacer los cambios
* /
SAVEPOINT
Especifique un punto de una
operación a la que más tarde se puede deshacer.
Ejemplo
insertar en emp (empno, Ename,
sal) values (109, 'Sami', 3000);
un punto de retorno;
insertar en los valores dept (10,
'Ventas', 'Hyd');
punto de retorno b;
insertar en los valores SALGRADE
('III', 9000,12000);
Ahora, si se le da
revertir a una;
Entonces fila de SALGRADE mesa y
sección será respaldado por rodar. Ahora usted puede cometer la fila insertada
en la tabla emp o deshacer la transacción.
Si usted le da
rollback para b;
A continuación, la fila se
inserta en la tabla SALGRADE será respaldado por rollo. Ahora usted puede
cometer la fila insertada en dept tabla y la tabla emp o revertir a un punto de
retorno o rodar completamente respaldado la transacción.
Si usted le da
rollback;
Entonces las transacciones
completas se rollo respaldó.
Si usted le da
cometerlo;
No hay comentarios:
Publicar un comentario