Source code
import operator
from functools import reduce
from django.core.exceptions import EmptyResultSet, FullResultSet
from django.db.models.expressions import Case, When
from django.db.models.functions import Mod
from django.db.models.lookups import Exact
from django.utils import tree
from django.utils.functional import cached_property
class ExtraWhere:
# The contents are a black box - assume no aggregates or windows are used.
contains_aggregate = False
contains_over_clause = False
def __init__(self, sqls, params):
self.sqls = sqls
self.params = params
def as_sql(self, compiler=None, connection=None):
return " AND ".join((["(%s)" % sql for sql in self.sqls])), list(self.params or ())
Run 1
The code is concise, well-structured, and easy to follow. Imports are organized and the class has a clear purpose. There is minimal nesting, with only one comprehension in the as_sql method, and the flow is logical. Naming conventions are descriptive (ExtraWhere, sqls, params), and the docstring-like comment adds context. The main weakness is that the as_sql signature includes unused parameters (compiler, connection) with a trailing blank line, which slightly obscures intent, and the variable `sqls` is slightly ambiguous but still understandable. Overall, it is highly readable.
Run 2
The code is highly readable. It has a clear, logical structure with a single, well-named class (`ExtraWhere`). Nesting is minimal; the only semi-complex part is the `as_sql` method’s list comprehension that wraps SQL fragments in parentheses and joins them with 'AND'. The intent is unambiguous — a wrapper for extra SQL conditions with parameters. Length is appropriate, with no redundant code. Actions are granular: attributes are set in one line, and the return statement combines logically-related operations (wrapping and joining) in one readable expression. The reading flow is natural, aided by the concise docstring-style comment explaining the 'black box' assumption. Minor deductions: `sqls` and `params` type hints could improve clarity, and the double parentheses in the join expression are slightly redundant, slightly affecting visual noise. Overall, this is clean, maintainable code.
Run 3
The code is relatively concise and each line performs a single action, but several readability issues exist. The imports are mostly unused (operator, reduce, EmptyResultSet, FullResultSet, Case, When, Mod, Exact, tree, cached_property), creating ambiguity about intent. The ExtraWhere class has two class attributes without explanations, and the comment is minimal. The as_sql method uses a nested tuple/list construction in one line, combining list comprehension with string formatting and parameter expansion, which hurts readability. The flow is natural but could be clearer with better documentation and simplified expression construction.
Run 1
Code Structure: The class is logically organized, with metadata, initialization, and SQL rendering clearly separated, though many imports are unused in this snippet. Nesting: Control flow is flat; the only comprehension is straightforward. Clarity of intent: The class name, method names, and comment explain its SQL-fragment role, although sqls is a slightly vague identifier. Code length: The implementation is concise, but redundant parentheses and unused imports add clutter. Action granularity: Assignments each occupy their own line; the return statement combines SQL formatting, joining, and parameter normalization, making it mildly dense. Reading flow: The sequence is natural and easy to follow, with minor formatting distractions from the blank line inside as_sql and the long return expression.
Run 2
Code Structure: The small class logically groups SQL fragments, parameters, and SQL rendering, though numerous unused imports add clutter. Nesting: Minimal nesting makes the code easy to scan. Clarity of intent: Names and the comment communicate the purpose, but the comment's assumptions and class flags require Django context. Code length: The implementation is concise, although the import list and redundant parentheses are unnecessary. Action granularity: Most lines perform one action; the return statement combines SQL formatting, joining, and parameter normalization. Reading flow: Initialization naturally precedes rendering, but the extra blank line inside as_sql and dense return expression slightly disrupt readability.
Run 3
Code Structure: The small class logically groups metadata, initialization, and SQL rendering, although numerous unused imports add clutter. Nesting: There is no deep nesting; the comprehension is straightforward. Clarity of intent: Names and the comment make the SQL-fragment wrapper's purpose reasonably clear, though the unused compiler and connection arguments may require framework context. Code length: The implementation is concise, but redundant parentheses, unused imports, and an empty line inside as_sql reduce polish. Action granularity: Initialization uses one assignment per line; the return statement combines SQL assembly and parameter normalization but remains manageable. Reading flow: The class reads naturally from attributes to initialization to output, with minor formatting distractions.