Fixed #13055 -- Cleaned up the implementation of transaction decorators to... (ca81ad4f) · Commits · Dom Sekotill / django

django/db/transaction.py

+46 −34

Original line number	Diff line number	Diff line
		@@ -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)

tests/modeltests/transactions/models.py

+37 −7

Original line number	Diff line number	Diff line
		@@ -56,17 +56,39 @@ Exception: I meant to do that
		>>> 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 @@ Exception: I meant to do that
		>>> 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 @@ 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

		"""