Theory
ભુલાયેલી Due Date ની કિંમત
કલ્પો કે એક student 15 દિવસ મોડું થયેલું પુસ્તક લઈને library counter પર આવે છે. student assistant તરીકે, તમે માત્ર table જોઈને કોઈ પણ મનફાવતો fine ટાઈપ કરી શકતા નથી. તમારે એક નાનો program લખવો પડે: પહેલું, due date ને કેટલા દિવસ વીતી ગયા એ તપાસો; બીજું, એક fine tier વાપરીને દંડ ગણો; ત્રીજું, student નો ખરાબ વર્તનનો ઇતિહાસ છે કે નહીં એ તપાસો; અને છેલ્લે, એમના account નું status update કરો.
Standard SQL rows લાવી કે બદલી શકે છે, પણ આપણે આ પગલાં-દર-પગલાં ની logic database ની અંદર જ કેવી રીતે બનાવીએ?
Theory
આપોઆપ ચાલતું Billing Counter
સામાન્ય SQL ને એક ઉત્સાહી assistant જેવું વિચારો જે માત્ર છાજલીઓ પરથી ચોક્કસ પુસ્તકો લાવી શકે કે હુકમ થતાં એમને પાછાં મૂકી શકે. એ નિર્ણયો લઈ શકતું નથી કે multi-step પ્રક્રિયાઓ ચલાવી શકતું નથી. PL/SQL એટલે એ assistant ને એક automated self-checkout kiosk માં ફેરવી નાખવું. Kiosk માત્ર barcode વાંચતું નથી; એ પાત્રતાના નિયમો તપાસે છે, ગણતરીની logic ચલાવે છે, receipts છાપે છે, અને card swipe નિષ્ફળ જાય તો errors સંભાળે છે, આ બધું એક જ સળંગ, સંરચિત workflow માં.
Theory
PL/SQL શું છે?
ઔપચારિક રીતે, PL/SQL (Procedural Language extension to SQL) એ Oracle નું માલિકીનું extension છે જે standard SQL માં loops, conditional branching, અને variables જેવા programming નિયંત્રણો રજૂ કરે છે.
Network પર database server ને એક પછી એક queries મોકલવાને બદલે, PL/SQL તમને અનેક SQL statements અને procedural logic ને code ના એક જ block માં બાંધવા દે છે. આ network traffic નાટકીય રીતે ઘટાડે છે, execution ની ઝડપ સુધારે છે, અને engine ની અંદર જ મજબૂત security અને error handling ની વ્યવસ્થા આપે છે.
At a glance
એક standard PL/SQL block નું ચાર-ભાગનું શારીરિક માળખું
| Section Block | Keyword | હેતુ | શું એ જરૂરી છે? |
|---|---|---|---|
| Declaration Block | DECLARE | Variables, constants, અને cursors માટે memory ફાળવે છે. | Optional |
| Executable Block | BEGIN | Data process કરવા મુખ્ય programming logic અને SQL statements ધરાવે છે. | Mandatory |
| Exception Block | EXCEPTION | Runtime errors કે database warnings ને સુઘડ રીતે પકડે અને સંભાળે છે. | Optional |
| Termination Marker | END; | PL/SQL block code structure ના અંતનો સંકેત આપે છે. | Mandatory |
Practical
A Complete CampusLib PL/SQL Block
-- An anonymous block to fetch a member's name and handle missing records
DECLARE
v_member_name members.name%TYPE;
v_target_id members.member_id%TYPE := 101;
BEGIN
SELECT name INTO v_member_name
FROM members
WHERE member_id = v_target_id;
DBMS_OUTPUT.PUT_LINE('Library Member Name: ' || v_member_name);
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE('Error: Member ID ' || v_target_id || ' does not exist.');
END;
/Follow along
Execution નું શરીરરચનાશાસ્ત્ર
- 1. ફાળવણી DECLARE section %TYPE વાપરીને એક variable બનાવે છે, members table ના column માંથી બિલકુલ એ જ data type structure નકલ કરતાં.
- 2. Data મેળવવો BEGIN ની અંદર, SELECT INTO statement query નું પરિણામ સીધું આપણા જાહેર કરેલા variable માં ધકેલે છે. સામાન્ય SQL PL/SQL ની બહાર INTO વાપરી શકતું નથી.
- 3. સલામત ઉતરાણ જો member ID અસ્તિત્વમાં ન હોય, execution crash થવાથી બચવા તરત BEGIN section માંથી કૂદી જાય છે.
- 4. Error નું નિરાકરણ EXCEPTION section NO_DATA_FOUND trigger પકડે છે, એક સાફ error message છાપે છે, અને સામાન્ય રીતે બહાર નીકળે છે.
Quiz
એક માન્ય anonymous PL/SQL block ચલાવવા માટે નીચેનામાંથી કઈ લીટીઓ બિલકુલ ન્યૂનતમ syntactical structure દર્શાવે છે?
- DECLARE ... END;
- BEGIN ... END;
- DECLARE ... BEGIN ... END;
- BEGIN ... EXCEPTION ... END;
Show the answer
BEGIN ... END;
માત્ર BEGIN અને END; થી ઘેરાયેલો executable block જ ફરજિયાત છે. DECLARE અને EXCEPTION sections સંપૂર્ણપણે optional છે અને જો તમને variables કે ચોક્કસ error handling ની જરૂર ન હોય તો છોડી શકાય છે.
Watch out
ઘાતક SELECT INTO ફાંદો
સામાન્ય SQL માં, શૂન્ય rows શોધતી એક query માત્ર 'no rows selected' છાપે છે. PL/SQL માં, એક block ની અંદરના દરેકે દરેક SELECT statement એ બિલકુલ એક જ row પાછી આપવી જોઈએ! જો તમારી query શૂન્ય rows પાછી આપે, Oracle તરત NO_DATA_FOUND error સાથે execution અટકાવી દે છે. જો એ અનેક rows પાછી આપે, એ TOO_MANY_ROWS સાથે crash થાય છે. તમારે હંમેશા આ પરિણામો એક સ્પષ્ટ EXCEPTION block વાપરીને સંભાળવાં પડશે અથવા અનેક records process કરવા cursors પર આધાર રાખવો પડશે.
Think first
Syntax Assignment ની ચકાસણી
એક PL/SQL block ની અંદરના આ assignment statement ને ધ્યાનથી જુઓ: 'v_fine_amount = 50;'. શું આ Oracle SQL માં સફળતાપૂર્વક compile થશે, કે એ exam બગાડનારી syntax error ઊભી કરશે? Tap કરતાં પહેલાં variable assignment ની syntax ધ્યાનથી વિચારો.
Show the answer
એ સીધી એક compile error ઊભી કરશે! PL/SQL માં, એકલો બરાબરનો ચિહ્ન (=) સખ્તાઈથી WHERE clauses કે conditionals માં એક comparison operator તરીકે વપરાય છે. એક variable ને value સોંપવા, તમારે assignment operator (:=) વાપરવો પડશે. સાચું statement 'v_fine_amount := 50;' છે.
Theory
વાસ્તવિક દુનિયાની Stored Procedures
Anonymous PL/SQL blocks testing માટે ઉત્તમ છે, પણ Semester 4 કે enterprise applications માં, તમે આ block structure ને Procedures, Functions, અને Triggers જેવા નામવાળા database constructs ની અંદર વીંટાળશો. Banking systems funds transfers સલામત રીતે સંભાળવા બિલકુલ આ જ blocks વાપરે છે: એક account માંથી પૈસા કાપવા અને બીજામાં ઉમેરવા, એક જ સુરક્ષિત execution container ની અંદર જે અધવચ્ચે નિષ્ફળ જઈ શકતું નથી.
Summary
Key takeaways
- PL/SQL variables, loops, અને conditions જેવા procedural ખ્યાલો ઉમેરીને standard SQL ને વિસ્તારે છે.
- માળખામાં ચાર blocks છે: DECLARE, BEGIN, EXCEPTION, અને END;.
- BEGIN અને END; keywords એકમાત્ર ફરજિયાત operational section બનાવે છે.
- એક block ની અંદરના SELECT statements ને એક INTO clause જોઈએ અને એમણે બિલકુલ એક જ row પાછી આપવી જોઈએ.
- Variable assignments ને સાદા બરાબરના ચિહ્નને બદલે સ્પષ્ટ assignment operator (:=) જોઈએ.
- Memory hook: તમારાં ઓજારો જાહેર કરો, કામ શરૂ કરો, ભૂલચૂક સંભાળો, અને એક end થી સમેટી લો!