Source code
from django.core.exceptions import FieldError, FullResultSet
from django.db.models.expressions import Col
from django.db.models.sql.compiler import SQLAggregateCompiler, SQLCompiler
from django.db.models.sql.compiler import SQLDeleteCompiler as BaseSQLDeleteCompiler
from django.db.models.sql.compiler import SQLInsertCompiler
from django.db.models.sql.compiler import SQLUpdateCompiler as BaseSQLUpdateCompiler
class SQLDeleteCompiler(BaseSQLDeleteCompiler):
def a(self):
# Prefer the non-standard DELETE FROM syntax over the SQL generated by
# the SQLDeleteCompiler's default implementation when multiple tables
# are involved since MySQL/MariaDB will generate a more efficient query
# plan than when using a subquery.
b, c, d = self.query.where.split_having_qualify(
must_group_by=self.query.group_by is not None
)
if self.single_alias or c or d:
# DELETE FROM cannot be used when filtering against aggregates or
# window functions as it doesn't allow for GROUP BY/HAVING clauses
# and the subquery wrapping (necessary to emulate QUALIFY).
return super().as_sql()
e = ["DELETE %s FROM" % self.quote_name(self.query.get_initial_alias())]
f, g = self.get_from_clause()
e.extend(f)
try:
h, i = self.compile(b)
except FullResultSet:
pass
else:
e.append("WHERE %s" % h)
g.extend(i)
return " ".join(e), tuple(g)
Run 1
The code is extremely difficult to read due to non-descriptive variable names (a, b, c, d, e, f, g, h, i), inconsistent naming, and cryptic structure. The method name 'a' gives no indication of its purpose. The logic is tangled with a try/except/else block that obscures control flow, and multiple actions are packed into dense lines. Nesting is moderate, but the overall intent is ambiguous without deep Django internals knowledge. Comments help slightly, but the unexplained abbreviations and compressed list building undermine clarity. The code fails most readability criteria: poor structure, weak clarity of intent, unnecessary obscurity, and poor granularity.
Run 2
This code is highly unreadable due to the use of cryptic single-letter variable names (a, b, c, d, e, f, g, h, i) that completely obscure intent. The method name 'a' gives no indication of its purpose. The code structure is tangled, mixing logic for syntax choice, SQL fragment construction, compilation, and error handling without clear separation. While nesting is minimal, clarity of intent is severely compromised. There are some comments, but they do not compensate for the obfuscated identifiers. Action granularity is acceptable (one primary action per line), but the reading flow is disorganized as the reader must repeatedly parse what each letter represents. Code length is not the issue; the lack of meaningful names is.
Run 3
The code is difficult to read due to single-letter variable names (b, c, d, e, f, g, h, i) that obscure meaning, though the explaining comment helps somewhat. Structure is mostly logical but the method name 'a' is vague and unhelpful. Nesting is shallow (try-except-else only), which is good. Clarity of intent is partially salvaged by the comment but still requires effort to understand variable purposes. Code length is reasonably concise. Action granularity is mostly one action per line, improving readability slightly. Reading flow is disrupted by needing to mentally map cryptic variable names to SQL components without explicit cues. Overall, the code is maintainable for the original author but unnecessarily difficult for other developers.
Run 1
Code Structure: Imports and a single compiler method are logically organized, with clear setup, filtering, and return stages. Nesting: Shallow conditional and try/except blocks keep complexity manageable, and the early return simplifies the main path. Clarity of intent: Detailed comments explain the SQL optimization and restrictions, but the method name 'a' and variables 'b' through 'i' obscure their roles and make the implementation harder to understand. Code length: Compact and generally necessary, although comments are relatively lengthy. Action granularity: Most lines perform one clear operation; tuple unpacking groups closely related values appropriately. Reading flow: Execution proceeds naturally from eligibility checks to SQL construction, condition compilation, and output, but readers must repeatedly infer what the abbreviated identifiers represent.
Run 2
Code Structure: The method is logically organized into condition handling, SQL construction, and return, though unrelated imports add clutter. Nesting: Shallow conditionals and a single try/except/else keep complexity manageable. Clarity of intent: Detailed comments explain the SQL optimization and limitations, but the method name 'a' and variables 'b' through 'i' obscure their roles and the expected compiler interface. Code length: The implementation is concise without obvious unnecessary logic; comments are useful rather than redundant. Action granularity: Most lines perform one action, and tuple unpacking naturally groups related results. Reading flow: Execution proceeds naturally from eligibility checking to assembling the query, but readers must repeatedly infer what anonymous variables represent. Meaningful names would substantially improve readability.
Run 3
Code Structure: The method follows a logical sequence: check SQL compatibility, build the DELETE statement, compile conditions, and return SQL with parameters. Nesting: Shallow conditional and try/except/else blocks keep complexity manageable. Clarity of intent: Detailed comments explain the optimization and fallback, but the method name 'a' and variables 'b' through 'i' obscure their roles and make the implementation harder to understand. Code length: The implementation is concise without obvious redundancy, though several imports are unused in this snippet. Action granularity: Most lines perform one clear operation; tuple unpacking appropriately groups related results. Reading flow: Execution proceeds naturally with an early return, but opaque identifiers force readers to infer meaning from framework calls and trace variables repeatedly.