Iterative statements: Loop-End Loop, For-Loop, While Loop, Exit Loop, Continue

📖 Theory

આપોઆપ ચાલતું છાપખાનું

કલ્પો કે તમે CampusLib database માટે backend terminal કામગીરી ચલાવી રહ્યા છો. મુખ્ય librarian તમને 50 જુદા students માટે એક personalized ચેતવણીનો સંદેશો છાપવાનું કહે છે જેમનાં પુસ્તકો મોડાં છે. હાથે વધારેલા numbers સાથે એ જ DBMS_OUTPUT.PUT_LINE statement 50 વાર લખવું માત્ર થકવનારું નથી, એ તમારા code ને ફૂલેલો અને તદ્દન કાચો દેખાડે છે. લીટીઓ દોહરાવ્યા વગર દોહરાવાતી database ક્રિયાઓ નિર્દોષ રીતે કરવા, આપણે iterative loops વાપરીએ છીએ. Oracle PL/SQL માં, આ ચક્રો સંભાળવા આપણી પાસે ત્રણ અલગ loop વ્યૂહરચનાઓ છે.

📖 Theory

છતનો પંખો અને Push-Up ની ગણતરી

એક Basic Loop ને પૂરી ઝડપે ચાલતા છતના પંખા જેવો વિચારો; જ્યાં સુધી તમે સ્પષ્ટપણે દીવાલની સ્વિચ (EXIT) ન દબાવો ત્યાં સુધી એ એક અનંત loop માં ફર્યા કરશે. એક WHILE loop એટલે ખુલ્લી છત્રી લઈને બહાર ચાલવું; જ્યાં સુધી વરસાદ પડે છે ત્યાં સુધી તમે ચાલતા રહો છો, પણ જે ક્ષણે વરસાદ અટકે, તમે છત્રી બંધ કરીને અંદર જતા રહો છો. એક FOR loop એટલે તમારી સવારની gym કસરત દરમિયાન બિલકુલ 20 push-ups કરવા; તમે પહેલી rep શરૂ કરો એ પહેલાં જ તમને શરૂઆતની ગણતરી (1) અને અંતિમ લક્ષ્ય (20) બિલકુલ ખબર છે.

📖 Theory

Iteration ના ત્રણ સ્વરૂપો

PL/SQL iterative logic ને ત્રણ પ્રકારમાં વહેંચે છે: Basic Loop (default રીતે અનંત), WHILE Loop (પ્રવેશદ્વારે conditional ચકાસણી), અને FOR Loop (counter થી ચાલતી સીમાઓ). આ blocks કાર્યક્ષમ રીતે સંભાળવા transition keywords પર પૂરું પ્રભુત્વ જોઈએ: EXIT WHEN એક ક્રમમાંથી વહેલું બહાર નીકળે છે, જ્યારે CONTINUE Oracle ને હાલના loop ની બાકીની લીટીઓ છોડીને સીધા આગલા iteration ની ટોચે કૂદવાનું કહે છે.

📊 At a glance

PL/SQL loop configurations નાં સંરચનાત્મક વર્તન અને ગુણધર્મો

⌨️ Practical

Tracking Fines and Skipping Holidays across Iterations

-- An anonymous block comparing a Basic Loop and a counter-driven FOR Loop
DECLARE
  v_basic_counter NUMBER := 1;
  v_total_fine    NUMBER := 0;
BEGIN
  DBMS_OUTPUT.PUT_LINE('--- 1. Processing via Basic Loop ---');
  LOOP
    v_total_fine := v_total_fine + 5;
    DBMS_OUTPUT.PUT_LINE('Day ' || v_basic_counter || ' Fine: Rs. ' || v_total_fine);
    
    v_basic_counter := v_basic_counter + 1;
    -- Mandatory exit guard to prevent system freeze
    EXIT WHEN v_basic_counter > 5;
  END LOOP;

  DBMS_OUTPUT.PUT_LINE('--- 2. Processing via Counter-Driven FOR Loop ---');
  -- Note: loop_idx does NOT need to be declared in the DECLARE section!
  FOR loop_idx IN 1..5 LOOP
    -- Using CONTINUE to skip an entry point dynamically
    IF loop_idx = 3 THEN
      DBMS_OUTPUT.PUT_LINE('Day 3 is a College Holiday! Skipping generation.');
      CONTINUE;
    END IF;
    
    DBMS_OUTPUT.PUT_LINE('Day ' || loop_idx || ' automated ledger entry processed.');
  END LOOP;
END;
/

🪜 Follow along

એક FOR Loop નો આંતરિક ક્રમ

