Declare, open, fetch and close cursors

📖 Theory

મોડી યાદી પર ચાલવું

કલ્પો કે તમારા university ના librarian તમને એક કાગળ આપે છે જેમાં 45 students નાં નામ છે જેમણે પોતાનાં programming નાં પાઠ્યપુસ્તકો પાછાં આપ્યાં નથી. તમારું કામ છે પહેલું નામ જોવું, એમનો phone number શોધવો, એક ચેતવણીની ચિઠ્ઠી છાપવી, એમને છેકી નાખવા, અને આગલી હરોળ પર સરકવું. Rows ખૂટે નહીં ત્યાં સુધી તમે આ ક્રમ હાથે દોહરાવો છો. PL/SQL માં, જો એક query અનેક records પાછા આપે, computer એ બધા એક જ ઝબકારામાં એકસાથે process કરી શકતું નથી. આપણે database engine ને આ ચોક્કસ ભૌતિક પગલાં દ્વારા સ્પષ્ટપણે દોરવું પડે: data તરફ ઈશારો કરવો, એને load કરવો, એક વખતે એક લીટી પકડવી, અને કાર્યક્ષેત્ર સાફ કરવું.

📖 Theory

ભૂગર્ભ પાણીની Pipeline

એક explicit cursor સંભાળવાનું એક ખેતરમાં borewell ની pipeline ગોઠવવા જેવું વિચારો. પહેલાં, તમે નકશો પાથરો છો કે ભૂગર્ભનો પાણીનો રસ્તો બિલકુલ ક્યાં જાય છે (DECLARE). પછી, તમે મુખ્ય વાલ્વ ખોલો છો, જેથી પાણી તમારી સ્થાનિક ટાંકીમાં ઊછળીને ચઢે (OPEN). પછી, તમે તમારા પાકને ક્રમશઃ પાણી આપવા નળમાંથી એક પછી એક ડોલ ભરો છો (FETCH). છેલ્લે, જ્યારે ખેતરો પૂરાં પિવાય, તમે વીજળી બચાવવા અને પૂર અટકાવવા વાલ્વ સખ્તાઈથી બંધ કરો છો (CLOSE).

📖 Theory

Explicit નિયંત્રણની ચાર આજ્ઞાઓ

તમારા code ને TOO_MANY_ROWS exception થી crash કર્યા વગર multi-row પરિણામો સલામત રીતે સંભાળવા, તમારે cursor ના જીવનચક્રની પૂરી programmatic માલિકી લેવી પડશે. આ જીવનચક્ર તમારા PL/SQL block ના માળખામાં લખાયેલા ચાર અલગ operational commands માં વહેંચાયેલું છે.

📊 At a glance

એક programmer-સંચાલિત explicit cursor ની વ્યવસ્થિત માળખાકીય મુસાફરી

⌨️ Practical

Stepping Through the Library Overdue Ledger

-- An anonymous block to manually fetch and display high-fine library members
DECLARE
  -- Step 1: Declare the cursor with its query blueprint
  CURSOR c_fine_ledger IS
    SELECT member_id, fine_balance 
    FROM members 
    WHERE fine_balance > 150;
    
  -- Variables to receive cursor values during FETCH
  v_mem_id   members.member_id%TYPE;
  v_balance  members.fine_balance%TYPE;
BEGIN
  -- Step 2: Open the data channel and freeze the active set
  OPEN c_fine_ledger;
  
  -- Iterating through rows explicitly
  LOOP
    -- Step 3: Pull data into target variables
    FETCH c_fine_ledger INTO v_mem_id, v_balance;
    
    -- Universal guard rule: exit early when no more rows exist
    EXIT WHEN c_fine_ledger%NOTFOUND;
    
    -- Operational logic on the current row
    DBMS_OUTPUT.PUT_LINE('Alert sent to Member ID: ' || v_mem_id || ' | Penalty: Rs. ' || v_balance);
  END LOOP;
  
  -- Step 4: Shut down the valve and reclaim RAM
  CLOSE c_fine_ledger;
END;
/

🪜 Follow along

Tracer Bullet: Row Pointer ની હિલચાલ

