UPDATE proc taking HUGE TIME

Question

Hi
Oracle UPDATE proc is taking over 10 Hours to update 1,30,000 records :-
/**********************CODE***************************/
PROCEDURE Update_SP IS
CURSOR C1 IS
select tim.c_col,mp.t_n
from Materialized_VW tim, MP_Table mp
where tim.R_id = mp.R_id
and tim.P_id = mp.P_id
and tim.t_id = mp.t_id
and mp.t_date between wk_comm and wk_end;
BEGIN
FOR I IN C1
LOOP
IF v_c=100000 THEN
v_c:=0;
COMMIT;
END IF;
v_c:=v_c+1;
UPDATE MP_Table mp
SET c_col = i.c_col
WHERE mp.t_n = i.t_n;
END LOOP;
COMMIT;
EXCEPTION
WHEN OTHERS THEN
ROLLBACK;
err_num := SQLCODE;
err_msg := SUBSTR(SQLERRM,1,100);
END Update_SP;
/**********************CODE***************************/
Materialized_VW :- It has 4 SEPARATE indexes on the columns R_id, P_id, t_id, c_col
MP_Table :- It has 4 SEPARATE indexes on the columns R_id, P_id, t_id, t_n
The Explain Plan shows (NOTE : Whenever NUMBER OF RECORDS is More)
SELECT STATEMENT ALL_ROWS
Cost: 17,542 Bytes: 67 Cardinality: 1
3 HASH JOIN
Cost: 17,542 Bytes: 67 Cardinality: 1
1 TABLE ACCESS FULL MP_TABLE
Cost: 14 Bytes: 111,645 Cardinality: 4,135
2 TABLE ACCESS FULL MATERIALIZED_VW
Cost: 16,957 Bytes: 178,668,800 Cardinality: 4,466,720
The Explain Plan shows (NOTE : Whenever NUMBER OF RECORDS is Less)
SELECT STATEMENT ALL_ROWS
Cost: 2,228 Bytes: 67 Cardinality: 1
6 NESTED LOOPS Cost: 2,228 Bytes: 67 Cardinality: 1
1 TABLE ACCESS FULL MP_TABLE Cost: 3 Bytes: 12,015 Cardinality: 445
5 TABLE ACCESS BY INDEX ROWID MATERIALIZED_VW Cost: 2,228 Bytes: 40 Cardinality: 1
4 AND-EQUAL
2 INDEX RANGE SCAN NON-UNIQUE MATERIALIZED_VW_INDX1
3 INDEX RANGE SCAN NON-UNIQUE MATERIALIZED_VW_INDX2
This INTERMITTENT behaviour of EXPLAIN PLAN is causing it to take HUGE TIME whenever the number of records is more.
This strange behaviour is causing problems as 10 Hours is too much for any UPDATE (that too the number of records is only 6 digit number).
But, we cannnot use a DIRECT UPDATE as well as that would result in Oracle Exceptions.
Please suggest ways of reducing the time or any other method of doing the above ASAP.
Also, is there any way to establish a standard behaviour which takes less time.
Thanks
Arnab

Answer 1

Hi BluShadow,
I followed up your example extending it to the bulk processing.
I have tested insert and update operations.
Here are the insert result:
SQL> CREATE TABLE mytable (x number, z varchar2(5));
Table created.
SQL> DECLARE
  2    v_sysdate DATE;
  3    v_insert NUMBER;
  4    TYPE t_nt_x IS TABLE OF NUMBER;
  5    TYPE t_nt_z IS TABLE OF VARCHAR2(5);
  6    v_nt_x t_nt_x;
  7    v_nt_z t_nt_z;
  8    CURSOR c1 IS SELECT rownum as x, 'test1' as z FROM DUAL CONNECT BY ROWNUM <= 1000000;
  9  BEGIN
