Changeset 7179

Timestamp:

02/29/08 09:53:25 (9 months ago)

Author:

mtredinnick

Message:

queryset-refactor: Made update() work with inherited models.

Files:

• django/branches/queryset-refactor/django/db/models/sql/query.py (modified) (7 diffs)
• django/branches/queryset-refactor/django/db/models/sql/subqueries.py (modified) (5 diffs)
• django/branches/queryset-refactor/tests/modeltests/model_inheritance/models.py (modified) (1 diff)

django/branches/queryset-refactor/django/db/models/sql/query.py

@@ -504 +504 @@
-        pieces = name.split(LOOKUP_SEP)
-        if not alias:
-join((None, opts.db_table, None, None)
+get_initial_alias(
-        field, target, opts, joins = self.setup_joins(pieces, opts, alias,
-                False)
@@ -581 +581 @@
-            return True
-        return False
+
+    def change_alias(self, old_alias, new_alias):
+        """
+        Changes old_alias to new_alias, relabelling any references to it in
+        select columns and the where clause.
+        """
+        assert new_alias not in self.alias_map
+
+        # 1. Update references in "select" and "where".
+        change_map = {old_alias: new_alias}
+        self.where.relabel_aliases(change_map)
+        for pos, col in enumerate(self.select):
+            if isinstance(col, (list, tuple)):
+                if col[0] == old_alias:
+                    self.select[pos] = (new_alias, col[1])
+            else:
+                col.relabel_aliases(change_map)
+
+        # 2. Rename the alias in the internal table/alias datastructures.
+        alias_data = self.alias_map[old_alias]
+        alias_data[ALIAS_JOIN][RHS_ALIAS] = new_alias
+        table_aliases = self.table_map[alias_data[ALIAS_TABLE]]
+        for pos, alias in enumerate(table_aliases):
+            if alias == old_alias:
+                table_aliases[pos] = new_alias
+                break
+        self.alias_map[new_alias] = alias_data
+        del self.alias_map[old_alias]
+        for pos, alias in enumerate(self.tables):
+            if alias == old_alias:
+                self.tables[pos] = new_alias
+                break
+
+        # 3. Update any joins that refer to the old alias.
+        for data in self.alias_map.values():
+            if data[ALIAS_JOIN][LHS_ALIAS] == old_alias:
+                data[ALIAS_JOIN][LHS_ALIAS] = new_alias
+
+    def get_initial_alias(self):
+        """
+        Returns the first alias for this query, after increasing its reference
+        count.
+        """
+        if self.tables:
+            alias = self.tables[0]
+            self.ref_alias(alias)
+        else:
+            alias = self.join((None, self.model._meta.db_table, None, None))
+        return alias
+
+    def count_active_tables(self):
+        """
+        Returns the number of tables in this query with a non-zero reference
+        count.
+        """
+        return len([1 for o in self.alias_map.values() if o[ALIAS_REFCOUNT]])
-
-    def join(self, connection, always_create=False, exclusions=(),
@@ -729 +785 @@
-
-        opts = self.get_meta()
-join((None, opts.db_table, None, None)
+get_initial_alias(
-        allow_many = trim or not negate
-
@@ -1022 +1078 @@
-        the root model (the one given in self.model).
-        """
-
-
+
+
+
+
+
+
-
-    def add_ordering(self, *ordering):
@@ -1112 +1172 @@
-        """
-        opts = self.model._meta
-join((None, opts.db_table, None, None)
+get_initial_alias(
-        field, col, opts, joins = self.setup_joins(start.split(LOOKUP_SEP),
-                opts, alias, False)
@@ -1142 +1202 @@
-        try:
-            sql, params = self.as_sql()
+            if not sql:
+                raise EmptyResultSet
-        except EmptyResultSet:
-            if result_type == MULTI:
@@ -1174 +1236 @@
-
-def results_iter(cursor):
+    """
+    An iterator over the result set that returns a chunk of rows at a time.
+    """
-    while 1:
-        rows = cursor.fetchmany(GET_ITERATOR_CHUNK_SIZE)

django/branches/queryset-refactor/django/db/models/sql/subqueries.py

@@ -2 +2 @@
-Query subclasses which provide extra functionality beyond simple data retrieval.
-"""
+from copy import deepcopy
+
-from django.contrib.contenttypes import generic
-from django.core.exceptions import FieldError
@@ -95 +97 @@
-    def _setup_query(self):
-        """
-
+
+
+
-        """
-        self.values = []
+        self.related_updates = {}
+        self.related_ids = None
+
+    def clone(self, klass=None, **kwargs):
+        return super(UpdateQuery, self).clone(klass,
+                related_updates=self.related_updates.copy, **kwargs)
+
+    def execute_sql(self, result_type=None):
+        super(UpdateQuery, self).execute_sql(result_type)
+        for query in self.get_related_updates():
+            query.execute_sql(result_type)
-
-    def as_sql(self):
@@ -104 +119 @@
-        parameters.
-        """
-        self.select_related = False
-        self.pre_sql_setup()
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-        qn = self.quote_name_unless_alias
-        result = ['UPDATE %s' % qn(table)]
@@ -136 +139 @@
-        return ' '.join(result), tuple(update_params + params)
-
+    def pre_sql_setup(self):
+        """
+        If the update depends on results from other tables, we need to do some
+        munging of the "where" conditions to match the format required for
+        (portable) SQL updates. That is done here.
+
+        Further, if we are going to be running multiple updates, we pull out
+        the id values to update at this point so that they don't change as a
+        result of the progressive updates.
+        """
+        self.select_related = False
+        self.clear_ordering(True)
+        super(UpdateQuery, self).pre_sql_setup()
+        count = self.count_active_tables()
+        if not self.related_updates and count == 1:
+            return
+
+        # We need to use a sub-select in the where clause to filter on things
+        # from other tables.
+        query = self.clone(klass=Query)
+        main_alias = query.tables[0]
+        if count != 1:
+            query.unref_alias(main_alias)
+        if query.alias_map[main_alias][ALIAS_REFCOUNT]:
+            alias = '%s0' % self.alias_prefix
+            query.change_alias(main_alias, alias)
+            col = query.model._meta.pk.column
+        else:
+            for model in query.model._meta.get_parent_list():
+                for alias in query.table_map.get(model._meta.db_table, []):
+                    if query.alias_map[alias][ALIAS_REFCOUNT]:
+                        col = model._meta.pk.column
+                        break
+        query.add_local_columns([col])
+
+        # Now we adjust the current query: reset the where clause and get rid
+        # of all the tables we don't need (since they're in the sub-select).
+        self.where = self.where_class()
+        if self.related_updates:
+            idents = []
+            for rows in query.execute_sql(MULTI):
+                idents.extend([r[0] for r in rows])
+            self.add_filter(('pk__in', idents))
+            self.related_ids = idents
+        else:
+            self.add_filter(('pk__in', query))
+        for alias in self.tables[1:]:
+            self.alias_map[alias][ALIAS_REFCOUNT] = 0
+
-    def clear_related(self, related_field, pk_list):
-        """
@@ -157 +209 @@
-            field, model, direct, m2m = self.model._meta.get_field_by_name(name)
-            if not direct or m2m:
-                # Can only update non-relation fields and foreign keys.
-                raise FieldError('Cannot update model field %r (only non-relations and foreign keys permitted).' % field)
+            # FIXME: Some sort of db_prep_* is probably more appropriate here.
-            if field.rel and isinstance(val, Model):
-                val = val.pk
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-class InsertQuery(Query):

django/branches/queryset-refactor/tests/modeltests/model_inheritance/models.py

@@ -217 +217 @@
-<Restaurant: Ristorante Miron the restaurant>
-
+# The update() command can update fields in parent and child classes at once
+# (although it executed multiple SQL queries to do so).
+>>> Restaurant.objects.filter(serves_hot_dogs=True, name__contains='D').update(name='Demon Puppies', serves_hot_dogs=False)
+>>> r1 = Restaurant.objects.get(pk=r.pk)
+>>> r1.serves_hot_dogs == False
+True
+>>> r1.name
+u'Demon Puppies'
-
-"""}