plain.models 0.49.1__py3-none-any.whl → 0.50.0__py3-none-any.whl

plain/models/backends/mysql/features.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import operator
 from functools import cached_property
 
@@ -26,19 +28,19 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_logical_xor = True
 
     @cached_property
-    def minimum_database_version(self):
+    def minimum_database_version(self) -> tuple[int, ...]:
         if self.connection.mysql_is_mariadb:
             return (10, 4)
         else:
             return (8,)
 
     @cached_property
-    def _mysql_storage_engine(self):
+    def _mysql_storage_engine(self) -> str:
         "Internal method used in Plain tests. Don't rely on this from your code"
         return self.connection.mysql_server_data["default_storage_engine"]
 
     @cached_property
-    def allows_auto_pk_0(self):
+    def allows_auto_pk_0(self) -> bool:
         """
         Autoincrement primary key can be set to 0 if it doesn't generate new
         autoincrement values.
@@ -46,7 +48,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         return "NO_AUTO_VALUE_ON_ZERO" in self.connection.sql_mode
 
     @cached_property
-    def update_can_self_select(self):
+    def update_can_self_select(self) -> bool:
         return self.connection.mysql_is_mariadb and self.connection.mysql_version >= (
             10,
             3,
@@ -54,7 +56,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         )
 
     @cached_property
-    def can_return_columns_from_insert(self):
+    def can_return_columns_from_insert(self) -> bool:
         return self.connection.mysql_is_mariadb and self.connection.mysql_version >= (
             10,
             5,
@@ -66,21 +68,21 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     )
 
     @cached_property
-    def has_zoneinfo_database(self):
+    def has_zoneinfo_database(self) -> bool:
         return self.connection.mysql_server_data["has_zoneinfo_database"]
 
     @cached_property
-    def is_sql_auto_is_null_enabled(self):
+    def is_sql_auto_is_null_enabled(self) -> bool:
         return self.connection.mysql_server_data["sql_auto_is_null"]
 
     @cached_property
-    def supports_over_clause(self):
+    def supports_over_clause(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return True
         return self.connection.mysql_version >= (8, 0, 2)
 
     @cached_property
-    def supports_column_check_constraints(self):
+    def supports_column_check_constraints(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return True
         return self.connection.mysql_version >= (8, 0, 16)
@@ -90,32 +92,32 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     )
 
     @cached_property
-    def can_introspect_check_constraints(self):
+    def can_introspect_check_constraints(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return True
         return self.connection.mysql_version >= (8, 0, 16)
 
     @cached_property
-    def has_select_for_update_skip_locked(self):
+    def has_select_for_update_skip_locked(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return self.connection.mysql_version >= (10, 6)
         return self.connection.mysql_version >= (8, 0, 1)
 
     @cached_property
-    def has_select_for_update_nowait(self):
+    def has_select_for_update_nowait(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return True
         return self.connection.mysql_version >= (8, 0, 1)
 
     @cached_property
-    def has_select_for_update_of(self):
+    def has_select_for_update_of(self) -> bool:
         return (
             not self.connection.mysql_is_mariadb
             and self.connection.mysql_version >= (8, 0, 1)
         )
 
     @cached_property
-    def supports_explain_analyze(self):
+    def supports_explain_analyze(self) -> bool:
         return self.connection.mysql_is_mariadb or self.connection.mysql_version >= (
             8,
             0,
@@ -123,7 +125,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         )
 
     @cached_property
-    def supported_explain_formats(self):
+    def supported_explain_formats(self) -> set[str]:
         # Alias MySQL's TRADITIONAL to TEXT for consistency with other
         # backends.
         formats = {"JSON", "TEXT", "TRADITIONAL"}
@@ -136,7 +138,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         return formats
 
     @cached_property
-    def supports_transactions(self):
+    def supports_transactions(self) -> bool:
         """
         All storage engines except MyISAM support transactions.
         """
@@ -145,17 +147,17 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     uses_savepoints = property(operator.attrgetter("supports_transactions"))
 
     @cached_property
-    def ignores_table_name_case(self):
+    def ignores_table_name_case(self) -> bool:
         return self.connection.mysql_server_data["lower_case_table_names"]
 
     @cached_property
-    def can_introspect_json_field(self):
+    def can_introspect_json_field(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return self.can_introspect_check_constraints
         return True
 
     @cached_property
-    def supports_index_column_ordering(self):
+    def supports_index_column_ordering(self) -> bool:
         if self._mysql_storage_engine != "InnoDB":
             return False
         if self.connection.mysql_is_mariadb:
@@ -163,7 +165,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         return self.connection.mysql_version >= (8, 0, 1)
 
     @cached_property
-    def supports_expression_indexes(self):
+    def supports_expression_indexes(self) -> bool:
         return (
             not self.connection.mysql_is_mariadb
             and self._mysql_storage_engine != "MyISAM"
@@ -171,7 +173,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
         )
 
     @cached_property
-    def supports_select_intersection(self):
+    def supports_select_intersection(self) -> bool:
         is_mariadb = self.connection.mysql_is_mariadb
         return is_mariadb or self.connection.mysql_version >= (8, 0, 31)
 
@@ -180,7 +182,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     )
 
     @cached_property
-    def can_rename_index(self):
+    def can_rename_index(self) -> bool:
         if self.connection.mysql_is_mariadb:
             return self.connection.mysql_version >= (10, 5, 2)
         return True

plain/models/backends/mysql/introspection.py

@@ -1,7 +1,10 @@
+from __future__ import annotations
+
 from collections import namedtuple
+from typing import Any
 
 import sqlparse
-from MySQLdb.constants import FIELD_TYPE
+from MySQLdb.constants import FIELD_TYPE  # type: ignore[import-untyped]
 
 from plain.models.backends.base.introspection import BaseDatabaseIntrospection
 from plain.models.backends.base.introspection import FieldInfo as BaseFieldInfo
@@ -46,7 +49,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         FIELD_TYPE.VAR_STRING: "CharField",
     }
 
-    def get_field_type(self, data_type, description):
+    def get_field_type(self, data_type: Any, description: Any) -> str:
         field_type = super().get_field_type(data_type, description)
         if "auto_increment" in description.extra:
             if field_type == "BigIntegerField":
@@ -64,7 +67,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             return "JSONField"
         return field_type
 
-    def get_table_list(self, cursor):
+    def get_table_list(self, cursor: Any) -> list[TableInfo]:
         """Return a list of table and view names in the current database."""
         cursor.execute(
             """
