From 3bdc7a6a70bb030324fdebe9b1dce1fa5358f0c6 Mon Sep 17 00:00:00 2001 From: Aymeric Augustin Date: Mon, 4 Mar 2013 15:24:01 +0100 Subject: [PATCH] Deprecated transaction.is_managed(). It's synchronized with the autocommit flag. --- django/db/backends/__init__.py | 30 ++++++++++++------------------ django/db/models/deletion.py | 2 +- django/db/models/query.py | 4 ++-- django/db/transaction.py | 12 +++++------- django/middleware/transaction.py | 2 +- docs/internals/deprecation.txt | 1 + tests/middleware/tests.py | 2 +- 7 files changed, 23 insertions(+), 30 deletions(-) diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py index 848f6df2d6..499bc32113 100644 --- a/django/db/backends/__init__.py +++ b/django/db/backends/__init__.py @@ -256,11 +256,12 @@ class BaseDatabaseWrapper(object): """ self.transaction_state.append(managed) - if managed and self.autocommit: - self.set_autocommit(False) - if not managed and self.is_dirty() and not forced: self.commit() + self.set_clean() + + if managed == self.autocommit: + self.set_autocommit(not managed) def leave_transaction_management(self): """ @@ -274,19 +275,20 @@ class BaseDatabaseWrapper(object): raise TransactionManagementError( "This code isn't under transaction management") - # That's the next state -- we already left the previous state behind. - managed = self.is_managed() + if self.transaction_state: + managed = self.transaction_state[-1] + else: + managed = settings.TRANSACTIONS_MANAGED if self._dirty: self.rollback() - if not managed and not self.autocommit: - self.set_autocommit(True) + if managed == self.autocommit: + self.set_autocommit(not managed) raise TransactionManagementError( "Transaction managed block ended with pending COMMIT/ROLLBACK") - if not managed and not self.autocommit: - self.set_autocommit(True) - + if managed == self.autocommit: + self.set_autocommit(not managed) def set_autocommit(self, autocommit=True): """ @@ -331,14 +333,6 @@ class BaseDatabaseWrapper(object): self._dirty = False self.clean_savepoints() - def is_managed(self): - """ - Checks whether the transaction manager is in manual or in auto state. - """ - if self.transaction_state: - return self.transaction_state[-1] - return settings.TRANSACTIONS_MANAGED - ##### Foreign key constraints checks handling ##### @contextmanager diff --git a/django/db/models/deletion.py b/django/db/models/deletion.py index 26f63391d5..27184c9350 100644 --- a/django/db/models/deletion.py +++ b/django/db/models/deletion.py @@ -53,7 +53,7 @@ def DO_NOTHING(collector, field, sub_objs, using): def force_managed(func): @wraps(func) def decorated(self, *args, **kwargs): - if not transaction.is_managed(using=self.using): + if transaction.get_autocommit(using=self.using): transaction.enter_transaction_management(using=self.using, forced=True) forced_managed = True else: diff --git a/django/db/models/query.py b/django/db/models/query.py index 22f71c6aee..834fe363b4 100644 --- a/django/db/models/query.py +++ b/django/db/models/query.py @@ -442,7 +442,7 @@ class QuerySet(object): self._for_write = True connection = connections[self.db] fields = self.model._meta.local_fields - if not transaction.is_managed(using=self.db): + if transaction.get_autocommit(using=self.db): transaction.enter_transaction_management(using=self.db, forced=True) forced_managed = True else: @@ -579,7 +579,7 @@ class QuerySet(object): self._for_write = True query = self.query.clone(sql.UpdateQuery) query.add_update_values(kwargs) - if not transaction.is_managed(using=self.db): + if transaction.get_autocommit(using=self.db): transaction.enter_transaction_management(using=self.db, forced=True) forced_managed = True else: diff --git a/django/db/transaction.py b/django/db/transaction.py index a8e80c6c02..49b67f4122 100644 --- a/django/db/transaction.py +++ b/django/db/transaction.py @@ -113,10 +113,8 @@ def clean_savepoints(using=None): get_connection(using).clean_savepoints() def is_managed(using=None): - """ - Checks whether the transaction manager is in manual or in auto state. - """ - return get_connection(using).is_managed() + warnings.warn("'is_managed' is deprecated.", + PendingDeprecationWarning, stacklevel=2) def managed(flag=True, using=None): warnings.warn("'managed' no longer serves a purpose.", @@ -281,7 +279,9 @@ def commit_on_success_unless_managed(using=None): """ Transitory API to preserve backwards-compatibility while refactoring. """ - if is_managed(using): + if get_autocommit(using): + return commit_on_success(using) + else: def entering(using): pass @@ -289,5 +289,3 @@ def commit_on_success_unless_managed(using=None): set_dirty(using=using) return _transaction_func(entering, exiting, using) - else: - return commit_on_success(using) diff --git a/django/middleware/transaction.py b/django/middleware/transaction.py index b5a07a02b7..35f765d99f 100644 --- a/django/middleware/transaction.py +++ b/django/middleware/transaction.py @@ -23,7 +23,7 @@ class TransactionMiddleware(object): def process_response(self, request, response): """Commits and leaves transaction management.""" - if transaction.is_managed(): + if not transaction.get_autocommit(): if transaction.is_dirty(): # Note: it is possible that the commit fails. If the reason is # closed connection or some similar reason, then there is diff --git a/docs/internals/deprecation.txt b/docs/internals/deprecation.txt index a81b16278f..1c8618713a 100644 --- a/docs/internals/deprecation.txt +++ b/docs/internals/deprecation.txt @@ -351,6 +351,7 @@ these changes. * The following private APIs will be removed: - ``django.db.close_connection()`` - ``django.db.backends.creation.BaseDatabaseCreation.set_autocommit()`` + - ``django.db.transaction.is_managed()`` - ``django.db.transaction.managed()`` - ``django.db.transaction.commit_unless_managed()`` - ``django.db.transaction.rollback_unless_managed()`` diff --git a/tests/middleware/tests.py b/tests/middleware/tests.py index 17751dd158..e704fce342 100644 --- a/tests/middleware/tests.py +++ b/tests/middleware/tests.py @@ -689,7 +689,7 @@ class TransactionMiddlewareTest(TransactionTestCase): def test_request(self): TransactionMiddleware().process_request(self.request) - self.assertTrue(transaction.is_managed()) + self.assertFalse(transaction.get_autocommit()) def test_managed_response(self): transaction.enter_transaction_management()