Theory
જ્યારે Code ચૂપચાપ Crash થાય
કલ્પો કે તમે TicketDesk માટે એક ticket ને એના ID નંબરથી શોધવા એક PL/SQL ઓજાર લખો છો. જો user અસ્તિત્વમાં હોય એવો ID ટાઈપ કરે, બધું બરાબર ચાલે છે. પણ જો એ અસ્તિત્વમાં ન હોય એવો ID ટાઈપ કરે તો શું થાય? Oracle તરત એક runtime error ફેંકે છે અને તમારી આખી application ને ત્યાં જ અટકાવી દે છે. તમારું સુંદર user interface થીજી જાય છે, અને તમારું database નું જોડાણ તૂટે છે. તો જીવંત execution દરમિયાન અનિશ્ચિત data ની errors થાય ત્યારે તમે તમારા software ને ભાંગી પડતાં કેવી રીતે બચાવો?
Theory
વીજળીના Circuit નો Fuse
Runtime errors ને એક મકાનમાં અચાનક વીજળીના ઉછાળા જેવી વિચારો. જો વીજળીનો એક વિશાળ ધક્કો એક અસુરક્ષિત સાધનને અડે, એ તાર બાળી નાખે છે અને મશીન સંપૂર્ણપણે નાશ કરે છે. આ અટકાવવા, engineers એક નાનો fuse બેસાડે છે. જ્યારે ઉછાળો આવે, fuse સલામત રીતે જોડાણ તોડે છે, જોખમ આંતરે છે, અને ઘરને અંધારામાં પણ સલામત રાખે છે. Exception handling એ તમારા database ના code માટેનો વીજળીનો fuse છે, crashes ને system તોડે એ પહેલાં પકડતાં.
Theory
Exception Handling ની વ્યાખ્યા
Oracle database ના dialect માં, એક exception એ block ના execution દરમિયાન ઊભી થતી runtime error છે. Exception handling એ એક PL/SQL block ના તળિયે મુકાયેલો ખાસ procedural વિભાગ છે જે આ errors ને સુઘડ રીતે પકડવા અને process કરવા રચાયેલો છે. Oracle આને predefined exceptions માં વર્ગીકૃત કરે છે, જે NO_DATA_FOUND કે TOO_MANY_ROWS જેવી system દ્વારા આપોઆપ નામ પામેલી built-in errors છે, અને user-defined exceptions માં, જે ચોક્કસ business ના નિયમો માટે programmers દ્વારા હાથે જાહેર થયેલી custom errors છે.
At a glance
Oracle PL/SQL systems માં સામાન્ય પહેલેથી વ્યાખ્યાયિત runtime exceptions
| Oracle Exception નું નામ | Oracle Error Code | Trigger થવાની સ્થિતિ |
|---|---|---|
| NO_DATA_FOUND | ORA-01403 | એક SELECT INTO query બિલકુલ શૂન્ય rows પાછી આપે છે |
| TOO_MANY_ROWS | ORA-01422 | એક SELECT INTO query એકથી વધુ હરોળ પાછી આપે છે |
| ZERO_DIVIDE | ORA-01476 | એક અંકગણિતનું statement શૂન્યથી ભાગવાનો પ્રયાસ કરે છે |
| VALUE_ERROR | ORA-06502 | એક truncation, રૂપાંતર, કે કદની મર્યાદાની નિષ્ફળતા થાય છે |
Practical
Safely Fetching Ticket Details
-- Enable terminal output display
SET SERVEROUTPUT ON;
DECLARE
v_title tickets.title%TYPE;
BEGIN
-- This query will fail if ID does not exist or matches multiple rows
SELECT title INTO v_title FROM tickets WHERE id = 999;
DBMS_OUTPUT.PUT_LINE('Ticket Title: ' || v_title);
EXCEPTION
WHEN NO_DATA_FOUND THEN
DBMS_OUTPUT.PUT_LINE('Error: That ticket ID was not found in TicketDesk.');
WHEN TOO_MANY_ROWS THEN
DBMS_OUTPUT.PUT_LINE('Error: Multiple tickets found with that same ID.');
WHEN OTHERS THEN
DBMS_OUTPUT.PUT_LINE('An unexpected error occurred in the system.');
END;
/Quiz
જો એક SELECT INTO statement એવા PL/SQL block ની અંદર શૂન્ય rows પાછી આપે જેમાં EXCEPTION section નથી, તો એ query પછી તરત આવેલાં statements નું શું થાય છે?
- એ સામાન્ય રીતે ચાલે છે કારણ કે Oracle ખૂટતી હરોળ અવગણે છે.
- એ સંપૂર્ણપણે છોડી દેવાય છે કારણ કે આખો block તરત સમાપ્ત થાય છે.
- એ ચાલે છે પણ બધા સ્થાનિક variables NULL કરી દેવાય છે.
- એ database નું જોડાણ time out થાય ત્યાં સુધી અનિશ્ચિત સમય loop કરે છે.
Show the answer
એ સંપૂર્ણપણે છોડી દેવાય છે કારણ કે આખો block તરત સમાપ્ત થાય છે.
જ્યારે એક exception થાય અને એ સ્થાનિક રીતે સંભાળાય નહીં, Oracle તરત executable વિભાગનું execution અટકાવે છે અને બહાર તરફ શોધે છે. જો ક્યાંય કોઈ handler અસ્તિત્વમાં ન હોય, block તરત સમાપ્ત થાય છે અને crash થાય છે, એટલે કે નિષ્ફળ query ની નીચેનાં કોઈ પણ statements સંપૂર્ણપણે છોડી દેવાય છે.
Think first
OTHERS નો વ્યાપ
જો તમે WHEN OTHERS handler ને તમારા EXCEPTION block ની બિલકુલ ટોચે WHEN NO_DATA_FOUND ની પહેલાં મૂકો, તો Oracle compiler કેવી પ્રતિક્રિયા આપશે? તપાસતાં પહેલાં મનમાં logic કાઢો.
Show the answer
Oracle માંગે છે કે WHEN OTHERS handler એ EXCEPTION section માં બિલકુલ છેલ્લી બધું પકડનારી condition હોય. જો તમે એને ચોક્કસ handlers ની પહેલાં મૂકો, Oracle એક compilation ની syntax error ઊભી કરશે કારણ કે WHEN OTHERS બાકીની દરેક error પકડી લે છે, જેથી પછીના કોઈ પણ handlers સંપૂર્ણપણે પહોંચી ન શકાય એવા બની જાય છે.
Watch out
આંધળા Catch-All નું બ્લેક હોલ
University ની laboratory ની practicals માં ભારતીય BCA students સૌથી વારંવાર જે ભૂલ કરે છે એ છે WHEN OTHERS THEN NULL; વાપરવું. જ્યારે આ તમારા program ને crash થતાં અટકાવે છે, ત્યારે એ error ને ક્યાંય છાપ્યા કે નોંધ્યા વગર સંપૂર્ણપણે ગળી જાય છે. જો ખરાબ data ને કારણે એક નિર્ણાયક ગણતરી નિષ્ફળ જાય, તમારો program બગડેલો data બહાર કાઢતાં પણ ડોળ કરશે કે બધું બરાબર છે. તમારા exception blocks ને સંપૂર્ણપણે ખાલી છોડવાને બદલે એમની અંદર હંમેશા એક error નો સંદેશો નોંધો કે દેખાડો.
Theory
Enterprise Logs અને આગલા Semester ના Objects
જીવંત helpdesk management ના platforms માં, exception blocks users ને સલામતી તરફ પાછા વાળતાં પહેલાં સમર્પિત system ની error log tables માં વિગતવાર crash ના reports લખે છે. તમે આગલા semester માં તમારા object-oriented courses માં બિલકુલ આ જ માનસિકતા ફરીથી વાપરશો, જ્યાં Oracle નું EXCEPTION માળખું સીધું Java, C++, અને Android ના crash અટકાવવાના માળખાંમાં મળતાં standard try-catch blocks માં બદલાઈ જાય છે.
Summary
Key takeaways
- Exceptions એ અણધારી runtime errors છે જે તરત સામાન્ય execution નો પ્રવાહ ખલેલ પહોંચાડે છે.
- Exception handling error સુધારવાના code ને મુખ્ય application ની logic ના blocks થી અલગ પાડે છે.
- NO_DATA_FOUND અને TOO_MANY_ROWS જેવા પહેલેથી વ્યાખ્યાયિત handlers અનુમાનયોગ્ય SQL query ની નિષ્ફળતાઓ પકડે છે.
- WHEN OTHERS keyword અણધારી system ની errors માટે અંતિમ બધું પકડનારા handler તરીકે કામ કરે છે.
- ન સંભાળાયેલી exceptions ઉપર તરફ ફેલાય છે અને database ના programs ને વહેલા સમાપ્ત કરે છે.
- Memory hook: તમારો block લખો, errors માટે તપાસો, crash પકડો, અને records નોંધો!