@@ -81,12 +84,12 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             for row in cursor.fetchall()
         ]
 
-    def get_table_description(self, cursor, table_name):
+    def get_table_description(self, cursor: Any, table_name: str) -> list[FieldInfo]:
         """
         Return a description of the table with the DB-API cursor.description
         interface."
         """
-        json_constraints = {}
+        json_constraints: set[Any] = set()
         if (
             self.connection.mysql_is_mariadb
             and self.connection.features.can_introspect_json_field
@@ -148,7 +151,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             f"SELECT * FROM {self.connection.ops.quote_name(table_name)} LIMIT 1"
         )
 
-        def to_int(i):
+        def to_int(i: Any) -> Any:
             return int(i) if i is not None else i
 
         fields = []
@@ -172,14 +175,16 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             )
         return fields
 
-    def get_sequences(self, cursor, table_name, table_fields=()):
+    def get_sequences(
+        self, cursor: Any, table_name: str, table_fields: tuple[Any, ...] = ()
+    ) -> list[dict[str, Any]]:
         for field_info in self.get_table_description(cursor, table_name):
             if "auto_increment" in field_info.extra:
                 # MySQL allows only one auto-increment column per table.
                 return [{"table": table_name, "column": field_info.name}]
         return []
 
-    def get_relations(self, cursor, table_name):
+    def get_relations(self, cursor: Any, table_name: str) -> dict[str, tuple[str, str]]:
         """
         Return a dictionary of {field_name: (field_name_other_table, other_table)}
         representing all foreign keys in the given table.
@@ -200,7 +205,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             for field_name, other_field, other_table in cursor.fetchall()
         }
 
-    def get_storage_engine(self, cursor, table_name):
+    def get_storage_engine(self, cursor: Any, table_name: str) -> str:
         """
         Retrieve the storage engine for a given table. Return the default
         storage engine if the table doesn't exist.