10 
11    -- Single insert
12    v_insert := 0;
13    EXECUTE IMMEDIATE 'TRUNCATE TABLE mytable';
14    v_sysdate := SYSDATE;
15    INSERT INTO mytable (x,z) SELECT rownum,'test1' FROM DUAL CONNECT BY ROWNUM <= 1000000;
16    v_insert := SQL%ROWCOUNT;
17    COMMIT;
18    DBMS_OUTPUT.PUT_LINE('Single insert--> Row Inserted: '||v_insert||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
19 
20    -- Multi insert
21    v_insert := 0;
22    EXECUTE IMMEDIATE 'TRUNCATE TABLE mytable';
23    v_sysdate := SYSDATE;
24    FOR i IN 1..1000000
25    LOOP
26      INSERT INTO mytable (x,z) VALUES (i,'test1');
27      v_insert := v_insert+SQL%ROWCOUNT;
28    END LOOP;
29    COMMIT;
30    DBMS_OUTPUT.PUT_LINE('Multi insert--> Row Inserted: '||v_insert||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
31 
32    -- Multi insert using bulk
33    v_insert := 0;
34    EXECUTE IMMEDIATE 'TRUNCATE TABLE mytable';
35    v_sysdate := SYSDATE;
36    OPEN c1;
37    LOOP
38      FETCH c1 BULK COLLECT INTO v_nt_x,v_nt_z LIMIT 100000;
39      EXIT WHEN C1%NOTFOUND;
40      FORALL i IN 1..v_nt_x.count
41        INSERT INTO mytable (x,z) VALUES (v_nt_x(i),v_nt_z(i));
42        v_insert := v_insert+SQL%ROWCOUNT;
43    END LOOP;
44    COMMIT;
45    DBMS_OUTPUT.PUT_LINE('Multi insert using bulk--> Row Inserted: '||v_insert||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
46 
47  END;
48  /
Single insert--> Row Inserted: 1000000 Time Taken: 3
Multi insert--> Row Inserted: 1000000 Time Taken: 62
Multi insert using bulk--> Row Inserted: 1000000 Time Taken: 10
PL/SQL procedure successfully completed.and here the update result:
SQL> DECLARE
  2    v_sysdate DATE;
  3    v_update NUMBER;
  4    TYPE t_nt_x IS TABLE OF ROWID;
  5    TYPE t_nt_z IS TABLE OF VARCHAR2(5);
  6    v_nt_x t_nt_x;
  7    v_nt_z t_nt_z;
  8    CURSOR c1 IS SELECT rowid as ri, 'test4' as z FROM mytable;
  9  BEGIN
10 
11    -- Single update
12    v_update := 0;
13    v_sysdate := SYSDATE;
14    UPDATE mytable SET z='test2';
15    v_update := SQL%ROWCOUNT;
16    COMMIT;
17    DBMS_OUTPUT.PUT_LINE('Single update--> Row Updated: '||v_update||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
18 
19    -- Multi update
20    v_update := 0;
21    v_sysdate := SYSDATE;
22    FOR rec IN (SELECT ROWID AS ri FROM mytable)
23    LOOP
24      UPDATE mytable SET z='test3' WHERE ROWID=rec.ri;
25      v_update := v_update+SQL%ROWCOUNT;
26    END LOOP;
27    COMMIT;
28    DBMS_OUTPUT.PUT_LINE('Multi update--> Row Updated: '||v_update||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
29 
30    -- Multi update using bulk
31    v_update := 0;
32    v_sysdate := SYSDATE;
33    OPEN c1;
34    LOOP
35      FETCH c1 BULK COLLECT INTO v_nt_x,v_nt_z LIMIT 100000;
36      EXIT WHEN C1%NOTFOUND;
37      FORALL i IN 1..v_nt_x.count
38        UPDATE mytable SET z=v_nt_z(i) WHERE ROWID=v_nt_x(i);
39        v_update := v_update+SQL%ROWCOUNT;
40    END LOOP;
41    COMMIT;
42    DBMS_OUTPUT.PUT_LINE('Multi update using bulk--> Row Updated: '||v_update||' Time Taken: '||ROUND(((SYSDATE-v_sysdate)*(24*60*60)),0));
43 
44  END;
45  /
Single update--> Row Updated: 1000000 Time Taken: 39
Multi update--> Row Updated: 1000000 Time Taken: 60
Multi update using bulk--> Row Updated: 1000000 Time Taken: 32
PL/SQL procedure successfully completed.The single statement has still got the better perfomance, but with the bulk processing the cursor performance has improved dramatically
(in the update case the bulk processing is even slightly better than the single statement).
I guess that with the bulk processing the switching between the SQL and PL/SQL engines is much less.
It would be interesting to test it with more rows, i might do it tomorrow.
Just thought it would have been interesting sharing the result with you guys.
Cheers,
Davide