Assigning Values to Variables

📖 Theory

Counter પરનું સંતુલન ફરી ગોઠવવું

કલ્પો કે તમે CampusLib checkout desk માટે backend module બનાવી રહ્યા છો. એક student 50 રૂપિયાનું મોડું fee ભરવા આવે છે. આ process કરવા, તમારા database program એ એમનું હાલનું balance જોવું પડશે, નવો કુલ સરવાળો ગણવો પડશે, અને એ નવી ગણતરીને memory buffer માં ધકેલવી પડશે. જો તમે ખોટો વિરામચિહ્ન વાપરો, database engine તમારા command ને એક ક્રિયા ('balance ને 50 કરો!') ને બદલે એક પ્રશ્ન ('શું balance 50 બરાબર છે?') તરીકે સમજશે. તો આપણે Oracle ને એક ચોક્કસ data સોંપણી કરવાનું કેવી રીતે કહીએ?

📖 Theory

Post-it કાગળ સામે ત્રાજવું

એક variable ને value સોંપવાનું એક ચીકણા Post-it કાગળ પર તાજો telephone number લખીને એને તમારા desk પરના જૂના number પર ચોંટાડી દેવા જેવું વિચારો. આ ક્રિયા આગળની સામગ્રીને એક તદ્દન નવી value થી સંપૂર્ણપણે બદલી નાખે છે. બીજી બાજુ, બે values સરખાવવી એટલે એક જૂના ત્રાજવાના ડાબા પલ્લામાં એક પુસ્તક અને જમણા પલ્લામાં એક વજન મૂકવું. તમે પુસ્તક કે વજન બદલી રહ્યા નથી; તમે ખાલી તપાસો છો કે એ બરાબર સંતુલિત થાય છે કે નહીં. PL/SQL માં, આ બે ક્રિયાઓ તદ્દન અલગ ચાવીઓ વાપરે છે.

📖 Theory

Value સોંપવાની ત્રણ પદ્ધતિઓ

Oracle PL/SQL માં, તમે ત્રણ અલગ રસ્તે variables ને values સોંપી શકો છો. પહેલું, જાહેરાત વખતે, તમે સ્પષ્ટ assignment operator કે DEFAULT keyword વાપરીને એક શરૂઆતની સ્થિતિ ગોઠવી શકો છો. બીજું, executable block ની અંદર, તમે program ના workflows ના આધારે values ને dynamically બદલવા assignment operator વાપરો છો. ત્રીજું, તમે SELECT INTO નામના એક ખાસ query format વાપરીને database columns માંથી સીધો જીવંત data ખેંચીને એને સીધો સ્થાનિક variables માં વહાવી શકો છો.

📊 At a glance

Variable ના data ની સ્થિતિ ગોઠવવા માટેના વિરામચિહ્નો અને વ્યૂહરચનાના ભેદ

⌨️ Practical

Demonstrating Value Ingestion and the Assignment Flow

-- An anonymous block showcasing all valid ways to populate local variables
DECLARE
  -- Method 1: Initializing at declaration phase
  v_base_fine      NUMBER(4) := 20;
  v_discount_rate  NUMBER(3,2) DEFAULT 0.10;
  v_final_payable  NUMBER(6,2);
  v_member_name    members.name%TYPE;
BEGIN
  -- Method 2: Direct assignment within the executable zone
  v_final_payable := v_base_fine - (v_base_fine * v_discount_rate);
  
  -- Method 3: Capturing a live column value via SELECT INTO
  SELECT name 
  INTO v_member_name
  FROM members
  WHERE member_id = 101;
  
  DBMS_OUTPUT.PUT_LINE('Member Name: ' || v_member_name);
  DBMS_OUTPUT.PUT_LINE('Calculated Payable Fine: Rs. ' || v_final_payable);
END;
/

🪜 Follow along

એક SELECT INTO Assignment ની વ્યવસ્થા

