SQL and PLSQL » SQL Transactions

Autonomous Transactions in PL/SQL -Autonomous Transactions

globinch-sql-plsql — Tue, 04 Nov 2008 11:54:00 +0000

Before going through this article it will be helpful to read SQL – Transaction Statements -Transaction Management… and Savepoints In SQL Transactions. – SAVEPOINT to know more about SQL transactions.
Autonomous transactions are independent transactions that can be called from within another transaction.
This allows you to leave the calling transaction and do some SQL operations, commit or rollback those operations, and return to the calling transaction’s context and continue with that transaction.Only committed data can be shared by both transactions.
The following is a simple example to explain Autonomous transactions.

Create a table using the following script.

SQL> create table Mytable (name varchar2(100), msg varchar2(500), id number);

Now create a small procedure using the following script.
The procedure will be executed under an autonomous transaction.
(This transaction will be independent of the parent transaction.)


create or replace procedure Autonomous_Example is

PRAGMA  AUTONOMOUS_TRANSACTION;
begin
insert into MyTable(name,msg,id) values('Abcd2','Inside Autonomous',4);
insert into MyTable(name,msg,id) values('Abcd2','Inside Autonomous',5);
commit;

end Autonomous_Example;

Here the keyword PRAGMA is a compiler directive.

Now executes the following TEST script

-- Created on 11/4/2008 by Globinch PLSQLTIPS
declare
-- Local variables here

begin
-- Test statements here
insert into MyTable(name,msg,id) values('Abcd','Outside Autonomous',1);
Autonomous_Example();
commit;
end;

This will create 3 rows in MyTable.

Now remove the records from MyTable

SQL> delete from mytable;
3 rows deleted

SQL> commit;
Commit complete
SQL>

Now change the TEST script as follows

-- Created on 11/4/2008 by Globinch PLSQLTIPS
declare
-- Local variables here

begin

-- Test statements here
insert into MyTable(name,msg,id) values('Abcd','Outside Autonomous',1);

Autonomous_Example();
rollback;
end;

See the above script,we have added a rollback statement
instead of COMMIT to rollback the current transaction.
This will not have any effect to the autonomous transaction in procedure Autonomous_Example.

This will create only 2 rows in MyTable as seen below.

This is because the ROLLBACK performed in the script (Main transaction) has no effect on the
Autonomous Transactions declared inside the procedure Autonomous_Example.
There are no limits on how many levels of autonomous transactions can be called in a chain.
The autonomous transaction can be declared in the following ,
1.Stored procedure
2.Function
3.Package
4.Type method
5.Top-level anonymous block

SQL – Transaction Statements -Transaction Management

globinch-sql-plsql — Tue, 04 Nov 2008 09:09:00 +0000

A Transaction ensures that the action of a group of statements is atomic.A transaction is a logical unit of work that contains one or more SQL statements.The effects of all the SQL statements in a transaction can be either all committed or all rolled back.

SQL>  create table MyTable (name varchar2(100),address varchar2(500),id number);
Table created
SQL>

Let us start with a simple transaction example.Here the transaction inserts a row of record to MyTable.

-- Created on 11/4/2008 by Globinch PLSQLTIPS
declare
  -- Local variables here
begin
  -- Test statements here
  insert into MyTable(name,address,id) values('Abcd','address1',1);
  commit;
end;

The above piece of code represents a single transaction.The row inserted into MyTable became permanent after the COMMIT statement.
Let us query MyTable.

SQL> select * from Mytable;
NAME                       ADDRESS                  ID
Abcd                        address1                     1
SQL>

The following example show two simple transactions

-- Created on 11/4/2008 by Globinch PLSQLTIPS
declare
-- Local variables here
begin
  -- Test statements here
  insert into MyTable(name,address,id) values('Abcd2','address2',2);
  insert into MyTable(name,address,id) values('Abcd4','address2',3);
  commit;
  delete from MyTable where id = 2;
  commit;
end;

SQL> select * from MyTable;
NAME                ADDRESS             ID
Abcd4               address2             3
SQL>

A transaction ends when any of the following occurs:
1.A user issues a COMMIT or ROLLBACK statement without a SAVEPOINT clause.
2.A user runs a DDL statement such as CREATE, DROP, RENAME, or ALTER.
3.A user disconnects from Oracle and the current transaction is committed.
4.A user process terminates abnormally then the current transaction is rolled back.

So What is SAVEPOINT? read it here
Savepoints In SQL Transactions. – SAVEPOINT

Savepoints In SQL Transactions. – SAVEPOINT

globinch-sql-plsql — Tue, 04 Nov 2008 09:00:00 +0000

The intermediate markers within the context of a transaction called savepoints. Savepoints divide a long transaction into smaller parts.
User then have the option of rolling back before the current point in the transaction but after a declared savepoint within the transaction.

The Folllowing simple example illustartes the SAVEPOINT.

-- Created on 11/4/2008 by PLSQLTIPS
declare
-- Local variables here
i integer;
begin
-- Test statements here

 insert into MyTable(name,address,id) values('Abcd2','address2',2);
insert into MyTable(name,address,id) values('Abcd3','address3',3);
commit;

end;

This will insert two rows in MyTable;

SQL> select * from MyTable;
NAME             ADDRESS             ID
Abcd2            address2             2
Abcd3            address3             3
SQL>

Now Let us add a SAVEPOINT in the above example

SQL> delete from MyTable;
2 rows deleted
SQL> commit;

Let us add a SAVEPOINT ‘abcd’ in between the DML statements.

-- Created on 11/4/2008 by PLSQLTIPS
declare
  -- Local variables here
begin
 -- Test statements here
  insert into MyTable(name,address,id) values('Abcd2','address2',2);
  savepoint abcd;
  insert into MyTable(name,address,id) values('Abcd3','address3',3);
 rollback to abcd;
  commit;
end;

SQL> select * from MyTable;
NAME            ADDRESS             ID
Abcd2           address2             2
SQL>

The second ‘INSERT‘ statement rolled back to the SAVEPOINT ‘abcd’ before committing the transaction.
So only one record is persisted in the table permanently.