Made transaction.managed a no-op and deprecated it.

enter_transaction_management() was nearly always followed by managed().

In three places it wasn't, but they will all be refactored eventually.
The "forced" keyword argument avoids introducing behavior changes until
then.

This is mostly backwards-compatible, except, of course, for managed
itself. There's a minor difference in _enter_transaction_management:
the top self.transaction_state now contains the new 'managed' state
rather than the previous one. Django doesn't access
self.transaction_state in _enter_transaction_management.

7 files changed, 16 insertions, 43 deletions

diff --git a/django/core/management/commands/loaddata.py b/django/core/management/commands/loaddata.py
index ed47b8fbf1..77b9a44a43 100644
--- a/django/core/management/commands/loaddata.py
+++ b/django/core/management/commands/loaddata.py
@@ -75,7 +75,6 @@ class Command(BaseCommand):
         if commit:
             transaction.commit_unless_managed(using=self.using)
             transaction.enter_transaction_management(using=self.using)
-            transaction.managed(True, using=self.using)
 
         class SingleZipReader(zipfile.ZipFile):
             def __init__(self, *args, **kwargs):
diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
index fe26c98baf..f11ee35260 100644
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -234,7 +234,7 @@ class BaseDatabaseWrapper(object):
 
     ##### Generic transaction management methods #####
 
-    def enter_transaction_management(self, managed=True):
+    def enter_transaction_management(self, managed=True, forced=False):
         """
         Enters transaction management for a running thread. It must be balanced with
         the appropriate leave_transaction_management call, since the actual state is
@@ -243,12 +243,14 @@ class BaseDatabaseWrapper(object):
         The state and dirty flag are carried over from the surrounding block or
         from the settings, if there is no surrounding block (dirty is always false
         when no current block is running).
+
+        If you switch off transaction management and there is a pending
+        commit/rollback, the data will be commited, unless "forced" is True.
         """
-        if self.transaction_state:
-            self.transaction_state.append(self.transaction_state[-1])
-        else:
-            self.transaction_state.append(settings.TRANSACTIONS_MANAGED)
+        self.transaction_state.append(managed)
         self._enter_transaction_management(managed)
+        if not managed and self.is_dirty() and not forced:
+            self.commit()
 
     def leave_transaction_management(self):
         """
@@ -314,22 +316,6 @@ class BaseDatabaseWrapper(object):
             return self.transaction_state[-1]
         return settings.TRANSACTIONS_MANAGED
 
-    def managed(self, flag=True):
-        """
-        Puts the transaction manager into a manual state: managed transactions have
-        to be committed explicitly by the user. If you switch off transaction
-        management and there is a pending commit/rollback, the data will be
-        commited.
-        """
-        top = self.transaction_state
-        if top:
-            top[-1] = flag
-            if not flag and self.is_dirty():
-                self.commit()
-        else:
-            raise TransactionManagementError("This code isn't under transaction "
-                "management")
-
     def commit_unless_managed(self):
         """
         Commits changes if the system is not in managed transaction mode.
@@ -574,7 +560,6 @@ class BaseDatabaseFeatures(object):
             # otherwise autocommit will cause the confimation to
             # fail.
             self.connection.enter_transaction_management()
-            self.connection.managed(True)
             cursor = self.connection.cursor()
             cursor.execute('CREATE TABLE ROLLBACK_TEST (X INT)')
             self.connection.commit()
diff --git a/django/db/models/deletion.py b/django/db/models/deletion.py
index 81f74923c2..93ef0006cb 100644
--- a/django/db/models/deletion.py
+++ b/django/db/models/deletion.py
@@ -54,7 +54,7 @@ def force_managed(func):
     @wraps(func)
     def decorated(self, *args, **kwargs):
         if not transaction.is_managed(using=self.using):
-            transaction.enter_transaction_management(using=self.using)
+            transaction.enter_transaction_management(using=self.using, forced=True)
             forced_managed = True
         else:
             forced_managed = False
diff --git a/django/db/models/query.py b/django/db/models/query.py
index 30be30ca43..b41007ee4f 100644
--- a/django/db/models/query.py
+++ b/django/db/models/query.py
@@ -443,7 +443,7 @@ class QuerySet(object):
         connection = connections[self.db]
         fields = self.model._meta.local_fields
         if not transaction.is_managed(using=self.db):
-            transaction.enter_transaction_management(using=self.db)
+            transaction.enter_transaction_management(using=self.db, forced=True)
             forced_managed = True
         else:
             forced_managed = False
@@ -582,7 +582,7 @@ class QuerySet(object):
         query = self.query.clone(sql.UpdateQuery)
         query.add_update_values(kwargs)
         if not transaction.is_managed(using=self.db):
