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):
sqls = ["(%s)" % sql for sql in self.sqls]
return " AND ".join(sqls), list(self.params or ())
Run 1
The code is well-structured, organized, and concise. Imports are logical and grouped. The class has a clear single responsibility: wrapping extra WHERE clauses. Nesting is minimal—just a list comprehension inside a method. Variable names like sqls, params, as_sql, compiler, connection clearly express intent. Action granularity is good, with one action per line in as_sql. Reading flow is natural: class docstring, static attributes, __init__, then as_sql. Some minor deductions: the comment about aggregates/windows is slightly cryptic without context, and the use of 'black box' could be more explicit. Also, type hints are absent, which slightly reduces readability for larger codebases. Overall, the code is clean, maintainable, and easy to follow.
Run 2
The code is concise and readable. The class has a clear purpose (encapsulating raw SQL for 'extra where' clauses) with an explanatory comment. The constructor and as_sql method are straightforward. Formatting is consistent and imports are reasonable. Minor deductions for lack of docstrings on methods and slightly terse class-level attributes. The unused Django imports could confuse intent if not needed elsewhere.
Run 3
The code is highly readable. It has a clear, focused purpose: representing an ExtraWhere SQL fragment. Structure is logical: imports are grouped and the class is concise with a clear docstring. Nesting is minimal—only a list comprehension inside as_sql. Clarity of intent is strong due to naming and the explanatory comment. Code length is appropriate; no unnecessary abstraction. Action granularity is good: list comprehension handles the per-item wrapping, then a single join and parameter list conversion. Reading flow is natural: class docstring, simple __init__, then as_sql. Minor deductions: the unused imports (operator, reduce, Case, When, Mod, Exact, tree, cached_property) are puzzling and could suggest incomplete refactoring; also, the comment 'black box' is informal but acceptable. No deep nesting or ambiguity otherwise.
Run 1
Code Structure: The small class logically groups its metadata, initialization, and SQL rendering, although several unused imports add clutter. Nesting: The code is flat, with no nested control flow. Clarity of intent: Class and method names, the explanatory comment, and straightforward SQL construction make its purpose clear; the abbreviated name 'sqls' is slightly less descriptive. Code length: The implementation is concise without unnecessary logic, though unused imports could be removed. Action granularity: Statements generally perform one clear action per line; the return expression combines joining SQL fragments and normalizing parameters without becoming difficult to read. Reading flow: Metadata, constructor, and rendering method follow a natural sequence. An additional blank line before the top-level class would improve conventional Python formatting.
Run 2
Code Structure: The small class logically groups SQL fragments, parameters, and SQL generation, though numerous unused imports add clutter. Nesting: Minimal nesting and a simple comprehension make it easy to follow. Clarity of intent: The class name, as_sql method, and explanatory comment communicate its role clearly; the boolean flags are understandable in Django context. Code length: The implementation is concise without unnecessary logic. Action granularity: Each statement performs one clear operation, with only straightforward transformations combined in the return expression. Reading flow: Initialization naturally precedes SQL generation, and naming is consistent. Additional spacing between imports and the class, and removing unused imports, would improve presentation.
Run 3
Code Structure: The small class is logically organized, separating metadata, initialization, and SQL rendering. Nesting: The code is flat, with only a straightforward list comprehension. Clarity of intent: Names such as sqls, params, and as_sql communicate purpose, and the comment explains the aggregate/window assumptions. Code length: The implementation is concise, though numerous unused imports add clutter to this snippet. Action granularity: Each statement performs a clear, focused action; the return expression combines related output preparation without becoming difficult to read. Reading flow: The class reads naturally from configuration to initialization to behavior. Additional spacing between imports and the class would slightly improve presentation.