How to Improve this PL/SQL script

Question

Hi All,
I have a package/procedure that insert data into table but it takes time more than 2 days. Have any known how to modify this script to improve the performance and reduce loading time, The following code is procedure I used to insert data.....
Procedure INSERT_DATA (p_month IN DATE, p_product_id IN NUMBER ) IS
cursor c1 is select * from tab#1; --reference data
cursor c2 is select * from tab#2;
cursor c3 is select * from tab#3;
cursor c4 is select * from tab#4;
cursor c5 is select * from tab#5;
v_rec claim_table%rowtype;
Begin
for c1rec in c1 loop
exit when c1%notfound;
call procedure in package....;
open c2(c1rec.claim_no);
fetch c2 into v_location_cd ,v_claim_type_cd ;
close c2;
v_rec.location_cd := v_location_cd;
v_rec.claim_type_cd := v_claim_type_cd ;
open c3(c1rec.claim_no);
fetch c3 into v_col#3,v_col#4;
close c3;
v_rec.col#3 := v_col#3 ;
v_rec.col#4 := v_col#4 ;
open c4(c1rec.claim_no);
fetch c4 into v_col#5,v_col#6;
close c4;
v_rec.col#5 := v_col#5 ;
v_rec.col#6 := v_col#6 ;
insert into claim_table values ( v_rec.location_cd, v_rec.claim_type_cd , v_rec.col#3 , .......) ;
if (c1%rowcount/1000) = trunc(c1%rowcount /1000) then
     commit;
end if;
end loop;
commit;
Exception
exception statement....
commit;
End;
Thanks All,
Mcka

Answer 1

A copy and paste of a reply I posted just a hour or so ago to the exact same approach used by a poster in [url http://forums.oracle.com/forums/thread.jspa?threadID=636929]this thread.
Yucky code IMO. You are using PL/SQL to drive a nested loop join. Why? SQL is by far more capable of joining tables and is not limited to a using a nested loop approach only.
Also, as you are using PL/SQL to drive it, it means that each cursor fetch in each (nested) FOR loop is a slow context switch from PL/SQL to SQL, in order to ship the row's data from the SQL engine to the PL/SQL engine. Only then to have that very same data shipped back (via yet another context switch) to the SQL engine to be inserted into table4.
This code violates one of the most rudimentary performance principles in Oracle - it is not maximizing SQL and it it not minimizing PL/SQL. It is doing the exact opposite.
As for the ad-hoc commits inside the loop - this does not make much sense. This will generate more redo and more overheads. Also, when something goes pear shape in that process, some rows would have been processed and inserted and committed. Some not.
In this case, how do you expect to restart the failed process at the very first row that failed to be committed and continue processing from there?