Concepts of Cursors: Implicit & Explicit

📖 Theory

Multi-Row નો Traffic Jam

કલ્પો કે તમારે CampusLib desk પર મોડું પુસ્તક ધરાવતા એક જ student ની સંપર્ક વિગતો શોધવી છે. એક સાદું SELECT INTO statement સરસ કામ કરે છે કારણ કે એ બિલકુલ એક હરોળને એક સ્થાનિક variable માં map કરે છે. પણ જો 50 students પાસે મોડાં પુસ્તકો હોય તો શું થાય? જો તમે એ જ standard query નું માળખું ચલાવો, database engine ગભરાય છે, એક 'TOO_MANY_ROWS' error ફેંકે છે, અને તમારી application crash કરે છે. SQL સ્વાભાવિક રીતે આખાં tables કે સમૂહોમાં વિચારે છે, પણ PL/SQL માત્ર હરોળ-દર-હરોળ logic process કરી શકે છે. તો આપણે એક વિશાળ multi-row table નું પરિણામ એક ક્રમિક program માં system ના ઢગલા વગર સલામત રીતે કેવી રીતે આપીએ?

📖 Theory

Restaurant નો Conveyor Belt સામે Buffet ની થાળી

એક Implicit Cursor ને એક fast-food counter પર ચોક્કસ combo meal નો order આપવા જેવો વિચારો, server બિલકુલ એક જ થાળી તૈયાર કરે છે, તમને આપે છે, અને વ્યવહાર તરત પૂરો થાય છે. એક Explicit Cursor એટલે ફરતા sushi conveyor belt પાસે બેસવું. રસોડું વૈવિધ્યસભર વાનગીઓનો એક મોટો સંગ્રહ (સક્રિય query નું પરિણામ) તૈયાર કરે છે અને એમને કામચલાઉ memory માં belt પર ચઢાવે છે. તમે એ બધું એકસાથે ખાતા નથી; તમે એક વખતે એક થાળી ઉપાડો છો (FETCH), એને process કરો છો, અને belt સંપૂર્ણપણે ખાલી થાય ત્યાં સુધી આગલી વાનગી નજર સામે સરકે એની રાહ જુઓ છો.

📖 Theory

Context Memory ના ખાનગી કાર્યક્ષેત્રની વ્યાખ્યા

ઔપચારિક રીતે, એક cursor એ Oracle database engine દ્વારા ફાળવાયેલા Context Area નામના ખાનગી memory કાર્યક્ષેત્ર તરફનું એક pointer છે. આ કાર્યક્ષેત્ર એક SQL query દ્વારા પાછી અપાયેલી rows ને execution ની સ્થિતિના flags સાથે રાખે છે. PL/SQL cursors ને બે અલગ operational models માં વહેંચે છે: Implicit અને Explicit. તમે જ્યારે પણ એક INSERT, UPDATE, DELETE, કે એક-હરોળની SELECT query ચલાવો, Oracle તમારા માટે ચૂપચાપ એક implicit cursor બનાવે અને સંભાળે છે. એથી ઊલટું, જ્યારે તમે અપેક્ષા રાખો કે એક query અનેક rows ને અડશે, ત્યારે તમારે program ના code ની અંદર તમારો પોતાનો cursor સ્પષ્ટપણે બનાવવો, નામ આપવું, અને સંભાળવો પડશે.

📊 At a glance

આંતરિક system cursors અને programmer-વ્યાખ્યાયિત loops વચ્ચેના કાર્યાત્મક ભેદ

⌨️ Practical

Contrasting Implicit Tracking with Explicit Cursor Blueprints

-- An anonymous block demonstrating implicit cursor execution alongside explicit definition
DECLARE
  -- Defining an explicit cursor layout for multi-row scanning
  CURSOR c_overdue_members IS
    SELECT name, member_id 
    FROM members 
    WHERE fine_balance > 100;
    
  v_name members.name%TYPE;
  v_id   members.member_id%TYPE;
BEGIN
  -- 1. Example of an Implicit Cursor action
  UPDATE members 
  SET fine_balance = fine_balance + 10 
  WHERE department = 'BCA';
  
  -- Checking implicit attributes using the global 'SQL' handle
  DBMS_OUTPUT.PUT_LINE('Rows updated implicitly: ' || SQL%ROWCOUNT);
  
  -- 2. Brief preview of the Explicit Cursor journey
  OPEN c_overdue_members;
  FETCH c_overdue_members INTO v_name, v_id;
  DBMS_OUTPUT.PUT_LINE('First high-fine member caught: ' || v_name);
  CLOSE c_overdue_members;
END;
/

🪜 Follow along

