Ticket #3460: 3640_r9734-autocommit.diff

django/db/backends/__init__.py

@@ -31 +31 @@
         if self.connection is not None:
             return self.connection.rollback()
 
+    def _enter_transaction_management(self, managed):
+        pass
+
+    def _leave_transaction_management(self, managed):
+        pass
+
     def _savepoint(self, sid):
         if not self.features.uses_savepoints:
             return
@@ -74 +80 @@
     # If True, don't use integer foreign keys referring to, e.g., positive
     # integer primary keys.
     related_fields_match_type = False
+    native_autocommit = False
 
 class BaseDatabaseOperations(object):
     """

django/db/backends/postgresql_psycopg2/base.py

@@ -4 +4 @@
 Requires psycopg 2: http://initd.org/projects/psycopg2
 """
 
+from django.conf import settings
 from django.db.backends import *
 from django.db.backends.postgresql.operations import DatabaseOperations as PostgresqlDatabaseOperations
 from django.db.backends.postgresql.client import DatabaseClient
@@ -28 +29 @@
 
 class DatabaseFeatures(BaseDatabaseFeatures):
     needs_datetime_string_cast = False
-    uses_savepoints = True
 
 class DatabaseOperations(PostgresqlDatabaseOperations):
     def last_executed_query(self, cursor, sql, params):
@@ -59 +59 @@
         super(DatabaseWrapper, self).__init__(*args, **kwargs)
         
         self.features = DatabaseFeatures()
+        if settings.DATABASE_OPTIONS.get('native_autocommit', False):
+          self.features.native_autocommit = True
+          self.features.uses_savepoints = False
+          self._isolation_level = 0
+        else:
+          self.features.native_autocommit = False
+          self.features.uses_savepoints = True
+          self._isolation_level = 1
         self.ops = DatabaseOperations()
         self.client = DatabaseClient()
         self.creation = DatabaseCreation(self)
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation()
+ 
+    def _enter_transaction_management(self, managed):
+        """Manages the mapping of transaction management to isolation levels"""
 
+        if self.features.native_autocommit and managed and self._isolation_level == 0:
+            try:
+                if self.connection != None:
+                    self.connection.set_isolation_level(1)
+            finally:
+                self._isolation_level = 1
+                self.features.uses_savepoints = True
+
+    def _leave_transaction_management(self, managed):
+        """Manages the mapping of transaction management to isolation levels"""
+
+        if self.features.native_autocommit and not managed and self._isolation_level == 1:
+            try:
+                if self.connection != None:
+                    self.connection.set_isolation_level(0)
+            finally:
+                self._isolation_level = 0
+                self.features.uses_savepoints = False
+
     def _cursor(self, settings):
         set_tz = False
         if self.connection is None:
@@ -81 +111 @@
                 conn_string += " host=%s" % settings.DATABASE_HOST
             if settings.DATABASE_PORT:
                 conn_string += " port=%s" % settings.DATABASE_PORT
-            self.connection = Database.connect(conn_string, **self.options)
-            self.connection.set_isolation_level(1) # make transactions transparent to all cursors
+            x = self.options.copy()
+            x.pop('native_autocommit', '')
+            self.connection = Database.connect(conn_string, **x)
+            self.connection.set_isolation_level(self._isolation_level)
             self.connection.set_client_encoding('UTF8')
         cursor = self.connection.cursor()
         cursor.tzinfo_factory = None

django/db/transaction.py

@@ -40 +40 @@
 # database commit.
 dirty = {}
 
-def enter_transaction_management():
+def enter_transaction_management(managed=True):
     """
     Enters transaction management for a running thread. It must be balanced with
     the appropriate leave_transaction_management call, since the actual state is
@@ -58 +58 @@
         state[thread_ident].append(settings.TRANSACTIONS_MANAGED)
     if thread_ident not in dirty:
         dirty[thread_ident] = False
+    connection._enter_transaction_management(managed)
 
 def leave_transaction_management():
     """
@@ -65 +66 @@
     over to the surrounding block, as a commit will commit all changes, even
     those from outside. (Commits are on connection level.)
     """
+    connection._leave_transaction_management(is_managed())
     thread_ident = thread.get_ident()
     if thread_ident in state and state[thread_ident]:
         del state[thread_ident][-1]
@@ -216 +218 @@
     """
     def _autocommit(*args, **kw):
         try:
-            enter_transaction_management()
+            enter_transaction_management(managed=False)
             managed(False)
             return func(*args, **kw)
         finally:

docs/ref/databases.txt

@@ -260 +260 @@
 column types have a maximum length restriction of 255 characters, regardless
 of whether ``unique=True`` is specified or not.
 
+.. _postgresql-notes:
+
+PostgreSQL notes
+================
+
+Django supports PostgreSQL using the psycopg_ package. Django supports both
+version 1 and 2. (When you configure Django's database layer, specify either
+``postgresql`` [for version 1] or ``postgresql_psycopg2`` [for version 2].)
+
+Native Autocommit
+-----------------
+
+By default, Django database backends run with a permanently open
+transaction, as per the Python DB-API. Django simulates autocommit behaviour
+by committing this transaction automatically (e.g. in ``save()``). For
+PostgreSQL, this corresponds to running in ``set_isolation_level(1)``.
+
+For higher performance, ``postgresql_psycopg2`` can be configured to run
+without an open connection when Django is in autocommit mode. This
+corresponds to PostgreSQL ``set_isolation_level(0)`` and is configured
+with::
+
+    DATABASE_OPTIONS = {'native_autocommit':True}
+
+.. _psycopg: http://initd.org/pub/software/psycopg/
+
 .. _sqlite-notes:
 
 SQLite notes