1. 1. OPEN નો સળગાટ Query ને 3 મળતી rows મળે છે. Database engine આ 3 entries રાખતો એક memory block બનાવે છે. Pointer 'શૂન્ય' સ્થાને, હરોળ 1 ની બરાબર ઉપર ટકે છે.
2. 2. પહેલો FETCH પ્રહાર Oracle હરોળ 1 વાંચે છે, એનો data 'v_mem_id' અને 'v_balance' માં નકલ કરે છે, અને તરત pointer ને નીચે સીધું હરોળ 2 પર ટેકવે છે.
3. 3. Data પૂરો થયાનો સંકેત ચોથા loop iteration દરમિયાન, FETCH data વાંચવાનો પ્રયાસ કરે છે, પણ pointer હરોળ 3 પછીની ખાલી જગ્યાએ અથડાય છે. આંતરિક system flag %NOTFOUND તરત FALSE થી TRUE થઈ જાય છે.
4. 4. સાફ ખાલી કરવું EXIT WHEN નિયમ TRUE flag પકડે છે, તરત loop ના ચક્રમાંથી બહાર નીકળે છે, અને 3-હરોળનો memory cache સાફ કરવા નિયંત્રણ CLOSE statement પર વાળે છે.

🧩 Quiz

જો એક developer એક નામવાળા explicit cursor પર એનું મળતું OPEN statement ચલાવ્યા પહેલાં FETCH statement ચલાવવાનો પ્રયાસ કરે તો શું થાય છે?

1. Block સફળતાપૂર્વક ચાલે છે પણ બધા લક્ષ્ય variables NULL values થી ભરાય છે.
2. Oracle execution બચાવવા પડદા પાછળ આપોઆપ cursor implicitly ખોલી નાખે છે.
3. PL/SQL engine એક runtime crash અનુભવે છે જે તરત એક 'INVALID_CURSOR' (ORA-01001) exception ફેંકે છે.
4. Compiler compilation દરમિયાન ક્રમ પકડે છે અને તરત એક syntax ભંગાણ દર્શાવે છે.

⚠️ Watch out

અનંત નકલનો ફાંદો

તમે તમારો EXIT WHEN સલામતીનો વાલ્વ ક્યાં મૂકો છો એના પર ખાસ ધ્યાન આપો! Practical exams માં university students દ્વારા થતી એક classic ભૂલ છે loop ની અંદર exit condition ને FETCH statement પહેલાં મૂકવી. જો તમે કોઈ પણ extraction થાય એ પહેલાં loop ની બિલકુલ શરૂઆતે %NOTFOUND તપાસો, તો attribute FALSE (કે NULL) આંકાય છે, એટલે loop પસાર થઈ જશે. છેલ્લા ફેરામાં, એ સૌથી છેલ્લી હરોળનો data બે વાર છાપી શકે છે કારણ કે program data નો પ્રવાહ સુકાઈ ગયો છે એ સમજ્યા પહેલાં જૂના variables આંકે છે!

💭 Think first

સંરચનાત્મક Variable ગોઠવણની ચકાસણી

જો તમારું cursor SELECT statement બિલકુલ ત્રણ columns કાઢે (દા.ત. id, name, fine), પણ તમારો FETCH code 'FETCH c1 INTO v_id, v_name;' કહે, તો Oracle શું કરશે? સંરચનાત્મક સોંપણીની સમમિતિ વિશે વિચારો.

📖 Theory

Lab Exam નો Score વધારનાર

જ્યારે એક બહારના university laboratory examiner તમને screen પર એક explicit cursor દેખાડવાનું કહે, ત્યારે હંમેશા બે વાર તપાસો કે તમારો CLOSE command loop ના શરીરની બહાર સલામત રીતે બેસે છે, પણ block ના અંતિમ END; statement ની બરાબર પહેલાં. Cursors બંધ ન કરવા એ બેદરકાર memory સંચાલનની ટેવો બદલ performance ના marks ગુમાવવાનો સૌથી સહેલો રસ્તો છે.

✅ Summary

Key takeaways

• Explicit cursors એ developers દ્વારા હાથે સંભાળાતી custom, programmatic હરોળ-દર-હરોળ data pipelines છે.
• DECLARE પગલું ખરેખરા records track કર્યા વગર કે હરોળની RAM ફાળવ્યા વગર લક્ષ્ય query નો નકશો ગોઠવે છે.
• OPEN પગલું નીચેની query ચલાવે છે, active set નું context area બનાવે છે, અને row pointer initialize કરે છે.
• FETCH પગલું સક્રિય record માંથી data સ્થાનિક variables માં ખેંચે છે અને pointer નીચે ખસેડે છે.
• CLOSE પગલું pipeline સલામત રીતે સમાપ્ત કરે છે, memory ના buffers database engine ને પાછા છોડતાં.
• %NOTFOUND attribute વાપરીને સ્થિતિના ફેરફારો track કરવામાં નિષ્ફળ જવાથી અનંત loops કે બેવડા records છપાઈ શકે છે.
• Memory hook: નકશો પાથરો (DECLARE), ચાલુ કરો (OPEN), rows દોહો (FETCH), અને વાલ્વ સીલ કરો (CLOSE)!