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

/dev/null

@@ +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)), ()

a/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 = [], []
-
-
-
-
-
-
+
+
+
-        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)
-None, '%s'
+'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:
-
-
-
+
+
+
+
+
+
-
-
-
-
-
-
+
+
-
-            if model:
-val, placeholder
+sql, params
-            else:
-val, placeholder
+sql, params
-
-value, placeholder
+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:
-value, placeholder
+sql, params
-        except KeyError:
-value, placeholder
+sql, params
-
-    def get_related_updates(self):
-        """