Ticket #9964: 9964-make-managed-transactions-dirty.patch

django/db/backends/__init__.py

@@ -22 +22 @@
         self.alias = alias
         self.vendor = 'unknown'
         self.use_debug_cursor = None
+        self.on_used = None
 
     def __eq__(self, other):
         return self.settings_dict == other.settings_dict
@@ -78 +79 @@
         if (self.use_debug_cursor or
             (self.use_debug_cursor is None and settings.DEBUG)):
             return self.make_debug_cursor(cursor)
+        # Used by transaction mechanism to be notified that db was used
+        if self.on_used:
+            self.on_used()
         return cursor
 
     def make_debug_cursor(self, cursor):

django/db/transaction.py

@@ -67 +67 @@
     if thread_ident not in dirty or using not in dirty[thread_ident]:
         dirty.setdefault(thread_ident, {})
         dirty[thread_ident][using] = False
+    def set_dirty_if_managed():
+        if is_managed(using): set_dirty(using)
+    connection.on_used = set_dirty_if_managed
     connection._enter_transaction_management(managed)
 
 def leave_transaction_management(using=None):

tests/regressiontests/transaction_regress/tests.py

@@ +1 @@
+from django.test import TransactionTestCase
+from django.db import connection, transaction
+from django.db.transaction import \
+    commit_on_success, commit_manually, \
+    TransactionManagementError
+from models import Mod
+
+class Test9964(TransactionTestCase):
+
+    def test_raw_committed_on_success(self):
+        
+        @commit_on_success
+        def raw_sql():
+            cursor = connection.cursor()
+            cursor.execute("INSERT into transaction_regress_mod (id,fld) values (17,18)")
+            
+        raw_sql()
+        transaction.rollback()
+        try:
+            obj = Mod.objects.get(pk=17)
+            self.assertEqual(obj.fld, 18)
+        except Mod.DoesNotExist:
+            self.fail("transaction with raw sql not committed")
+
+    def test_commit_manually_enforced(self):
+        @commit_manually
+        def non_comitter():
+            _ = Mod.objects.count()
+            
+        self.assertRaises(TransactionManagementError, non_comitter)
+
+    def test_commit_manually_commit_ok(self):
+        @commit_manually
+        def committer():
+            _ = Mod.objects.count()
+            transaction.commit()
+        
+        try:
+            committer()
+        except TransactionManagementError:
+            self.fail("Commit did not clear the transaction state")
+
+    def test_commit_manually_rollback_ok(self):
+        @commit_manually
+        def roller_back():
+            _ = Mod.objects.count()
+            transaction.rollback()
+        
+        try:
+            roller_back()
+        except TransactionManagementError:
+            self.fail("Rollback did not clear the transaction state")
+
+    def test_commit_manually_enforced_after_commit(self):
+        @commit_manually
+        def fake_committer():
+            _ = Mod.objects.count()
+            transaction.commit()
+            _ = Mod.objects.count()            
+            
+        self.assertRaises(TransactionManagementError, fake_committer)
+

tests/regressiontests/transaction_regress/models.py

@@ +1 @@
+from django.db import models
+
+class Mod(models.Model):
+    fld = models.IntegerField()

tests/regressiontests/fixtures_regress/tests.py

@@ -613 +613 @@
 
     def test_ticket_11101(self):
         """Test that fixtures can be rolled back (ticket #11101)."""
-        ticket_11101 = transaction.commit_manually(self.ticket_11101)
+        ticket_11101 = transaction.commit_on_success(self.ticket_11101)
         ticket_11101()

docs/topics/db/sql.txt

@@ -231 +231 @@
 
 Transactions and raw SQL
 ------------------------
-If you are using transaction decorators (such as ``commit_on_success``) to
-wrap your views and provide transaction control, you don't have to make a
-manual call to ``transaction.commit_unless_managed()`` -- you can manually
-commit if you want to, but you aren't required to, since the decorator will
-commit for you. However, if you don't manually commit your changes, you will
-need to manually mark the transaction as dirty, using
-``transaction.set_dirty()``::
 
-    @commit_on_success
-    def my_custom_sql_view(request, value):
-        from django.db import connection, transaction
-        cursor = connection.cursor()
+.. versionchanged:: 1.3
 
-        # Data modifying operation
-        cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [value])
+If you write functions that modify the database via raw SQL, you need to
+consider the transaction management mode they run under. If this may be
+Django's default mode (by default or using the ``auto_commit``
+decorator), you need to make manual calls to
+``transaction.commit_unless_managed()`` to make sure the changes are
+committed. If you are using transaction decorators (such as
+``commit_on_success``) to wrap your views and provide transaction
+control, you don't have to make such calls.
 
-        # Since we modified data, mark the transaction as dirty
-        transaction.set_dirty()
 
-        # Data retrieval operation. This doesn't dirty the transaction,
-        # so no call to set_dirty() is required.
-        cursor.execute("SELECT foo FROM bar WHERE baz = %s", [value])
-        row = cursor.fetchone()
-
-        return render_to_response('template.html', {'row': row})
-
-The call to ``set_dirty()`` is made automatically when you use the Django ORM
-to make data modifying database calls. However, when you use raw SQL, Django
-has no way of knowing if your SQL modifies data or not. The manual call to
-``set_dirty()`` ensures that Django knows that there are modifications that
-must be committed.
-
 Connections and cursors
 -----------------------