CAN I DO FORALL OR JUST DO ONE BY ONE PROCESSING IN THIS SCENEARIO

Question

VERSION : ORACLE 11G
I HAVE A FLAT RECORD STRUCTURE WHICH I LOADED INTO LOAD TABLE USING SQL LOADER. AND FROM LOAD TABLE I HAVE TO LOAD INTO MASTER TABLE USING PEOCEDURE.
IF FLAT RECORD STRUCTURE CONSIST OF 4 PERSONS(OWNER1&OWNER_SPOUSE/OWNER2&OWNER2_SPOUSE) I HAVE TO INSERT 4 RECORDS INTO PEOPLE_MASTER.
WHAT IS THE BEST WAY TO DO THAT ????????? LOAD TABLE HAS ABOUT 110 MILLIONS .
LOAD TABLE
EXAMPLE :  PROPERTY ID   OWNER         OWNER_SP OWNER2 OWNER2_SP WE_PID WE_PID_SP WE_PID2 WE_PID_SP2
                   100                 WILLIAMS     AMY           CHUNK      JUDY
INSERT MASTER TABLE
                 ID           OWNER         WE_PID
                 100        WILLIAMS       1
                 101        AMY               2
                 103        CHUNK           3
                 104       JUDY               4
UPDATE LOAD TABLE
               PROPERTY ID   OWNER         OWNER_SP OWNER2 OWNER2_SP WE_PID WE_PID_SP WE_PID2 WE_PID_SP2
                   100                 WILLIAMS     AMY           CHUNK      JUDY       1            2                3              4PLEASE SHARE SOME IDEAS.
