Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

Fixed #13055 -- Cleaned up the implementation of transaction decorato…

…rs to provide a consistent external facing API. Thanks to olb@nebkha.net for the report.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@12752 bcc190cf-cafb-0310-a4f2-bffc1f526a37
  • Loading branch information...
commit ca81ad4f9dedfb8b0935c58e9c5e2d4846a3db15 1 parent f74b9ae
@freakboy3742 freakboy3742 authored
Showing with 83 additions and 41 deletions.
  1. +46 −34 django/db/transaction.py
  2. +37 −7 tests/modeltests/transactions/models.py
View
80 django/db/transaction.py
@@ -257,79 +257,91 @@ def savepoint_commit(sid, using=None):
# DECORATORS #
##############
-def autocommit(func_or_using=None):
+def autocommit(using=None):
"""
Decorator that activates commit on save. This is Django's default behavior;
this decorator is useful if you globally activated transaction management in
your settings file and want the default behavior in some view functions.
"""
- def inner_autocommit(func, using=None):
+ def inner_autocommit(func, db=None):
def _autocommit(*args, **kw):
try:
- enter_transaction_management(managed=False, using=using)
- managed(False, using=using)
+ enter_transaction_management(managed=False, using=db)
+ managed(False, using=db)
return func(*args, **kw)
finally:
- leave_transaction_management(using=using)
+ leave_transaction_management(using=db)
return wraps(func)(_autocommit)
- if func_or_using is None:
- func_or_using = DEFAULT_DB_ALIAS
- if callable(func_or_using):
- return inner_autocommit(func_or_using, DEFAULT_DB_ALIAS)
- return lambda func: inner_autocommit(func, func_or_using)
+
+ # Note that although the first argument is *called* `using`, it
+ # may actually be a function; @autocommit and @autocommit('foo')
+ # are both allowed forms.
+ if using is None:
+ using = DEFAULT_DB_ALIAS
+ if callable(using):
+ return inner_autocommit(using, DEFAULT_DB_ALIAS)
+ return lambda func: inner_autocommit(func, using)
-def commit_on_success(func_or_using=None):
+def commit_on_success(using=None):
"""
This decorator activates commit on response. This way, if the view function
runs successfully, a commit is made; if the viewfunc produces an exception,
a rollback is made. This is one of the most common ways to do transaction
control in web apps.
"""
- def inner_commit_on_success(func, using=None):
+ def inner_commit_on_success(func, db=None):
def _commit_on_success(*args, **kw):
try:
- enter_transaction_management(using=using)
- managed(True, using=using)
+ enter_transaction_management(using=db)
+ managed(True, using=db)
try:
res = func(*args, **kw)
except:
# All exceptions must be handled here (even string ones).
- if is_dirty(using=using):
- rollback(using=using)
+ if is_dirty(using=db):
+ rollback(using=db)
raise
else:
- if is_dirty(using=using):
- commit(using=using)
+ if is_dirty(using=db):
+ commit(using=db)
return res
finally:
- leave_transaction_management(using=using)
+ leave_transaction_management(using=db)
return wraps(func)(_commit_on_success)
- if func_or_using is None:
- func_or_using = DEFAULT_DB_ALIAS
- if callable(func_or_using):
- return inner_commit_on_success(func_or_using, DEFAULT_DB_ALIAS)
- return lambda func: inner_commit_on_success(func, func_or_using)
-def commit_manually(func_or_using=None):
+ # Note that although the first argument is *called* `using`, it
+ # may actually be a function; @autocommit and @autocommit('foo')
+ # are both allowed forms.
+ if using is None:
+ using = DEFAULT_DB_ALIAS
+ if callable(using):
+ return inner_commit_on_success(using, DEFAULT_DB_ALIAS)
+ return lambda func: inner_commit_on_success(func, using)
+
+def commit_manually(using=None):
"""
Decorator that activates manual transaction control. It just disables
automatic transaction control and doesn't do any commit/rollback of its
own -- it's up to the user to call the commit and rollback functions
themselves.
"""
- def inner_commit_manually(func, using=None):
+ def inner_commit_manually(func, db=None):
def _commit_manually(*args, **kw):
try:
- enter_transaction_management(using=using)
- managed(True, using=using)
+ enter_transaction_management(using=db)
+ managed(True, using=db)
return func(*args, **kw)
finally:
- leave_transaction_management(using=using)
+ leave_transaction_management(using=db)
return wraps(func)(_commit_manually)
- if func_or_using is None:
- func_or_using = DEFAULT_DB_ALIAS
- if callable(func_or_using):
- return inner_commit_manually(func_or_using, DEFAULT_DB_ALIAS)
- return lambda func: inner_commit_manually(func, func_or_using)
+
+ # Note that although the first argument is *called* `using`, it
+ # may actually be a function; @autocommit and @autocommit('foo')
+ # are both allowed forms.
+ if using is None:
+ using = DEFAULT_DB_ALIAS
+ if callable(using):
+ return inner_commit_manually(using, DEFAULT_DB_ALIAS)
+ return lambda func: inner_commit_manually(func, using)
View
44 tests/modeltests/transactions/models.py
@@ -56,17 +56,39 @@ def __unicode__(self):
>>> Reporter.objects.all()
[<Reporter: Alice Smith>, <Reporter: Ben Jones>]
-# With the commit_on_success decorator, the transaction is only comitted if the
+# the autocommit decorator also works with a using argument
+>>> using_autocomitted_create_then_fail = transaction.autocommit(using='default')(create_a_reporter_then_fail)
+>>> using_autocomitted_create_then_fail("Carol", "Doe")
+Traceback (most recent call last):
+ ...
+Exception: I meant to do that
+
+# Same behavior as before
+>>> Reporter.objects.all()
+[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
+
+# With the commit_on_success decorator, the transaction is only committed if the
# function doesn't throw an exception
>>> committed_on_success = transaction.commit_on_success(create_a_reporter_then_fail)
->>> committed_on_success("Carol", "Doe")
+>>> committed_on_success("Dirk", "Gently")
Traceback (most recent call last):
...
Exception: I meant to do that
# This time the object never got saved
>>> Reporter.objects.all()
-[<Reporter: Alice Smith>, <Reporter: Ben Jones>]
+[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
+
+# commit_on_success decorator also works with a using argument
+>>> using_committed_on_success = transaction.commit_on_success(using='default')(create_a_reporter_then_fail)
+>>> using_committed_on_success("Dirk", "Gently")
+Traceback (most recent call last):
+ ...
+Exception: I meant to do that
+
+# This time the object never got saved
+>>> Reporter.objects.all()
+[<Reporter: Alice Smith>, <Reporter: Ben Jones>, <Reporter: Carol Doe>]
# If there aren't any exceptions, the data will get saved
>>> def remove_a_reporter():
@@ -76,22 +98,22 @@ def __unicode__(self):
>>> remove_comitted_on_success = transaction.commit_on_success(remove_a_reporter)
>>> remove_comitted_on_success()
>>> Reporter.objects.all()
-[<Reporter: Ben Jones>]
+[<Reporter: Ben Jones>, <Reporter: Carol Doe>]
# You can manually manage transactions if you really want to, but you
# have to remember to commit/rollback
>>> def manually_managed():
-... r = Reporter(first_name="Carol", last_name="Doe")
+... r = Reporter(first_name="Dirk", last_name="Gently")
... r.save()
... transaction.commit()
>>> manually_managed = transaction.commit_manually(manually_managed)
>>> manually_managed()
>>> Reporter.objects.all()
-[<Reporter: Ben Jones>, <Reporter: Carol Doe>]
+[<Reporter: Ben Jones>, <Reporter: Carol Doe>, <Reporter: Dirk Gently>]
# If you forget, you'll get bad errors
>>> def manually_managed_mistake():
-... r = Reporter(first_name="David", last_name="Davidson")
+... r = Reporter(first_name="Edward", last_name="Woodward")
... r.save()
... # oops, I forgot to commit/rollback!
>>> manually_managed_mistake = transaction.commit_manually(manually_managed_mistake)
@@ -99,4 +121,12 @@ def __unicode__(self):
Traceback (most recent call last):
...
TransactionManagementError: Transaction managed block ended with pending COMMIT/ROLLBACK
+
+# commit_manually also works with a using argument
+>>> using_manually_managed_mistake = transaction.commit_manually(using='default')(manually_managed_mistake)
+>>> using_manually_managed_mistake()
+Traceback (most recent call last):
+ ...
+TransactionManagementError: Transaction managed block ended with pending COMMIT/ROLLBACK
+
"""

0 comments on commit ca81ad4

Please sign in to comment.
Something went wrong with that request. Please try again.