Theory
રિયાના marks કોણે બદલ્યા?
સોમવાર: રિયાનો DBMS નો score 78 વંચાય છે. ગુરુવાર: 88 વંચાય છે. પરીક્ષા વિભાગ ResultDesk ને પૂછે છે: કોણે બદલ્યું, ક્યારે, અને શેમાંથી?
તમારાં કોષ્ટકો હાલનું મૂલ્ય સંઘરે છે, એની પાછળની કથા નહીં. તમે marks ને અડતા દરેક program ને એક log પણ લખવાની વિનંતી કરી શકો... અને જે દિવસે એક ભૂલી જાય, તપાસના પગેરામાં કાણું પડે.
વધુ સારું: database ને પોતાને પ્રતિભાવ આપતાં શીખવો. "જ્યારે પણ કોઈ marks સુધારે, જૂનું અને નવું મૂલ્ય આપોઆપ નોંધો." એ ઊભી સૂચના એ trigger છે.
Theory
રજિસ્ટર ઉપરનું CCTV
કારકુન દરેક સુધારો નોંધવાનું વચન આપી શકે, પણ વચનો તૂટે છે. રજિસ્ટર ઉપરનો CCTV કેમેરો તૂટતો નથી: એ દરેક ફેરફાર નોંધે છે, કોઈ પણ કરે, રાત્રે 2 વાગ્યે પણ.
Trigger એ કોષ્ટક માટેનું CCTV છે: કોષ્ટક પર જ પાર્ક કરેલું, પસંદ કરેલી ઘટના (INSERT, UPDATE, DELETE) જોતું, અને પોતાની નોંધવાની રીત આપોઆપ ચલાવતું. કોઈ application એ ભૂલી શકતું નથી, કારણ કે કોઈ application ને પૂછાતું જ નથી.
Theory
Trigger, ઔપચારિક રીતે
Trigger એ નામ ધરાવતો database નો પદાર્થ છે જેમાં એવું SQL હોય છે જે ચોક્કસ કોષ્ટક પર ચોક્કસ ઘટના બને ત્યારે આપોઆપ ચાલે છે.
ત્રણ પસંદગી એને વ્યાખ્યાયિત કરે છે:
- ઘટના: INSERT, UPDATE કે DELETE.
- સમય: ફેરફાર પહેલાં (BEFORE) (ચકાસવું, ખરાબ data રોકવો) કે એની પછી (AFTER) (log કરવું, આગળ ફેલાવવું).
- શરીર: BEGIN અને END વચ્ચેનું SQL.
શરીરની અંદર બે જાદુઈ હરોળનાં aliases વસે છે: NEW (આવતાં મૂલ્યો) અને OLD (જેની જગ્યા લેવાય છે એ મૂલ્યો). INSERT પાસે ફક્ત NEW છે; DELETE પાસે ફક્ત OLD; UPDATE પાસે બંને.
Practical
તપાસનું CCTV, ગોઠવાયેલું
CREATE TABLE marks_log (
roll INTEGER,
subject TEXT,
old_score INTEGER,
new_score INTEGER,
changed_on TEXT
);
CREATE TRIGGER log_marks_change
AFTER UPDATE ON marks
BEGIN
INSERT INTO marks_log
VALUES (OLD.roll, OLD.subject, OLD.score, NEW.score,
datetime('now'));
END;
-- now ANY update writes its own evidence:
UPDATE marks SET score = 88 WHERE roll = 101 AND subject = 'DBMS';
-- marks_log gains: 101, DBMS, 78, 88, 2026-07-04 ...
-- a BEFORE trigger can BLOCK bad data:
CREATE TRIGGER stop_bad_scores
BEFORE UPDATE ON marks
WHEN NEW.score > 100 OR NEW.score < 0
BEGIN
SELECT RAISE(ABORT, 'score must be 0..100');
END;
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Think first
BEFORE કે AFTER? કામ પ્રમાણે પસંદ કરો
બે કામ: (1) પરિણામના અઠવાડિયા દરમિયાન students ના કોષ્ટક પર કોઈ પણ DELETE નકારો; (2) જ્યારે પણ નવો mark INSERT થાય, ત્યારે વિષયનો ચાલુ કુલ સુધારો. Tap કરતાં પહેલાં: દરેક માટે સમય (BEFORE/AFTER) અને ઘટના પસંદ કરો, અને કહો કે દરેક શરીર NEW/OLD માંથી કયું વાપરી શકે.
Show the answer
(1) students પર BEFORE DELETE: ચકાસણી/રોકવાનું ફેરફાર પહેલાં થાય છે, શરીર OLD (જે હરોળ મરવાની છે) અને RAISE(ABORT, ...) વાપરીને નકારે છે.
(2) marks પર AFTER INSERT: હરોળ સલામત રીતે અસ્તિત્વમાં આવે પછી પ્રતિભાવ આપો, શરીર NEW (આવતાં મૂલ્યો) વાપરીને NEW.score ને કુલમાં ઉમેરે છે.
અંગૂઠાનો નિયમ: BEFORE રક્ષણ કરે છે, AFTER પ્રતિભાવ આપે છે. અને NEW/OLD ની ઉપલબ્ધિ ઘટનાને અનુસરે છે: INSERT NEW લાવે છે, DELETE OLD છોડે છે, UPDATE બંને વહન કરે છે.
Quiz
એક પરીક્ષા તમને SQLite માં trigger ને હંગામી રીતે નિષ્ક્રિય કરવાનું કહે છે. સાચો જવાબ શું છે?
- SQLite માં DISABLE/ENABLE TRIGGER નથી: તમે trigger ને DROP કરો છો અને પછી ફરી CREATE કરો છો
- ALTER TRIGGER log_marks_change DISABLE;
- DISABLE TRIGGER log_marks_change;
- કોષ્ટકના schema માં trigger_enabled = 0 ગોઠવો
Show the answer
SQLite માં DISABLE/ENABLE TRIGGER નથી: તમે trigger ને DROP કરો છો અને પછી ફરી CREATE કરો છો
મોટાં engines (SQL Server, Oracle) DISABLE/ENABLE TRIGGER આપે છે; SQLite નથી આપતું, અને એની પાસે ALTER TRIGGER પણ નથી. પ્રામાણિક SQLite નો workflow છે DROP TRIGGER name; અને જરૂર પડે ત્યારે ફરી CREATE કરવું (CREATE નું વિધાન સાચવી રાખો). Engine નો આ ભેદ જ કારણ છે કે અભ્યાસક્રમમાં 'disable and enable trigger' લખ્યું છે: અપેક્ષિત જવાબ SQLite ની મર્યાદા જાણવાનો છે, syntax ઉપજાવવાનો નહીં.
Watch out
Trigger ના ત્રણ ફાંદા
DISABLE ની syntax ઉપજાવવી: SQLite માં જવાબ છે drop કરીને ફરી બનાવવું, બસ.
ઘટના માટે ખોટું alias: INSERT ના trigger માં OLD, કે DELETE માં NEW, એ ભૂલ છે: alias ને ઘટના પાસે ખરેખર જે હોય એની સાથે મેળવો.
BEFORE થી log કરવું: BEFORE UPDATE નું log એવો ફેરફાર નોંધી શકે જે પછી નિષ્ફળ જાય અને ક્યારેય થાય જ નહીં. તપાસનાં logs AFTER ના triggers માં જ હોય, ફેરફાર સાચો થયા પછી.
Theory
તમારી આસપાસના triggers, અને એમની કિંમત
બેંકનાં statements (દરેક વ્યવહાર log થાય), માલસામાનની systems (દરેક વેચાણે stock ઘટે), તમારી college ની ફીની system બાકીદારો ઉજાગર કરે: trigger નો પ્રદેશ. ટાંકવા લાયક એક વ્યાવસાયિક ચેતવણી: triggers અદૃશ્ય રીતે ચાલે છે, એટલે ઘણા triggers વાળા કોષ્ટક વિશે તર્ક કરવો અઘરો બને છે. એમને આડા-છેદતી બાંયધરી (તપાસ, અખંડિતતા) માટે વાપરો, એવા ધંધાના logic માટે નહીં જેની માલિકી program પાસે હોવી જોઈએ. તમે sqlite_master ના કોષ્ટક (type = 'trigger') દ્વારા database ના triggers ની યાદી કરી શકો છો.
Summary
Key takeaways
- Trigger = સંઘરાયેલું SQL જે કોષ્ટકના INSERT/UPDATE/DELETE પર database આપોઆપ ચલાવે છે.
- સમય: BEFORE રક્ષણ કરે છે (ચકાસવું, RAISE(ABORT)), AFTER પ્રતિભાવ આપે છે (log, ફેલાવો).
- NEW = આવતાં મૂલ્યો, OLD = બદલાતાં મૂલ્યો; INSERT પાસે ફક્ત NEW, DELETE પાસે ફક્ત OLD, UPDATE પાસે બંને.
- CREATE TRIGGER name AFTER UPDATE ON table BEGIN ... END; DROP TRIGGER name; એને કાઢે છે.
- SQLite માં DISABLE/ENABLE કે ALTER TRIGGER નથી: એને બદલે drop કરીને ફરી બનાવો (પરીક્ષાનું પ્રિય).
- જાણીતો ઉપયોગ: marks નું તપાસનું log જેને કોઈ ભુલક્કડ application છોડી શકે નહીં.
- Memory hook: રજિસ્ટર ઉપરનું CCTV.