How to tune this update statement?

Question

Hello,
I have to solve the following task:
Update every row in table A which has an appropriate row in table B and log what you have done in a log-table.
It is possible that there are more than one fitting rows in table A for a row in table B.
My first approach is looping over the table B and doing an update of table A for every entry in table B.
This works and looks like this:
Table A:
PK number (This is the primary key of this table)
KEY number
Table B:
KEY_OLD number
KEY_NEW number
Log table:
PK number
KEY_OLD number
KEY_NEW number
declare
  TYPE PK_TAB_TYPE IS TABLE OF number INDEX BY BINARY_INTEGER;
  v_tab_PK       PK_TAB_TYPE;
  v_empty_tab_PK PK_TAB_TYPE;
begin
  for v_rec in (select * from table_B) loop
    v_tab_PK := v_empty_tab_PK;  /* clearing the array */
    update table_A
    set    KEY = v_rec.KEY_NEW
    where (KEY = v_rec.KEY_OLD)
    returning PK bulk collect into v_tab_PK;
    if (v_tab_PK.count > 0) then
      for i in v_tab_PK.first..v_tab_PK.last loop
        insert into TMP_TAB_LOG(PK, KEY_OLD, KEY_NEW)
          values (v_tab_PK(i), v_rec.KEY_OLD, v_rec.KEY_NEW);
      end loop;
    end if;
  end loop;
end;Because the table B can have up to 500.000 entries (and the table A has even more entries) this solution will cause many update-statements.
So I am looking for a solution which has better performance.
My second approach was using an correlated update and looks like this:
declare
  TYPE PK_TAB_TYPE IS TABLE OF number INDEX BY BINARY_INTEGER;
  v_tab_PK            PK_TAB_TYPE;
  v_empty_tab_PK PK_TAB_TYPE;
  v_tab_NewKey    PK_TAB_TYPE;
begin
  v_tab_PK         := v_empty_tab_PK;  /* clear the arrays */
  v_tab_NewKey := v_empty_tab_PK;
  update table_A a
  set    KEY = (select KEY_NEW from table_B where (KEY_OLD = a.KEY))
  where exists (select 'x' as OK
                     from   table_B
                     where (KEY_OLD = a.KEY)
  returning PK, KEY bulk collect into v_tab_PK, v_tab_NewKey;
  if (v_tab_PK.count > 0) then
    for i in v_tab_PK.first..v_tab_PK.last loop
      insert into TMP_TAB_LOG_DUB(PK, KEY_OLD, KEY_NEW)
        values (v_tab_PK(i), null, v_tab_NewKey(i));
    end loop;
  end if;
end;Now I have only one update statement.
The only thing missing in this second approach is the old KEY before the update in the log table.
But I have no idea how to get the old value.
Is there a possibility to modify this second approach to get the old value of the KEY before the update to write it in the log-table?
And now I need your help:
What is the best way to get a performant solution for my task?
Every help appreciated.
Regards Hartmut

Answer 1

Below is a script you can run in another testing schema to do the update with logging..... I have created the tables (A and B) with primary key constraints defined...
create table table_a(pk number primary key
, key number);
create table table_b(key_old number primary key
, key_new number);
create table TMP_TAB_LOG_DUB(pk number primary key
, key_old number
, key_new number);
---------insert test data
insert into table_a values(1,2);
insert into table_a values(2,2);
insert into table_a values(3,2);
insert into table_a values(11,1);
insert into table_a values(12,1);
insert into table_a values(13,1);
insert into table_a values(21,4);
insert into table_a values(22,4);
insert into table_a values(23,4);
commit;
insert into table_b values(1,3);
insert into table_b values(4,2);
commit;
----- insert to log
insert into TMP_TAB_LOG_DUB(PK, KEY_OLD, KEY_NEW)
select a.pk
, a.key as key_old
, b.key_new as key_new
from table_a a
join table_b b on a.key = b.key_old;
----- update table_a
update(select a.pk
, a.key as key_old
, b.key_new as key_new
from table_a a
join table_b b on a.key = b.key_old)
set key_old = key_new;
commit;