Looping in cursors in oracle pl/sql - oracle

Question

Basically, a cursor is an area of memory which is used to store the result of a particular query. One question I have is do cursors implicitly loop through all the records? Suppose I write a code snippet like the following:
declare
cursor cur_dum is
select name,class,enroll_id from table_student;
begin
fetch cur_dum into the_name, the_class, the_enroll_id;
update table_log set statement = the_name || '-'||'-'||to_char(the_enroll_id)
where roll_id = the_enroll_id;
close cur_dum;
end;
Will this code snippet,without any explicit statement of loop, automatically loop through all the records in table_student and perform the corresponding update in table_log ?Do I need to add a loop after the fetch statement ? What difference would it make if I use a Bulk collect statement during fetching ?
From the answer , I got it that explicitly stating a loop is necessary .
I came across a snippet of code which used a loop for a cursor and also used a for loop inside it .The following is the code snippet :
Cursor CurSquirell IS
select Name,a_val,b_val,col_ID from table_temp;
BEGIN
LoopCounter := 0;
commit;
LOOP
FETCH CurSquirell BULK COLLECT INTO my_name,my_a_val,my_b_val,my_col_id LIMIT 1000;
LoopCounter := LoopCounter + 1;
FOR intIndex IN 1 .. my_col_id.COUNT LOOP
counter := counter +1;
BEGIN
select t.tender_val,t.tender_pay, t.page_no, t.loc
into my_tender_val,my_tender_pay,my_page_no , my_loc
from bussiness_trans bt, tender_details t
where t.account_no = bt.account_no
and bt.external_id=my_col_id(intIndex)
and trim(replace(t.tender_pay,'0',' ')) = trim(replace(a_val(intIndex),'0',' '))
and bt.id_type=1;
BEGIN
select pp.lock_id into my__lock_id
from pay_roll pp
where pp.pay_points= my_tender_pay
and bt.id_type=5;
BEGIN
update tab_cross_exchange tce
set tce.cross_b_val = my_b_val(intIndex)
where tce.lock_id = my_lock_id;
..............................sql statements...
...sql statements...
end;
end;
end;
When in the code loop has already been used to go through the records one by one , why has the for loop been used ? In what situations would you require a for loop like this inside a cursor loop ? Does the bulk collect has to do anything to force the usage of For loop ?

Answer 1

"a cursor is an area of memory which is used to store the result of a particular query"
Not quite. A cursor is a pointer to an area of memory used to store information about a query. Results of the query are stored in other areas of memory.
The PL/SQL syntax you use specifies a variable which defines a query. To execute the query you need to
Open the cursor
Fetch the data into target variable(s)
When finished, close the cursor
Each fetch returns one row. To exhaust the query you need to execute the fetch in a loop. This is the verbose way of doing so:
declare
cursor cur_dum is
select name,class,enroll_id from table_student;
rec_dum cur_dum%rowtype;
begin
open cur_dum;
loop
fetch cur_dum into rec_dum;
exit when cur_dum%notfound;
update table_log
set statement = rec_dum.name || '-'||'-'||to_char(rec_dum.enroll_id)
where roll_id = rec_dum.enroll_id;
end loop;
close cur_dum;
end;
Note: one benefit of this explicit cursor notation is that we can define a variable typed to the projection of the cursor's query (rec_dum above).
This is the same logic using implicit cursor notation:
declare
cursor cur_dum is
rec_dum cur_dum%rowtype;
begin
for rec_dum in (select name,class,enroll_id from table_student)
loop
update table_log
set statement = rec_dum.name || '-'||'-'||to_char(rec_dum.enroll_id)
where roll_id = rec_dum.enroll_id;
end loop;
end;
" Does the bulk collect has to do anything to force the usage of For loop ?"
BULK COLLECT is the the syntax which allows us to populate a nested table variable with a set of records and so do bulk processing rather than the row-by-row processing of the basic FETCH illustrated above; the snippet you quote grabs a sub-set of 1000 records at a time, which is necessary when dealing with large amounts of data because variables populate private (session) memory rather than global (shared memory). The code you quoted is very poor, not least because the FETCH ... BULK COLLECT INTO statement is not followed by a test for whether the FETCH returned any values. Because there's no test the subsequent code will fail at runtime.
"Does the usage of for loop inside the cursor loop make the code poor ? "
No, not automatically. For instance when doing bulk processing we may often do something like this:
<< batch_loop >>
loop
fetch dum_cur bulk collect into dum_recs limit 1000;
exit when dum_recs.count() = 0;
<< row_loop >>
for idx in dum_recs.first()..dum_recs.last()
loop
do_something(dum_recs(idx));
end loop row_loop;
end loop batch_loop;
However, we should be suspicious of nested CURSOR FOR loops. Nested loops are common in 3GL programs like Java:
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 10; j++) {
So developers familiar with that style of coding often reach for nested loops when moving to PL/SQL. But SQL is a set-based paradigm. There are usually better ways of implementing that logic, such as a JOIN: make the two cursors into one.