Transaction control language: commit, savepoint, rollback

📖 Theory

અધવચ્ચે અટકેલી Banking ની આફત

કલ્પો કે તમારું university નું billing portal તમારી semester ની પરીક્ષાની fee process કરી રહ્યું છે. તમારી script એક update statement ચલાવે છે જે સફળતાપૂર્વક તમારા bank ખાતાના table માંથી ₹5,000 બાદ કરે છે. પણ જેવું server તમારા student નું status 'Paid' તરીકે નિશાન કરવા બીજું update statement ચલાવવા જાય છે, college campus માં અચાનક વીજળી જાય છે કે internet તૂટે છે. જો database ના updates અધૂરા રહી જાય, તમારા પૈસા હવામાં ઓગળી જાય છે, પણ college ની system તમને હજી પણ admit card ઉતારતાં રોકે છે! તો databases કેવી રીતે ખાતરી આપે છે કે અનેક પગલાંનો ક્રમ કાં તો સંપૂર્ણપણે પૂરો થાય કાં તો સંપૂર્ણપણે પોતાની જાતને પાછો ખેંચી લે, પાછળ શૂન્ય તૂટેલો data છોડતાં?

📖 Theory

Notepad નો Draft સામે કાયમી Marker

Database માં data ના ફેરફારો લખવાનું એક ઊંચા દાવવાળા group project પર કામ કરવા જેવું વિચારો. જ્યારે તમે standard DML commands (INSERT કે UPDATE) લખો છો, ત્યારે તમે એક draft pad પર આછી ભૂખરી પેન્સિલથી લખી રહ્યા છો. તમારા group માં બીજું કોઈ હજી એ નોંધો જોઈ શકતું નથી, અને જો તમે ગણતરીની ભૂલ કરો તો તમે એ સહેલાઈથી ભૂંસી શકો છો. એક COMMIT ચલાવવું એટલે એ પેન્સિલની લીટીઓ પર ન ભૂંસાય એવા કાયમી શાહીના marker થી ફરી વળવું અને એ પાનું બધા જુએ એ માટે સહિયારા કબાટમાં મૂકી દેવું. એક ROLLBACK ચલાવવું એટલે એક વિશાળ રબર લઈને draft pad ને દિવસ શરૂ થયો ત્યારે જેવો દેખાતો હતો એવો સંપૂર્ણપણે સાફ કરી નાખવો.

📖 Theory

TCL માળખું અને Transaction ની સ્થિતિઓ ઔપચારિક રીતે

Relational Database Management Systems માં, એક Transaction એ processing નો એક તાર્કિક એકમ છે જે એક કે વધુ data બદલવાની કામગીરી એક જ અવિભાજ્ય block તરીકે કરે છે. Transaction Control Language (TCL) commands આ blocks સંભાળે છે જેથી database systems ના Atomicity અને Consistency ના ગુણધર્મો લાગુ થાય. જ્યાં સુધી એક transaction સ્પષ્ટપણે આખરી ન થાય, બધા updates અસ્થિર session ની memory ના buffers ની અંદર અલગ રહે છે, બીજા સમાંતર database users થી સંપૂર્ણપણે છુપાયેલા.

📊 At a glance

Table 1: Transaction Control Language commands અને એમની માળખાકીય અસરનું સંરચનાત્મક mapping.

📖 Theory

Worked Example: Fee Ledger ની Recovery નો નકશો

ચાલો એક exam-શૈલીની તાર્કિક સમસ્યા પગલું-દર-પગલું ટ્રેસ કરીએ. આપણે એક campus ના ledger table પર એક transaction block ખોલીશું, કામચલાઉ records નાખીશું, સ્પષ્ટ ચોકીઓ રોપીશું, અને સંગ્રહમાં પાછળ બિલકુલ કઈ હરોળનું સંતુલન રહે છે એ જોવા એક પસંદગીયુક્ત પાછું વળવું ચલાવીશું.

⌨️ Practical

Campus Wallet Transaction Pipeline

-- Step 1: Initialize the session state with an empty base tracking ledger
CREATE TABLE wallet_ledger (
    tx_id INT PRIMARY KEY,
    item_name VARCHAR(30),
    amt INT
);

-- Step 2: Begin the sequence by logging the baseline breakfast charge
INSERT INTO wallet_ledger VALUES (1, 'Chai & Samosa', 50);
SAVEPOINT after_breakfast;

-- Step 3: Log subsequent library fine and print shop entries
INSERT INTO wallet_ledger VALUES (2, 'Library Overdue Fine', 100);
INSERT INTO wallet_ledger VALUES (3, 'Lab Printouts', 20);
SAVEPOINT after_studies;

-- Step 4: Accidentally execute a broken double-entry charge
INSERT INTO wallet_ledger VALUES (4, 'Accidental Duplicate Charge', 500);

-- Step 5: Execute structural rewinds and commit the final stable records
ROLLBACK TO after_studies;
ROLLBACK TO after_breakfast;
COMMIT;

