Ticket #7210: 0001-Added-expression-support-for-QuerySet.update.patch

new file django/db/models/sql/expressions.py

@@ +1 @@
+from copy import deepcopy
+
+from django.db import connection
+from django.db.models.fields import FieldDoesNotExist
+from django.core.exceptions import FieldError
+from django.utils import tree
+
+class Expression(object):
+    """
+    Base class for all sql expressions, expected by QuerySet.update.
+    """
+    # Arithmetic connection types
+    ADD = '+'
+    SUB = '-'
+    MUL = '*'
+    DIV = '/'
+    MOD = '%'
+
+    # Logical connection types
+    AND = 'AND'
+    OR = 'OR'
+
+    def _combine(self, other, conn, node=None):
+        if not isinstance(other, Expression):
+            raise TypeError(other)
+        obj = node or ExpressionNode([self], conn)
+        obj.add(other, conn)
+        return obj
+
+    def __add__(self, other):
+        return self._combine(other, self.ADD)
+
+    def __sub__(self, other):
+        return self._combine(other, self.SUB)
+
+    def __mul__(self, other):
+        return self._combine(other, self.MUL)
+
+    def __div__(self, other):
+        return self._combine(other, self.DIV)
+
+    def __mod__(self, other):
+        return self._combine(other, self.MOD)
+
+    def __and__(self, other):
+        return self._combine(other, self.AND)
+
+    def __or__(self, other):
+        return self._combine(other, self.OR)
+
+    def __invert__(self, node=None):
+        obj = node or ExpressionNode([self])
+        obj.negate()
+        return obj
+
+    def as_sql(self, field, opts, qn=None):
+        raise NotImplementedError
+
+class ExpressionNode(Expression, tree.Node):
+    def __init__(self, children=None, connector=None, negated=False):
+        if children and len(children) > 1 and connector in (None, self.default):
+            raise TypeError('You have to specify a connector.')
+        super(ExpressionNode, self).__init__(children, connector, negated)
+
+    def _combine(self, *args, **kwargs):
+        return super(ExpressionNode, self)._combine(node=deepcopy(self), *args, **kwargs)
+
+    def __invert__(self):
+        return super(ExpressionNode, self).__invert__(node=deepcopy(self))
+
+    def as_sql(self, field, opts, qn=None, node=None):
+        if node is None:
+            node = self
+        result = []
+        result_params = []
+        for child in node.children:
+            if hasattr(child, 'as_sql'):
+                sql, params = child.as_sql(field, opts, qn)
+                format = '%s'
+            else:
+                sql, params = self.as_sql(field, opts, qn, child)
+                if child.negated:
+                    format = 'NOT %s'
+                else:
+                    format = '%s'
+                if len(child.children) > 1:
+                    format %= '(%s)'
+            if sql:
+                result.append(format % sql)
+                result_params.extend(params)
+        conn = ' %s ' % node.connector
+        return conn.join(result), result_params
+
+class LiteralExpr(Expression):
+    """
+    An expression representing the given value.
+    """
+    def __init__(self, value):
+        self.value = value
+
+    def as_sql(self, field, opts, qn=None):
+        if self.value is None:
+            return 'NULL', ()
+        if hasattr(field, 'get_placeholder'):
+            return field.get_placeholder(self.value), (self.value,)
+        return '%s', (self.value,)
+
+class ColumnExpr(Expression):
+    """
+    An expression representing the value of the given column.
+    """
+    def __init__(self, column):
+        self.column = column
+
+    def as_sql(self, field, opts, qn=None):
+        if not qn:
+            qn = connection.ops.quote_name
+        try:
+            column = opts.get_field(self.column).attname
+        except FieldDoesNotExist:
+            names = opts.get_all_field_names()
+            raise FieldError('Cannot resolve keyword %r into field. '
+                    'Choices are: %s' % (self.column, ', '.join(names)))
+        return '%s.%s' % (qn(opts.db_table), qn(column)), ()
+
+class CurrentExpr(Expression):
+    """
+    An expression representing the value of the current column.
+    """
+    def as_sql(self, field, opts, qn=None):
+        if not qn:
+            qn = connection.ops.quote_name
+        return '%s.%s' % (qn(opts.db_table), qn(field.attname)), ()

django/db/models/sql/subqueries.py

@@ -8 +8 @@
 from django.db.models.sql.datastructures import RawValue, Date
 from django.db.models.sql.query import Query
 from django.db.models.sql.where import AND
+from django.db.models.sql.expressions import Expression, LiteralExpr
 
 __all__ = ['DeleteQuery', 'UpdateQuery', 'InsertQuery', 'DateQuery',
         'CountQuery']
@@ -126 +127 @@
         result = ['UPDATE %s' % qn(table)]
         result.append('SET')
         values, update_params = [], []
-        for name, val, placeholder in self.values:
-            if val is not None:
-                values.append('%s = %s' % (qn(name), placeholder))
-                update_params.append(val)
-            else:
-                values.append('%s = NULL' % qn(name))
+        for name, sql, params in self.values:
+            values.append('%s = %s' % (qn(name), sql))
+            update_params.extend(params)
         result.append(', '.join(values))
         where, params = self.where.as_sql()
         if where:
@@ -207 +205 @@
             self.where.add((None, f.column, f, 'in',
                     pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]),
                     AND)
-            self.values = [(related_field.column, None, '%s')]
+            self.values = [(related_field.column, 'NULL', ())]
             self.execute_sql(None)
 
     def add_update_values(self, values):
@@ -232 +230 @@
         """
         from django.db.models.base import Model
         for field, model, val in values_seq:
-            # FIXME: Some sort of db_prep_* is probably more appropriate here.
-            if field.rel and isinstance(val, Model):
-                val = val.pk
+            if isinstance(val, Expression):
+                expr = val
+            elif field.rel and isinstance(val, Model):  # FIXME: Some sort of
+                expr = LiteralExpr(val.pk)              # db_prep_* is probably
+            else:                                       # more appropriate here.
+                expr = LiteralExpr(val)
 
-            # Getting the placeholder for the field.
-            if hasattr(field, 'get_placeholder'):
-                placeholder = field.get_placeholder(val)
-            else:
-                placeholder = '%s'
+            sql, params = expr.as_sql(
+                field, self.get_meta(), self.connection.ops.quote_name)
 
             if model:
-                self.add_related_update(model, field.column, val, placeholder)
+                self.add_related_update(model, field.column, sql, params)
             else:
-                self.values.append((field.column, val, placeholder))
+                self.values.append((field.column, sql, params))
 
-    def add_related_update(self, model, column, value, placeholder):
+    def add_related_update(self, model, column, sql, params):
         """
         Adds (name, value) to an update query for an ancestor model.
 
         Updates are coalesced so that we only run one update query per ancestor.
         """
         try:
-            self.related_updates[model].append((column, value, placeholder))
+            self.related_updates[model].append((column, sql, params))
         except KeyError:
-            self.related_updates[model] = [(column, value, placeholder)]
+            self.related_updates[model] = [(column, sql, params)]
 
     def get_related_updates(self):
         """