Ticket #11156: 11156.diff

django/db/models/query.py

@@ -364 +364 @@
                 params = dict([(k, v) for k, v in kwargs.items() if '__' not in k])
                 params.update(defaults)
                 obj = self.model(**params)
-                sid = transaction.savepoint(using=self.db)
+                sid = transaction.savepoint(using=self.db, only_if_needed=True)
                 obj.save(force_insert=True, using=self.db)
-                transaction.savepoint_commit(sid, using=self.db)
+                transaction.savepoint_commit(sid, using=self.db,
+                                             only_if_needed=True)
                 return obj, True
             except IntegrityError, e:
-                transaction.savepoint_rollback(sid, using=self.db)
+                transaction.savepoint_rollback(sid, using=self.db,
+                                               only_if_needed=True)
                 try:
                     return self.get(**kwargs), False
                 except self.model.DoesNotExist:

django/db/backends/postgresql/base.py

@@ -67 +67 @@
 
 class DatabaseFeatures(BaseDatabaseFeatures):
     uses_savepoints = True
+    needs_savepoint_on_exception = True
 
 class DatabaseWrapper(BaseDatabaseWrapper):
     operators = {

django/db/backends/__init__.py

@@ -50 +50 @@
         """
         pass
 
-    def _savepoint(self, sid):
+    def _savepoint(self, sid, only_if_needed=False):
         if not self.features.uses_savepoints:
             return
+        if only_if_needed and not self.features.needs_savepoint_on_exception:
+            return
         self.cursor().execute(self.ops.savepoint_create_sql(sid))
 
-    def _savepoint_rollback(self, sid):
+    def _savepoint_rollback(self, sid, only_if_needed=False):
         if not self.features.uses_savepoints:
             return
+        if only_if_needed and not self.features.needs_savepoint_on_exception:
+            return
         self.cursor().execute(self.ops.savepoint_rollback_sql(sid))
 
-    def _savepoint_commit(self, sid):
+    def _savepoint_commit(self, sid, only_if_needed=False):
         if not self.features.uses_savepoints:
             return
+        if only_if_needed and not self.features.needs_savepoint_on_exception:
+            return
         self.cursor().execute(self.ops.savepoint_commit_sql(sid))
 
     def close(self):
@@ -92 +98 @@
     can_return_id_from_insert = False
     uses_autocommit = False
     uses_savepoints = False
+    needs_savepoint_on_exception = False
     # If True, don't use integer foreign keys referring to, e.g., positive
     # integer primary keys.
     related_fields_match_type = False

django/db/backends/postgresql_psycopg2/base.py

@@ -30 +30 @@
 class DatabaseFeatures(BaseDatabaseFeatures):
     needs_datetime_string_cast = False
     can_return_id_from_insert = False
+    uses_savepoints = True
 
 class DatabaseOperations(PostgresqlDatabaseOperations):
     def last_executed_query(self, cursor, sql, params):
@@ -148 +149 @@
                 self.connection.set_isolation_level(level)
         finally:
             self.isolation_level = level
-            self.features.uses_savepoints = bool(level)
+            self.features.needs_savepoint_on_exception = bool(level)

django/db/transaction.py

@@ -209 +209 @@
     connection._rollback()
     set_clean(using=using)
 
-def savepoint(using=None):
+def savepoint(using=None, only_if_needed=False):
     """
     Creates a savepoint (if supported and required by the backend) inside the
     current transaction. Returns an identifier for the savepoint that will be
@@ -226 +226 @@
         savepoint_state[thread_ident][using] = [None]
     tid = str(thread_ident).replace('-', '')
     sid = "s%s_x%d" % (tid, len(savepoint_state[thread_ident][using]))
-    connection._savepoint(sid)
+    connection._savepoint(sid, only_if_needed)
     return sid
 
-def savepoint_rollback(sid, using=None):
+def savepoint_rollback(sid, using=None, only_if_needed=False):
     """
     Rolls back the most recent savepoint (if one exists). Does nothing if
-    savepoints are not supported.
+    savepoints are not supported, or if only_if_needed is set and the backend
+    does not need to use savepoints to recover from exceptions.
     """
     if using is None:
         using = DEFAULT_DB_ALIAS
     connection = connections[using]
     thread_ident = thread.get_ident()
     if thread_ident in savepoint_state and using in savepoint_state[thread_ident]:
-        connection._savepoint_rollback(sid)
+        connection._savepoint_rollback(sid, only_if_needed)
 
-def savepoint_commit(sid, using=None):
+def savepoint_commit(sid, using=None, only_if_needed=False):
     """
     Commits the most recent savepoint (if one exists). Does nothing if
-    savepoints are not supported.
+    savepoints are not supported, or if only_if_needed is set and the backend
+    does not need to use savepoints to recover from exceptions.
     """
     if using is None:
         using = DEFAULT_DB_ALIAS
     connection = connections[using]
     thread_ident = thread.get_ident()
     if thread_ident in savepoint_state and using in savepoint_state[thread_ident]:
-        connection._savepoint_commit(sid)
+        connection._savepoint_commit(sid, only_if_needed)
 
 ##############
 # DECORATORS #

django/contrib/sessions/backends/db.py

@@ -58 +58 @@
             session_data = self.encode(self._get_session(no_load=must_create)),
             expire_date = self.get_expiry_date()
         )
-        sid = transaction.savepoint(using=self.using)
+        sid = transaction.savepoint(using=self.using, only_if_needed=True)
         try:
             obj.save(force_insert=must_create)
         except IntegrityError:
             if must_create:
-                transaction.savepoint_rollback(sid, using=self.using)
+                transaction.savepoint_rollback(sid, using=self.using,
+                                               only_if_needed=True)
                 raise CreateError
             raise