PLSQL code optimizing

Question

Hi
My oracle db version is 11g R1/AIX5.3
how following plsql code can be re-written for better performance
CREATE OR REPLACE PROCEDURE CSCOMMON.POST_SEQ_PROCESS
AS
   -- Declare variables to hold sequenced infomration.
   pragma autonomous_transaction;
   V_RECORD_ID           POST_SEQUENCING_PROCESS.RECORD_ID%TYPE;
   V_RECEIVED            POST_SEQUENCING_PROCESS.RECEIVED%TYPE;
   V_PROCESS_NAME        POST_SEQUENCING_PROCESS.PROCESS_NAME%TYPE;
   V_PROCESS_ID          POST_SEQUENCING_PROCESS.PROCESS_ID%TYPE;
   V_PROCESS_SEQ         POST_SEQUENCING_PROCESS.PROCESS_SEQ%TYPE;
   V_RECEIVER            POST_SEQUENCING_PROCESS.RECEIVER%TYPE;
   V_RECEIVER_ID         POST_SEQUENCING_PROCESS.RECEIVER_ID%TYPE;
   V_RECEIVER_SEQ        POST_SEQUENCING_PROCESS.RECEIVER_SEQ%TYPE;
   V_SENDER              POST_SEQUENCING_PROCESS.SENDER%TYPE;
   V_SENDER_ID           POST_SEQUENCING_PROCESS.SENDER_ID%TYPE;
   V_MESSAGE_ID          POST_SEQUENCING_PROCESS.MESSAGE_ID%TYPE;
   V_INSTANCE_ID         POST_SEQUENCING_PROCESS.INSTANCE_ID%TYPE;
   V_STATUS              POST_SEQUENCING_PROCESS.STATUS%TYPE;
   V_STEP_ID             POST_SEQUENCING_PROCESS.STEP_ID%TYPE;
   V_INTERNAL_ID         POST_SEQUENCING_PROCESS.INTERNAL_ID%TYPE;
   V_LOCK_ID             POST_SEQUENCING_PROCESS.LOCK_ID%TYPE;
   V_ERROR_HANDLING      POST_SEQUENCING_PROCESS.ERROR_HANDLING%TYPE;
   V_STARTED             POST_SEQUENCING_PROCESS.STARTED%TYPE;
   V_WARNINGS            POST_SEQUENCING_PROCESS.WARNINGS%TYPE;
   V_DOCUMENTTYPE_NAME   POST_SEQUENCING_PROCESS.DOCUMENTTYPE_NAME%TYPE;
   V_DOCUMENTTYPE_ID     POST_SEQUENCING_PROCESS.DOCUMENTTYPE_ID%TYPE;
   V_DOCUMENTTYPE_SEQ    POST_SEQUENCING_PROCESS.DOCUMENTTYPE_SEQ%TYPE;
   v_current             VARCHAR2 (600);
   v_sql_error           VARCHAR2 (600);
   lv_count              NUMBER;
   CURSOR c_first500
   IS
      SELECT RECORD_ID,
             RECEIVED,
             PROCESS_NAME,
             PROCESS_ID,
             PROCESS_SEQ,
             RECEIVER,
             RECEIVER_ID,
             RECEIVER_SEQ,
             SENDER,
             SENDER_ID,
             MESSAGE_ID,
             INSTANCE_ID,
             STATUS,
             STEP_ID,
             INTERNAL_ID,
             LOCK_ID,
             ERROR_HANDLING,
             STARTED,
             WARNINGS,
             DOCUMENTTYPE_NAME,
             DOCUMENTTYPE_ID,
             DOCUMENTTYPE_SEQ
        FROM (  SELECT RECORD_ID,
                       RECEIVED,
                       PROCESS_NAME,
                       PROCESS_ID,
                       PROCESS_SEQ,
                       RECEIVER,
                       RECEIVER_ID,
                       RECEIVER_SEQ,
                       SENDER,
                       SENDER_ID,
                       MESSAGE_ID,
                       INSTANCE_ID,
                       STATUS,
                       STEP_ID,
                       INTERNAL_ID,
                       LOCK_ID,
                       ERROR_HANDLING,
                       STARTED,
                       WARNINGS,
                       DOCUMENTTYPE_NAME,
                       DOCUMENTTYPE_ID,
                       DOCUMENTTYPE_SEQ
                  FROM CSCOMMON.SEQUENCING_PROCESS
              ORDER BY RECEIVED)
       WHERE ROWNUM < 101;
   P_RAND                NUMBER;
   V_LID                 NUMBER;
