Llamar a una operación de reversión deshace todos los efectos o modificaciones que ha realizado una Transacción (T i ) y finaliza la Ti y todas las variables obtienen sus valores anteriores almacenados. La reversión se llama principalmente cuando obtiene una o más de una excepción de SQL en las declaraciones de Transaction (T i ), luego T i se aborta y comienza de nuevo desde el principio. Esta es la única forma de saber qué se ha cometido y qué no.
Una excepción de SQL simplemente indica que algo está mal en su declaración que ha escrito, pero no menciona qué y dónde se ha hecho mal. Entonces, la única opción que le queda es llamar a un método de reversión.
Procedimiento: Se trata principalmente de dos pasos. Primero, crea una base de datos y luego trata con las transacciones.
- crear una base de datos
- Ejecutar las transacciones para la reversión
- Importar la base de datos
- Cargue y registre los controladores si es necesario
- Crear una nueva conexión
- Crear una declaración para compromiso/reversión
- Ejecute la consulta para confirmar/revertir
- Procesar los resultados
- Cierre la conexión, de lo contrario, el procesamiento anterior puede perderse, si corresponde.
Paso 1: También podemos deshacer las modificaciones en la base de datos hasta un indicador en particular o un punto de guardado con solo pasar el nombre de los puntos de guardado necesarios como parámetro en el siguiente método:
// Set the Flag or Save point
con.rollback("MysavePoint");
Paso 2. Para deshacer una transacción: Cargue el controlador JDBC, utilizando el método de la API para el nombre (String className) de la clase. En este ejemplo, estamos usando Oracle
- Registre el controlador requerido usando el método registerDriver()
// To register the needed Driver DriverManager.registerDriver(new com.mysql.jdbc.Driver());
- Obtenga la información de conexión utilizando el método API getConnection() de DriverManager:
// For getting the connection String url = "jdbc:mysql://localhost/mydatabase/icpc"; Connection conn = DriverManager.getConnection(string url, String user, String password);
- Deshabilite la confirmación automática utilizando el método API del método setAutoCommit(boolean auto-commit) fuera de conexión como:
// Set the auto commit false. This will execute all // SQL statements as individual transactions con.setAutoCommit(false);
- Ahora, establezca el punto de guardado usando setSavepoint() o confirme la transacción usando el método API commit() de conexión como se muestra a continuación:
Savepoint savePoint = con.setSavepoint("MysavePoint");
Con.commit();
- Si se encuentra alguna excepción SQL, entonces, en ese caso, invoque el método API rollback( ) para toda la transacción hasta el punto de guardado previamente establecido:
con.rollback() Or, con. rollback(my_Savepoint);
Implementación: el programa Java para demostrar tanto el programa rollback() como commit() es el siguiente
Java
// Importing generic java libraries
import java.io.*;
// Retrieving SQL DB
// javaconnector-linkage for JDBC
import java.sql.*;
import java.sql.SQLException;
import java.sql.DriverManager;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Date;
// Importing drivers(if necessarily)
// GFG class only to illustrate JDBC
// not illustrating connection class
class GFG {
/* Step 1: Importing DB */
// Database URL so as to create/fetch data from DB
static String DB_URL
= "jdbc:oracle:thin:@localhost/my_database_";
// DB userID
static String DB_USER = "local";
// Remember randomly self createdDB password
// to deal with above DB root
static String DB_PASSWORD = "test";
// Main driver method
public static void main(String args[])
{
// Try block to check exceptions if occurs
try {
/* Step 2: Loading and registering drivers*/
Class.forName(
"oracle.jdbc.driver.OracleDriver");
/* Step 3: Create the new connection */
Connection conn = DriverManager.getConnection(
DB_URL, DB_USER, DB_PASSWORD);
// set auto commit of the connection to false
conn.setAutoCommit(false);
/* Step 4: Create a statement */
// Input the info into record
String sql_
= "INSERT INTO Employee (empid, empname) VALUES (?, ?)";
// Create a Statement_object
PreparedStatement ps
= conn.prepareStatement(sql_);
/* Step 5: Execute a query */
// Take user input
BufferedReader br = new BufferedReader(
new InputStreamReader(System.in));
while (true) {
// Asking user to enter data(EmpID)
System.out.print("Enter emp_Id: ");
// Reading above user entered EmpID
String s_1 = br.readLine();
int empid = Integer.parseInt(s_1);
// Asking user to enter data(EmpName)
System.out.print("Enter emp_name: ");
// Reading above user entered EmpName
String name = br.readLine();
// Creating entry in table
// Set emp_id
ps.setInt(1, empid);
// Set emp_name
ps.setString(2, name);
// Execute the updation operation
ps.executeUpdate();
/* Step 6: Process the results */
/* Displaying choice what user wants to do
with updation, either Commit() or
rollback() */
System.out.println("commit or rollback");
// Reading choice from user
String answer = br.readLine();
/* Asking user's choice for condition
* check*/
/* Checking if users want to commit or
* rollback */
// If user wants to commit
if (answer.equals("commit")) {
conn.commit();
}
// If user wants to rollback
if (answer.equals("rollback")) {
// Rollback the update in case if some
// flaw in your record
conn.rollback();
}
/* Display message to user for inputing next
record if user wants to add */
System.out.println(
"Do you want to include more records");
/* Asking choice */
System.out.println("\n yes/no");
// Read user's choice
String answ = br.readLine();
if (answ.equals("no")) {
break;
}
}
conn.commit();
// Print message
System.out.println(
"record is successfully saved");
/* Step 7: Close the connection */
// calling commit() before closing connection
// else updation would be lost
conn.close();
}
// Exception handled if occurred by catch block
catch (Exception exc) {
// Highlighting line where exception occurred
// as execution is equal
exc.printStackTrace();
}
}
}
Salida: hay dos imágenes de salida de muestra que cubren ambos casos: confirmación y reversión o simplemente reversión directa, como se ilustra en las siguientes salidas.
Publicación traducida automáticamente
Artículo escrito por madhav_mohan y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA