Ticket #2705: for_update_14751.diff

django/db/models/sql/compiler.py

@@ -117 +117 @@
                         result.append('LIMIT %d' % val)
                 result.append('OFFSET %d' % self.query.low_mark)
 
+        if self.query.select_for_update and self.connection.features.has_select_for_update:
+            nowait = self.query.select_for_update_nowait and self.connection.features.has_select_for_update
+            result.append("%s" % self.connection.ops.for_update_sql(nowait=nowait))
+
         return ' '.join(result), tuple(params)
 
     def as_nested_sql(self):

django/db/models/sql/query.py

@@ -11 +11 @@
 from django.utils.tree import Node
 from django.utils.datastructures import SortedDict
 from django.utils.encoding import force_unicode
-from django.db import connections, DEFAULT_DB_ALIAS
+from django.db import connections, DEFAULT_DB_ALIAS, DatabaseError
 from django.db.models import signals
 from django.db.models.fields import FieldDoesNotExist
 from django.db.models.query_utils import select_related_descend, InvalidQuery
@@ -23 +23 @@
     ExtraWhere, AND, OR)
 from django.core.exceptions import FieldError
 
-__all__ = ['Query', 'RawQuery']
+__all__ = ['Query', 'RawQuery', 'LockNotAvailable']
 
+
+class LockNotAvailable(DatabaseError): 
+    '''
+    Raised when a query fails because a lock was not available. 
+    '''
+    pass
+
+
 class RawQuery(object):
     """
     A single raw SQL query
@@ -84 +92 @@
 
     def _execute_query(self):
         self.cursor = connections[self.using].cursor()
-        self.cursor.execute(self.sql, self.params)
+        try:
+            self.cursor.execute(self.sql, self.params)
+        except DatabaseError, e:
+            if self.connection.features.has_select_for_update_nowait and self.connection.ops.signals_lock_not_available(e):
+                raise LockNotAvailable(*e.args)
+            raise
 
-
 class Query(object):
     """
     A single SQL query.
@@ -131 +143 @@
         self.order_by = []
         self.low_mark, self.high_mark = 0, None  # Used for offset/limit
         self.distinct = False
+        self.select_for_update = False
+        self.select_for_update_nowait = False
         self.select_related = False
         self.related_select_cols = []
 
@@ -260 +274 @@
         obj.order_by = self.order_by[:]
         obj.low_mark, obj.high_mark = self.low_mark, self.high_mark
         obj.distinct = self.distinct
+        obj.select_for_update = self.select_for_update
+        obj.select_for_update_nowait = self.select_for_update_nowait
         obj.select_related = self.select_related
         obj.related_select_cols = []
         obj.aggregates = deepcopy(self.aggregates, memo=memo)
@@ -366 +382 @@
 
         query.clear_ordering(True)
         query.clear_limits()
+        query.select_for_update = False
         query.select_related = False
         query.related_select_cols = []
         query.related_select_fields = []

django/db/models/manager.py

@@ -164 +164 @@
     def order_by(self, *args, **kwargs):
         return self.get_query_set().order_by(*args, **kwargs)
 
+    def select_for_update(self, *args, **kwargs):
+        return self.get_query_set().select_for_update(*args, **kwargs)
+
     def select_related(self, *args, **kwargs):
         return self.get_query_set().select_related(*args, **kwargs)
 

django/db/models/query.py

@@ -432 +432 @@
         del_query._for_write = True
 
         # Disable non-supported fields.
+        del_query.query.select_for_update = False
         del_query.query.select_related = False
         del_query.query.clear_ordering()
 
@@ -580 +581 @@
         else:
             return self._filter_or_exclude(None, **filter_obj)
 
+    def select_for_update(self, **kwargs): 
+        """ 
+        Returns a new QuerySet instance that will select objects with a 
+        FOR UPDATE lock. 
+        """ 
+        # Default to false for nowait 
+        nowait = kwargs.pop('nowait', False) 
+        obj = self._clone() 
+        obj.query.select_for_update = True 
+        obj.query.select_for_update_nowait = nowait 
+        return obj
+
     def select_related(self, *fields, **kwargs):
         """
         Returns a new QuerySet instance that will select related objects.

django/db/backends/mysql/base.py

@@ -23 +23 @@
     raise ImproperlyConfigured("MySQLdb-1.2.1p2 or newer is required; you have %s" % Database.__version__)
 
 from MySQLdb.converters import conversions
-from MySQLdb.constants import FIELD_TYPE, FLAG, CLIENT
+from MySQLdb.constants import FIELD_TYPE, FLAG, CLIENT, ER
 
 from django.db import utils
 from django.db.backends import *
@@ -124 +124 @@
     allows_group_by_pk = True
     related_fields_match_type = True
     allow_sliced_subqueries = False
+    has_select_for_update = True
+    has_select_for_update_nowait = False
     supports_forward_references = False
     supports_long_model_names = False
     supports_microsecond_precision = False
@@ -135 +137 @@
 
 class DatabaseOperations(BaseDatabaseOperations):
     compiler_module = "django.db.backends.mysql.compiler"
+    signals_deadlock = lambda self, e: e.args[0] == ER.LOCK_DEADLOCK
 
     def date_extract_sql(self, lookup_type, field_name):
         # http://dev.mysql.com/doc/mysql/en/date-and-time-functions.html

django/db/backends/oracle/base.py

@@ -48 +48 @@
     needs_datetime_string_cast = False
     interprets_empty_strings_as_nulls = True
     uses_savepoints = True
+    has_select_for_update = True 
+    has_select_for_update_nowait = True
     can_return_id_from_insert = True
     allow_sliced_subqueries = False
     supports_subqueries_in_group_by = False
@@ -285 +287 @@
                                            'column': column_name})
         return output
 
+    def signals_deadlock(self, exception): 
+        return exception.args[0].code == 60 
+
+    def signals_lock_not_available(self, exception): 
+        return exception.args[0].code == 54 
+
     def start_transaction_sql(self):
         return ''
 

django/db/backends/__init__.py

@@ -103 +103 @@
     # integer primary keys.
     related_fields_match_type = False
     allow_sliced_subqueries = True
+    has_select_for_update = False
+    has_select_for_update_nowait = False
 
     # Does the default test database allow multiple connections?
     # Usually an indication that the test database is in-memory
@@ -281 +283 @@
         ordering.
         """
         return []
