drop table t_target purge;
drop table err$_t_target purge;
drop table t_source;

create table t_target
as 
   select 
    level  n1
  ,trunc(dbms_random.value(1,250)) n2
  ,date'2012-06-07' + mod((level-1)*5,10)   start_date   
	 ,rpad('xx',10) padding
   from dual
  connect
    by level <= 1000;	 

alter table t_target add constraint t_g_pk primary key(n1);
alter table t_target modify start_date not null;
create index t_g_ind1 on t_target(n2);
exec dbms_errlog.create_error_log('t_target');

create table t_source as
    select 
     case rownum 
        when 1 then 1 
        when 10 then 10
      else rownum + 1000 end id1
    , mod(rownum-1, 10) id2
    ,case mod(rownum,3)
        when 0 then null
    else sysdate + rownum end date1
from dual
  connect by level <= 10;

Run without DML error logging

/* 
1. insert id 1 --> duplicate record rejected
2. insert several successful rows
3. insert 3 rejected rows dues to null start_date
4. insert several successful rows
5. insert id = 10 --> duplicate record rejected
*/
@@c:\stats#
begin
  for x in (select   
        id1
       ,id2
       ,date1
       ,'yy'
  from
      t_source
) loop
begin
  insert into t_target
   (n1, n2,start_date, padding)
  values
    (x.id1, x.id2, x.date1, 'yy');  
  commit;
 exception
   when others then
     null;
 end;
end loop;
end;        
/
@@c:\stats#

NAME                                       VALUE
----------------------------------------- ----------
user commits                                9
user rollbacks                              0
recursive calls                             25331
rollback changes - undo records applied     0
transaction rollbacks                       0

PL/SQL procedure successfully completed.

NAME                                        VALUE
------------------------------------------- ----------
user commits                                14
user rollbacks                              0
recursive calls                             25482  151
rollback changes - undo records applied     2
transaction rollbacks                       2      2 

Run with DML error logging

/* -------------------------------------------------
1. insert id 1 --> duplicate record rejected
2. insert several successful rows
3. insert 3 rejected rows dues to null start_date
4. insert several successful rows
5. insert id = 10 --> duplicate record rejected
* -------------------------------------------------- */
@@c:\stats#

begin
  for x in (select   
        id1
       ,id2
       ,date1
       ,'yy'
  from
      t_source
) loop
begin
  insert into t_target
   (n1, n2,start_date, padding)
  values
    (x.id1, x.id2, x.date1, 'yy')
  log errors into err$_t_target reject limit unlimited;
  commit;
 exception
   when others then
     null;
 end;
end loop;
end;        
/
@@c:\stats#

NAME                                        VALUE
------------------------------------------- -------
user commits                                22
user rollbacks                              0
recursive calls                             34291
rollback changes - undo records applied     2
transaction rollbacks                       2

PL/SQL procedure successfully completed.

NAME                                        VALUE
---------------------------- -------------- -----
user commits                                27
user rollbacks                              0
recursive calls                             34488  197
rollback changes - undo records applied     4
transaction rollbacks                       2      0

When I changed a little bit my DML error logging script in order to use direct path load I got the following results:

@@c:\stats#

begin
  insert /*+ append */ into t_target
   (n1, n2,start_date, padding)
  select   
        id1
       ,id2
       ,date1
       ,'yy'
  from
      t_source
  log errors into err$_t_target reject limit unlimited;
  commit;
end;
/
@@c:\stats#



NAME                                         VALUE
-------------------------------------------- ----------
user commits                                 62
user rollbacks                               0
recursive calls                              99427
rollback changes - undo records applied      7
transaction rollbacks                        3

begin
*
ERROR at line 1:
ORA-00001: unique constraint (XXX.T_G_PK) violated
ORA-06512: at line 2


NAME                                         VALUE
-------------------------------------------- ----------
user commits                                 62
user rollbacks                               0
recursive calls                              99571
rollback changes - undo records applied      8
transaction rollbacks                        4   1

SQL> select ORA_ERR_MESG$ from err$_t_target;

ORA_ERR_MESG$
--------------------------------------------------------------------
ORA-01400: cannot insert NULL into ("XXX"."T_TARGET"."START_DATE")
ORA-01400: cannot insert NULL into ("XXX"."T_TARGET"."START_DATE")
ORA-01400: cannot insert NULL into ("XXX"."T_TARGET"."START_DATE")

As far as the DML Error logging is able to catch the error and let the insert continue there seem to be no transaction rollbacks applied. Unless you hit a restriction of the DML error logging (as unique constraint during direct path) where transaction rollbacks statistics starts to be incremented.

Thanks for the demo; if you hadn’t come up with this example, I would have suggested it as another area for Mohamed to look at.

One of the big problems I find with Oracle – as soon as I start looking at something a little bit too closely I keep finding more and more cases that ought to be examined at the same time. Are there any differences regarding recursive call counts between the bulk exceptions strategy and the error logging strategy, for example ? And does this change with version ?

I thought I had a blog with some quick demos of the interesting side effects and costs of error logging – but it turns out that the thing I had in mind was an article that Mark Rittman wrote about it nearly 8 years ago, with a little 11g follow-up reference a couple of years later.

Thanks for the example. I think the results are as I would have guessed. Having covered this case, it would be interesting to extend the checks to get to (a) multiple indexes, not all unique, (b) multiple rows rejected, including first, middle, and last rows of insert as select. It would also be interesting to take a note of how the logging action affected the number of recursive calls.

