Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Fixed #18816 -- Removed "trim" argument from add_filter()

The trim argument was used by split_exclude() only to trim the last
join from the given lookup. It is cleaner to just trim the last part
from the lookup in split_exclude() directly so that there is no need
to burden add_filter() with the logic needed for only split_exclude().
  • Loading branch information...
commit f811649710fb51e48217e9a78991735977decfd8 1 parent d7b49f5
Anssi Kääriäinen akaariai authored
Showing with 32 additions and 24 deletions.
  1. +32 −24 django/db/models/sql/query.py
56 django/db/models/sql/query.py
View
@@ -1029,7 +1029,7 @@ def add_aggregate(self, aggregate, model, alias, is_summary):
# Add the aggregate to the query
aggregate.add_to_query(self, alias, col=col, source=source, is_summary=is_summary)
- def add_filter(self, filter_expr, connector=AND, negate=False, trim=False,
+ def add_filter(self, filter_expr, connector=AND, negate=False,
can_reuse=None, process_extras=True, force_having=False):
"""
Add a single filter to the query. The 'filter_expr' is a pair:
@@ -1042,9 +1042,6 @@ def add_filter(self, filter_expr, connector=AND, negate=False, trim=False,
should only happen once. So the caller is responsible for this (the
caller will normally be add_q(), so that as an example).
- If 'trim' is True, we automatically trim the final join group (used
- internally when constructing nested queries).
-
If 'can_reuse' is a set, we are processing a component of a
multi-component filter (e.g. filter(Q1, Q2)). In this case, 'can_reuse'
will be a set of table aliases that can be reused in this filter, even
@@ -1115,7 +1112,7 @@ def add_filter(self, filter_expr, connector=AND, negate=False, trim=False,
opts = self.get_meta()
alias = self.get_initial_alias()
- allow_many = trim or not negate
+ allow_many = not negate
try:
field, target, opts, join_list, last, extra_filters = self.setup_joins(
@@ -1141,7 +1138,7 @@ def add_filter(self, filter_expr, connector=AND, negate=False, trim=False,
# Process the join list to see if we can remove any inner joins from
# the far end (fewer tables in a query is better).
nonnull_comparison = (lookup_type == 'isnull' and value is False)
- col, alias, join_list = self.trim_joins(target, join_list, last, trim,
+ col, alias, join_list = self.trim_joins(target, join_list, last,
nonnull_comparison)
if connector == OR:
@@ -1456,7 +1453,7 @@ def setup_joins(self, names, opts, alias, can_reuse, allow_many=True,
return field, target, opts, joins, last, extra_filters
- def trim_joins(self, target, join_list, last, trim, nonnull_check=False):
+ def trim_joins(self, target, join_list, last, nonnull_check=False):
"""
Sometimes joins at the end of a multi-table sequence can be trimmed. If
the final join is against the same column as we are comparing against,
@@ -1473,10 +1470,6 @@ def trim_joins(self, target, join_list, last, trim, nonnull_check=False):
same way, so 'last' has an entry for the first of the two tables and
then the table immediately after the second table, in that case.
- The 'trim' parameter forces the final piece of the join list to be
- trimmed before anything. See the documentation of add_filter() for
- details about this.
-
The 'nonnull_check' parameter is True when we are using inner joins
between tables explicitly to exclude NULL entries. In that case, the
tables shouldn't be trimmed, because the very action of joining to them
@@ -1489,16 +1482,7 @@ def trim_joins(self, target, join_list, last, trim, nonnull_check=False):
penultimate = last.pop()
if penultimate == final:
penultimate = last.pop()
- if trim and final > 1:
- extra = join_list[penultimate:]
- join_list = join_list[:penultimate]
- final = penultimate
- penultimate = last.pop()
- col = self.alias_map[extra[0]].lhs_join_col
- for alias in extra:
- self.unref_alias(alias)
- else:
- col = target.column
+ col = target.column
alias = join_list[-1]
while final > 1:
join = self.alias_map[alias]
@@ -1520,6 +1504,19 @@ def split_exclude(self, filter_expr, prefix, can_reuse):
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.
+
+ As an example we could have original filter ~Q(child__name='foo').
+ We would get here with filter_expr = child_name, prefix = child and
+ can_reuse is a set of joins we can reuse for filtering in the original
+ query.
+
+ We will turn this into
+ WHERE pk NOT IN (SELECT parent_id FROM thetable
+ WHERE name = 'foo' AND parent_id IS NOT NULL)
+
+ It might be worth it to consider using WHERE NOT EXISTS as that has
+ saner null handling, and is easier for the backend's optimizer to
+ handle.
"""
query = Query(self.model)
query.add_filter(filter_expr)
@@ -1532,8 +1529,19 @@ def split_exclude(self, filter_expr, prefix, can_reuse):
# nothing
alias, col = query.select[0].col
query.where.add((Constraint(alias, col, None), 'isnull', False), AND)
+ # We need to trim the last part from the prefix.
+ trimmed_prefix = '__'.join(prefix.split(LOOKUP_SEP)[0:-1])
Simon Charette Collaborator

Is there a reason why you use LOOKUP_SEP for splitting but not for joining?

Anssi Kääriäinen Collaborator

No reason, fixed.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
+ if not trimmed_prefix:
+ rel, _, direct, m2m = self.model._meta.get_field_by_name(prefix)
+ if not m2m:
+ trimmed_prefix = rel.field.rel.field_name
+ else:
+ if direct:
+ trimmed_prefix = rel.m2m_target_field_name()
+ else:
+ trimmed_prefix = rel.field.m2m_reverse_target_field_name()
- self.add_filter(('%s__in' % prefix, query), negate=True, trim=True,
+ self.add_filter(('%s__in' % trimmed_prefix, query), negate=True,
can_reuse=can_reuse)
# If there's more than one join in the inner query (before any initial
@@ -1546,8 +1554,8 @@ def split_exclude(self, filter_expr, prefix, can_reuse):
active_positions = len([count for count
in query.alias_refcount.items() if count])
if active_positions > 1:
- self.add_filter(('%s__isnull' % prefix, False), negate=True,
- trim=True, can_reuse=can_reuse)
+ self.add_filter(('%s__isnull' % trimmed_prefix, False), negate=True,
+ can_reuse=can_reuse)
def set_limits(self, low=None, high=None):
"""
Simon Charette

Is there a reason why you use LOOKUP_SEP for splitting but not for joining?

Anssi Kääriäinen

No reason, fixed.

Please sign in to comment.
Something went wrong with that request. Please try again.