From ca81ad4f9dedfb8b0935c58e9c5e2d4846a3db15 Mon Sep 17 00:00:00 2001 From: Russell Keith-Magee Date: Wed, 10 Mar 2010 13:13:57 +0000 Subject: [PATCH] Fixed #13055 -- Cleaned up the implementation of transaction decorators 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 --- django/db/transaction.py | 80 ++++++++++++++----------- tests/modeltests/transactions/models.py | 44 +++++++++++--- 2 files changed, 83 insertions(+), 41 deletions(-) diff --git a/django/db/transaction.py b/django/db/transaction.py index a6dd519a7c..6cd078d94d 100644 --- a/django/db/transaction.py +++ b/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) diff --git a/tests/modeltests/transactions/models.py b/tests/modeltests/transactions/models.py index 6b92fd01d6..0c1cd21a04 100644 --- a/tests/modeltests/transactions/models.py +++ b/tests/modeltests/transactions/models.py @@ -56,17 +56,39 @@ Exception: I meant to do that >>> Reporter.objects.all() [, ] -# 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() +[, , ] + +# 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() -[, ] +[, , ] + +# 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() +[, , ] # If there aren't any exceptions, the data will get saved >>> def remove_a_reporter(): @@ -76,22 +98,22 @@ Exception: I meant to do that >>> remove_comitted_on_success = transaction.commit_on_success(remove_a_reporter) >>> remove_comitted_on_success() >>> Reporter.objects.all() -[] +[, ] # 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() -[, ] +[, , ] # 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 @@ Exception: I meant to do that 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 + """