1. 1. Parsing અને મૂલ્યાંકન Oracle સામાન્ય query નું માળખું parse કરે છે અને WHERE filter ના માપદંડ સાથે મળતા records માટે ભૌતિક table rows શોધે છે.
2. 2. Memory માં પકડ Engine મળતી આવતી row ની value ને એ console output buffer પર છપાય એ પહેલાં આંતરી લે છે.
3. 3. INTO નો રસ્તો આંતરેલી attribute values સીધી ડાબી બાજુ INTO keyword પછી યાદી કરેલા લક્ષ્ય variables માં વહે છે.
4. 4. Data નું તાળું સ્થાનિક variables તરત પોતાની આંતરિક memory ની જગ્યાઓ update કરે છે, આગળનાં PL/SQL processing પગલાં માટે data ને જકડી લેતાં.

🧩 Quiz

જો તમે એક PL/SQL block ના BEGIN section ની અંદર 'v_total_cost = 500;' જેવું assignment statement લખવાનો પ્રયાસ કરો તો શું થશે?

1. Statement સફળતાપૂર્વક ચાલે છે અને variable ની value 500 પર update કરે છે.
2. Oracle આપોઆપ એને એક comparison expression માં બદલી નાખે છે અને એ row સંપૂર્ણપણે છોડી દે છે.
3. Compilation એક syntax error સાથે નિષ્ફળ જાય છે કારણ કે એકલો બરાબરનો ચિહ્ન assignment ની ક્રિયા કરી શકતો નથી.
4. Block ચાલે છે પણ એને બદલે લક્ષ્ય variable ને NULL ની value સોંપે છે.

⚠️ Watch out

ઊલટો ફાંદો: WHERE ની અંદર := વાપરવો

જ્યારે એક ગણતરીના loop ની અંદર = ને := સાથે ગૂંચવવાથી તમારું compilation તૂટે છે, ત્યારે ઊલટી ભૂલ પણ એટલી જ વિનાશક હોઈ શકે છે. જો તમે ભૂલથી SELECT name INTO v_name FROM members WHERE member_id := 101; લખો, તો તમે એક filter માં એક assignment token આપી રહ્યા છો. Oracle નું query analyzer WHERE clause ની અંદર એક comparison operator ની અપેક્ષા રાખે છે અને એક સંરચનાત્મક expression error ફેંકશે. તમારા colons ને સખ્તાઈથી તમારી ક્રિયાઓમાં જ રાખો, તમારા પ્રશ્નોમાં નહીં!

💭 Think first

Default Value ફરીથી લખાવાના વર્તનની ચકાસણી

કલ્પો કે તમે એક text variable જાહેર કર્યો છે: 'v_grade VARCHAR2(2) DEFAULT 'A';'. જો તમે executable block ની અંદર 'v_grade := 'B';' દ્વારા એને એક નવી value સોંપો, તો પછીથી v_grade નો સંદર્ભ લેતાં કઈ value છપાશે? સંરચનાત્મક અગ્રતા વિશે વિચારો.

📖 Theory

Lab Exam નો Score સુધારવો

બહારના examiners students ને syntax ની ભૂલચૂક બદલ દંડ કરવાનું પસંદ કરે છે. Semester 4 ની lab examinations દરમિયાન કાગળ પર કે terminal screens પર code scripts લખતી વખતે, દરેક assignment block બે વાર તપાસો. ખાતરી કરો કે તમારા variables assignment operator ની બરાબર ડાબી બાજુ બેસે છે (variable := value;), અને એકલા બરાબરના ચિહ્નને સખ્તાઈથી તમારાં IF statements અને query conditions માટે બચાવી રાખો.

✅ Summary

Key takeaways

• Value assignment એક variable ની આંતરિક memory ની જગ્યાને એક તદ્દન નવી સ્થિતિથી ફરીથી લખી નાખે છે.
• સ્પષ્ટ assignment operator (:=) data ની સોંપણી process કરવાનું મુખ્ય engine છે.
• DEFAULT keyword જાહેરાત વખતે એક variable initialize કરે છે પણ runtime updates આવતાં બાજુએ ખસી જાય છે.
• SELECT INTO clause database storage tables માંથી row ની values ને dynamically memory ના લક્ષ્યોમાં map કરે છે.
• એકલો બરાબરનો ચિહ્ન (=) માત્ર comparison ના સંદર્ભો પૂરતો મર્યાદિત છે અને assignments માટે વપરાય તો syntax crashes કરે છે.
• Memory hook: એક ફેરફાર ધકેલવા colon-equal (:=) થી વિરામ કરો, સ્થિતિ તપાસવા શુદ્ધ equal (=) વાપરો!