1. 1. આપોઆપ ગોઠવણી Oracle engine FOR loop statement નોંધે છે અને પડદા પાછળ counter variable ને આપોઆપ એક integer તરીકે જાહેર કરે છે.
2. 2. Range નું Initialization Compiler સીમાઓ તપાસે છે (દા.ત. 1..5). જો નીચલી value ઉપલા લક્ષ્ય કરતાં નાની કે બરાબર હોય, execution અંદર ઊતરે છે.
3. 3. આપોઆપ પગલું મળતા END LOOP નિશાનને અડતાં, Oracle ગણિતનું પગલું આંતરિક રીતે સંભાળે છે, હાથે code ના સંકેત વગર counter ને 1 થી update કરતાં.
4. 4. આપોઆપ સંદર્ભ સફાઈ એક વાર index ઉપલી range ની સીમા વટાવે, loop સમાપ્ત થાય છે અને આપોઆપ બનેલો index variable session ની memory માંથી કાયમ માટે ભૂંસાઈ જાય છે.

🧩 Quiz

જો તમે એક PL/SQL FOR loop ના શરીરની અંદર loop index variable ને હાથે બદલવાનો કે એને value સોંપવાનો પ્રયાસ કરો (દા.ત. 'loop_idx := loop_idx + 2;' લખવું) તો શું થાય છે?

1. Statement સફળતાપૂર્વક ચાલે છે અને loop નું પગલું બદલી નાખે છે.
2. Block ચાલે છે પણ FOR loop ને એક અનંત Basic Loop માં ફેરવી નાખે છે.
3. Oracle તરત એક compilation error ફેંકે છે કારણ કે એક FOR loop નો counter loop ના શરીરની અંદર સખ્તાઈથી માત્ર વાંચી શકાય એવો variable છે.
4. Block સફળતાપૂર્વક compile થાય છે પણ runtime પર એ લીટી સંપૂર્ણપણે અવગણે છે.

⚠️ Watch out

REVERSE સીમાનો ફાંદો

જ્યારે તમારે એક FOR loop ને 10 થી ઊલટું ગણીને 1 સુધી લાવવો હોય, તમે સહજપણે FOR i IN 10..1 LOOP લખી બેસો. આ પાકો ફાંદો છે! Oracle સખ્તાઈથી લાગુ કરે છે કે નીચલી સીમા હંમેશા ડાબી બાજુ અને ઉપલી સીમા જમણી બાજુ બેસવી જોઈએ. ઊલટાં ચક્રો ચલાવવા, તમારે FOR i IN REVERSE 1..10 LOOP લખવું પડશે. જો તમે 10..1 લખો, Oracle આંકે છે કે 10 એ 1 થી મોટું છે, સીમાની ચકાસણી નિષ્ફળ કરે છે, અને એક પણ લીટી ચલાવ્યા વગર આખો loop block છોડી દે છે!

💭 Think first

Loop Index Variable ઢંકાવાની કસોટી

માનસિક પડકાર: જો તમે તમારા DECLARE block માં 'v_counter NUMBER := 100;' નામનો એક variable જાહેર કરો, અને પછી 'FOR v_counter IN 1..5 LOOP' તરીકે રચાયેલો એક loop ચલાવો, તો END LOOP statement ની તરત પછી v_counter નો સંદર્ભ લેતાં કઈ value છપાશે? Variable ના scope વિશે વિચારો.

📖 Theory

University Lab Exam માં ગુણ મેળવવાની ટેવ

Semester 4 ના database lab નું મૂલ્યાંકન કરતા બહારના examiners ખાસ કરીને તમારા Basic Loops માં એક EXIT condition ની હાજરી તપાસે છે. જો તમે કાગળ પર કે terminal screen પર એક સાદું LOOP-END LOOP માળખું લખો અને એની સાથે એક સ્પષ્ટ EXIT WHEN statement ન જોડો, તો એક ખતરનાક અનંત lockup નું જોખમ ઊભું કરવા બદલ તમે તરત performance ના marks ગુમાવશો.

✅ Summary

Key takeaways

• Iterative loops બિનજરૂરી code blocks બનાવ્યા વગર દોહરાવાતી કામગીરી સલામત રીતે આપોઆપ કરે છે.
• Basic Loops સતત ચાલે છે અને execution માંથી બહાર નીકળવા એક સ્પષ્ટ EXIT નિશાન માંગે છે.
• WHILE Loops અંદરની કોઈ પણ code લીટી process કરતાં પહેલાં શરૂઆતના પ્રવેશદ્વારે conditions આંકે છે.
• FOR Loops index variables અને range ની સીમાઓ આપોઆપ સંભાળે છે, loop counters ને માત્ર વાંચી શકાય એવા ગણતાં.
• REVERSE loop ની syntax સખ્તાઈથી નીચલી સીમા પહેલાં માંગે છે, આ રીતે: REVERSE lower..upper.
• CONTINUE modifier ચાલુ loop ચક્રનો બાકીનો ભાગ છોડીને સીધો આગલા ફેરા પર કૂદે છે.
• Memory hook: Basic loops ને હાથે સ્વિચ જોઈએ, WHILE પ્રવેશદ્વારે ગાળે છે, અને FOR પોતાના ગિયર જાતે ચલાવે છે!