Sign upLogin

django/django

View on GitHub
Star
django/db/models/sql/compiler.py

Summary

Maintainability
F
1 wk
Test Coverage

File compiler.py has 1754 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import collections
import json
import re
from functools import partial
from itertools import chain
Severity: Major
Found in django/db/models/sql/compiler.py - About 4 days to fix

    Function _order_by_pairs has a Cognitive Complexity of 75 (exceeds 5 allowed). Consider refactoring.
    Open

        def _order_by_pairs(self):
        if self.query.extra_order_by:
            ordering = self.query.extra_order_by
        elif not self.query.default_ordering:
            ordering = self.query.order_by
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 1 day to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

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

        def get_group_by(self, select, order_by):
        """
        Return a list of 2-tuples of form (sql, params).

        The logic of what exactly the GROUP BY clause contains is hard
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 5 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function get_order_by has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_order_by(self):
        """
        Return a list of 2-tuples of the form (expr, (sql, params, is_ref)) for
        the ORDER BY clause.
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 5 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function get_select has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_select(self, with_col_aliases=False):
        """
        Return three values:
        - a list of 3-tuples of (expression, (sql, params), alias)
        - a klass_info structure,
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 4 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function get_combinator_sql has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

        def get_combinator_sql(self, combinator, all):
        features = self.connection.features
        compilers = [
            query.get_compiler(self.using, self.connection, self.elide_empty)
            for query in self.query.combined_queries
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 3 hrs to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

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

            def collect_replacements(expressions):
            while expressions:
                expr = expressions.pop()
                if expr in replacements:
                    continue
    Severity: Minor
    Found in django/db/models/sql/compiler.py - About 1 hr to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function get_related_selections has 8 arguments (exceeds 4 allowed). Consider refactoring.
    Open

        def get_related_selections(
    Severity: Major
    Found in django/db/models/sql/compiler.py - About 1 hr to fix

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

          def find_ordering_name(
      Severity: Minor
      Found in django/db/models/sql/compiler.py - About 45 mins to fix

        Avoid deeply nested control flow statements.
        Open

                                if (
                            self.query.has_select_fields
                            and col_alias in self.query.annotation_select
                            and not (
                                isinstance(expr_src, F) and col_alias == expr_src.name
        Severity: Major
        Found in django/db/models/sql/compiler.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                                  if q.has_select_fields:
                            raise DatabaseError(
                                "ORDER BY term does not match any column in "
                                "the result set."
                            )
          Severity: Major
          Found in django/db/models/sql/compiler.py - About 45 mins to fix

            Consider simplifying this complex logical expression.
            Open

                    if (
            field.is_relation
            and opts.ordering
            and getattr(field, "attname", None) != pieces[-1]
            and name != "pk"
            Severity: Major
            Found in django/db/models/sql/compiler.py - About 40 mins to fix

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

                  def get_default_columns(
              Severity: Minor
              Found in django/db/models/sql/compiler.py - About 35 mins to fix

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

                    def results_iter(
                Severity: Minor
                Found in django/db/models/sql/compiler.py - About 35 mins to fix

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

                          def _get_field_choices():
            """Yield all allowed field paths in breadth-first search order."""
            queue = collections.deque([(None, self.klass_info)])
            while queue:
                parent_path, klass_info = queue.popleft()
                  Severity: Minor
                  Found in django/db/models/sql/compiler.py - About 35 mins to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

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

                      def get_extra_select(self, order_by, select):
        extra_select = []
        if self.query.distinct and not self.query.distinct_fields:
            select_sql = [t[1] for t in select]
            for expr, (sql, params, is_ref) in order_by:
                  Severity: Minor
                  Found in django/db/models/sql/compiler.py - About 25 mins to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  There are no issues that match your filters.

                  Category
                  Status