This example runs in Gri-Learn on the web, where you can edit it and see the output.

💭 Think first

બચી ગયેલી Database Rows ટ્રેસ કરો

Rollbacks નો ક્રમિક પ્રવાહ ધ્યાનથી તપાસો. Step 5 એના બે rollback commands અને પછી અંતિમ COMMIT statement ચલાવે એ પછી, કાયમી wallet_ledger table ની અંદર બિલકુલ કયા records રહેશે?

🧩 Quiz

જો એક developer એક વૈકલ્પિક command ક્રમ ચલાવે: INSERT, પછી SAVEPOINT A, પછી UPDATE, પછી 'TO' clause વગરનું એક સાદું ખાલી ROLLBACK statement, તો database ની સ્થિતિનું શું થાય છે?

1. માત્ર UPDATE statements ભૂંસાય છે; શરૂઆતનું INSERT સલામત રીતે બાકી રહે છે.
2. આખા સક્રિય transaction block દરમિયાન થયેલો દરેકે દરેક ફેરફાર, INSERT અને UPDATE બંને સહિત, સંપૂર્ણપણે ભૂંસાઈ જાય છે.
3. System તરત એક SyntaxError ફેંકે છે કારણ કે એક ખાલી ROLLBACK statement savepoints ને નિષ્ક્રિય કરે છે.
4. Transaction ચોકી A સુધી આપોઆપ commit થઈ જાય છે.

🧩 Quiz

જો એક developer સ્પષ્ટપણે COMMIT કે ROLLBACK ચલાવ્યા વગર પોતાનું terminal session સાફ રીતે બંધ કરે, તો એક database table ની અંદર થયેલા data ના ફેરફારોના કાયમીપણાની સ્થિતિ શું છે?

1. ફેરફારો જાહેર commit ન થયેલા records તરીકે વૈશ્વિક રીતે પ્રસારિત થાય છે.
2. મોટા ભાગનાં enterprise RDBMS engines એક સાફ બહાર નીકળવાને એક અંતર્ગત COMMIT statement તરીકે સમજશે.
3. મોટા ભાગની standard relational database management systems data ની સુસંગતતા બચાવવા આપોઆપ એક અંતર્ગત ROLLBACK કરે છે.
4. લક્ષ્ય tables બગડી જાય છે અને memory ની જગ્યામાંથી સંપૂર્ણપણે નીકળી જાય છે.

⚠️ Watch out

Classic ફાંદો: DDL નો Auto-Commit હુમલો

Semester ની laboratory examinations માં સૌથી સામાન્ય marks-ગુમાવતો ફાંદો છે એક INSERT statement લખવું, પછી એક CREATE TABLE કે DROP TABLE command, અને પછી ROLLBACK એ insert ની હરોળ ભૂંસશે એવી અપેક્ષા રાખવી. સાવધાન: CREATE, DROP, કે ALTER જેવાં Data Definition Language (DDL) statements પડદા પાછળ એક આપોઆપ અંતર્ગત COMMIT ચલાવે છે. આ તમારી બધી પહેલાંની પેન્સિલની હરોળો કાયમ માટે સંગ્રહમાં જકડી દે છે, જેથી પછીનું rollback તદ્દન નકામું બની જાય છે!

📖 Theory

Transactions ને Semester 3 PL/SQL સાથે જોડવા

Transaction ની સીમાઓ પર પ્રભુત્વ મેળવવું સુરક્ષિત enterprise software ની logic લખવા માટે એક આવશ્યક પાયો છે. Semester 3 Database Administration (BCA301) અને backend development ની pipelines માં, તમે TCL statements ને આપોઆપ ચાલતા PL/SQL exception-handling blocks (EXCEPTION WHEN OTHERS THEN ROLLBACK;) ની અંદર મૂકશો જેથી એવી applications બને જે અણધાર્યા server ના crashes દરમિયાન પણ મજબૂત રહે.

✅ Summary

Key takeaways

• Transaction Control Language databases ને એકીકૃત અને સુસંગત રાખવા DML statements ના જૂથો સંભાળે છે.
• એક transaction એ બધું-કે-કંઈ નહીં કામગીરી છે જે આખરી ન થાય ત્યાં સુધી હરોળના updates અલગ રાખે છે.
• COMMIT command સક્રિય buffer ના records ને કાયમ માટે ભૌતિક સંગ્રહની disk પર જકડી દે છે.
• ROLLBACK command commit ન થયેલા session ની memory ના ફેરફારો સંપૂર્ણપણે સાફ કરી નાખે છે.
• SAVEPOINT કામચલાઉ તાર્કિક સીમાચિહ્નો બનાવે છે જે પસંદગીયુક્ત query rollbacks ને support કરે છે.
• Memory Hook: COMMIT એને કાયમ માટે શાહીથી લખે છે, ROLLBACK draft ની પાટી સાફ કરે છે, અને DDL commands આપોઆપ commit કરે છે!