Theory
બે UPDATE વચ્ચે વીજળી ગઈ
ResultDesk ને એનું પહેલું ડરાવનારું કામ મળે છે: પરીક્ષા વિભાગે પેપર 7 ફરી તપાસ્યું, અને રિયાનો DBMS નો score 78 થી 88 થવો જોઈએ, જ્યારે વર્ગના કુલનું કોષ્ટક મેળ ખાવા 10 વધવું જોઈએ.
બે UPDATE નાં વિધાન. તમે પહેલું ચલાવો છો. Lab ની વીજળી જાય છે.
Database હવે કહે છે કે રિયાને 88 છે, પણ કુલ હજી એનો જૂનો 78 ગણે છે. બે સંખ્યાઓ અસંમત છે, અને કયો અડધો ભાગ ચાલ્યો એ કોઈને યાદ નથી. બેંકમાં રોજના હજાર updates થી આને ગુણો અને તમને દેખાય છે કે SQL આને નસીબ પર છોડવાની ના કેમ પાડે છે.
Theory
પહેલાં પેન્સિલનો નિયમ
સાવધ કારકુન કાગળના રજિસ્ટરમાં પહેલાં પેન્સિલ થી સુધારે છે: બંને નોંધ બદલો, એ મળે છે એ તપાસો, અને પછી જ એમના પર પેન ફેરવો.
જો વચ્ચે કશું ખોટું લાગે, તો પેન્સિલ ભૂંસી નાખો: રજિસ્ટર સત્તાવાર રીતે ક્યારેય બદલાયું જ નહીં.
Transaction એ પેન્સિલનો તબક્કો છે. COMMIT એ પેન છે. ROLLBACK એ રબર છે. રજિસ્ટર (તમારો database) હંમેશા ફક્ત પૂરી થયેલી, સુસંગત સ્થિતિ જ દેખાડે છે.
Theory
ત્રણ શબ્દો, ઔપચારિક રીતે
Transaction એટલે એક તાર્કિક કામના એકમ તરીકે ચલાવાયેલો SQL ની ક્રિયાઓનો ક્રમ: કાં તો બધું થાય, કાં તો કશું નહીં.
BEGIN TRANSACTION;એકમ ખોલે છે (પેન્સિલ બહાર).COMMIT;BEGIN પછીના દરેક ફેરફારને સાથે, કાયમી કરે છે.ROLLBACK;BEGIN પછીના દરેક ફેરફારને પાછો વાળે છે, જાણે એ ક્યારેય ચાલ્યો જ ન હોય.
બધા-કે-કંઈ નહીં ના ગુણનું marks લાયક નામ છે: અખંડિતતા (atomicity), ACID (Atomicity, Consistency, Isolation, Durability) નો A, અને SQLite ચારેયની ખાતરી આપે છે.
Practical
ફરી તપાસ, સલામત રીતે
BEGIN TRANSACTION;
UPDATE marks
SET score = 88
WHERE roll = 101 AND subject = 'DBMS';
UPDATE class_totals
SET total = total + 10
WHERE subject = 'DBMS';
-- both worked? make them permanent TOGETHER:
COMMIT;
-- had anything gone wrong instead:
-- ROLLBACK; and the database is exactly as before BEGIN
This example runs in Gri-Learn on the web, where you can edit it and see the output.
Think first
વીજળી જવાનું ભજવો
એ જ બે UPDATE, BEGIN ... COMMIT માં વીંટાળેલાં. વીજળી પહેલા UPDATE પછી પણ COMMIT પહેલાં જાય છે. યંત્ર ફરી ચાલુ થાય અને SQLite college.db ફરી ખોલે ત્યારે રિયાનો score શું દેખાડે છે, અને કેમ?
Show the answer
78, જૂનું મૂલ્ય. Transaction ક્યારેય COMMIT સુધી પહોંચ્યું જ નહીં, એટલે ફરી ચાલુ થતાં SQLite અધૂરું કામ પાછું વાળે છે: પેન્સિલનાં નિશાન આપોઆપ ભૂંસાય છે. Database છેલ્લી સુસંગત સ્થિતિ દેખાડે છે, જ્યાં બંને સંખ્યાઓ સંમત છે. એ જ અખંડિતતા બરાબર ત્યારે પોતાનું કામ કરે છે જ્યારે વસ્તુઓ ખોટી પડે, અને એ જ આખો મુદ્દો છે: transactions એ વીમો છે જે તમે અકસ્માત પહેલાં ખરીદો છો.
Quiz
એક કારકુન BEGIN; UPDATE ...; COMMIT; ચલાવે છે અને પછી, ભૂલ સમજાતાં, ROLLBACK; ચલાવે છે. Database કઈ સ્થિતિમાં છે?
- UPDATE રહે છે: ROLLBACK commit થયેલા transaction ને પાછું વાળી શકતું નથી
- UPDATE પાછું વળે છે: ROLLBACK હંમેશા છેલ્લું transaction ઊલટાવે છે
- ભૂલ: COMMIT પછી ROLLBACK ટાઈપ કરી શકાતું નથી
- અડધું UPDATE પાછું વળે છે
Show the answer
UPDATE રહે છે: ROLLBACK commit થયેલા transaction ને પાછું વાળી શકતું નથી
COMMIT એ પેન છે: એક વાર લખાયા પછી, transaction કાયમી છે (ACID નો D, ટકાઉપણું). પછીના ROLLBACK પાસે રદ કરવા કોઈ ખુલ્લું transaction નથી, એટલે એ commit થયેલા ફેરફારને કશું કરતું નથી (વધુમાં વધુ હાનિરહિત ચેતવણી). વિકલ્પ B એ ગેરસમજ છે જેને પકડવા આ પ્રશ્ન છે: ROLLBACK ફક્ત હાલના, હજી ખુલ્લા transaction ના BEGIN સુધી પહોંચે છે. Commit થયેલી ભૂલ સુધારવા નવું સુધારાનું transaction જોઈએ.
Watch out
Auto-commit નું આશ્ચર્ય
BEGIN વગર, SQLite દરેક વિધાનને પોતાના નાનકડા auto-commit ના transaction માં ચલાવે છે: એકલાં વિધાનો માટે ઠીક, ફરી તપાસ જેવી જોડાયેલી જોડી માટે નકામું.
અને ઊલટો ફાંદો એકમ 3 માં આવે છે: Python નું sqlite3 તમારા ફેરફાર આપોઆપ commit કરતું નથી. Python માંથી INSERT ચલાવો, conn.commit() ભૂલો, program બંધ કરો, અને દરેક હરોળ ચૂપચાપ અદૃશ્ય થાય છે. Students દર વર્ષે આના કારણે ખરેખરો project નો data ગુમાવે છે; તમને વહેલી ચેતવણી મળી ગઈ.
Theory
તમે પહેલેથી transactions પર ક્યાં ભરોસો કરો છો
દરેક UPI નું ચુકવણું એક transaction છે: એક ખાતામાંથી કપાત, બીજામાં જમા, બંને કે એકેય નહીં. ટ્રેનની બેઠક બુક કરવી: બેઠક અનામત કરો, પૈસા લો, સાથે. જ્યારે આ વિષયનો Python નો એકમ CSV માંથી marks સુધારશે, ત્યારે તમે આખી આયાતને એક transaction માં વીંટાળશો, જેથી એક ખરાબ હરોળ અડધો વર્ગ આયાત કરવાને બદલે આખું રદ કરે.
Summary
Key takeaways
- Transaction = એક બધા-કે-કંઈ નહીં એવા એકમ તરીકે ચલાવાયેલાં અનેક વિધાનો (અખંડિતતા).
- BEGIN TRANSACTION એ ખોલે છે; COMMIT બધા ફેરફારને કાયમી કરે છે; ROLLBACK એ બધાને પાછા વાળે છે.
- COMMIT પહેલાં ભંગાણ છેલ્લી સુસંગત સ્થિતિ સુધી આપોઆપ પાછું વાળે છે.
- ROLLBACK commit થયેલા transaction ને પાછું વાળી શકતું નથી: commit થયું એટલે કાયમી (ટકાઉપણું).
- ACID: Atomicity, Consistency, Isolation, Durability; SQLite પૂરેપૂરું ACID છે.
- Python ના sqlite3 ને સ્પષ્ટ conn.commit() જોઈએ, એકમ 3 નો ફાંદો અહીં વવાયો છે.
- Memory hook: પેન્સિલ, પેન, રબર.