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, sql2, par):
self.sqls = sql2
self.params = par
def as2(self, com=None, con=None):
sql3 = ["(%s)" % sql4 for sql4 in self.sqls]
return " AND ".join(sql3), list(self.params or ())
Run 1
The code is difficult to read due to unclear naming (sql2, par, as2, com, con, sql3, sql4), ambiguous purpose, and inconsistent parameter conventions. The class has no docstring explaining its role, and the method 'as2' gives no hint of what it does or returns. The abbreviation-heavy names and lack of type hints or comments make intent opaque. While the code is short and flat (low nesting), those positives are outweighed by poor naming and structure. The method mixes list comprehension, formatting, and tuple/list conversion in two lines, but the logic is not self-evident. Overall, it reads like legacy or hastily written code where the author's mental model is not conveyed to the reader.
Run 2
The code is difficult to read due to unclear and abbreviated naming (sql2, par, as2, con, sql3, sql4, com). The purpose of the class and method is not evident from the code alone. Action granularity is acceptable, but the reading flow is impeded by ambiguous variable names and a lack of explanatory comments. The structure is simple, but this does little to mitigate the lack of clarity. There is minimal nesting, which is positive, but the method signature and list operations are not self-documenting. Overall, the code requires external knowledge or additional context to understand, and the naming choices actively work against readability.
Run 3
The code is a small class but suffers from unclear naming and ambiguous intent. Structure is logical (imports, class, methods), but 'ExtraWhere' and abbreviations like 'sql2', 'par', 'as2', 'sql3', 'sql4', 'com', 'con' obscure what the class does. The method 'as2' performs string formatting, list construction, and joining in one expression, making it harder to follow. Nesting is minimal, and code length is concise, but readability suffers because the parameters and variable names do not convey meaning. The reading flow is broken by abbreviations and lack of docstrings or type hints. Action granularity is partially mixed, especially in the list comprehension inside 'as2'. The code is not deeply nested or overly long, but clarity of intent is low, which significantly reduces its readability.
Run 1
Code Structure: The small class logically groups SQL fragments, parameters, and rendering, though numerous unused imports add clutter. Nesting: Methods are flat, with only a straightforward list comprehension. Clarity of intent: Parenthesizing and joining SQL fragments is understandable, but names such as sql2, sql3, sql4, par, and as2 obscure meaning; unused com and con parameters also lack explanation. Code length: The implementation is concise, although the import block is disproportionately large. Action granularity: Each statement performs a focused action, and the return expression remains manageable. Reading flow: Initialization followed by rendering provides a natural progression, but vague naming and irrelevant imports interrupt comprehension.
Run 2
Code Structure: A small, logically organized class separates metadata, initialization, and SQL rendering, though numerous unused imports add clutter. Nesting: Flat methods and a simple comprehension are easy to follow. Clarity of intent: The comment and SQL joining reveal the purpose, but names such as sql2, sql3, sql4, par, and as2 obscure meaning; unused com and con parameters also distract. Code length: The implementation is concise, although imports are disproportionate to the functionality shown. Action granularity: Each statement performs a focused action, with only straightforward formatting in the comprehension. Reading flow: Execution proceeds naturally from storing inputs to formatting and joining SQL fragments, but clearer identifiers and cleaner spacing would improve readability.
Run 3
Code Structure: The small class logically groups metadata, initialization, and SQL rendering, but numerous unused imports add clutter. Nesting: The code is flat, with only a straightforward list comprehension. Clarity of intent: ExtraWhere, sqls, and params suggest its purpose, and the comment explains assumptions; however, names such as as2, sql2, sql3, sql4, par, com, and con obscure meaning. Code length: The implementation is concise, though unused imports and unused method parameters reduce focus. Action granularity: Each statement performs one clear action, with no compressed multi-statement lines. Reading flow: Initialization naturally precedes rendering, and the transformation into parenthesized, AND-joined SQL is easy to follow, but inconsistent naming interrupts readability.