Copying table in pl/sql 1000 rows at once.

Question

Hi everybody,
I have an PL/SQL procedure that does the following.
execute immediate 'create table ' || p_descination_table || ' as select * from ' || p_source_table || '; '
And this copies a table from one schema to another (the procedure is in a user that has create table anywhere privilege).
The problem is if the table is very big I want to copy 1000 rows at a time and do a commit between batches.
So I can do
execute immediate 'create table ' || p_descination_table || ' as select * from ' || p_source_table || ' where 1=0; '
To create the structure but how do I copy the rows 1000 at a time.
Lastly does anyone have code that generates the create index commands so I can also create the indexes on the target table.
Ben

Answer 1

You could test this:
CREATE TABLE BIGTABLE
AS SELECT ROWNUM RN, A.* FROM
  SELECT x.* FROM ALL_OBJECTS x
  CROSS JOIN
  (SELECT 1 FROM DUAL CONNECT BY LEVEL <= 100)
) A
SELECT COUNT(*) FROM BIGTABLE;
COUNT(*)              
7129000
DECLARE
    NUM NUMBER;
    T1    PLS_INTEGER;
    T2    PLS_INTEGER;
    SRC_TABLE CONSTANT VARCHAR2(30) := 'BIGTABLE';
    DST_TABLE CONSTANT VARCHAR2(30) := 'BIGTABLE_2';
  BEGIN
      T1 := DBMS_UTILITY.GET_TIME;
      EXECUTE IMMEDIATE 'CREATE TABLE ' || DST_TABLE ||
                        ' AS SELECT * FROM ' || SRC_TABLE ||
                        ' WHERE 1=0';
      EXECUTE IMMEDIATE ''
        || 'DECLARE '
        || '   TYPE REC_TABLE IS TABLE OF ' || SRC_TABLE || '%ROWTYPE; '
        || '   records REC_TABLE; '
        || ' '
        || '   CURSOR cur IS SELECT * FROM ' || SRC_TABLE || '; '
        || '   num NUMBER;  '
        || '   NUM_REC     PLS_INTEGER := 0; '
        || '   num_batch   PLS_INTEGER := 0; '
        || 'BEGIN '
        || '    OPEN cur; '
        || '    LOOP '
        || '        FETCH cur BULK COLLECT INTO records LIMIT 1000;'
        || '        FORALL I IN records.FIRST .. records.LAST '
        || '        INSERT INTO ' || DST_TABLE || ' VALUES RECORDS(I);'
        || '        COMMIT; '
        || '        num_rec := num_rec + records.count; '
        || '        num_batch := num_batch + 1; '
        || '        EXIT WHEN RECORDS.COUNT < 1000; '
        || '    END LOOP; '
        || '    CLOSE CUR;'
        || '    DBMS_OUTPUT.PUT_LINE(''Batches = '' || num_batch || '
        || '                         ''  Records = '' || num_rec ); '
        || 'END;';
      T2 := DBMS_UTILITY.GET_TIME;
      DBMS_OUTPUT.PUT_LINE('Total time = ' || to_char( (T2-T1)/100, '99999D99' ) );
END;
Batches = 7130  Records = 7129000
Total time =    385.97
SELECT COUNT(*) FROM BIGTABLE_2;
COUNT(*)              
7129000
SELECT count(*) FROM (
  SELECT rn FROM BIGTABLE
  INTERSECT
  SELECT rn FROM BIGTABLE_2
COUNT(*)              
7129000   However, look at the simple CTAS command:
DECLARE
  T1 PLS_INTEGER;
  T2 PLS_INTEGER;
  SRC_TABLE CONSTANT VARCHAR2(30) := 'BIGTABLE';
  DST_TABLE CONSTANT VARCHAR2(30) := 'BIGTABLE_1';
BEGIN
  T1 := DBMS_UTILITY.GET_TIME;
  EXECUTE IMMEDIATE 'CREATE TABLE ' || DST_TABLE ||
                    ' AS SELECT * FROM ' || SRC_TABLE;
  T2 := DBMS_UTILITY.GET_TIME;
  DBMS_OUTPUT.PUT_LINE('CTAS Time = ' || to_char( (T2-T1)/100, '99999D99' ) );
end;
CTAS Time =     28.55It's your choice:
- splitting data into batches and committing - 390 seconds,
- simple CTAS - 30 seconds.