Theory
એક હરોળની મર્યાદા
કલ્પો કે TicketDesk પર તમારા manager તમને હાલમાં Open તરીકે નિશાન કરેલા દરેકે દરેક ticket ની વિગતો દેખાડવાનું કહે છે. તમે આત્મવિશ્વાસથી એક PL/SQL block ની અંદર એક standard SQL SELECT statement લખો છો. પણ જે ક્ષણે તમારી query એકથી વધુ હરોળ પાછી આપે, Oracle database engine તરત એક કડવી TOO_MANY_ROWS exception ફેંકે છે અને તમારો program crash કરે છે. Standard PL/SQL variables એક વખતે માત્ર એક value કે હરોળ રાખી શકે છે. તો તમે તમારી database system crash કર્યા વગર અનેક rows સલામત રીતે ક્રમશઃ કેવી રીતે લાવો અને process કરો?
Theory
વખારનો Conveyor Belt
તમારા database ના table ને હજારો ઉત્પાદનનાં ખોખાંથી ભરેલા એક મોટા વખારના સંગ્રહના ઓરડા જેવો વિચારો. જો તમે બિલકુલ એક જ સમયે બધાં ખોખાં હાથમાં ઊંચકવાનો પ્રયાસ કરો, તમે એ પાડી નાખશો અને પૂરી આફત સર્જશો. એને બદલે, તમે એક સાંકડો conveyor belt ગોઠવો છો. વખારનો supervisor એક વખતે એક ખોખું belt પર મૂકે છે. તમે છેડે ઊભા રહો છો, એ એક ખોખું ઉપાડો છો, એને process કરો છો, અને પછીનું આવે એની રાહ જુઓ છો. એક cursor એ તમારી data ની rows માટેનો એ conveyor belt છે.
Theory
Oracle PL/SQL માં Cursors ની વ્યાખ્યા
Oracle database ના dialect માં, એક cursor એ system દ્વારા SQL statements ચલાવવા અને પાછા આવેલા સક્રિય હરોળના સમૂહને સંઘરવા ફાળવાયેલો ખાનગી memory નો વિસ્તાર છે. Cursors એવા pointers તરીકે કામ કરે છે જે તમને અનેક હરોળના query ના પરિણામને લીટી-દર-લીટી લાવવા અને process કરવા દે છે. Oracle cursors ની બે શ્રેણીઓ વાપરે છે: implicit cursors, જે દરેકે દરેક DML statement માટે system દ્વારા આપોઆપ બને છે, અને explicit cursors, જે અનેક હરોળની queries માટે programmer દ્વારા પૂરેપૂરા જાહેર અને સંભાળાય છે.
At a glance
Oracle databases માં implicit અને explicit cursors વચ્ચેના સંરચનાત્મક ભેદ
| લક્ષણ | Implicit Cursor | Explicit Cursor |
|---|---|---|
| સર્જન | બધી એકલી SQL queries માટે Oracle દ્વારા આપોઆપ બને છે | DECLARE section માં programmer દ્વારા હાથે વ્યાખ્યાયિત થાય છે |
| હરોળની ક્ષમતા | એક હરોળની કામગીરી કે આખા જથ્થાબંધ સમૂહો માટે રચાયેલો | ખાસ અનેક rows લીટી-દર-લીટી લાવવા અને process કરવા બનેલો |
| જીવનચક્રનું નિયંત્રણ | શરૂઆતથી અંત સુધી સંપૂર્ણપણે system દ્વારા સંભાળાય છે | સ્પષ્ટ DECLARE, OPEN, FETCH, અને CLOSE commands વાપરીને હાથે નિયંત્રિત થાય છે |
| Default નામ | સામાન્ય keyword SQL વાપરીને સંદર્ભાય છે | Programmer દ્વારા સોંપાયેલા એક custom નામથી ઓળખાય છે |
Practical
Walking Through an Open Tickets Query Lifecycle
-- Enable text printing in Oracle SQL*Plus
SET SERVEROUTPUT ON;
DECLARE
-- Step 1: Declare the explicit cursor with its query
CURSOR c_open_tickets IS
SELECT id, title FROM tickets
WHERE status = 'Open';
v_id tickets.id%TYPE;
v_title tickets.title%TYPE;
BEGIN
-- Step 2: Open the cursor to allocate memory and run query
OPEN c_open_tickets;
LOOP
-- Step 3: Fetch the current row data into local variables
FETCH c_open_tickets INTO v_id, v_title;
-- Exit loop when no more rows are found
EXIT WHEN c_open_tickets%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('Processing Ticket ID: ' || v_id || ' - ' || v_title);
END LOOP;
-- Step 4: Close the cursor to release database server resources
CLOSE c_open_tickets;
END;
/Quiz
Explicit cursor ના જીવનચક્રનો કયો command સંબંધિત SELECT query ચલાવવા અને સક્રિય memory ની જગ્યા ફાળવવા જવાબદાર છે?
- DECLARE
- OPEN
- FETCH
- CLOSE
Show the answer
OPEN
જ્યારે DECLARE code માં સંરચનાત્મક નકશો બનાવે છે, ત્યારે OPEN statement ખરેખર database engine ની અંદર નીચેની SQL query ચલાવે છે અને સક્રિય વિસ્તારને rows થી ભરે છે. FETCH માત્ર હાલની હરોળ મેળવે છે, અને CLOSE memory ની જગ્યા છોડે છે.
Think first
માનસિક પડકાર: Variables નો ક્રમ
ધારો કે તમારો cursor tickets table માંથી પહેલાં id અને પછી title પસંદ કરે છે. જો તમે FETCH c_open_tickets INTO v_title, v_id લખો જ્યાં variables અકસ્માતે અદલાબદલી થયા હોય તો શું થાય? Tap કરીને ઉજાગર કરતાં પહેલાં મનમાં પરિણામ વિશે વિચારો.
Show the answer
Oracle values ને સખ્તાઈથી ક્રમિક જગ્યા પ્રમાણે map કરે છે, variable નાં નામ પ્રમાણે નહીં. જો v_title એક VARCHAR2 હોય અને id એક NUMBER હોય, Oracle રૂપાંતરનો પ્રયાસ કરશે. જો એ એક અક્ષર-આંકડાવાળા title ને એક આંકડાકીય ID ના variable માં ફેરવી ન શકે, તમારો block તરત એક runtime VALUE_ERROR exception સાથે નિષ્ફળ જશે. Variables ને હંમેશા cursor ના SELECT ના column ના ક્રમ સાથે બરાબર મેળવો.
Watch out
તરતા Cursor નું Memory Leak
University ની lab exams માં ભારતીય BCA students સૌથી વારંવાર જે ભૂલ કરે છે એ છે સ્પષ્ટ CLOSE command ભૂલી જવો. Implicit cursors થી વિપરીત, એક explicit cursor તમારો PL/SQL block execution પૂરું કરે પછી પણ database server ની memory ની અંદર સંપૂર્ણપણે ખુલ્લો રહે છે. જો આ block એક application ના loop ની અંદર વારંવાર ચાલે, એ સતત સક્રિય context ના વિસ્તારો leak કરે છે જ્યાં સુધી database પાસે cursor નાં ખાનાં સંપૂર્ણપણે ખૂટી ન જાય અને એ ડરામણો maximum open cursors exceeded નો crash ફેંકે.
Theory
Enterprise Record Navigation અને Mobile Frameworks
Helpdesk ticket routers જેવા મોટા enterprise ના ગ્રાહક support ના platforms માં, explicit cursors server ની RAM પર બોજ નાખ્યા વગર લાખો rows પર ભારે જથ્થાબંધ સ્થળાંતર અને રોજિંદા SLA ના status ના ફેરા સલામત રીતે સંભાળે છે. તમે આગલા semester માં તમારા Sem 3 ના SQLite mobile database ના course માં બિલકુલ આ જ pointer કાઢવાનો ખ્યાલ ફરીથી વાપરશો, જ્યાં તમે database ના records ને smartphone ની screen ના list view પર દોરવા સંરચનાત્મક Android loop cursor adapters વાપરશો.
Summary
Key takeaways
- એક cursor એ ખાનગી database ની memory નો વિસ્તાર છે જે query નાં પરિણામો સલામત રીતે લીટી-દર-લીટી સંભાળવા વપરાય છે.
- Implicit cursors standard એક હરોળની queries અને updates માટે Oracle દ્વારા આપોઆપ સંભાળાય છે.
- Explicit cursors ને એક કડક હાથે કરવાનું ચાર પગલાંનું ચક્ર જોઈએ: DECLARE, OPEN, FETCH, અને CLOSE.
- FETCH statement સક્રિય dataset માંથી values ક્રમશઃ સ્થાનિક variables માં નકલ કરે છે.
- Server ની ઊંચી memory leaks અને context ના ખાનાં ખૂટવાનું અટકાવવા હંમેશા explicit cursors બંધ કરો.
- Memory hook: Loop જાહેર કરો, લાઈન ખોલો, હરોળ લાવો, અને સમયસર બંધ કરો!