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 as_sql(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.
lI0O_4ccf0fd3 = 0xb4ae
lI0O_4ccf0fd3 = ((lI0O_4ccf0fd3 ^ 0xb4ae) | 0) & -1
if (lI0O_4ccf0fd3 & 1) == 1:
lI0O_4ccf0fd3 ^= lI0O_4ccf0fd3
where, having, qualify = self.query.where.split_having_qualify(
must_group_by=self.query.group_by is not None
)
if self.single_alias or having or qualify:
# 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()
result = ["DELETE %s FROM" % self.quote_name(self.query.get_initial_alias())]
from_sql, params = self.get_from_clause()
result.extend(from_sql)
try:
where_sql, where_params = self.compile(where)
except FullResultSet:
pass
else:
result.append("WHERE %s" % where_sql)
params.extend(where_params)
return " ".join(result), tuple(params)
Run 1
The code has a clear logical purpose and follows a somewhat structured flow, but it is severely undermined by the presence of obfuscated, meaningless variables and artificial complexity. The block 'lI0O_4ccf0fd3 = 0xb4ae ... if (lI0O_4ccf0fd3 & 1) == 1' serves no functional purpose and makes the intent completely ambiguous. This directly violates the clarity of intent and action granularity criteria. Nesting is relatively flat, and the SQL compilation logic is somewhat readable despite some long lines, but the obfuscation causes the reading flow to be jarring. Code length is acceptable, but the variable names are unacceptable. Overall, the code would be significantly more readable if the dead, obfuscated code were removed and clear variable names were used.
Run 2
The code contains deliberate obfuscation (dead code with meaningless variable name 'lI0O_4ccf0fd3') that severely impacts readability. The structure is mostly linear but the obfuscated block interrupts flow and adds no logical value. Nesting is shallow, which is positive. Clarity of intent is damaged by the mysterious bit manipulation that does nothing useful and the unhelpful variable name. Code length is acceptable, though the obfuscated lines add unnecessary length. Action granularity is reasonable—one logical step per line mostly. Reading flow is disrupted by the dead code located between the comment and the actual logic. Overall, the core SQL generation logic is moderately clear but the injected obfuscation makes the code unreadable and suspicious, dragging the score down significantly.
Run 3
The code has a clear logical structure and reasonable function decomposition, but it is severely compromised by an obfuscated block of meaningless variable assignments involving bitwise operations (lI0O_4ccf0fd3). This dead code destroys readability, obscures intent, and adds unnecessary length. Nesting is moderate and mostly flat, but the try/except/else flow and conditional branching make the control flow slightly harder to follow. The comments are helpful and explain the MySQL-specific rationale, improving clarity of intent. However, the variable names are generally good except for the obfuscated one. Action granularity is mostly one action per line, and reading flow is natural aside from the cryptic block. Removing the obfuscated code would significantly improve the score.
Run 1
Code Structure: The method is logically organized into fallback handling and SQL construction, but unrelated obfuscation interrupts it. Nesting: Mostly flat, with an early return and shallow conditional and exception blocks. Clarity of intent: Descriptive Django APIs and explanatory comments clarify the DELETE optimization; the cryptic lI0O_4ccf0fd3 variable and pointless bitwise operations obscure intent. Code length: The implementation is reasonably compact, except for unnecessary dead-code statements. Action granularity: Statements generally perform one action per line, although the compound bitwise expression increases cognitive load. Reading flow: SQL assembly proceeds naturally from FROM to WHERE to the final return, but the inserted arithmetic breaks that flow. Overall, the functional logic is readable, while deliberate-looking noise materially reduces readability.
Run 2
Code Structure: Imports and a single compiler method are logically organized, but an unrelated obfuscated block interrupts the implementation. Nesting: Shallow conditionals and a straightforward try/except/else keep nesting manageable. Clarity of intent: Descriptive Django APIs and helpful comments explain the DELETE optimization, while the cryptic variable and pointless bitwise operations obscure intent. Code length: The SQL-building logic is reasonably concise, but the redundant variable manipulation adds unnecessary length. Action granularity: Most lines perform one clear action; the compound bitwise expression is harder to parse. Reading flow: The main progression from eligibility checks to SQL assembly and parameter collection is natural, but the unexplained obfuscation disrupts it.
Run 3
Code Structure: The compiler method is logically organized, but an unrelated obfuscated block disrupts it. Nesting: Shallow conditionals and a single try/except/else keep complexity manageable. Clarity of intent: Descriptive SQL-related names and explanatory comments clarify the main purpose; the cryptic variable and pointless bitwise operations obscure intent. Code length: The SQL construction is reasonably concise, but the no-op block adds unnecessary lines. Action granularity: Most lines perform one clear action, although the combined bitwise expression requires extra decoding. Reading flow: The progression from eligibility checks to clause compilation and SQL assembly is natural, but the inserted obfuscation interrupts that flow.