+    def for_update_sql(self, nowait=False): 
+        """ 
+        Return FOR UPDATE SQL clause to lock row for update 
+        """ 
+        if nowait: 
+            nowaitstr = ' NOWAIT' 
+        else: 
+            nowaitstr = '' 
+        return 'FOR UPDATE' + nowaitstr 
 
     def fulltext_search_sql(self, field_name):
         """

django/db/backends/postgresql_psycopg2/base.py

@@ -19 +19 @@
 try:
     import psycopg2 as Database
     import psycopg2.extensions
+    from psycopg2 import errorcodes
 except ImportError, e:
     from django.core.exceptions import ImproperlyConfigured
     raise ImproperlyConfigured("Error loading psycopg2 module: %s" % e)
@@ -70 +71 @@
     requires_rollback_on_dirty_transaction = True
     has_real_datatype = True
     can_defer_constraint_checks = True
+    has_select_for_update = True
+    has_select_for_update_nowait = True
+    
 
 class DatabaseOperations(PostgresqlDatabaseOperations):
+    signals_deadlock = lambda self, e: e.pgcode == errorcodes.DEADLOCK_DETECTED
+    signals_lock_not_available = lambda self, e: e.pgcode == errorcodes.LOCK_NOT_AVAILABLE
+    
     def last_executed_query(self, cursor, sql, params):
         # With psycopg2, cursor objects have a "query" attribute that is the
         # exact query sent to the database. See docs here:

docs/ref/models/querysets.txt

@@ -975 +975 @@
     # queries the database with the 'backup' alias
     >>> Entry.objects.using('backup')
 
+``select_for_update(nowait=False)`` 
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
+         
+Returns a queryset that will lock rows until the end of the transaction,  
+generating a SELECT ... FOR UPDATE statement on supported databases. 
+         
+For example:: 
+         
+    entries = Entry.objects.select_for_update().filter(author=request.user) 
+ 
+All matched entries will be locked until the end of the transaction block,  
+meaning that other transactions will be prevented from changing or acquiring  
+locks on them. 
+ 
+Usually, if another transaction has already acquired a lock on one of the  
+selected rows, the query will block until the lock is released. If this is  
+not the behaviour you want, call ``select_for_update(nowait=True)``. This will  
+make the call non-blocking. If a conflicting lock is already acquired by  
+another transaction, ``django.db.models.LockNotAvailable`` will be raised when  
+the queryset is evaluated. 
+ 
+Using blocking locks on a database can lead to deadlocks. This occurs when two  
+concurrent transactions are both waiting on a lock the other transaction  
+already holds. To deal with deadlocks, wrap your views that use  
+``select_for_update(nowait=False)`` with the  
+``django.views.decorators.deadlock.handle_deadlocks`` decorator.  
+ 
+For example:: 
+ 
+    from django.db import transaction 
+    from django.views.decorators.deadlock import handle_deadlocks 
+ 
+    @handle_deadlocks(max_retries=2) 
+    @transaction.commit_on_success 
+    def my_view(request): 
+        ... 
+ 
+If the database engine detects a deadlock involving ``my_view`` and decides  
+to abort its transaction, it will be automatically retried. If deadlocks keep  
+occurring after two repeated attempts,  
+``django.views.decorators.DeadlockError`` will be raised, which can be  
+propagated to the user or handled in a middleware. 
+ 
+Currently the ``postgresql_psycopg2``, ``oracle``, and ``mysql`` 
+database backends support ``select_for_update()`` but MySQL has no 
+support for the ``nowait`` argument. Other backends will simply 
+generate queries as if ``select_for_update()`` had not been used. 
 
 Methods that do not return QuerySets
 ------------------------------------

docs/ref/databases.txt

@@ -362 +362 @@
 column types have a maximum length restriction of 255 characters, regardless
 of whether ``unique=True`` is specified or not.
 
+Row locking with ``QuerySet.select_for_update()`` 
+------------------------------------------------- 
+ 
+MySQL does not support the NOWAIT option to the SELECT ... FOR UPDATE  
+statement. However, you may call the ``select_for_update()`` method of a  
+queryset with ``nowait=True``. In that case, the argument will be silently  
+discarded and the generated query will block until the requested lock can be  
+acquired. 
+
 .. _sqlite-notes:
 
 SQLite notes