PROCEDURE individual
IS
   TYPE people_rec
   IS
      RECORD (
         row_id             VARCHAR2 (100),
         orig_owner_name    VARCHAR2 (100),
         we_pid             NUMBER,
         owner_name         VARCHAR2 (50),                -- owner nane parsed
         owner_first        VARCHAR2 (50),
         owner_last         VARCHAR2 (50),
         owner_middle       VARCHAR2 (20),
         owner_prefix       VARCHAR2 (10),
         owner_suffix       VARCHAR2 (5),
         we_pid_sp          NUMBER,
         owner_name_sp      VARCHAR2 (50),                -- owner nane parsed
         owner_first_sp     VARCHAR2 (50),
         owner_middle_sp    VARCHAR2 (20),
         owner_suffix_sp    VARCHAR2 (5),
         orig_owner_name2   VARCHAR2 (100),
         we_pid2            NUMBER,
         owner_name2        VARCHAR2 (50),                -- owner nane parsed
         owner_first2       VARCHAR2 (50),
         owner_last2        VARCHAR2 (50),
         owner_middle2      VARCHAR2 (20),
         owner_suffix2      VARCHAR2 (5),
         we_pid_sp2         NUMBER,
         owner_name_sp2     VARCHAR2 (100),               -- owner nane parsed
         owner_first_sp2    VARCHAR2 (50),
         owner_middle_sp2   VARCHAR2 (20),
         mail_addr1         VARCHAR2 (100),
         mail_addr2         VARCHAR2 (100),
         mail_city          VARCHAR2 (30),
         mail_state         VARCHAR2 (2),
         mail_zip           VARCHAR2 (10),
         mail_zip4          VARCHAR2 (6),
         match_string       VARCHAR2 (35)
   TYPE people_type
   IS
      TABLE OF people_rec
         INDEX BY BINARY_INTEGER;
   people_tab   people_type;
   --  owner_type 0,2 = individual
   -- process all individual except Trust.
   -- process all records where site address and mail address are same (site_mail_same = Y)
   -- Process records where names are parsed correctly
   CURSOR people_cur
   IS
      SELECT   row_id,
               orig_owner_name,
               fn_get_person_id we_pid,
               owner_name,
               owner_first,
               owner_last,
               owner_middle,
               owner_prefix,
               owner_suffix,
               DECODE (owner_name_sp, NULL, NULL, fn_get_person_id) we_pid_sp,
               owner_name_sp,
               owner_first_sp,
               owner_middle_sp,
               owner_suffix_sp,
               orig_owner_name2,
               DECODE (owner_name2, NULL, NULL, fn_get_person_id) we_pid2,
               owner_name2,
               owner_first2,
               owner_last2,
               owner_middle2,
               owner_suffix2,
               DECODE (owner_name_sp2, NULL, NULL, fn_get_person_id)
                  we_pid_sp2,
               owner_name_sp2,
               owner_first_sp2,
               owner_middle_sp2,
               mail_addr1,
               mail_addr2,
               mail_city,
               mail_state,
               mail_zip,
               mail_zip4,
               match_string
        FROM   (SELECT                                   /*+ PARALLEL( A,16)*/
                      ROWID ROW_ID,
                         CASE
                            WHEN     OWNER_NAME NOT LIKE '%&%'
                                 AND OWNER_FIRST IS NOT NULL
                                 AND OWNER_LAST IS NOT NULL
                            THEN
                               1
                            WHEN     OWNER_NAME LIKE '%&%'
                                 AND OWNER_FIRST IS NOT NULL
                                 AND OWNER_LAST IS NOT NULL
                                 AND OWNER_FIRST_SP IS NOT NULL
                            THEN
                               1
                            ELSE
                               0
                         END
                            owner_flag,
                         CASE
                            WHEN OWNER_NAME2 IS NULL
                            THEN
                               1
                            WHEN     OWNER_NAME2 NOT LIKE '%&%'
                                 AND OWNER_FIRST2 IS NOT NULL
                                 AND OWNER_LAST2 IS NOT NULL
                            THEN
                               1
                            WHEN     OWNER_NAME2 LIKE '%&%'
                                 AND OWNER_FIRST2 IS NOT NULL
                                 AND OWNER_LAST2 IS NOT NULL
                                 AND OWNER_FIRST_SP2 IS NOT NULL
                            THEN
                               1
                            ELSE
                               0
                         END
                            owner_flag_2,
                         owner_name orig_owner_name,
                         REGEXP_SUBSTR (owner_name, '[^&]+') owner_name,
                         owner_first,
                         owner_last,
                         owner_middle,
                         owner_prefix,
                         owner_suffix,
                         TRIM(DECODE (
                                 owner_first_sp,
                                 NULL,
                                 NULL,
                                 owner_first_sp
                                 || REGEXP_REPLACE (
                                       || owner_middle_sp
                                       || ' '
                                       || owner_last
                                       || ' '
                                       || OWNER_SUFFIX_SP,
                                       '( ){2,}',
                            owner_name_sp,
                         owner_first_sp,
                         owner_middle_sp,
                         owner_suffix_sp,
                         owner_name2 orig_owner_name2,
                         REGEXP_SUBSTR (owner_name2, '[^&]+') owner_name2,
                         owner_first2,
                         owner_last2,
                         owner_middle2,
                         owner_suffix2,
                         TRIM(DECODE (
                                 owner_first_sp2,
                                 NULL,
                                 NULL,
                                 owner_first_sp2
                                 || REGEXP_REPLACE (
                                       || owner_middle_sp2
                                       || ' '
                                       || owner_last2,
                                       '( ){2,}',
                            owner_name_sp2,
                         owner_first_sp2,
                         owner_middle_sp2,
                         REGEXP_REPLACE (
                            TRIM(   mail_house_no
                                 || ' '
                                 || mail_dir
                                 || ' '
                                 || mail_street_name
                                 || ' '
                                 || mail_suf),
                            '( ){2,}',
                            mail_addr1,
                         REGEXP_REPLACE (
                            TRIM (mail_unit_pre || ' ' || mail_unit_val),
                            '( ){2,}',
                            mail_addr2,
                         TRIM (REGEXP_SUBSTR (mail_city_state, '\w(.* )'))
                            mail_city,
                         state_code mail_state,
                         mail_zip,
                         mail_zip4,
                         RPAD ('000000000000' || '1', 35, '0') match_string
                  FROM   dq_assessment_load a
                 WHERE       owner_type IN (0, 2)
                         AND owner_name IS NOT NULL
                         AND owner_name NOT LIKE '%TRUST%'
                         AND NVL (owner_name2, 'X') NOT LIKE '%TRUST%'
                         AND site_mail_same = 'Y') T
       WHERE   owner_flag = 1 AND owner_flag_2 = 1;
BEGIN
   OPEN people_cur;
   LOOP
      FETCH PEOPLE_CUR BULK COLLECT INTO   people_tab LIMIT 5000;
      -- INSERT INTO PEOPLE_MASTER ONCE FOR EACH OWNER
      EXIT WHEN people_cur%NOTFOUND;
   END LOOP;
END individual;THANKS
Edited by: new learner on May 12, 2011 7:59 AM
found this solution on this thread i will try this
Using IF with FORALL.
/* Conditional FORALL INSERT... */
22     FORALL i IN aa_ids.FIRST .. aa_ids.LAST
23        INSERT ALL
24           WHEN aa_types(i) = 'TABLE'
25              THEN INTO t1 VALUES ( aa_ids(i), aa_names(i) )
26           WHEN aa_types(i) = 'INDEX'
27              THEN INTO t2 VALUES ( aa_ids(i), aa_names(i) )
28           WHEN aa_types(i) NOT IN ( 'TABLE', 'INDEX' )
29              THEN INTO t3 VALUES ( aa_ids(i), aa_names(i) )
30        SELECT dummy FROM dual;Edited by: new learner on May 12, 2011 8:06 AM

Answer 1

Check this link and follow the simple mantra.
http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:47458244605081
Also, posting in uppercase is considered shouting in discussion forums. So please try to avoid doing that in the future.
Regards
Raj