@@ -220,8 +225,10 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             return self.connection.features._mysql_storage_engine
         return result[0]
 
-    def _parse_constraint_columns(self, check_clause, columns):
-        check_columns = OrderedSet()
+    def _parse_constraint_columns(
+        self, check_clause: str, columns: set[str]
+    ) -> OrderedSet:
+        check_columns: OrderedSet = OrderedSet()
         statement = sqlparse.parse(check_clause)[0]
         tokens = (token for token in statement.flatten() if not token.is_whitespace)
         for token in tokens:
@@ -233,12 +240,14 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
                 check_columns.add(token.value[1:-1])
         return check_columns
 
-    def get_constraints(self, cursor, table_name):
+    def get_constraints(
+        self, cursor: Any, table_name: str
+    ) -> dict[str, dict[str, Any]]:
         """
         Retrieve any constraints or keys (unique, pk, fk, check, index) across
         one or more columns.
         """
-        constraints = {}
+        constraints: dict[str, dict[str, Any]] = {}
         # Get the actual constraint names and columns
         name_query = """
             SELECT kc.`constraint_name`, kc.`column_name`,

plain/models/backends/mysql/operations.py

@@ -1,4 +1,8 @@
+from __future__ import annotations
+
+import datetime
 import uuid
+from typing import TYPE_CHECKING, Any
 
 from plain.models.backends.base.operations import BaseDatabaseOperations
 from plain.models.backends.utils import split_tzname_delta
@@ -9,6 +13,9 @@ from plain.utils import timezone
 from plain.utils.encoding import force_str
 from plain.utils.regex_helper import _lazy_re_compile
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
 
 class DatabaseOperations(BaseDatabaseOperations):
     compiler_module = "plain.models.backends.mysql.compiler"
@@ -39,7 +46,9 @@ class DatabaseOperations(BaseDatabaseOperations):
     # EXTRACT format cannot be passed in parameters.
     _extract_format_re = _lazy_re_compile(r"[A-Z_]+")
 
-    def date_extract_sql(self, lookup_type, sql, params):
+    def date_extract_sql(
+        self, lookup_type: str, sql: str, params: list[Any] | tuple[Any, ...]
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         # https://dev.mysql.com/doc/mysql/en/date-and-time-functions.html
         if lookup_type == "week_day":
             # DAYOFWEEK() returns an integer, 1-7, Sunday=1.
@@ -63,7 +72,13 @@ class DatabaseOperations(BaseDatabaseOperations):
                 raise ValueError(f"Invalid loookup type: {lookup_type!r}")
             return f"EXTRACT({lookup_type} FROM {sql})", params
 
-    def date_trunc_sql(self, lookup_type, sql, params, tzname=None):
+    def date_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None = None,
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         fields = {
             "year": "%Y-01-01",
@@ -83,11 +98,13 @@ class DatabaseOperations(BaseDatabaseOperations):
         else:
             return f"DATE({sql})", params
 
-    def _prepare_tzname_delta(self, tzname):
+    def _prepare_tzname_delta(self, tzname: str) -> str:
         tzname, sign, offset = split_tzname_delta(tzname)
         return f"{sign}{offset}" if offset else tzname
 
-    def _convert_sql_to_tz(self, sql, params, tzname):
+    def _convert_sql_to_tz(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         if tzname and self.connection.timezone_name != tzname:
             return f"CONVERT_TZ({sql}, %s, %s)", (
                 *params,
@@ -96,19 +113,35 @@ class DatabaseOperations(BaseDatabaseOperations):
             )
         return sql, params
 
-    def datetime_cast_date_sql(self, sql, params, tzname):
+    def datetime_cast_date_sql(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return f"DATE({sql})", params
 
-    def datetime_cast_time_sql(self, sql, params, tzname):
+    def datetime_cast_time_sql(
+        self, sql: str, params: list[Any] | tuple[Any, ...], tzname: str | None
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return f"TIME({sql})", params
 
-    def datetime_extract_sql(self, lookup_type, sql, params, tzname):
+    def datetime_extract_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None,
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         return self.date_extract_sql(lookup_type, sql, params)
 
-    def datetime_trunc_sql(self, lookup_type, sql, params, tzname):
+    def datetime_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None,
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         fields = ["year", "month", "day", "hour", "minute", "second"]
         format = ("%Y-", "%m", "-%d", " %H:", "%i", ":%s")
@@ -133,7 +166,13 @@ class DatabaseOperations(BaseDatabaseOperations):
             return f"CAST(DATE_FORMAT({sql}, %s) AS DATETIME)", (*params, format_str)
         return sql, params
 
-    def time_trunc_sql(self, lookup_type, sql, params, tzname=None):
+    def time_trunc_sql(
+        self,
+        lookup_type: str,
+        sql: str,
+        params: list[Any] | tuple[Any, ...],
+        tzname: str | None = None,
+    ) -> tuple[str, list[Any] | tuple[Any, ...]]:
         sql, params = self._convert_sql_to_tz(sql, params, tzname)
         fields = {
             "hour": "%H:00:00",
@@ -146,17 +185,17 @@ class DatabaseOperations(BaseDatabaseOperations):
         else:
             return f"TIME({sql})", params
 
-    def fetch_returned_insert_rows(self, cursor):
+    def fetch_returned_insert_rows(self, cursor: Any) -> list[Any]:
         """
         Given a cursor object that has just performed an INSERT...RETURNING
         statement into a table, return the tuple of returned data.
         """
         return cursor.fetchall()
 
-    def format_for_duration_arithmetic(self, sql):
+    def format_for_duration_arithmetic(self, sql: str) -> str:
         return f"INTERVAL {sql} MICROSECOND"
 
-    def force_no_ordering(self):
+    def force_no_ordering(self) -> list[tuple[None, tuple[str, list[Any], bool]]]:
         """
         "ORDER BY NULL" prevents MySQL from implicitly ordering by grouped
         columns. If no ordering would otherwise be applied, we don't want any