[oracle@DB1 ~]$ cat test.sql
drop table u.t1 purge;

create table u.t1(id number(6,0) primary key, n1 number, v1 varchar2(10), padding varchar2(100));
insert into u.t1 select level, 1, 'x', 'x' from dual connect by level <= 3000;

exec dbms_workload_repository.create_snapshot;

declare
    a1 dbms_sql.number_table;
begin
    for i in 1 .. &1 loop
      a1(i) := i;
    end loop;
    
    begin
        forall i in 1..&1 save exceptions
            insert into u.t1 values(50,a1(i),'x','x');
    exception
        when others then null;
    end;

    for i in 1..&2 loop
        begin
            insert into u.t1 values(50,i,'x','x');
            commit;
        exception
            when others then null;
        end;
    end loop;

end;
/

exec dbms_workload_repository.create_snapshot;

define num_days = 1;

column inst_num   new_value inst_num  format 99999;
column inst_name  new_value inst_name format a12;
column db_name    new_value db_name   format a12;
column dbid       new_value dbid      format 9999999999;

select d.dbid            dbid
     , d.name            db_name
     , i.instance_number inst_num
     , i.instance_name   inst_name
  from v$database d,
       v$instance i;

column begin_snap new_value begin_snap  format 99999;
column end_snap   new_value end_snap    format 99999;

select max(snap_id) end_snap, max(snap_id)-1 begin_snap from dba_hist_snapshot;

define  report_type  = 'text';
define  report_name  = '';

@@?/rdbms/admin/awrrpti

exit

[oracle@DB1 ~]$ sqlplus / as sysdba @test 200 0 | egrep "user commits|user rollbacks|transaction rollbacks|rollback changes"
rollback changes - undo records                 201          348.4          18.3
transaction rollbacks                             0            0.0           0.0
user commits                                     11           19.1           1.0
user rollbacks                                    0            0.0           0.0
[oracle@DB1 ~]$ sqlplus / as sysdba @test 0 200 | egrep "user commits|user rollbacks|transaction rollbacks|rollback changes"
rollback changes - undo records                 200          338.4          18.2
transaction rollbacks                           200          338.4          18.2
user commits                                     11           18.6           1.0
user rollbacks                                    0            0.0           0.0
[oracle@DB1 ~]$ 

Unless I missed something I found a different behavior for transaction rollbacks statistic when using DML error logging. This statistic seems not be incremented in this particular case. The column id is the primary key of table t1 and id = 1 has already been inserted into t1.The test has been conducted under Oracle Database 10g Enterprise Edition Release 10.2.0.4.0 – 64bi

SQL> start c:\stats#

NAME                                      VALUE
---------------------------------------- -------
user commits                               1
user rollbacks                             0
rollback changes - undo records applied    0
transaction rollbacks                      0

SQL> begin
  2          insert into t1(id) values(1);
  3          commit;
  4        exception
  5         when others then
  6           null;
  7        end;
  8        /

PL/SQL procedure successfully completed.

SQL> start c:\stats#

NAME                                      VALUE
----------------------------------------- ------
user commits                               1
user rollbacks                             0
rollback changes - undo records applied    1
transaction rollbacks                      1

SQL> select count(1) from t1;

  COUNT(1)
----------
         1

SQL> select count(1) from err$_t1;

  COUNT(1)
----------
         0

SQL> begin
  2          insert into t1(id) values(1)
  3          log errors into err$_t1 reject limit unlimited;
  4          commit;
  5        exception
  6         when others then
  7           null;
  8        end;
  9        /

PL/SQL procedure successfully completed.

SQL> start c:\stats#

NAME                                          VALUE
--------------------------------------------- ------
user commits                                   1
user rollbacks                                 0
rollback changes - undo records applied        2
transaction rollbacks                          1

SQL> select count(1) from t1;

  COUNT(1)
----------
         1

SQL> select count(1) from err$_t1;

  COUNT(1)
----------
         1

The first loop will be responsible for 200 ORA-1 errors which should turn into:
200 transaction rollbacks
0 user rollbacks
200 rollback changed – undo records applied (to “repair” the ORA-1 errors on the index only: we did no change on the base table, thus we have no undo record applied on the base table)

The second loop will be responsible for 40 insert+rollback which should turn into:
40 transaction rollbacks
40 user rollbacks ( since these are explicit rollbacks)
80 rollback changed – undo records applied (40 changes on the index and 40 changes on the table)

The third loop will be responsible for 50 insert+commit which should turn into:
0 transaction rollbacks
50 user commits
0 rollback changed – undo records applied

The fourth loop will be responsible for 70 insert+rollback to savepoint which should turn into:
0 transaction rollback (the “rollback to savepoint” does not close the transaction even if we rollback to the “starting” savepoint)
0 user rollbacks (same as before)
140 rollback changed – undo records applied (70 changes on the index and 70 changes on the table)

We should thus get
420 rollback changes – undo records applied
240 transaction rollbacks
40 user rollbacks
50 user commits
(200+40+50) = 290 closed transactions from the first three loops,
1 open transaction from the last loop
(40) / (40+50) = 0.44 “Rollback per transaction %” since we should only account for “user commits” and “user rollback” to evaluate this metric

Next time I’ll double-check my guesses. Regards, Andrea

user commits                                 50  
user rollbacks                               40  
rollback changes - undo records applied      420  
transaction rollbacks                        240