એક Explicit Cursor માળખાનું જીવનચક્ર

1. 1. જાહેરાત Developer DECLARE section માં એક નામવાળું cursor handle નોંધે છે, એને કાયમ માટે એક ચોક્કસ SELECT query ના નકશા સાથે map કરતાં.
2. 2. Initialization (OPEN) Program નીચેની query ચલાવે છે, મળતી rows ને એક ખાનગી સક્રિય memory સમૂહમાં લાવે છે, અને એક આંતરિક row pointer ને પહેલી entry પર ગોઠવે છે.
3. 3. કાઢવું (FETCH) Runtime engine હાલની હરોળના column ની values ડાબી બાજુ સ્થાનિક variables માં નકલ કરે છે અને pointer ને પછીના record પર નીચે ખસેડે છે.
4. 4. નિકાલ (CLOSE) Program cursor બંધ કરે છે, સક્રિય memory નું context area database server ને પાછું છોડે છે અને row pointer નો cache નાશ કરે છે.

🧩 Quiz

નીચેનામાંથી કઈ database ઘટના એક PL/SQL block ની અંદર એક Implicit Cursor ના આપોઆપ સર્જનને trigger કરશે?

1. એક custom composite record type જાહેર કરવો.
2. એક table ની હરોળ પર સીધું એક standard UPDATE કે DELETE statement ચલાવવું.
3. એક FOR loop block ની અંદર એક loop counter variable વ્યાખ્યાયિત કરવો.
4. Executable section માં એક નામવાળું cursor statement ખોલવું.

⚠️ Watch out

એક-હરોળના SELECT INTO નો ફાંદો

University theory exams માટે અહીં એક પાકો પ્રિય પ્રશ્ન છે! Students ઘણી વાર ધારે છે કે એક standard SELECT ... INTO query cursors વાપરતી નથી કારણ કે કોઈ CURSOR keyword દેખાતો નથી. હકીકતમાં, એ એક implicit cursor ચલાવે છે. કારણ કે implicit cursors બિલકુલ 1-થી-1 મેળ માંગે છે, જો તમારી query શૂન્ય rows પાછી આપે, એ NO_DATA_FOUND exception સાથે crash થાય છે. જો એ એકથી વધુ હરોળ પાછી આપે, એ TOO_MANY_ROWS સાથે crash થાય છે. અસ્થિર, અચકાસાયેલી અનેક rows માટે ક્યારેય પાયાની implicit selections ન વાપરો!

💭 Think first

બંધ ન કરેલા Explicit Cursor ની અસરની ચકાસણી

જો તમે એક Explicit Cursor ખોલો પણ PL/SQL block નું execution પૂરું થાય એ પહેલાં CLOSE command આપવાનું ભૂલી જાઓ, તો એ memory block નું શું થાય છે? Server ના સંસાધનોની સ્થિરતા વિશે વિચારો.

📖 Theory

University બહારના Viva ની વ્યૂહરચના

Semester 2 ના મૂલ્યાંકન દરમિયાન બહારના lab examiners સામે હો ત્યારે, તમારે Active Set keyword યાદ રાખવો જ પડશે. Examiner કદાચ પૂછશે: 'જ્યારે એક cursor ખૂલે ત્યારે rows ક્યાં રહે છે?' આ જવાબ આપીને એમને તરત પ્રભાવિત કરો: 'Rows disk storage માંથી લવાય છે અને server ની memory ના ખાનગી Context Area ની અંદર Active Set નામના એક કામચલાઉ સંગ્રહ તરીકે રખાય છે.'

✅ Summary

Key takeaways

• એક cursor એ સમર્પિત programmatic pointer છે જે PL/SQL ને એક SQL પરિણામના સંગ્રહમાં હરોળ-દર-હરોળ દોરે છે.
• Implicit cursors ને 'SQL' નામ અપાય છે અને એ અલગ DML કે એક-હરોળની સોંપણીઓ માટે આપોઆપ ચાલે છે.
• Explicit cursors programmer દ્વારા multi-row પરિણામો સલામત રીતે સંભાળવા હાથે જાહેર થાય છે.
• એક explicit cursor ના initialization દરમિયાન load થતા data ના સંગ્રહને ઔપચારિક રીતે Active Set કહેવાય છે.
• એક CLOSE કામગીરી ચલાવવામાં નિષ્ફળ જવાથી explicit context area ના buffers લટકતા રહે છે, server ની RAM લીક કરતાં.
• Memory hook: Implicit cursors system આપોઆપ ચલાવે છે; explicit cursors એવાં ખાસ બનાવેલાં ખોખાં છે જે તમારે Open, Fetch, અને Close કરવાં જ પડે!