Theory
એક અનિશ્ચિત Ticket ના ઓળખકર્તાને Track કરવો
ધારો કે તમે એક આવતી ગ્રાહકની ફરિયાદ track કરવા TicketDesk માટે એક આપોઆપ ચાલતી management ની script લખી રહ્યા છો. જ્યારે પણ કોઈ ગ્રાહક નવો મુદ્દો રજૂ કરે ત્યારે ticket ID નંબર દર વખતે બદલાય છે. તાકીદનું સ્તર અત્યારે Critical હોઈ શકે, પણ એક administrator થોડી મિનિટોમાં એને Low માં બદલી શકે. તો તમારું server નિયમો આંકે એ દરમિયાન તમે માહિતીના આ વહેતા ટુકડા કેવી રીતે પકડો અને જાળવો? તમને database engine ની memory ની અંદર એક અલગ સંગ્રહનો ડબ્બો જોઈએ જે તરત values રાખી, વાંચી, અને બદલી શકે.
Theory
Label લગાવેલી Storage Bins
તમારા Oracle database server ને એક વિશાળ, ધમધમતા વખારના માળ જેવો વિચારો. જો તમે કોઈ ખોખા વગર ભોંય પર raw લખાણ ફેંકો, એ ખોવાઈ જાય છે. એક variable એ 'Numbers Only' દર્શાવતી ચીકણી ચિઠ્ઠી વાળી ખાલી plastic ની bin જેવો છે. એક constant એ ઔદ્યોગિક ગુંદરથી સીલ કરેલા ભારે લાકડાના પટારા જેવો છે: એક વાર તમે અંદર વસ્તુ મૂકી અને એની શ્રેણી જાહેર કરી, પછી કોઈ એ બદલી શકતું નથી. Value સોંપવી એટલે ખાલી એ ચોક્કસ bin માં એક વસ્તુ નાખવી.
Theory
PL/SQL કામગીરીમાં Variables અને Constants
Oracle PL/SQL માં, એક variable એ નામ આપેલું સંગ્રહનું સરનામું છે જેની આંતરિક સામગ્રી program ના execution દરમિયાન વધઘટ થઈ શકે છે. એક constant એ નિશ્ચિત data નું એકમ છે જે initialization પછી બદલી શકાતું નથી અને CONSTANT keyword માંગે છે. દરેક ડબ્બાને સુસંગતતા લાગુ કરવા એક વ્યાખ્યાયિત datatype (જેમ કે NUMBER કે VARCHAR2) જોઈએ. તમે આ ખાનાં કાં તો assignment operator := વાપરીને હાથે ગણતરીથી ભરો છો કાં તો એક SELECT INTO database query વાપરીને column ના records મેળવીને.
At a glance
Oracle PL/SQL engine માં મુખ્ય જાહેરાત અને assignment નાં માળખાં
| Syntax નો ઘટક | મુખ્ય કામગીરીનો હેતુ | ઉદાહરણનું Statement |
|---|---|---|
| Assignment Operator | એક જાહેર થયેલા variable ને સીધો એક ચોક્કસ value થી ફરીથી લખે છે | v_status := 'Open'; |
| CONSTANT Keyword | એક memory ના ખાનાને એવું જકડે છે કે એની શરૂઆતની વ્યાખ્યા બદલી ન શકાય | c_tax CONSTANT NUMBER := 0.18; |
| %TYPE Attribute | એક column નો મળતો datatype dynamically નકલ કરે છે | v_title tickets.title%TYPE; |
| SELECT INTO Clause | Database નાં fields memory ના variables માં ખેંચે છે | SELECT status INTO v_status FROM tickets; |
Practical
Declaring and Allocating Ticket Fields within a Block
-- Enable console text printing in Oracle terminal
SET SERVEROUTPUT ON;
DECLARE
-- Anchor variable data properties directly to our schema layout
v_ticket_title tickets.title%TYPE;
v_ticket_status VARCHAR2(20) := 'Unassigned';
-- Establish a strict baseline tracking limit constant
c_max_days CONSTANT NUMBER := 7;
BEGIN
-- Update the tracking state using the assignment mechanism
v_ticket_status := 'In Progress';
-- Extract a live row directly into our localized variable placeholder
SELECT title INTO v_ticket_title
FROM tickets
WHERE id = 101;
DBMS_OUTPUT.PUT_LINE('Processing Title: ' || v_ticket_title);
DBMS_OUTPUT.PUT_LINE('Current Status: ' || v_ticket_status);
DBMS_OUTPUT.PUT_LINE('SLA Day Limit: ' || c_max_days);
END;
/Quiz
કયું code નું configuration એક Oracle ના જાહેરાતના વિસ્તારની અંદર મહત્તમ priority ની મર્યાદા રાખતો એક ન બદલી શકાય એવો constant યોગ્ય રીતે બનાવે છે?
- c_limit NUMBER CONSTANT = 5;
- c_limit CONSTANT NUMBER := 5;
- c_limit NUMBER := 5 CONSTANT;
- c_limit CONSTANT NUMBER = 5;
Show the answer
c_limit CONSTANT NUMBER := 5;
Oracle PL/SQL માં, એક constant ને એક ચોક્કસ સંરચનાત્મક ભાત જોઈએ: પહેલાં ઓળખકર્તા, પછી સ્પષ્ટ CONSTANT keyword, પછી સંરચનાત્મક datatype, અને છેલ્લે := assignment operator દ્વારા initialization. એકલો બરાબરનો ચિહ્ન = SQL queries માં conditional મેળ માટે અનામત છે, ફાળવણી માટે નહીં.
Think first
માનસિક પડકાર: %TYPE સાથે માળખાકીય અનુકૂલન
જો એક system administrator database ના schema માં tickets.title column ની પહોળાઈ VARCHAR2(100) થી બદલીને VARCHAR2(300) કરે, તો buffer ના crashes ટાળવા %TYPE વાપરતી એક script માં તમારે કયા ફેરફારો કરવા પડશે? Tap કરતાં પહેલાં મનમાં આ તપાસો.
Show the answer
તમારે code માં કોઈ update કરવાની જરૂર નથી! આ જ anchoring %TYPE વ્યવસ્થાનો મુખ્ય engineering નો ફાયદો દર્શાવે છે. એ execution ના runtime પર નીચેના table ના નકશાનો dynamically સંદર્ભ લે છે, આપોઆપ વિસ્તરેલા માપ સાથે મળી જતાં અને code ના compilation ની errors વગર block ની સ્થિરતા જાળવતાં.
Watch out
Laboratory ના Mismatch અને Assignment ના ફાંદા
University ના examiners વારંવાર students ની scripts ને બે classic ફાળવણીની ભૂલો પર પકડે છે. પહેલી, execution ના expressions ની અંદર અજાણતાં := ને બદલે સાદો = ટાઈપ કરવો, જે તરત compilation ની નિષ્ફળતા ઊભી કરે છે. બીજી, એવી queries પર SELECT INTO વાપરવું જે અનેક rows ના પ્રવાહો કે શૂન્ય records આપે. એક પાયાનું SELECT INTO બિલકુલ 1 મેળની અપેક્ષા રાખે છે: બીજું કંઈ પણ TOO_MANY_ROWS કે NO_DATA_FOUND ની અસાધારણતા દ્વારા runtime crash પર મજબૂર કરે છે.
Theory
Enterprise નો ઉપયોગ અને Frontend માં સંક્રમણ
Anchor કરેલી variable ની ફાળવણી વાપરવાથી production ની analytics pipelines માં બિનજરૂરી લખાણનું ફરીથી parsing અટકે છે, transaction process કરવાની ઝડપ વધારતાં. જ્યારે તમે SQLite data frameworks વાપરતા તમારા Sem 3 ના mobile architecture ના courses પર જશો, ત્યારે તમે બિલકુલ આ જ binding ના વર્તનને પ્રતિબિંબિત કરતી parameterized lookup queries બનાવશો, frontend ના inputs ને SQL injection ની નબળાઈઓનું જોખમ લીધા વગર સીધા memory ની જગ્યાઓ સાથે સલામત રીતે જોડતાં.
Summary
Key takeaways
- Variables memory માં નિયુક્ત data ની bins દર્શાવે છે જેમની values block ની કામગીરી દરમિયાન બદલી શકાય એવી રહે છે.
- Constants જાહેરાત વખતે સ્પષ્ટ
CONSTANTkeyword modifier વાપરીને initialization માંગે છે. - ખાસ operator ની જોડી
:=સક્રિય block ની logic ની અંદર આંતરિક value નું mapping સંભાળે છે. %TYPEanchoring નું ઓજાર data ના mismatch ની errors દૂર કરવા આપોઆપ જીવંત column ના ગુણધર્મો વારસામાં લે છે.SELECT INTOવાપરતી queries એ exceptions ટાળવા બિલકુલ 1 મળતો record શોધવો જ પડે.- Memory hook: માળખું વ્યાખ્યાયિત કરો, percent-type થી anchor કરો, colon-equals વાપરીને assign કરો, અને એકલી rows પકડો!