Source code
from django.contrib.gis.db.models.fields import BaseSpatialField
from django.contrib.gis.measure import Distance
from django.db import NotSupportedError
from django.db.models import Expression, Lookup, Transform
from django.db.models.sql.query import Query
from django.utils.regex_helper import _lazy_re_compile
class DistanceLookupFromFunction(DistanceLookupBase):
def as_sql(self, compiler, connection):
spheroid = (
len(self.rhs_params) == 2 and self.rhs_params[-1] == "spheroid"
) or None
distance_expr = connection.ops.distance_expr_for_lookup(
self.lhs, self.rhs, spheroid=spheroid
)
sql, params = compiler.compile(distance_expr.resolve_expression(compiler.query))
dist_sql, dist_params = self.process_distance(compiler, connection)
return (
"%(func)s %(op)s %(dist)s" % {"func": sql, "op": self.op, "dist": dist_sql},
(*params, *dist_params),
)
Run 1
The code is reasonably structured but has readability issues. The DistanceLookupFromFunction class has a single method with moderate complexity. The `spheroid` variable uses a tuple comparison that's somewhat convoluted, making intent unclear. The method chains multiple operations like `resolve_expression` and `compiler.compile`, which compresses several actions. Variable naming is adequate but not self-documenting. The return statement combining string formatting and tuple unpacking is dense. Nesting is minimal, which is good, but the logic would benefit from breaking into smaller, named steps to improve clarity of intent and action granularity.
Run 2
The code has a relatively clear purpose and follows Django conventions, but it suffers from several readability issues. The main method is fairly flat, but the first statement uses a complex conditional expression that combines assignment and a boolean check with an 'or None' fallback, making intent somewhat ambiguous. The method performs multiple actions including conditional logic, obtaining an expression, compiling SQL, processing distance, and constructing a return tuple, which could be broken into smaller pieces. The string formatting with '%(func)s %(op)s %(dist)s' is reasonably clear, but the return tuple mixes formatting with parameter unpacking in a way that requires careful reading. Variable names are mostly good ('distance_expr', 'dist_sql', 'dist_params'), but 'spheroid' being assigned a boolean or None is confusing. Overall, it's readable for experienced Django developers familiar with the ORM internals, but could benefit from more explicit conditionals and perhaps splitting the return value construction into a separate variable.
Run 3
The code is generally readable with a clear structure and good action granularity. Each logical step—computing spheroid, building the distance expression, compiling SQL, and formatting the result—is separated into its own line, aiding clarity. Nesting is minimal, and variable names are descriptive. However, readability is reduced by the implicit boolean-to-None idiom `(... ) or None` and the packed tuple return, which obscure intent slightly. The method also assumes familiarity with Django internals, limiting accessibility for readers unfamiliar with the ORM's spatial lookup machinery. Overall, it is concise and well-organized, but a few expressions could be made more explicit to improve clarity.
Run 1
Code Structure: The method follows a logical sequence: determine spheroid use, build and compile the distance expression, process the threshold, and return SQL with parameters. Nesting: Minimal nesting keeps the logic easy to follow. Clarity of intent: Descriptive method and variable names communicate the spatial lookup purpose, although the boolean-or-None idiom and framework-specific calls require some familiarity. Code length: The implementation is concise, but several imports are unused in the shown snippet. Action granularity: Most statements perform one clear operation; the combined resolve-and-compile call adds slight density. Reading flow: Formatting and sequential organization support smooth reading, though the unshown DistanceLookupBase definition limits standalone understanding.
Run 2
Code Structure: The method logically separates spheroid selection, distance-expression construction, compilation, and SQL assembly. Several imports appear unused in this snippet, and the base class is not shown. Nesting: The code is flat, with no nested control flow. Clarity of intent: Descriptive method and variable names communicate the SQL-generation purpose, though the boolean-or-None spheroid expression and positional parameter check require interpretation. Code length: The implementation is concise without substantial repetition. Action granularity: Most statements perform one clear action, although expression resolution and compilation are combined on one line. Reading flow: Operations proceed naturally from configuration to the returned SQL and parameters; consistent formatting helps, while dictionary-based string interpolation adds minor visual complexity.
Run 3
Code Structure: The method follows a logical sequence: determine spheroid usage, construct and compile the distance expression, process the distance, and return SQL with parameters. Nesting: It is flat, with no nested control flow. Clarity of intent: Descriptive method and variable names communicate the purpose, though the boolean-or-None expression and positional spheroid check require interpretation. The undefined base class limits standalone understanding. Code length: The implementation is concise, although several imports are unused in the provided snippet. Action granularity: Most statements perform one clear step; resolving and compiling the expression on one line slightly compresses distinct actions. Reading flow: Consistent formatting and sequential processing make the method easy to follow, but a blank line before the class and brief context for spheroid handling would improve readability.