BEGIN
   v_current := 'BEFORE CURSOR OPENING';
   SELECT COUNT (*) INTO lv_count FROM POST_SEQUENCING_PROCESS;
   OPEN c_first500;          
   LOOP
      SELECT CSCOMMON.SEQ_LID_SEQUENCING_PROCESS_NU.NEXTVAL
        INTO V_LID
        FROM DUAL;
     UPDATE CSCOMMON.SEQUENCING_PROCESS A
         SET A.LOCK_ID = V_LID ,
             A.STATUS = 1,
             A.STARTED = SYSDATE,
             A.WARNINGS = 0
       WHERE NOT EXISTS
                    (SELECT 1
                       FROM CSCOMMON.SEQUENCING_PROCESS B
                      WHERE ( (A.RECEIVER_ID = B.RECEIVER_ID
                               AND A.RECEIVER_SEQ = 1)
                             OR (A.PROCESS_ID = B.PROCESS_ID
                                 AND A.PROCESS_SEQ = 1)
                             OR (A.DOCUMENTTYPE_ID = B.DOCUMENTTYPE_ID
                                 AND A.DOCUMENTTYPE_SEQ = 1))
                            AND (A.ERROR_HANDLING = 0 OR B.STATUS != 4)
                            AND B.RECORD_ID < A.RECORD_ID)
             AND A.STATUS = 2
             AND 1024 =
                                    (SELECT WM1.STATUS
                       FROM WMLOG610.WMPROCESS WM1,
                            (  SELECT MAX (AUDITTIMESTAMP) AUDITTIMESTAMP,
                                      INSTANCEID
                                 FROM WMLOG610.WMPROCESS WM2
                                WHERE INSTANCEID IN
                                         (SELECT INSTANCE_ID
                                            FROM CSCOMMON.SEQUENCING_PROCESS where rownum<101)
                             GROUP BY INSTANCEID
                             ORDER BY instanceid) WM2
                      WHERE     A.INSTANCE_ID = WM1.INSTANCEID
                            AND WM1.INSTANCEID = WM2.INSTANCEID
                            AND WM1.AUDITTIMESTAMP = WM2.AUDITTIMESTAMP
                            AND ROWNUM = 1)
             AND A.LOCK_ID IS NULL
             AND A.DOCUMENTTYPE_NAME != 'FxHaulage';
commit;
      FETCH c_first500
      INTO V_RECORD_ID,
           V_RECEIVED,
           V_PROCESS_NAME,
           V_PROCESS_ID,
           V_PROCESS_SEQ,
           V_RECEIVER,
           V_RECEIVER_ID,
           V_RECEIVER_SEQ,
           V_SENDER,
           V_SENDER_ID,
           V_MESSAGE_ID,
           V_INSTANCE_ID,
           V_STATUS,
           V_STEP_ID,
           V_INTERNAL_ID,
           V_LOCK_ID,
           V_ERROR_HANDLING,
           V_STARTED,
           V_WARNINGS,
           V_DOCUMENTTYPE_NAME,
           V_DOCUMENTTYPE_ID,
           V_DOCUMENTTYPE_SEQ;
      EXIT WHEN c_first500%NOTFOUND;
      BEGIN
         v_current := 'INSERT INTO POST_SEQUENCING_PROCESS';
         IF (lv_count = 0)
         THEN
            INSERT INTO POST_SEQUENCING_PROCESS (RECORD_ID,
                                                 RECEIVED,
                                                 PROCESS_NAME,
                                                 PROCESS_ID,
                                                 PROCESS_SEQ,
                                                 RECEIVER,
                                                 RECEIVER_ID,
                                                 RECEIVER_SEQ,
                                                 SENDER,
                                                 SENDER_ID,
                                                 MESSAGE_ID,
                                                 INSTANCE_ID,
                                                 STATUS,
                                                 STEP_ID,
                                                 INTERNAL_ID,
                                                 LOCK_ID,
                                                 ERROR_HANDLING,
                                                 STARTED,
                                                 WARNINGS,
                                                 DOCUMENTTYPE_NAME,
                                                 DOCUMENTTYPE_ID,
                                                 DOCUMENTTYPE_SEQ)
                 SELECT *
                   FROM cscommon.sequencing_process A
                  WHERE lock_id IS NOT NULL
                        AND A.DOCUMENTTYPE_NAME != 'FxHaulage' order by lock_id;
                        commit;
            INSERT INTO CSCOMMON.PRE_SEQUENCING_PROCESS
               (SELECT * FROM CSCOMMON.POST_SEQUENCING_PROCESS);
commit;
            DELETE FROM CSCOMMON.POST_SEQUENCING_PROCESS;
            COMMIT;
            v_current := 'DELETE FROM SEQUENCING_PROCESS';
            DELETE FROM CSCOMMON.SEQUENCING_PROCESS
                  WHERE LOCK_ID IS NOT NULL
                        AND DOCUMENTTYPE_NAME != 'FxHaulage';
            COMMIT;
         ELSE
            RETURN;
         END IF;
      END;
   END LOOP;
   CLOSE c_first500;                    
   COMMIT;
EXCEPTION
   WHEN OTHERS
   THEN
      v_sql_error := SQLERRM || ' - ' || v_current;
      ROLLBACK;
END;
/May be by using forall /bulk collections
Thanks
Raj

Answer 1

You need to understand transactional consistency. Not only are your commits
slowing things down, they are not good for maintaining transactional consistency.
Ask yourself what would happen if there was a problem in your procedure after
the first commit? How would you recover from that with some records
updated but the rest of your procedure not having been run?
In general you should only have one commit at the topmost level. By that I mean if
there is a program that kicks of other ones and is the 'master' controller, that
should be the one that decides to commit or rollback the whole transaction.
Also you need to understand exception handling. Your exception processing is dangeroulsly wrong.
Remove it.
Finally, try and do this processing without using cursor loops: pure (set-based) SQL is much faster than
slow cursor based PL/SQL and SQL together.