Introduction to Transaction Control

Language
In a Relational Database Management System (RDBMS), the Structured

Query Language (SQL) is used to perform multiple operations to store,

retrieve and manipulate the data across various tables in a database. Let

us consider few scenarios where we might have updated a record

mistakenly and want to restore the data or we have inserted few records

and want to save them, there Transaction Control Language (TCL) comes

into the picture. The Transaction Control Language is used to maintain

the integrity and consistency of the data stored in the database.

Needs of Transaction Control Language

The Transaction Control Language manages the changes in the data

which are made by the DML operations. The alteration made by the DML

commands such as UPDATE, INSERT or DELETE is not permanent and

these changes can be canceled before the present session gets closed.

To control the changes and processing of data, TCL is used

simultaneously with the Data Manipulation Language. As we perform

many operations on the data, the database might become inconsistent

between the transactions.

So the Transaction Control Language (TCL) is used to maintain

consistency and manage the transaction in a database. After the commit

is performed the database state is changed from one to another

consistent state. The Transactions are used on all the DDL and DML

queries automatically.

How does Transaction Control Language Work?

A transaction in a database is a logical unit of processing which may

comprise of one or more database operations. A series of low-level

changes into a logical update are grouped together by using a

transaction. For example, a transaction might be updating a single value

or updating of a complex procedure such as the insertion of multiple

rows to different tables. Normally, a transaction is started and then as

the individual DML commands are executed, they become the part of the

transaction and when the logical procedure is over, the transaction gets
committed. The commit command ensures that the changes are made

permanent in the database. If the commit operation fails, the transaction

gets rolled back and all the changes are removed.

TCL Commands with Examples

The commands in Transaction Control Language are Commit, Rollback,

and Savepoint.

1. COMMIT
This command is used to make a transaction permanent in a database.

So it can be said that commit command saves the work done as it ends

the current transaction by making permanent changes during the

transaction. The syntax for this command is as below.

COMMIT;

For instance, we want to update the location of an employee in the table

“EMPLOYEE”. Sample EMPLOYEE table is given below:

EMP_ID EMP_NAME EMP_LOC

 1356 Raju Delhi

2678 Neeta Bangalore

9899 Sanjay Hyderabad

Let us update the EMP_ LOC for Raju as below:

Query:

UPDATE EMPLOYEE SET EMP_ LOC = 'Hyderabad' WHERE EMP_NAME=

'Raju';
COMMIT;

The update transaction is completed with the commit command as

above and the usage of the above statements will update the location of

the employee ‘Raju’ and the change will be saved in the database

permanently.

The updated table is as shown below:

EMP_ID EMP_NAME EMP_LOC

 1356 Raju Hyderabad

2678 Neeta Bangalore

9899 Sanjay Hyderabad

2. ROLLBACK
This command is used to restore the database to its original state since

the last command that was committed. The syntax of the Rollback

command is as below:

ROLLBACK;

Also, the ROLLBACK command is used along with savepoint command to

leap to a save point in a transaction. The syntax for the same is as below:

ROLLBACK TO <savepoint_name>;

Let us take the example of the EMPLOYEE table as cited above. Let us

consider that we have updated EMP_LOC for Raju to Bangalore later and

realize that the update was done mistakenly as below. Then we can
restore the EMP_LOC for ‘Raju’ to Hyderabad again by using the Rollback

command as below.

Query:

UPDATE EMPLOYEE SET EMP_LOC= 'Bangalore' WHERE EMP_NAME =

'Raju';
ROLLBACK;

After the wrong update the table is as below:

EMP_ID EMP_NAME EMP_LOC

1356 Raju Bangalore

2678 Neeta Bangalore

9899 Sanjay Hyderabad

After the Rollback is performed, the location for Raju is restored to the

last committed state as shown below.

EMP_ID EMP_NAME EMP_LOC

 1356 Raju Hyderabad

2678 Neeta Bangalore

9899 Sanjay Hyderabad

3. SAVEPOINT
This command is used to save the transaction temporarily. So the users

can rollback to the required point of the transaction. The syntax for using

this command is as below:

SAVEPOINT savepoint_name;

Let us take the example of a table “ORDERS” with columns as ORDER_ID

and ITEM_NAME.

ORDER_ID ITEM_NAME

199 TELEVISION

290 CAMERA
Let us insert the below values to the ORDERS table below and perform

the updates using savepoint.

Query:

INSERT INTO ORDERS VALUES ('355' , 'CELL PHONE');

COMMIT;
UPDATE ORDERS SET ITEM_NAME = 'SMART PHONE' WHERE ORDER_ID=
'355';
SAVEPOINT A;
INSERT INTO ORDERS VALUES ('566' , 'BLENDER');
SAVEPOINT B;
Now the ORDERS table will be as below:

Now the ORDERS table will be as below:

ORDER_ID ITEM_NAME

199 TELEVISION

290 CAMERA

355 SMART PHONE

566 BLENDER
Now we can use the SAVEPOINT command to Rollback the transaction.

Let us Rollback the transaction to savepoint A.

Query:

ROLLBACK TO A;

The ORDERS table will be as below:

ORDER_ID ITEM_NAME

199 TELEVISION

290 CAMERA

355 SMART PHONE

Advantages of Transaction Control Language

The Transaction Control Language provides the privilege to rollback the

transaction if the data is updated in the tables by mistake. It performs a

permanent change to the database by locking the data using the commit
command. Also with the help of savepoint command, users can save the

transactions temporarily and if required, can also perform rollback using

the savepoint.

Conclusion
Transaction Control Language helps in maintaining the consistency and

integrity of the data. The database can be restored to the last committed

state as well as modifications made can be saved permanently with the

help of TCL. The developers should have a keen understanding of TCL to

build a robust system.