Theory
દોહરાવાતા Ticket ના Updates આપોઆપ કરવા
કલ્પો કે TicketDesk પર તમારા manager તમને સળંગ 10 બાકી tickets માટે એક આપોઆપ ચેતવણીનો સંદેશો છાપવાનું કહે છે. શું તમે તમારી script માં DBMS_OUTPUT.PUT_LINE statement હાથે 10 અલગ વાર લખશો? અને જો કાલે 1000 tickets હોય તો? તમારો code વિરાટ અને સંભાળી ન શકાય એવો બની જશે. તમને એક એવું સંરચનાત્મક ઓજાર જોઈએ જે code નો એક જ block વારંવાર ચલાવી શકે અને સાથે આપોઆપ હિસાબ રાખે કે કેટલા records સંભાળવાના બાકી છે.
Theory
Supermarket નું Scanner
એક supermarket ના billing counter ને વિચારો. તમારી ખરીદીની ટોપલીની દરેક વસ્તુ માટે cashier એક તદ્દન નવો computer નો program ચાલુ કરતો નથી. એને બદલે, એ એક સાદી પ્રક્રિયા ચલાવે છે: એક વસ્તુ પકડો, એને optical scanner પર ફેરવો, અને કુલ કિંમતમાં ઉમેરો. એ બિલકુલ આ જ ક્રિયાનો loop વારંવાર દોહરાવે છે. જ્યારે ટોપલી સંપૂર્ણપણે ખાલી થાય, loop આપોઆપ તૂટે છે અને એ તમારું બિલ આખરી કરે છે.
Theory
Oracle Dialect માં Iterative Statements
Oracle PL/SQL માં, iterative statements એ નિયંત્રણની વ્યવસ્થા છે જે code ના statements નો એક ક્રમ અનેક વાર ચલાવે છે. PL/SQL ત્રણ મુખ્ય loop ના પ્રકારો આપે છે: પાયાનો loop (LOOP ... END LOOP), conditional WHILE loop, અને counter થી ચાલતો FOR loop. આ પુનરાવર્તનને બારીકાઈથી સુધારવા, તમે loop નાં નિયંત્રણો વાપરો છો: loop માંથી તરત બહાર નીકળવા EXIT કે EXIT WHEN, અને હાલના iteration નો બાકીનો code છોડીને સીધા આગલા ચક્ર પર કૂદવા CONTINUE કે CONTINUE WHEN.
At a glance
Oracle PL/SQL ના ત્રણ મુખ્ય iteration ના પ્રકારોની કામગીરીની રૂપરેખા
| Loop નું માળખું | Condition ક્યારે તપાસાય છે | શ્રેષ્ઠ Use Case |
|---|---|---|
| Basic Loop | શરીરની અંદર સ્પષ્ટ EXIT WHEN દ્વારા | જ્યારે loop નું શરીર ઓછામાં ઓછું એક વાર ચાલવું જ જોઈએ |
| WHILE Loop | Loop માં પ્રવેશતાં પહેલાં ટોચે | જ્યારે દોહરાવવું એક બદલાતી condition પર આધાર રાખતું હોય |
| FOR Loop | એક નિશ્ચિત index ની range માટે ટોચે | જ્યારે તમને પહેલેથી બિલકુલ iteration ની સંખ્યા ખબર હોય |
Practical
Processing a Batch of Tickets Using Loops
-- Enable text rendering in the Oracle engine
SET SERVEROUTPUT ON;
DECLARE
v_counter NUMBER := 1;
v_max_tickets NUMBER := 3;
BEGIN
DBMS_OUTPUT.PUT_LINE('=== Starting Basic Loop ===');
LOOP
DBMS_OUTPUT.PUT_LINE('Processing Ticket ID: ' || v_counter);
v_counter := v_counter + 1;
-- Explicit exit condition safely stops the execution
EXIT WHEN v_counter > v_max_tickets;
END LOOP;
DBMS_OUTPUT.PUT_LINE('=== Starting FOR Loop Control ===');
-- The loop index variable i is implicitly declared here
FOR i IN 1..3 LOOP
IF i = 2 THEN
-- Skip processing for ticket 2 and proceed to next index
CONTINUE;
END IF;
DBMS_OUTPUT.PUT_LINE('Handling Priority Index: ' || i);
END LOOP;
END;
/Quiz
એક Oracle PL/SQL FOR loop statement ની અંદર એક નિશ્ચિત આંકડાકીય range વ્યાખ્યાયિત કરવા સાચી syntax કઈ છે?
- FOR i IN 1 TO 10 LOOP
- FOR i IN 1..10 LOOP
- FOR i = 1 TO 10 LOOP
- FOR i IN 1...10 LOOP
Show the answer
FOR i IN 1..10 LOOP
Oracle PL/SQL એક FOR loop ની અંદર બે integers વચ્ચેની સમાવેશક range દર્શાવવા બેવડા બિંદુનો operator (..) વાપરે છે. આ ભાષાના dialect માં TO જેવા keywords કે બરાબરના ચિહ્નો અમાન્ય loop ની મર્યાદાઓ છે અને તમારી lab exam દરમિયાન તરત compilation ની નિષ્ફળતા ઊભી કરશે.
Think first
માનસિક પડકાર: Execution નો ભેદ
જો એક WHILE loop ની condition એની સૌથી પહેલી તપાસમાં જ FALSE આંકાય તો શું થાય? શું loop નું શરીર બિલકુલ ચાલે છે? Tap કરતાં પહેલાં મનમાં execution નો રસ્તો શોધો.
Show the answer
Loop નું શરીર એક પણ વાર ચાલશે નહીં! એક WHILE loop engine ને અંદર જવા દેતાં પહેલાં બિલકુલ ટોચે પોતાની પ્રવેશની condition આંકે છે. જો statement તરત false આંકાય, engine સંપૂર્ણપણે END LOOP statement ને વટાવી જાય છે, સીધું પછીની program ની logic પર કૂદતાં.
Watch out
ડરામણું અનંત Loop નું દુઃસ્વપ્ન
Lab practicals માં BCA students દ્વારા થતી સૌથી વારંવારની ભૂલ છે એક પાયાના LOOP ની અંદર loop નો counter વધારવાનું ભૂલી જવું. જો તમે v_counter := v_counter + 1; છોડી દો, તમારો counter કાયમ માટે એની શરૂઆતની value પર અટકી રહે છે. કારણ કે તમારો EXIT WHEN નો clause ક્યારેય સાચો થઈ શકતો નથી, database engine terminal જકડાઈ જાય કે server સંપૂર્ણપણે crash થાય ત્યાં સુધી એક અનંત ચક્ર process કરતાં નિર્ણાયક memory ખાઈ જશે.
Theory
Cursor Navigation અને ભવિષ્યની Sync Routines
Production ના enterprise વાતાવરણોમાં, loops સીધા cursors સાથે જોડાય છે જેથી જીવંત table ના records ની rows માંથી dynamically ચાલી શકાય. તમે આગલા semester માં તમારી Sem 3 ની SQLite mobile database sync ની routines માં આ ભાત વ્યાપકપણે વાપરશો, જ્યાં તમે smartphone ના diagnostic સંકેતો તપાસવા અને સ્થાનિક logs એક વખતે એક record કરીને કેન્દ્રીય backend master server પર મોકલવા એક loop program કરશો.
Summary
Key takeaways
- પાયાના loops એક સ્પષ્ટ exit ની condition ના statement થી અટકે નહીં ત્યાં સુધી અનિશ્ચિત સમય ચાલે છે.
- WHILE loops કોઈ પણ block ના statements ચલાવતાં પહેલાં પ્રવેશની સીમાએ conditions ચકાસે છે.
- FOR loops આપોઆપ જાહેર થયેલા આંકડાકીય index વાપરીને range ની પ્રગતિ સલામત રીતે આપોઆપ કરે છે.
- EXIT keyword loop નું execution સંપૂર્ણપણે સમાપ્ત કરે છે અને block ની સીમાની બહાર કૂદે છે.
- CONTINUE modifier હાલનું loop નું ચક્ર છોડીને સીધું પછીનું iteration શરૂ કરે છે.
- Memory hook: દોહરાવવા Loop, પૂરું કરવા exit, બિંદુ-બિંદુથી ગણો, continue થી છોડો!