@@ -164,26 +203,31 @@ class DatabaseOperations(BaseDatabaseOperations):
         """
         return [(None, ("NULL", [], False))]
 
-    def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None):
+    def adapt_decimalfield_value(
+        self,
+        value: Any,
+        max_digits: int | None = None,
+        decimal_places: int | None = None,
+    ) -> Any:
         return value
 
-    def last_executed_query(self, cursor, sql, params):
+    def last_executed_query(self, cursor: Any, sql: str, params: Any) -> str | None:
         # With MySQLdb, cursor objects have an (undocumented) "_executed"
         # attribute where the exact query sent to the database is saved.
         # See MySQLdb/cursors.py in the source distribution.
         # MySQLdb returns string, PyMySQL bytes.
         return force_str(getattr(cursor, "_executed", None), errors="replace")
 
-    def no_limit_value(self):
+    def no_limit_value(self) -> int:
         # 2**64 - 1, as recommended by the MySQL documentation
         return 18446744073709551615
 
-    def quote_name(self, name):
+    def quote_name(self, name: str) -> str:
         if name.startswith("`") and name.endswith("`"):
             return name  # Quoting once is enough.
         return f"`{name}`"
 
-    def return_insert_columns(self, fields):
+    def return_insert_columns(self, fields: list[Any]) -> tuple[str, tuple[Any, ...]]:
         # MySQL and MariaDB < 10.5.0 don't support an INSERT...RETURNING
         # statement.
         if not fields:
@@ -194,7 +238,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         ]
         return "RETURNING {}".format(", ".join(columns)), ()
 
-    def validate_autopk_value(self, value):
+    def validate_autopk_value(self, value: int) -> int:
         # Zero in AUTO_INCREMENT field does not work without the
         # NO_AUTO_VALUE_ON_ZERO SQL mode.
         if value == 0 and not self.connection.features.allows_auto_pk_0:
@@ -203,7 +247,9 @@ class DatabaseOperations(BaseDatabaseOperations):
             )
         return value
 
-    def adapt_datetimefield_value(self, value):
+    def adapt_datetimefield_value(
+        self, value: datetime.datetime | Any | None
+    ) -> str | Any | None:
         if value is None:
             return None
 
@@ -216,7 +262,9 @@ class DatabaseOperations(BaseDatabaseOperations):
             value = timezone.make_naive(value, self.connection.timezone)
         return str(value)
 
-    def adapt_timefield_value(self, value):
+    def adapt_timefield_value(
+        self, value: datetime.time | Any | None
+    ) -> str | Any | None:
         if value is None:
             return None
 
@@ -225,23 +273,25 @@ class DatabaseOperations(BaseDatabaseOperations):
             return value
 
         # MySQL doesn't support tz-aware times
-        if timezone.is_aware(value):
+        if timezone.is_aware(value):  # type: ignore[arg-type]
             raise ValueError("MySQL backend does not support timezone-aware times.")
 
         return value.isoformat(timespec="microseconds")
 
-    def max_name_length(self):
+    def max_name_length(self) -> int:
         return 64
 
-    def pk_default_value(self):
+    def pk_default_value(self) -> str:
         return "NULL"
 
-    def bulk_insert_sql(self, fields, placeholder_rows):
+    def bulk_insert_sql(
+        self, fields: list[Any], placeholder_rows: list[list[str]]
+    ) -> str:
         placeholder_rows_sql = (", ".join(row) for row in placeholder_rows)
         values_sql = ", ".join(f"({sql})" for sql in placeholder_rows_sql)
         return "VALUES " + values_sql
 
-    def combine_expression(self, connector, sub_expressions):
+    def combine_expression(self, connector: str, sub_expressions: list[str]) -> str:
         if connector == "^":
             return "POW({})".format(",".join(sub_expressions))
         # Convert the result to a signed integer since MySQL's binary operators
@@ -254,7 +304,7 @@ class DatabaseOperations(BaseDatabaseOperations):
             return f"FLOOR({lhs} / POW(2, {rhs}))"
         return super().combine_expression(connector, sub_expressions)
 
-    def get_db_converters(self, expression):
+    def get_db_converters(self, expression: Any) -> list[Any]:
         converters = super().get_db_converters(expression)
         internal_type = expression.output_field.get_internal_type()
         if internal_type == "BooleanField":
@@ -265,27 +315,38 @@ class DatabaseOperations(BaseDatabaseOperations):
             converters.append(self.convert_uuidfield_value)
         return converters
 
-    def convert_booleanfield_value(self, value, expression, connection):
+    def convert_booleanfield_value(
+        self, value: Any, expression: Any, connection: BaseDatabaseWrapper
+    ) -> Any:
         if value in (0, 1):
             value = bool(value)
         return value
 
-    def convert_datetimefield_value(self, value, expression, connection):
+    def convert_datetimefield_value(
+        self, value: Any, expression: Any, connection: BaseDatabaseWrapper
+    ) -> datetime.datetime | None:
         if value is not None:
             value = timezone.make_aware(value, self.connection.timezone)
         return value
 
-    def convert_uuidfield_value(self, value, expression, connection):
+    def convert_uuidfield_value(
+        self, value: Any, expression: Any, connection: BaseDatabaseWrapper
+    ) -> uuid.UUID | None:
         if value is not None:
             value = uuid.UUID(value)
         return value
 
-    def binary_placeholder_sql(self, value):
+    def binary_placeholder_sql(self, value: Any) -> str:
         return (
             "_binary %s" if value is not None and not hasattr(value, "as_sql") else "%s"
         )
 
-    def subtract_temporals(self, internal_type, lhs, rhs):
+    def subtract_temporals(
+        self,
+        internal_type: str,
+        lhs: tuple[str, list[Any] | tuple[Any, ...]],
+        rhs: tuple[str, list[Any] | tuple[Any, ...]],
+    ) -> tuple[str, tuple[Any, ...]]:
         lhs_sql, lhs_params = lhs
         rhs_sql, rhs_params = rhs
         if internal_type == "TimeField":
@@ -306,7 +367,7 @@ class DatabaseOperations(BaseDatabaseOperations):
         params = (*rhs_params, *lhs_params)
         return f"TIMESTAMPDIFF(MICROSECOND, {rhs_sql}, {lhs_sql})", params
 
-    def explain_query_prefix(self, format=None, **options):
+    def explain_query_prefix(self, format: str | None = None, **options: Any) -> str:
         # Alias MySQL's TRADITIONAL to TEXT for consistency with other backends.
         if format and format.upper() == "TEXT":
             format = "TRADITIONAL"
@@ -327,7 +388,7 @@ class DatabaseOperations(BaseDatabaseOperations):
             prefix += f" FORMAT={format}"
         return prefix
 
-    def regex_lookup(self, lookup_type):
+    def regex_lookup(self, lookup_type: str) -> str:
         # REGEXP_LIKE doesn't exist in MariaDB.
         if self.connection.mysql_is_mariadb:
             if lookup_type == "regex":
@@ -337,12 +398,12 @@ class DatabaseOperations(BaseDatabaseOperations):
         match_option = "c" if lookup_type == "regex" else "i"
         return f"REGEXP_LIKE(%s, %s, '{match_option}')"
 
-    def insert_statement(self, on_conflict=None):
+    def insert_statement(self, on_conflict: Any = None) -> str:
         if on_conflict == OnConflict.IGNORE:
             return "INSERT IGNORE INTO"
         return super().insert_statement(on_conflict=on_conflict)
 
-    def lookup_cast(self, lookup_type, internal_type=None):
+    def lookup_cast(self, lookup_type: str, internal_type: str | None = None) -> str:
         lookup = "%s"
         if internal_type == "JSONField":
             if self.connection.mysql_is_mariadb or lookup_type in (
@@ -359,7 +420,7 @@ class DatabaseOperations(BaseDatabaseOperations):
                 lookup = "JSON_UNQUOTE(%s)"
         return lookup
 
-    def conditional_expression_supported_in_where_clause(self, expression):
+    def conditional_expression_supported_in_where_clause(self, expression: Any) -> bool:
         # MySQL ignores indexes with boolean fields unless they're compared
         # directly to a boolean value.
         if isinstance(expression, Exists | Lookup):
@@ -372,7 +433,13 @@ class DatabaseOperations(BaseDatabaseOperations):
             return False
         return super().conditional_expression_supported_in_where_clause(expression)
 
-    def on_conflict_suffix_sql(self, fields, on_conflict, update_fields, unique_fields):
+    def on_conflict_suffix_sql(
+        self,
+        fields: list[Any],
+        on_conflict: Any,
+        update_fields: list[Any],
+        unique_fields: list[Any],
+    ) -> str:
         if on_conflict == OnConflict.UPDATE:
             conflict_suffix_sql = "ON DUPLICATE KEY UPDATE %(fields)s"
             # The use of VALUES() is deprecated in MySQL 8.0.20+. Instead, use
@@ -388,13 +455,13 @@ class DatabaseOperations(BaseDatabaseOperations):
             else:
                 field_sql = "%(field)s = VALUE(%(field)s)"
 
-            fields = ", ".join(
+            fields_str = ", ".join(
                 [
                     field_sql % {"field": field}
                     for field in map(self.quote_name, update_fields)
                 ]
             )
-            return conflict_suffix_sql % {"fields": fields}
+            return conflict_suffix_sql % {"fields": fields_str}
         return super().on_conflict_suffix_sql(
             fields,
             on_conflict,