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, data, client):
self.sqls = data
self.params = client
def delete(self, localKey=None, finalScore=None):
step = ["(%s)" % key for key in self.sqls]
return " AND ".join(step), list(self.params or ())
Run 1
The code is concise and logically organized, with a clear class definition for ExtraWhere. Nesting is minimal, with no deeply nested control flow. The intent is mostly clear, though the 'client' parameter name is slightly ambiguous (it holds params). Code length is efficientâno unnecessary lines. Action granularity is good: each line performs one distinct action, especially in delete(). Reading flow is natural: imports, class attributes, constructor, method. Minor drawbacks: the comment is sparse and the use of the name 'client' for params is confusing. Overall, very readable and maintainable.
Run 2
The code is generally readable but has several clarity issues. The class structure and imports are logical, but variable naming is ambiguous: 'data' stores SQL fragments, 'client' stores parameters, and 'localKey'/'finalScore' are unused parameters whose purpose is unclear. The delete() method is concise with flat nesting, but it performs multiple actions on one line (list comprehension, string formatting, join, and tuple conversion), which hurts readability. The method name 'delete' is misleading since it actually builds a WHERE clause. The 'step' variable name doesn't convey its meaning. The string formatting using '(%s)' is simple but the overall intent could be clearer with better naming and perhaps splitting the return statement into more explicit steps. The unused parameters suggest either dead code or incomplete implementation, which adds to the ambiguity.
Run 3
The code has several readability issues. The class name 'ExtraWhere' is vague about its purpose, and the constructor parameters ('data' and 'client') are misleadingly named - 'data' is actually SQL strings while 'client' holds parameters. The method signature 'delete(localKey=None, finalScore=None)' contains unused parameters, creating ambiguity about intended usage. Variable names like 'step' don't convey meaning (it contains parenthesized SQL fragments). The core logic - building a WHERE clause with AND joins - is straightforward but obscured by poor naming. The imports are unused within this snippet and add noise. The method name 'delete' is misleading since the method builds expressions rather than performing deletion. Action granularity is acceptable (one action per line), and nesting is minimal, but the reading flow is disrupted by unclear naming and unused code. This code would require multiple reads to understand what it actually does: constructs SQL conditions with parameters.
Run 1
Code Structure: Imports and a small class are logically organized, though many imports are unused. Nesting: Methods are flat, with only a simple comprehension. Clarity of intent: SQL fragment combination is understandable, but names such as delete, data, client, and step obscure the purpose; unused localKey and finalScore parameters add confusion. Code length: The implementation is concise, but unnecessary imports and parameters create clutter. Action granularity: Most lines perform one action; the return combines SQL construction and parameter normalization, which remains manageable. Reading flow: Initialization followed by SQL assembly reads naturally, although misleading naming and unrelated imports interrupt comprehension.
Run 2
Code Structure: The small class is logically organized, but numerous unused imports add clutter. Nesting: The code is flat, with no deeply nested control flow. Clarity of intent: The SQL conjunction is understandable, but names such as delete, data, client, and step obscure the method's actual purpose; unused parameters localKey and finalScore are misleading. Code length: The implementation is concise, though imports and unused parameters unnecessarily increase its size. Action granularity: Most lines perform one clear action; the return statement combines joining SQL fragments and normalizing parameters but remains manageable. Reading flow: Initialization followed by SQL assembly is natural, although inconsistent naming conventions and unrelated imports interrupt comprehension.
Run 3
Code Structure: The small class cleanly separates attributes, initialization, and SQL generation, but numerous unused imports add clutter. Nesting: There is no deep nesting; the single list comprehension is easy to follow. Clarity of intent: SQL fragment combination is understandable, but delete misleadingly names a SQL-rendering method, while data, client, and step are vague. Unused localKey and finalScore parameters further obscure the interface. Code length: The implementation is concise, though unnecessary imports and parameters reduce economy. Action granularity: Each statement performs a focused operation; the return line combines joining fragments and converting parameters, but remains manageable. Reading flow: Execution proceeds naturally from stored inputs to formatted SQL and parameters, although misleading names and irrelevant imports interrupt comprehension.