Deprecated transaction.is_managed().

It's synchronized with the autocommit flag.

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.
+        if self.transaction_state:
-        managed = self.is_managed()
+            managed = self.transaction_state[-1]
+        else:
+            managed = settings.TRANSACTIONS_MANAGED
 
         if self._dirty:
             self.rollback()
-            if not managed and not self.autocommit:
+            if managed == self.autocommit:
-                self.set_autocommit(True)
+                self.set_autocommit(not managed)
             raise TransactionManagementError(
                 "Transaction managed block ended with pending COMMIT/ROLLBACK")
 
-        if not managed and not self.autocommit:
+        if managed == self.autocommit:
-            self.set_autocommit(True)
+            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

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:

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:

django/db/transaction.py

@@ -113,10 +113,8 @@ def clean_savepoints(using=None):
     get_connection(using).clean_savepoints()
 
 def is_managed(using=None):
-    """
+    warnings.warn("'is_managed' is deprecated.",
-    Checks whether the transaction manager is in manual or in auto state.
+        PendingDeprecationWarning, stacklevel=2)
-    """
-    return get_connection(using).is_managed()
 
 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)

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

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()``

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()