Is commit necessary to end autonomous transaction?

Question

CREATE OR REPLACE TRIGGER TRIG_EMP
AFTER UPDATE
ON EMP
FOR EACH ROW
DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
CNT NUMBER := 0 ;
BEGIN
--PROCE_TRIG_TEST_EMP;
SELECT COUNT(*)
INTO CNT
FROM EMP;
UPDATE EMP_bkp
SET COMM=999
WHERE ENAME ='SMITH';
-- COMMIT;
DBMS_OUTPUT.put_line('TRIG_EMP CALLED.. DONE: '||CNT);
END;
Error: "autonomous transaction detected "
if i open update n block commit code then error.
if i block both update n commit code then without commit code is running fine.
My Ques: If commit is necessary to end autonomous transaction then when i m blocking update n commit lines then too running without above error?
plz clear my concept..
pc

Answer 1

PC wrote:
thanks ..I will take care of it i.e. "IM".
In above code when I am blocking both "update & commit code lines" then there is no error raised by program.
I am using commit when I need that my "update transaction must be commit",if I am only taking "count of table emp" then no need of commit...
Like this I am not getting any exception..!Doing anything on the same table that caused the trigger to fire can lead to you getting a mutating table error, so care should be taken in that respect.
I got your point that I must commit and I will use it but here if I am using autonomous transaction without commit then I must get error but I am not facing ..plz guide me againThe point of an autonomous transaction is to effectively make Oracle spawn off a seperate transaction. Usually we consider that we have just a single transaction per session at any one time, but there are times, like when we need to log errors or audit something, that we want to ensure something get's written to a table, even if the transaction we are in needs to be rolled back or is about to raise an exception. In such cases we use an autonomous transaction to spawn the seperate transaction to perform that task. Good design would have that autonmous transaction as a seperate procedure to be called (rather than in the trigger itself) to keep it completely seperate from the current transaction, and thus when that seperate procedure finishes, any changes it has made must be committed or rolled back because the autonomous transaction that has been spawned is about to finish. Of course, if that procedure doesn't actually do any work on the database that requires committing or rolling back, then it's not necessary to issue one, but then there would be no need for an autonomous transaction in the first place.
So, with your trigger (let's ignore that fact that making the trigger autonomous is p!ss poor design), if you only do the count and don't do the update statement, then there is nothing to be committed, so there's no need for a commit statement, even if the trigger is defined as an autonomous transaction. But, if you include the update statement, then that spawned transaction must be committed before the trigger ends, so that the transaction is completed and control can return to the calling transaction. So, making your trigger autonomous doesn't mean that it must commit by itself... but making it autonomous and including something that needs committing, does mean it must commit.