File query.py has 2134 lines of code (exceeds 250 allowed). Consider refactoring.

Open

"""
Create SQL statements for QuerySets.

The code in here encapsulates all of the SQL construction so that QuerySets
themselves do not have to (and could be backed by things other than SQL

Query has 90 functions (exceeds 20 allowed). Consider refactoring.

Open

class Query(BaseExpression):
    """A single SQL query."""

    alias_prefix = "T"
    empty_result_set_value = None

Function names_to_path has a Cognitive Complexity of 58 (exceeds 5 allowed). Consider refactoring.

Open

    def names_to_path(self, names, opts, allow_many=True, fail_on_missing=False):
        """
        Walk the list of names and turns them into PathInfo tuples. A single
        name in 'names' can generate multiple PathInfos (m2m, for example).

• Read up
  Read up

Function get_aggregation has a Cognitive Complexity of 56 (exceeds 5 allowed). Consider refactoring.

Open

    def get_aggregation(self, using, aggregate_exprs):
        """
        Return the dictionary with the values of the existing aggregations.
        """
        if not aggregate_exprs:

• Read up
  Read up

Function build_filter has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.

Open

    def build_filter(
        self,
        filter_expr,
        branch_negated=False,
        current_negated=False,

• Read up
  Read up

Function resolve_ref has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

    def resolve_ref(self, name, allow_joins=True, reuse=None, summarize=False):
        annotation = self.annotations.get(name)
        if annotation is not None:
            if not allow_joins:
                for alias in self._gen_col_aliases([annotation]):

• Read up
  Read up

Function setup_joins has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

    def setup_joins(
        self,
        names,
        opts,
        alias,

• Read up
  Read up

Function set_values has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.

Open

    def set_values(self, fields):
        self.select_related = False
        self.clear_deferred_loading()
        self.clear_select_fields()
        self.has_select_fields = True

• Read up
  Read up

Function combine has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.

Open

    def combine(self, rhs, connector):
        """
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, "to the right of") anything in the
        current query. 'rhs' is not modified during a call to this function.

• Read up
  Read up

Function add_ordering has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.

Open

    def add_ordering(self, *ordering):
        """
        Add items from the 'ordering' sequence to the query's "order by"
        clause. These items are either field names (not column names) --
        possibly with a direction prefix ('-' or '?') -- or OrderBy

• Read up
  Read up

Function trim_start has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.

Open

    def trim_start(self, names_with_path):
        """
        Trim joins from the start of the join path. The candidates for trim
        are the PathInfos in names_with_path structure that are m2m joins.

• Read up
  Read up

Function add_extra has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    def add_extra(self, select, select_params, where, params, tables, order_by):
        """
        Add data to the various extra_* attributes for user-created additions
        to the query.
        """

• Read up
  Read up

Function join has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def join(self, join, reuse=None):
        """
        Return an alias for the 'join', either reusing an existing alias for
        that join or creating a new one. 'join' is either a base_table_class or
        join_class.

• Read up
  Read up

Function _get_defer_select_mask has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.

Open

    def _get_defer_select_mask(self, opts, mask, select_mask=None):
        if select_mask is None:
            select_mask = {}
        select_mask[opts.pk] = {}
        # All concrete fields that are not part of the defer mask must be

• Read up
  Read up

Function bump_prefix has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def bump_prefix(self, other_query, exclude=None):
        """
        Change the alias prefix to the next letter in the alphabet in a way
        that the other query's aliases and this query's aliases will not
        conflict. Even tables that previously had no alias will get an alias

• Read up
  Read up

Function set_group_by has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.

Open

    def set_group_by(self, allow_aliases=True):
        """
        Expand the GROUP BY clause required by the query.

        This will usually be the set of all non-aggregate fields in the

• Read up
  Read up

Function add_filtered_relation has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

    def add_filtered_relation(self, filtered_relation, alias):
        filtered_relation.alias = alias
        relation_lookup_parts, relation_field_parts, _ = self.solve_lookup_type(
            filtered_relation.relation_name
        )

• Read up
  Read up

Function get_child_with_renamed_prefix has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.

Open

def get_child_with_renamed_prefix(prefix, replacement, child):
    from django.db.models.query import QuerySet

    if isinstance(child, Node):
        return rename_prefix_from_q(prefix, replacement, child)

• Read up
  Read up

Consider simplifying this complex logical expression.

Open

        if (
            isinstance(self.group_by, tuple)
            or self.is_sliced
            or has_existing_aggregation
            or refs_subquery

Function change_aliases has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def change_aliases(self, change_map):
        """
        Change the aliases in change_map (which maps old-alias -> new-alias),
        relabelling any references to them in select columns and the where
        clause.

• Read up
  Read up

Function build_lookup has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.

Open

    def build_lookup(self, lookups, lhs, rhs):
        """
        Try to extract transforms and lookup from given lhs.

        The lhs value is something that works like SQLExpression.

• Read up
  Read up

Function combine has 29 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def combine(self, rhs, connector):
        """
        Merge the 'rhs' query into the current one (with any 'rhs' effects
        being applied *after* (that is, "to the right of") anything in the
        current query. 'rhs' is not modified during a call to this function.

Function build_filter has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def build_filter(

Function _add_q has 9 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def _add_q(

Function _get_only_select_mask has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.

Open

    def _get_only_select_mask(self, opts, mask, select_mask=None):
        if select_mask is None:
            select_mask = {}
        select_mask[opts.pk] = {}
        # Only include fields mentioned in the mask.

• Read up
  Read up

Function build_filter has 26 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    def build_filter(
        self,
        filter_expr,
        branch_negated=False,
        current_negated=False,

Function check_related_objects has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def check_related_objects(self, field, value, opts):
        """Check the type of object passed to query relations."""
        if field.is_relation:
            # Check that the field and the queryset use the same model in a
            # query like .filter(author=Author.objects.all()). For example, the

• Read up
  Read up

Function set_limits has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def set_limits(self, low=None, high=None):
        """
        Adjust the limits on the rows retrieved. Use low/high to set these,
        as it makes it more Pythonic to read and write. When the SQL query is
        created, convert them to the appropriate offset and limit values.

• Read up
  Read up

Function get_children_from_q has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

def get_children_from_q(q):
    for child in q.children:
        if isinstance(child, Node):
            yield from get_children_from_q(child)
        elif isinstance(child, tuple):

• Read up
  Read up

Function _gen_cols has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def _gen_cols(cls, exprs, include_external=False, resolve_refs=True):
        for expr in exprs:
            if isinstance(expr, Col):
                yield expr
            elif include_external and callable(

• Read up
  Read up

Function add_fields has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.

Open

    def add_fields(self, field_names, allow_m2m=True):
        """
        Add the given (model) fields to the select set. Add the field names in
        the order specified.
        """

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if p.m2m:
                            cur_names_with_path[1].extend(pathinfos[0 : inner_pos + 1])
                            names_with_path.append(cur_names_with_path)
                            raise MultiJoin(pos + 1, names_with_path)
                last = pathinfos[-1]

Function get_paths_from_expression has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

def get_paths_from_expression(expr):
    if isinstance(expr, F):
        yield expr.name
    elif hasattr(expr, "flatten"):
        for child in expr.flatten():

• Read up
  Read up

Function trim_joins has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def trim_joins(self, targets, joins, path):
        """
        The 'target' parameter is the final field being joined to, 'joins'
        is the full list of join aliases. The 'path' contain the PathInfos
        used to create the joins.

• Read up
  Read up

Function promote_joins has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def promote_joins(self, aliases):
        """
        Promote recursively the join type of given aliases and its children to
        an outer join. If 'unconditional' is False, only promote the join if
        it is nullable or the parent join is an outer join.

• Read up
  Read up

Function update_join_types has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def update_join_types(self, query):
        """
        Change join types so that the generated query is as efficient as
        possible, but still correct. So, change as many joins as possible
        to INNER, but don't make OUTER joins INNER if that could remove

• Read up
  Read up

Function resolve_expression has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def resolve_expression(self, query, *args, **kwargs):
        clone = self.clone()
        # Subqueries need to use a different set of aliases than the outer query.
        clone.bump_prefix(query)
        clone.subquery = True

• Read up
  Read up

Function add_extra has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def add_extra(self, select, select_params, where, params, tables, order_by):

Function add_deferred_loading has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    def add_deferred_loading(self, field_names):
        """
        Add the given list of model field names to the set of fields to
        exclude from loading from the database when automatic column selection
        is done. Add the new field names to any existing field names that

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        if self.annotation_select:
                            self.names_to_path(f.split(LOOKUP_SEP), self.model._meta)
                        field_names.append(f)

Avoid deeply nested control flow statements.

Open

                        for expr in self.group_by:
                            annotation_mask |= expr.get_refs()
                    for aggregate in aggregates.values():

Avoid deeply nested control flow statements.

Open

                        if annotation.get_group_by_cols():
                            annotation_mask.add(annotation_alias)
                    inner_query.set_annotation_mask(annotation_mask)

Function setup_joins has 5 arguments (exceeds 4 allowed). Consider refactoring.

Open

    def setup_joins(

Function solve_lookup_type has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def solve_lookup_type(self, lookup, summarize=False):
        """
        Solve the lookup type from the lookup (e.g.: 'foobar__id__icontains').
        """
        lookup_splitted = lookup.split(LOOKUP_SEP)

• Read up
  Read up

Function join_parent_model has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.

Open

    def join_parent_model(self, opts, model, alias, seen):
        """
        Make sure the given 'model' is joined in the query. If 'model' isn't
        a parent of 'opts' or if it is None this method is a no-op.

• Read up
  Read up

Avoid too many return statements within this function.

Open

        return clause, used_joins if not require_outer else ()

Function exists has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def exists(self, limit=True):
        q = self.clone()
        if not (q.distinct and q.is_sliced):
            if q.group_by is True:
                q.add_fields(

• Read up
  Read up

Function clone has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def clone(self):
        """
        Return a copy of the current Query. A lightweight alternative to
        deepcopy().
        """

• Read up
  Read up

Function demote_joins has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def demote_joins(self, aliases):
        """
        Change join type from LOUTER to INNER for all joins in aliases.

        Similarly to promote_joins(), this method must ensure no join chains

• Read up
  Read up

Function _add_q has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.

Open

    def _add_q(
        self,
        q_object,
        used_aliases,
        branch_negated=False,

• Read up
  Read up