-            transaction.enter_transaction_management(using=self.db)
+            transaction.enter_transaction_management(using=self.db, forced=True)
             forced_managed = True
         else:
             forced_managed = False
diff --git a/django/db/transaction.py b/django/db/transaction.py
index 809f14f628..09ce2abbd2 100644
--- a/django/db/transaction.py
+++ b/django/db/transaction.py
@@ -12,6 +12,8 @@ Managed transactions don't do those commits, but will need some kind of manual
 or implicit commits or rollbacks.
 """
 
+import warnings
+
 from functools import wraps
 
 from django.db import connections, DEFAULT_DB_ALIAS
@@ -49,7 +51,7 @@ def abort(using=None):
     """
     get_connection(using).abort()
 
-def enter_transaction_management(managed=True, using=None):
+def enter_transaction_management(managed=True, using=None, forced=False):
     """
     Enters transaction management for a running thread. It must be balanced with
     the appropriate leave_transaction_management call, since the actual state is
@@ -59,7 +61,7 @@ def enter_transaction_management(managed=True, using=None):
     from the settings, if there is no surrounding block (dirty is always false
     when no current block is running).
     """
-    get_connection(using).enter_transaction_management(managed)
+    get_connection(using).enter_transaction_management(managed, forced)
 
 def leave_transaction_management(using=None):
     """
@@ -105,13 +107,8 @@ def is_managed(using=None):
     return get_connection(using).is_managed()
 
 def managed(flag=True, using=None):
-    """
-    Puts the transaction manager into a manual state: managed transactions have
-    to be committed explicitly by the user. If you switch off transaction
-    management and there is a pending commit/rollback, the data will be
-    commited.
-    """
-    get_connection(using).managed(flag)
+    warnings.warn("'managed' no longer serves a purpose.",
+        PendingDeprecationWarning, stacklevel=2)
 
 def commit_unless_managed(using=None):
     """
@@ -224,7 +221,6 @@ def autocommit(using=None):
     """
     def entering(using):
         enter_transaction_management(managed=False, using=using)
-        managed(False, using=using)
 
     def exiting(exc_value, using):
         leave_transaction_management(using=using)
@@ -240,7 +236,6 @@ def commit_on_success(using=None):
     """
     def entering(using):
         enter_transaction_management(using=using)
-        managed(True, using=using)
 
     def exiting(exc_value, using):
         try:
@@ -268,7 +263,6 @@ def commit_manually(using=None):
     """
     def entering(using):
         enter_transaction_management(using=using)
-        managed(True, using=using)
 
     def exiting(exc_value, using):
         leave_transaction_management(using=using)
diff --git a/django/middleware/transaction.py b/django/middleware/transaction.py
index 4440f377a7..b5a07a02b7 100644
--- a/django/middleware/transaction.py
+++ b/django/middleware/transaction.py
@@ -10,7 +10,6 @@ class TransactionMiddleware(object):
     def process_request(self, request):
         """Enters transaction management"""
         transaction.enter_transaction_management()
-        transaction.managed(True)
 
     def process_exception(self, request, exception):
         """Rolls back the database and leaves transaction management"""
diff --git a/django/test/testcases.py b/django/test/testcases.py
index 44ddb624d6..7f6b1a49ba 100644
--- a/django/test/testcases.py
+++ b/django/test/testcases.py
@@ -67,7 +67,6 @@ real_commit = transaction.commit
 real_rollback = transaction.rollback
 real_enter_transaction_management = transaction.enter_transaction_management
 real_leave_transaction_management = transaction.leave_transaction_management
-real_managed = transaction.managed
 real_abort = transaction.abort
 
 def nop(*args, **kwargs):
@@ -78,7 +77,6 @@ def disable_transaction_methods():
     transaction.rollback = nop
     transaction.enter_transaction_management = nop
     transaction.leave_transaction_management = nop
-    transaction.managed = nop
     transaction.abort = nop
 
 def restore_transaction_methods():
@@ -86,7 +84,6 @@ def restore_transaction_methods():
     transaction.rollback = real_rollback
     transaction.enter_transaction_management = real_enter_transaction_management
     transaction.leave_transaction_management = real_leave_transaction_management
-    transaction.managed = real_managed
     transaction.abort = real_abort
 
 
@@ -833,7 +830,6 @@ class TestCase(TransactionTestCase):
 
         for db_name in self._databases_names():
             transaction.enter_transaction_management(using=db_name)
-            transaction.managed(True, using=db_name)
         disable_transaction_methods()
 
         from django.contrib.sites.models import Site