Does cursor hit database everytime ??

Question

Hi seniors,
I am little confused with the concept of the cursor. I juts want to know is cursor has anything to deal with the database hit.
Explanation :
Say for example I have a cursor which is returning the 1000 rows from multiple table then that recordset will stored in some named sql area called cursor.
Now my question is when I loop the cursor will it get the actual data directly from the cursor OR It will just get an address location from the cursor to the actual database table or something.
If possible please help me to clear this doubt.
the reason being I have created one package which will move or drop the table with its all objects from all the schema available on the database server and it makes use of lot of cursor which are based on system views like all_table,all_trigger etc
Thanks in advance.

Answer 1

Example is :
PROCEDURE move_table_pd
                        cTable                  in      varchar2,
                        cFromSchema             in      varchar2 := 'STI_COUNTRY_USA',
                        cToSchema               in      varchar2 := 'STI_COMMON',
                        nVerbosity              in      number   := 0,
                        nExecuteImmediate       in      number   := 1
        IS
        BEGIN
                if ((cTable is not null) AND (cFromSchema is not null) AND (cToSchema is not null)) then
                        if (nVerbosity <> 0) then
                                print_start_time_pd;
                        end if;
                        cTableName              :=      upper(cTable);
                        cSourceSchema           :=      upper(cFromSchema);
                        cDestinationSchema      :=      upper(cToSchema);
                        DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'PRETTY',false);
                        DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'SQLTERMINATOR',false);
                        -- Step 1 : Create the table at destination schema if needed.
                        create_table_pd(cTableName,cSourceSchema,cDestinationSchema);
                        -- Step 2 : Create Sequences and Triggers for the table at destination schema if needed.
                        create_trigger_and_sequence_pd(cTableName,cSourceSchema,cDestinationSchema);
                        -- Step 3 : Create Indexes for the table at destination schema if needed and then drop the rest all indexes if any.
                        create_index_pd(cTableName,cSourceSchema,cDestinationSchema);
                        -- step 4 : Insert the data at destination schema table
                        populateTable_pd(cTableName,cSourceSchema,cDestinationSchema);
                        -- The last step is to Drop the table and we need to really take care here.
                        -- step 5 : Drop the table from all other schema except destination schema.
                        drop_table_pd(cTableName,cDestinationSchema);
                        -- Again create the public synonyms on table
                        create_and_grant_synonym_pd(cTableName,cTableName);
                        -- Step 6 : Now execute all the statements from the statement array.
                        executeStatement_pd(nVerbosity,nExecuteImmediate,cDestinationSchema);
                         if (nVerbosity <> 0) then
                                print_end_time_pd;
                        end if;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                        null;
        END move_table_pd;
        PROCEDURE create_table_pd
                cTableName in ALL_TABLES.TABLE_NAME%TYPE,
                cSourceSchema in ALL_TABLES.OWNER%TYPE,
                cDestinationSchema in ALL_TABLES.OWNER%TYPE
        IS
        BEGIN
                -- Step 1 : Create or drop the table depending on the the tables schema.
                if ((cTableName is not null) AND (cSourceSchema is not null))   then
                        FOR REC_TABLE IN cur_get_create_table_detail(cTableName,cSourceSchema)
                        LOOP
                        BEGIN
                                if      (REC_TABLE.OWNER        =       cSourceSchema)  then
                                        --Get the DDL of the table
                                        cSqlStatement   :=      getObjectDDL_fd('TABLE',cTableName,REC_TABLE.OWNER);
                                        -- As This sql statement is with the source table schma name we need to replace that with the destination schema
                                        -- And then we should create the table.
                                        cSqlStatement   :=      FindAndReplace_fd(cSqlStatement,cSourceSchema,cDestinationSchema);
                                        -- Now first check whether the same table exist at destination schema or not if yes no need to create the same else create.
                                        nObjectFound    :=      isTableAlreadyExist_fd(cTableName,cDestinationSchema);
                                        if (nObjectFound = 0)   then
                                                -- Now we are assured that the same table does not present at cDestinationSchema
                                                -- So now we can push the statement to be executed in statements array.
                                                pushStatement_pd(cSqlStatement);
                                                cSqlStatement   :=      null;
                                        end if;
                                end if;
                        EXCEPTION
                                WHEN OTHERS THEN
                                        null;
                        END;
                        END LOOP;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                        null;
        END create_table_pd;
        PROCEDURE create_trigger_and_sequence_pd
                cTableName              in      ALL_TABLES.TABLE_NAME%TYPE,
                cSourceSchema           in      ALL_TRIGGERS.OWNER%TYPE,
                cDestinationSchema      in      ALL_TRIGGERS.OWNER%TYPE
        IS
                -- Procedure local variables.
                -- for triggers details
                cTriggerSchema        ALL_TRIGGERS.owner%TYPE;
                cDescription          ALL_TRIGGERS.description%TYPE;
                cTriggerBody          ALL_TRIGGERS.trigger_body%TYPE;
                cTriggerName          ALL_TRIGGERS.trigger_name%TYPE;
                -- for sequence details
                cSequenceOwner          ALL_SEQUENCES.sequence_owner%TYPE       ;
                cSequenceName           ALL_SEQUENCES.sequence_name%TYPE        ;
                -- Check Trigger count on table
                cTriggerCount   number  :=0;
        BEGIN
                -- Step 2 : Create the sequences, triggers and there synonyms and grants  on the the tables schema.
                if ((cTableName is not null) AND (cSourceSchema is not null) and (cDestinationSchema is not null))   then
                        FOR REC_TRIGGER IN cur_get_create_trigger_detail(cTableName,cSourceSchema)
                        LOOP
                        BEGIN
                                cTriggerSchema  :=      REC_TRIGGER.owner       ;
                                cDescription    :=      REC_TRIGGER.description ;
                                cTriggerBody    :=      REC_TRIGGER.trigger_body;
                                cTriggerName    :=      REC_TRIGGER.trigger_name;
                                if      (cTriggerSchema =       cSourceSchema)  then
                                                -- check the sequences for that trigger if any then create the same
                                                FOR REC_SEQUENCE IN cur_get_create_sequence_detail(cTriggerName,cSourceSchema) LOOP
                                                        cSequenceOwner  :=      REC_SEQUENCE.sequence_owner;
                                                        cSequenceName   :=      REC_SEQUENCE.sequence_name;
                                                BEGIN
                                                        if ((cSequenceName is not null) AND (cSequenceOwner     =       cSourceSchema)) then
                                                        --Get the DDL of the sequence
                                                        cSqlStatement   :=      getObjectDDL_fd('SEQUENCE',cSequenceName,cSequenceOwner);
                                                        -- As This sql statement is with the source sequence schema name we need to replace that with the destination schema
                                                        -- And then we should create the sequence.
                                                        cSqlStatement   :=      FindAndReplace_fd(cSqlStatement,cSourceSchema,cDestinationSchema);
                                                        -- Now first check whether the same sequence exist at destination schema or not if yes no need to create the same else create.
                                                        nObjectFound    :=      isSequenceAlreadyExist_fd(cSequenceName,cDestinationSchema);
                                                                if (nObjectFound = 0)   then
                                                                        -- Now we are assured that the same sequence does not present at cDestinationSchema
                                                                        -- So now we can push the statement to be executed in statements array.
                                                                        pushStatement_pd(cSqlStatement);
                                                                        cSqlStatement   :=      null;
                                                                        -- First drop synonym and then create
                                                                        drop_synonym_pd(cSequenceName,cDestinationSchema);
                                                                        -- Create the public synonym for sequence and give the grants to the sequence
                                                                        -- As we know this sequence is the part of the trigger so we do not need
                                                                        -- to create the synoyms and grants for the same
                                                                        --create_and_grant_synonym_pd(cSequenceName,cSequenceName);
                                                                        -- And now drop this existing sequences
                                                                        drop_sequence_pd(cSequenceName,cSourceSchema,cDestinationSchema);
                                                                end if;
                                                        end if;
                                                EXCEPTION
                                                        WHEN OTHERS THEN
                                                                null;
                                                END;
                                                END LOOP;
                                        -- Now first check whether the same table exist at destination schema or not if yes no need to create the same else create.
                                        nObjectFound    :=      isTriggerAlreadyExist_fd(cTriggerName,cDestinationSchema);
                                        if (nObjectFound = 0)   then
                                                -- Now we are assured that the same table does not present at cDestinationSchema
                                                -- So now we can push the statement to be executed in statements array.
                                                -- Rather we can create the trigger using some different way as show below
                                                -- Create trigger using different way
                                                cDescription    :=      FindAndReplace_fd(UPPER(cDescription),cTableName,cDestinationSchema||'.'||cTableName);
                                                cSqlStatement     :='CREATE OR REPLACE TRIGGER '||cDescription||UPPER(cTriggerBody);
                                                pushStatement_pd(cSqlStatement);
                                                cSqlStatement   :=      null;
                                        end if;
                                        -- Now drop the existing synonyms on triggers if any
                                        -- As we do not create the synonyms for triggers then we dont have to drop the same
                                        --drop_synonym_pd(cTriggerName,cDestinationSchema);
                                        -- Now drop the existing triggers from other schema
                                        -- We do not need to drop the triggers manually as it gets dropped along with the table.
                                        --drop_trigger_pd(cTriggerName,cSourceSchema,cDestinationSchema);
                                end if;
                        EXCEPTION
                                WHEN OTHERS THEN
                                        null;
                        END;
                        END LOOP;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                        null;
        END create_trigger_and_sequence_pd;
        PROCEDURE       create_index_pd
                cTableName              in      ALL_INDEXES.TABLE_NAME%TYPE,
                cSourceSchema           in      ALL_INDEXES.OWNER%TYPE,
                cDestinationSchema      in      ALL_INDEXES.OWNER%TYPE
        IS
        BEGIN
        --cur_get_create_index_detail   index_name
                if((cTableName is not null) AND (cSourceSchema is not null) AND (cDestinationSchema is not null) )      then
                        FOR REC_CREATE_INDEX IN cur_get_create_index_detail(cTableName,cSourceSchema)
                        LOOP
                                BEGIN
                                        if      ((REC_CREATE_INDEX.index_name IS NOT NULL ) AND (REC_CREATE_INDEX.owner =       cSourceSchema))  then
                                                --Get the DDL of the Index
                                                cSqlStatement   :=      getObjectDDL_fd('INDEX',REC_CREATE_INDEX.index_name,REC_CREATE_INDEX.owner);
                                                -- As This sql statement is with the source index schema name
                                                -- we need to replace that with the destination schema
                                                -- And then we should create the sequence.
                                                cSqlStatement   :=      FindAndReplace_fd(cSqlStatement,cSourceSchema,cDestinationSchema);
                                                 -- Now first check whether the same index exist at destination schema or not
                                                 -- if yes no need to create the same else create.
                                                 nObjectFound    :=      isIndexAlreadyExist_fd(REC_CREATE_INDEX.index_name,cDestinationSchema);
                                                 if (nObjectFound = 0)   then
                                                        -- Now we are assured that the same index does not present at cDestinationSchema
                                                        -- So now we can push the statement to be executed in statements array.
                                                        pushStatement_pd(cSqlStatement);
                                                        cSqlStatement   :=      null;
                                                        -- Now as we have created a statement to create the index
                                                        -- So we need to check its existing Synonmyms and drop the same if exist
                                                        drop_synonym_pd(REC_CREATE_INDEX.index_name,cDestinationSchema);
                                                        -- Guess for Indexes we do not need to creat public synonym and no need to give grant to index
                                                        --create_and_grant_synonym_pd(REC_CREATE_INDEX.index_name,REC_CREATE_INDEX.index_name);
                                                         -- And now drop this existing indexes if any
                                                         --  We do not need to drop the indexes manually as it gets dropped along with the table.
                                                         -- drop_index_pd(REC_CREATE_INDEX.index_name,cSourceSchema,cDestinationSchema);
                                                 end if;
                                        end if;
                                EXCEPTION
                                        WHEN OTHERS THEN
                                                null;
                                END;
                        END LOOP;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                        null;
        END create_index_pd;
        PROCEDURE       populateTable_pd
                cTableName              in      ALL_TABLES.TABLE_NAME%TYPE,
                cSourceSchema           in      ALL_TABLES.OWNER%TYPE,
                cDestinationSchema      in      ALL_TABLES.OWNER%TYPE
        IS
        BEGIN
                if((cTableName is not null) AND (cSourceSchema is not null) AND (cDestinationSchema is not null) )      then
                        nObjectFound    :=      isTableAlreadyExist_fd(cTableName,cSourceSchema);
                        if (nObjectFound <> 0) then
                                cSqlStatement   :=      'INSERT INTO ' ||cDestinationSchema||'.'|| cTableName||
                                                        ' SELECT * FROM '||cSourceSchema||'.'||cTableName;
                                pushStatement_pd(cSqlStatement);
                                cSqlStatement   :=      null;
                        end if;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                        null;
        END populateTable_pd;
        PROCEDURE        executeStatement_pd
                nVerbosity              in      number :=0,
                nExecuteImmediate       in      number  := 1,
                cExecuteOn              in      varchar2:=      'STI_COMMON'
        IS
        nTotalRecords   number  :=0;
        l_strsql LONG;
        cStmt varchar2(200);
        cError varchar2(300);
        cCurrentSchema  varchar2(50);
        BEGIN
                if (aAllStatement is not null)  then
                        cCurrentSchema  :=      getCurrentSchema_fd;
                        if (nExecuteImmediate <> 0) then
                                --altersession_pd;
                                DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'PRETTY',false);
                                DBMS_METADATA.SET_TRANSFORM_PARAM(DBMS_METADATA.SESSION_TRANSFORM,'SQLTERMINATOR',false);
                        end if;
                        nTotalRecords   :=      aAllStatement.COUNT;
                        if (nVerbosity <> 0)    then
                                DBMS_OUTPUT.PUT_LINE('TOTAL STATEMENTS TO BE EXECUTED :'|| nTotalRecords);
                                DBMS_OUTPUT.PUT_LINE('---------------------- EXECUTION BEGINS HERE -----------------');
                        end if;
                        --FOR cntr      in      1..nTotalRecords
                        FOR cntr      in      aAllStatement.FIRST..aAllStatement.LAST
                        LOOP
                                BEGIN
                                        if aAllStatement.EXISTS(cntr) then
                                                cSqlStatement :=        aAllStatement(cntr);
                                                l_strsql := dbms_lob.SUBSTR( cSqlStatement, 32765, 1 );
                                                if (nVerbosity <> 0)    then
                                                        DBMS_OUTPUT.PUT_LINE(cntr||' Now executing : '||cSqlStatement );
                                                end if;
                                                if (nExecuteImmediate <> 0)     then
                                                        if (l_strsql is not null)       then
                                                                BEGIN
                                                                --EXECUTE IMMEDIATE     cSqlStatement;
                                                                EXECUTE IMMEDIATE       l_strsql;
                                                                INSERT INTO gen_sql_log (t_sql_log_time,c_os_user,c_host,c_Server_Host,c_sql) VALUES (LOCALTIMESTAMP,sys_context('USERENV', 'OS_USER'),sys_context('USERENV', 'HOST'),sys_context('USERENV', 'SERVER_HOST'),l_strsql);
                                                                EXCEPTION
                                                                        WHEN OTHERS THEN
                                                                                cError:=substr(SQLERRM,1,300);
                                                                                DBMS_OUTPUT.PUT_LINE('-------------<< ERROR >>-------------');
                                                                                DBMS_OUTPUT.PUT_LINE('Error while running : '|| l_strsql);
                                                                                DBMS_OUTPUT.PUT_LINE('');
                                                                                DBMS_OUTPUT.PUT_LINE('Error Occured : '|| cError);
                                                                                DBMS_OUTPUT.PUT_LINE('-------------<< END OF ERROR >>-------------');
                                                                END;
                                                        end if;
                                                end if;
                                        end if;
                                EXCEPTION
                                        WHEN OTHERS THEN
                                                null;
                                END;
                        END LOOP;
                        aAllStatement.DELETE(aAllStatement.FIRST,aAllStatement.LAST);
                        --aAllStatement.TRIM(nTotalRecords);
                        nStatementCounter       :=0;
                        -- Move back to previous session
                        if (nExecuteImmediate <> 0) then
                                --altersession_pd(cCurrentSchema);
                                cCurrentSchema  :=      getCurrentSchema_fd;
                                if (nVerbosity <> 0)    then
                                        DBMS_OUTPUT.PUT_LINE(' CURRENT SCHEMA : '|| cCurrentSchema);
                                 end if;
                        end if;
                        commit;
                end if;
        EXCEPTION
                WHEN OTHERS THEN
                null;
        END executeStatement_pd;