એક ડેટાબેસ ટ્રાન્જેક્શન બહુવિધ ઑપરેશન્સને એક જૂથમાં બાંધે છે જેથી તે બધા સફળ થાય અથવા બધા એક સાથે નિષ્ફળ જાય (આટોમિસિટી) — આંશિક, અસંગત અપડેટ્સ રોકે છે. Django transaction.atomic પ્રદાન કરે છે જે ઑપરેશન્સને ટ્રાન્જેક્શનમાં લપેટવા માટે, મલ્ટી-સ્ટેપ ઑપરેશન્સ માટે ડેટા ઇન્ટીગ્રિટી સુનિશ્ચિત કરે છે.
():
from_account.balance -= amount
from_account.save()
to_account.balance += amount
to_account.save()
ટ્રાન્જેક્શન વિના, જો બીજું ઑપરેશન નિષ્ફળ થાય, તો પહેલું પહેલેથી જ કમિટ થઈ ગયું હોય — ડેટાબેસને તૂટેલી, અસંગત સ્થિતિમાં છોડીને (પૈસો ડેબિટ થયો પણ ક્રેડિટ નહીં).
from django.db import transaction
# as a context manager
def transfer_money(from_account, to_account, amount):
with transaction.atomic(): # everything inside is ONE transaction
from_account.balance -= amount
from_account.save()
to_account.balance += amount
to_account.save()
# if ANY operation raises an exception, the WHOLE block is ROLLED BACK
# → either both saves happen, or neither does (atomicity)
# or as a decorator on a whole function/view
@transaction.atomic
def create_order(request):
order = Order.objects.create(...)
for item in items:
OrderItem.objects.create(order=order, ...)
# all-or-nothing: a failure anywhere rolls back the entire order creation
atomic() અંદર, જો કોઈ પણ ઑપરેશન એક્સેપ્શન ઉત્થાપિત કરે, Django બ્લોક માટે દરેક ફેરફાર રોલબેક કરે — તેથી ડેટાબેસ ક્યારેય અર્ધ-અપડેટેડ ન્યાયમાં ખોવાય નહીં. સફળતા પર, બધા ફેરફારો એક સાથે કમિટ થાય.
with transaction.atomic(): # outer transaction
do_something()
try:
with transaction.atomic(): # inner = a SAVEPOINT
risky_operation()
except Exception:
pass # inner rolls back to the savepoint; outer continues
નેસ્ટેડ atomic બ્લોક્સ savepoints વાપરે છે — આંતરિક બ્લોક સ્વતંત્ર રીતે રોલબેક કરી શકે છે સમગ્ર બાહ્ય ટ્રાન્જેક્શન ગમાવ્યા વિના.
✓ Catch exceptions OUTSIDE the atomic block (catching inside can break rollback handling)
✓ select_for_update() locks rows within a transaction (prevent race conditions on updates)
with transaction.atomic():
account = Account.objects.select_for_update().get(pk=id) # row locked until commit
✓ ATOMIC_REQUESTS setting wraps EVERY request in a transaction (per-database)
✓ Keep transactions SHORT — long transactions hold locks, hurting concurrency
ડેટાબેસ ટ્રાન્જેક્શન્સ ડેટા ઇન્ટીગ્રિટી માટે આવશ્યક છે જ્યાં કોઈ પણ સમય એક ઑપરેશન બહુવિધ સંબંધિત ડેટાબેસ ફેરફારો સાથે જણાય છે જે એક એકમ તરીકે સફળ અથવા નિષ્ફળ હોવા આવશ્યક છે — અને transaction.atomic સમજવું સही, વિશ્વસનીય એપ્લિકેશન્સ બનાવવા માટે મહત્વપૂર્ણ જ્ઞાન છે.
ટ્રાન્જેક્શન્સ જે મુખ્ય સમસ્યા હલ કરે છે તે આંશિક નિષ્ફળતા છે: આટોમિસિટા વિના, જો મલ્ટી-સ્ટેપ ઑપરેશન મધ્યમાં નિષ્ફળ થાય (ક્રેશ, એક્સેપ્શન, કોન્સ્ટ્રેઇન્ટ ઉલ્લંઘન), ડેટાબેસ અસંગત સ્થિતિમાં છોડવામાં આવે છે — ક્લાસિક ધન-ટ્રાન્સફર ઉદાહરણ (એક એકાઉન્ટ્ર્સમાંથી ડેબિટ કરવામાં આવ્યો પણ બીજામાં ક્રેડિટ નહીં) તે બતાવે છે કે તે કેવી રીતે ડેટાને તોડે છે અને ગંભીર પરિણામો હોઈ શકે છે. transaction.atomic ગેરેંટી પ્રદાન કરે છે કે ઑપરેશન્સ બધું-અથવા-કંઈ-નહીં છે (કોઈ પણ નિષ્ફળતા પર સમગ્ર બ્લોક રોલબેક કરીને), જે કોઈ પણ ઑપરેશનના માટે જરૂરી છે જે બહુવિધ લખવા માટે વિસ્તૃત હોય — ઓર્ડર તેના લાઇન આઇટમ્સ સાથે બનાવવું, ફંડ ટ્રાન્સફર કરવું, સંબંધિત રેકોર્ડ્સ અપડેટ કરવું — સંગત ડેટાબેસ જાળવવા માટે.
এटોમિક બ્લોક્સ કેવી રીતે વાપરવાથી સમજવું (કન્ટેક્સ્ટ મેનેજર અથવા ડેકોરેટર તરીકે), نेsted ટ્રાન્જેક્શન્સ savepoints સાથે, અને મહત્વપૂર્ણ વિગતો — બ્લોક બહાર એક્સેપ્શન્સ પકડવું, select_for_update() વાપરીને સમવર્તી અપડેટ્સમાં રેસ કન્ડીશન્સ અટકાવવા માટે પંક્તિઓ તાળો મારવું, અને લૉક્સ પકડીને ટ્રાન્જેક્શન્સ ટૂંકા રાખવું — મજબૂત એપ્લિકેશન્સ બનાવવા માટે વ્યવહારુ જ્ઞાન છે.
ડેટા સંગતતા વિશ્વસનીય સિસ્ટમ્સની મૂળભૂત આવશ્યકતા છે, અને ટ્રાન્જેક્શન્સ તે મિકેનિઝ્મ છે જે મલ્ટી-સ્ટેપ ડેટાબેસ ઑપરેશન્સ માટે તેને સુનિશ્ચિત કરે છે, આ વિષયને મહત્વપૂર્ણ બનાવે છે જે તે ડેવલપર્સને અલગ પાડે છે જેઓ સાચો, ઇન્ટીગ્રિટી-સংરક્ષણ કોડ લખે છે તેમના પાસેથી જેમની એપ્લિકેશન્સ નિષ્ફળતા શરતો અથવા સમવર્તી એક્સેસ હેઠળ ચૂપચાપ ડેટાને તોડી શકે છે — કોઈ પણ એપ્લિકેશનમાં વારંવાર-સંબંધિત ચિંતા જે મહત્વપૂર્ણ, સંબંધિત ડેટા ફેરફારો હેન્ડલ કરે છે.