Changeset 7170

Timestamp:

02/28/08 06:57:10 (9 months ago)

Author:

mtredinnick

Message:

queryset-refactor: Fixed exclude() filtering for the various N-to-many relations.

This means we can now do nested SQL queries (since we need nested queries to
get the right answer). It requires poking directly at the Query class. Might
add support for this through QuerySets? later.

Files:

• django/branches/queryset-refactor/django/db/models/fields/related.py (modified) (1 diff)
• django/branches/queryset-refactor/django/db/models/sql/query.py (modified) (14 diffs)
• django/branches/queryset-refactor/django/db/models/sql/where.py (modified) (2 diffs)
• django/branches/queryset-refactor/tests/modeltests/many_to_many/models.py (modified) (1 diff)
• django/branches/queryset-refactor/tests/regressiontests/queries/models.py (modified) (1 diff)

django/branches/queryset-refactor/django/db/models/fields/related.py

@@ -101 +101 @@
-            return v
-
+        if hasattr(value, 'as_sql'):
+            sql, params = value.as_sql()
+            return ('(%s)' % sql), params
-        if lookup_type == 'exact':
-            return [pk_trace(value)]

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

@@ -46 +46 @@
-        self.default_ordering = True
-        self.standard_ordering = True
+        self.start_meta = None
-
-        # SQL-related attributes
@@ -81 +82 @@
-        sql, params = self.as_sql()
-        return sql % params
+
+    def __deepcopy__(self, memo):
+        result= self.clone()
+        memo[id(self)] = result
+        return result
+
+    def get_meta(self):
+        """
+        Returns the Options instance (the model._meta) from which to start
+        processing. Normally, this is self.model._meta, but it can change.
+        """
+        if self.start_meta:
+            return self.start_meta
+        return self.model._meta
-
-    def quote_name_unless_alias(self, name):
@@ -115 +130 @@
-        obj.default_ordering = self.default_ordering
-        obj.standard_ordering = self.standard_ordering
+        obj.start_meta = self.start_meta
-        obj.select = self.select[:]
-        obj.tables = self.tables[:]
@@ -385 +401 @@
-                alias_str = ''
-                name = alias
-
+ and not first
-                result.append('%s %s%s ON (%s.%s = %s.%s)'
-                        % (join_type, qn(name), alias_str, qn(lhs),
@@ -650 +666 @@
-            return
-        if not opts:
-model._meta
+get_meta()
-            root_alias = self.tables[0]
-            self.select.extend([(root_alias, f.column) for f in opts.fields])
@@ -682 +698 @@
-                    used, next, restricted)
-
-
-
-
+
+
+
+
+
+
+
+
-        """
-        arg, value = filter_expr
@@ -707 +728 @@
-            value = value()
-
-model._meta
+get_meta()
-        alias = self.join((None, opts.db_table, None, None))
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        alias = join_list[-1][-1]
-
@@ -730 +763 @@
-            # If the comparison is against NULL, we need to use a left outer
-            # join when connecting to the previous model. We make that
-because
+as
-            # efficient at the database level.
-            self.promote_alias(join_list[-1][0])
@@ -768 +801 @@
-            self.where.negate()
-            if flag:
+                # XXX: Change this to the field we joined against to allow
+                # for node sharing and where-tree optimisation?
-                self.where.add([alias, col, field, 'isnull', True], OR)
-
@@ -798 +833 @@
-            self.where.end_subtree()
-
-
+, allow_many=True
-        """
-        Compute the necessary table joins for the passage through the fields
@@ -808 +843 @@
-
-        Returns the final field involved in the join, the target database
-
-
-
+
+
-        """
-        joins = [[alias]]
@@ -823 +857 @@
-                raise FieldError("Cannot resolve keyword %r into field. "
-                        "Choices are: %s" % (name, ", ".join(names)))
+            if not allow_many and (m2m or not direct):
+                for join in joins:
+                    for alias in join:
+                        self.unref_alias(alias)
+                return pos + 1
-            if model:
-                # The field lives on a base class of the current model.
@@ -930 +969 @@
-        return field, target, opts, joins
-
+    def split_exclude(self, filter_expr, prefix):
+        """
+        When doing an exclude against any kind of N-to-many relation, we need
+        to use a subquery. This method constructs the nested query, given the
+        original exclude filter (filter_expr) and the portion up to the first
+        N-to-many relation field.
+        """
+        query = Query(self.model, self.connection)
+        query.add_filter(filter_expr)
+        query.set_start(prefix)
+        query.clear_ordering(True)
+        self.add_filter(('%s__in' % prefix, query), negate=True, trim=True)
+
-    def set_limits(self, low=None, high=None):
-        """
@@ -1048 +1100 @@
-        self.select_related = field_dict
-
+    def set_start(self, start):
+        """
+        Sets the table from which to start joining. The start position is
+        specified by the related attribute from the base model. This will
+        automatically set to the select column to be the column linked from the
+        previous table.
+
+        This method is primarily for internal use and the error checking isn't
+        as friendly as add_filter(). Mostly useful for querying directly
+        against the join table of many-to-many relation in a subquery.
+        """
+        opts = self.model._meta
+        alias = self.join((None, opts.db_table, None, None))
+        field, col, opts, joins = self.setup_joins(start.split(LOOKUP_SEP),
+                opts, alias, False)
+        alias = joins[-1][0]
+        self.select = [(alias, self.alias_map[alias][ALIAS_JOIN][RHS_JOIN_COL])]
+        self.start_meta = opts
+
+        # The call to setup_joins add an extra reference to everything in
+        # joins. So we need to unref everything once, and everything prior to
+        # the final join a second time.
+        for join in joins[:-1]:
+            for alias in join:
+                self.unref_alias(alias)
+                self.unref_alias(alias)
+        for alias in joins[-1]:
+            self.unref_alias(alias)
+
-    def execute_sql(self, result_type=MULTI):
-        """

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

@@ -106 +106 @@
-            cast_sql = '%s'
-
-        format = "%s %%s" % connection.ops.lookup_cast(lookup_type)
-        params = field.get_db_prep_lookup(lookup_type, value)
+        if isinstance(params, tuple):
+            extra, params = params
+        else:
+            extra = ''
-
-        if lookup_type in connection.operators:
+            format = "%s %%s %s" % (connection.ops.lookup_cast(lookup_type),
+                    extra)
-            return (format % (field_sql,
-                    connection.operators[lookup_type] % cast_sql), params)
@@ -116 +121 @@
-            if not value:
-                raise EmptyResultSet
+            if extra:
+                return ('%s IN %s' % (field_sql, extra), params)
-            return ('%s IN (%s)' % (field_sql, ', '.join(['%s'] * len(value))),
-                    params)
-        elif lookup_type in ('range', 'year'):
-
-
+
-        elif lookup_type in ('month', 'day'):
-            return ('%s = %%s' % connection.ops.date_extract_sql(lookup_type,

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

@@ -127 +127 @@
-[<Publication: Highlights for Children>, <Publication: Science News>, <Publication: Science Weekly>, <Publication: The Python Journal>]
-
+# Excluding a related item works as you would expect, too (although the SQL
+# involved is a little complex).
+>>> Article.objects.exclude(publications=p2)
+[<Article: Django lets you build Web apps easily>]
+
-# If we delete a Publication, its Articles won't be able to access it.
->>> p1.delete()

django/branches/queryset-refactor/tests/regressiontests/queries/models.py

@@ -323 +323 @@
-[<Author: a2>, <Author: a3>, <Author: a4>]
-
+
+# Excluding across a m2m relation when there is more than one related object
+# associated was problematic.
+>>> Item.objects.exclude(tags__name='t1').order_by('name')
+[<Item: four>, <Item: three>]
+>>> Item.objects.exclude(tags__name='t1').exclude(tags__name='t4')
+[<Item: three>]
+
-# Excluding from a relation that cannot be NULL should not use outer joins.
->>> query = Item.objects.exclude(creator__in=[a1, a2]).query
->>> query.LOUTER not in [x[2][2] for x in query.alias_map.values()]
-True
-
-# When only one of the joins is nullable (here, the Author -> Item join), we
-# should only get outer joins after that point (one, in this case). We also
-# show that three tables (so, two joins) are involved.
->>> qs = Report.objects.exclude(creator__item__name='one')
->>> list(qs)
-[<Report: r2>]
->>> len([x[2][2] for x in qs.query.alias_map.values() if x[2][2] == query.LOUTER])
-1
->>> len(qs.query.alias_map)
-3
-
-Similarly, when one of the joins cannot possibly, ever, involve NULL values (Author -> ExtraInfo, in the following), it should never be promoted to a left outer join. So hte following query should only involve one "left outer" join (Author -> Item is 0-to-many).