instructure-pysqlsync 0.8.5.dev0__py3-none-any.whl

pysqlsync/dialect/mssql/mutation.py

@@ -0,0 +1,46 @@
+import typing
+from typing import Optional
+
+from pysqlsync.formation.mutation import Mutator
+from pysqlsync.formation.object_types import Column, ColumnFormationError, StatementList, Table, join_or_none
+
+from .object_types import MSSQLColumn
+
+
+class MSSQLMutator(Mutator):
+    def mutate_column_stmt(self, source: Column, target: Column) -> Optional[str]:
+        if source.identity != target.identity:
+            raise ColumnFormationError(
+                "operation not permitted; cannot add or drop identity property",
+                source.name,
+            )
+
+        if source.data_type != target.data_type or source.nullable != target.nullable:
+            nullable = " NOT NULL" if not target.nullable else ""
+            return f"ALTER COLUMN {source.name} {target.data_type}{nullable}"
+        else:
+            return None
+
+    def mutate_table_stmt(self, source: Table, target: Table) -> Optional[str]:
+        statements = StatementList()
+
+        constraints: list[str] = []
+        common_columns = source.columns.intersection(target.columns)
+        for source_column, target_column in common_columns:
+            source_def = source_column.default
+            target_def = target_column.default
+
+            if source_def == target_def:
+                continue
+
+            name = typing.cast(MSSQLColumn, source_column).default_constraint_name
+            if source_def is not None:
+                constraints.append(f"DROP CONSTRAINT {name}")
+            if target_def is not None:
+                constraints.append(f"ADD CONSTRAINT {name} DEFAULT {target_def} FOR {source_column.name}")
+
+        if constraints:
+            statements.append(source.alter_table_stmt(constraints))
+
+        statements.append(super().mutate_table_stmt(source, target))
+        return join_or_none(statements)

pysqlsync/dialect/mssql/object_types.py

@@ -0,0 +1,135 @@
+import random
+import string
+from dataclasses import dataclass
+from typing import Optional, Union
+
+from pysqlsync.formation.object_types import (
+    Column,
+    EnumTable,
+    Namespace,
+    ObjectFactory,
+    Table,
+    join_or_none,
+)
+from pysqlsync.model.data_types import SqlDataType, quote
+from pysqlsync.model.id_types import LocalId
+from pysqlsync.util.typing import override
+
+ID_GENERATOR = random.Random()
+
+
+@dataclass
+class MSSQLDefault:
+    """
+    Default value constraint.
+
+    :param name: Globally unique name for the default constraint.
+    :param expr: SQL expression for the default value.
+    """
+
+    name: str
+    expr: str
+
+
+class MSSQLColumn(Column):
+    """
+    A column in a Microsoft SQL Server database table.
+
+    :param default_constraint_name: The name of the constraint for DEFAULT.
+    """
+
+    default_constraint_name: LocalId
+
+    def __init__(
+        self,
+        name: LocalId,
+        data_type: SqlDataType,
+        nullable: bool,
+        default: Union[MSSQLDefault, str, None] = None,
+        identity: bool = False,
+        description: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            name,
+            data_type,
+            nullable=nullable,
+            default=default.expr if isinstance(default, MSSQLDefault) else default,
+            identity=identity,
+            description=description,
+        )
+        if isinstance(default, MSSQLDefault):
+            self.default_constraint_name = LocalId(default.name)
+        else:
+            r = "".join(ID_GENERATOR.choices(string.ascii_lowercase, k=6))
+            self.default_constraint_name = LocalId(f"df_{self.name.local_id}_{r}")
+
+    @property
+    def data_spec(self) -> str:
+        nullable = " NOT NULL" if not self.nullable else ""
+        name = self.default_constraint_name
+        default = f" CONSTRAINT {name} DEFAULT {self.default}" if self.default is not None else ""
+        identity = " IDENTITY" if self.identity else ""
+        return f"{self.data_type}{nullable}{default}{identity}"
+
+    @override
+    def create_stmt(self) -> str:
+        return f"ADD {self.column_spec}"
+
+    @override
+    def drop_stmt(self) -> str:
+        if self.default is not None:
+            name = self.default_constraint_name
+            return f"DROP CONSTRAINT {name}, COLUMN {self.name}"
+        else:
+            return f"DROP COLUMN {self.name}"
+
+
+class MSSQLTable(Table):
+    def alter_table_stmt(self, statements: list[str]) -> str:
+        return "\n".join(f"ALTER TABLE {self.name} {statement};" for statement in statements)
+
+    def add_constraints_stmt(self) -> Optional[str]:
+        statements: list[str] = []
+        if self.table_constraints:
+            statements.append(f"ALTER TABLE {self.name} ADD\n" + ",\n".join(f"CONSTRAINT {c.spec}" for c in self.table_constraints) + ";")
+        return join_or_none(statements)
+
+    def drop_constraints_stmt(self) -> Optional[str]:
+        statements: list[str] = []
+        if self.table_constraints:
+            statements.append(
+                f"ALTER TABLE {self.name} DROP\n" + ",\n".join(f"CONSTRAINT {c.name}" for c in self.table_constraints) + "\n;"
+            )
+
+        return join_or_none(statements)
+
+
+class MSSQLEnumTable(EnumTable, MSSQLTable):
+    pass
+
+
+class MSSQLNamespace(Namespace):
+    def create_schema_stmt(self) -> Optional[str]:
+        if self.name.local_id:
+            # Microsoft SQL Server requires a separate batch for creating a schema
+            return f"IF NOT EXISTS ( SELECT * FROM sys.schemas WHERE name = N{quote(self.name.id)} ) EXEC('CREATE SCHEMA {self.name}');"
+        else:
+            return None
+
+
+class MSSQLObjectFactory(ObjectFactory):
+    @property
+    def column_class(self) -> type[Column]:
+        return MSSQLColumn
+
+    @property
+    def table_class(self) -> type[Table]:
+        return MSSQLTable
+
+    @property
+    def enum_table_class(self) -> type[EnumTable]:
+        return MSSQLEnumTable
+
+    @property
+    def namespace_class(self) -> type[Namespace]:
+        return MSSQLNamespace

pysqlsync/dialect/mysql/connection.py

@@ -0,0 +1,126 @@
+import logging
+import ssl
+import typing
+from typing import Optional, TypeVar
+
+import aiomysql
+import pymysql
+from strong_typing.inspection import DataclassInstance, is_dataclass_type
+
+from pysqlsync.base import BaseConnection, BaseContext, DataSource
+from pysqlsync.connection import ConnectionSSLMode, create_context
+from pysqlsync.model.data_types import escape_like
+from pysqlsync.model.id_types import LocalId
+from pysqlsync.resultset import resultset_unwrap_dict, resultset_unwrap_tuple
+from pysqlsync.util.typing import override
+
+D = TypeVar("D", bound=DataclassInstance)
+T = TypeVar("T")
+
+LOGGER = logging.getLogger("pysqlsync.mysql")
+
+
+def quoted_id(identifier: str) -> str:
+    return "`" + identifier.replace("`", "``") + "`"
+
+
+class MySQLConnection(BaseConnection):
+    native: aiomysql.Connection
+
+    @override
+    async def open(self) -> BaseContext:
+        LOGGER.info("connecting to %s (with aiomysql)", self.params)
+
+        ssl_mode = self.params.ssl
+        if ssl_mode is None or ssl_mode is ConnectionSSLMode.disable:
+            return await self._open()
+        elif ssl_mode is ConnectionSSLMode.prefer:
+            try:
+                return await self._open(create_context(ssl_mode))
+            except pymysql.err.OperationalError:
+                return await self._open()
+        elif ssl_mode is ConnectionSSLMode.allow:
+            try:
+                return await self._open()
+            except pymysql.err.OperationalError:
+                return await self._open(create_context(ssl_mode))
+        elif ssl_mode is ConnectionSSLMode.require or ssl_mode is ConnectionSSLMode.verify_ca or ssl_mode is ConnectionSSLMode.verify_full:
+            return await self._open(create_context(ssl_mode))
+        else:
+            raise ValueError(f"unsupported SSL mode: {ssl_mode}")
+
+    async def _open(self, ctx: Optional[ssl.SSLContext] = None) -> BaseContext:
+        sql_mode = ",".join(
+            [
+                "ANSI_QUOTES",
+                "NO_AUTO_VALUE_ON_ZERO",
+                "STRICT_ALL_TABLES",
+            ]
+        )
+        self.native = await aiomysql.connect(
+            host=self.params.host or "localhost",
+            port=self.params.port or 3306,
+            user=self.params.username,
+            password=self.params.password or "",
+            db=self.params.database,
+            sql_mode=f"'{sql_mode}'",
+            init_command='SET @@session.time_zone = "+00:00";',
+            autocommit=True,
+            ssl=ctx,
+        )
+        return MySQLContext(self)
+
+    @override
+    async def close(self) -> None:
+        self.native.close()
+
+
+class MySQLContext(BaseContext):
+    def __init__(self, connection: MySQLConnection) -> None:
+        super().__init__(connection)
+
+    @property
+    def native_connection(self) -> aiomysql.Connection:
+        return typing.cast(MySQLConnection, self.connection).native
+
+    @override
+    async def _execute(self, statement: str) -> None:
+        async with self.native_connection.cursor() as cur:
+            await cur.execute(statement)
+
+    @override
+    async def _execute_all(self, statement: str, source: DataSource) -> None:
+        async for batch in source.batches():
+            async with self.native_connection.cursor() as cur:
+                await cur.executemany(statement, batch)
+
+    @override
+    async def _query_all(self, signature: type[T], statement: str) -> list[T]:
+        if is_dataclass_type(signature):
+            cur = await self.native_connection.cursor(aiomysql.cursors.DictCursor)
+            await cur.execute(statement)
+            records = await cur.fetchall()
+            return resultset_unwrap_dict(signature, records)  # type: ignore
+        else:
+            cur = await self.native_connection.cursor()
+            await cur.execute(statement)
+            records = await cur.fetchall()
+            return resultset_unwrap_tuple(signature, records)
+
+    @override
+    async def current_schema(self) -> Optional[str]:
+        return None
+
+    @override
+    async def drop_schema(self, namespace: LocalId) -> None:
+        LOGGER.debug("drop schema: %s", namespace)
+
+        tables = await self.query_all(
+            str,
+            "SELECT table_name\n"
+            "FROM information_schema.tables\n"
+            f"WHERE table_schema = DATABASE() AND table_name LIKE '{escape_like(namespace.id, '~')}~_~_%' ESCAPE '~';",
+        )
+        if tables:
+            table_list = ", ".join(quoted_id(table) for table in tables)
+            await self.execute(f"DROP TABLE IF EXISTS {table_list};")

pysqlsync/dialect/mysql/data_types.py

@@ -0,0 +1,40 @@
+from pysqlsync.model.data_types import SqlTimestampType, SqlVariableBinaryType, SqlVariableCharacterType
+
+
+class MySQLDateTimeType(SqlTimestampType):
+    def __str__(self) -> str:
+        if self.precision is not None:
+            precision = f"({self.precision})"
+        else:
+            precision = ""
+        return f"datetime{precision}"
+
+
+class MySQLVariableCharacterType(SqlVariableCharacterType):
+    def __str__(self) -> str:
+        if self.limit is None:
+            return "mediumtext"
+
+        if self.limit < 65536:
+            return f"varchar({self.limit})"
+        elif self.limit < 16777216:
+            return "mediumtext"
+        elif self.limit < 4294967296:
+            return "longtext"
+        else:
+            raise ValueError(f"character count exceeds maximum: {self.limit}")
+
+
+class MySQLVariableBinaryType(SqlVariableBinaryType):
+    def __str__(self) -> str:
+        if self.storage is None:
+            return "mediumblob"
+
+        if self.storage < 65536:
+            return f"varbinary({self.storage})"
+        elif self.storage < 16777216:
+            return "mediumblob"
+        elif self.storage < 4294967296:
+            return "longblob"
+        else:
+            raise ValueError(f"storage size exceeds maximum: {self.storage}")

pysqlsync/dialect/mysql/dependency.py

@@ -0,0 +1,10 @@
+"""
+pysqlsync: Synchronize schema and large volumes of data.
+
+This module defines dependencies required for MySQL.
+
+:see: https://github.com/instructure-internal/pysqlsync
+"""
+
+import aiomysql  # pyright: ignore[reportUnusedImport] # noqa: F401
+import cryptography  # pyright: ignore[reportUnusedImport] # noqa: F401

pysqlsync/dialect/mysql/discovery.py

@@ -0,0 +1,145 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from pysqlsync.base import BaseContext
+from pysqlsync.formation.constraints import ForeignFactory
+from pysqlsync.formation.data_types import SqlDiscovery, SqlDiscoveryOptions
+from pysqlsync.formation.discovery import AnsiColumnMeta, AnsiConstraintMeta, AnsiExplorer
+from pysqlsync.formation.object_types import Column, ForeignConstraint, Namespace
+from pysqlsync.model.data_types import quote
+from pysqlsync.model.id_types import LocalId, PrefixedId, SupportsQualifiedId
+from pysqlsync.util.typing import override
+
+from .data_types import MySQLDateTimeType, MySQLVariableBinaryType, MySQLVariableCharacterType
+from .object_types import MySQLObjectFactory
+
+
+@dataclass
+class MySQLColumnMeta(AnsiColumnMeta):
+    column_type: str
+    extra: str
+    column_comment: str
+
+
+class MySQLExplorer(AnsiExplorer):
+    def __init__(self, conn: BaseContext) -> None:
+        super().__init__(
+            conn,
+            SqlDiscovery(
+                SqlDiscoveryOptions(
+                    substitutions={
+                        "datetime": MySQLDateTimeType(),
+                        "varchar": MySQLVariableCharacterType(),
+                        "tinytext": MySQLVariableCharacterType(limit=255),
+                        "text": MySQLVariableCharacterType(limit=65535),
+                        "mediumtext": MySQLVariableCharacterType(limit=16777215),
+                        "longtext": MySQLVariableCharacterType(limit=4294967295),
+                        "varbinary": MySQLVariableBinaryType(),
+                        "tinyblob": MySQLVariableBinaryType(storage=255),
+                        "blob": MySQLVariableBinaryType(storage=65535),
+                        "mediumblob": MySQLVariableBinaryType(storage=16777215),
+                        "longblob": MySQLVariableBinaryType(storage=4294967295),
+                    }
+                )
+            ),
+            MySQLObjectFactory(),
+        )
+
+    @override
+    def get_qualified_id(self, namespace: Optional[str], id: str) -> SupportsQualifiedId:
+        return PrefixedId(namespace, id)
+
+    def split_composite_id(self, name: str) -> SupportsQualifiedId:
+        if "__" in name:
+            parts = name.split("__", 1)
+            return PrefixedId(parts[0], parts[1])
+        else:
+            return PrefixedId(None, name)
+
+    async def get_columns(self, table_id: SupportsQualifiedId) -> list[Column]:
+        column_meta = await self.conn.query_all(
+            MySQLColumnMeta,
+            "SELECT\n"
+            "    column_name AS column_name,\n"
+            "    data_type AS data_type,\n"
+            "    CASE WHEN is_nullable = 'YES' THEN 1 ELSE 0 END AS nullable,\n"
+            "    column_default AS column_default,\n"
+            "    character_maximum_length AS character_maximum_length,\n"
+            "    numeric_precision AS numeric_precision,\n"
+            "    numeric_scale AS numeric_scale,\n"
+            "    datetime_precision AS datetime_precision,\n"
+            "    column_type AS column_type,\n"
+            "    extra AS extra,\n"
+            "    column_comment AS column_comment\n"
+            "FROM information_schema.columns AS col\n"
+            f"WHERE {self._where_table(table_id, 'col')}\n"
+            "ORDER BY ordinal_position",
+        )
+
+        columns: list[Column] = []
+        for col in column_meta:
+            columns.append(
+                self.factory.column_class(
+                    LocalId(col.column_name),
+                    self.discovery.sql_data_type_from_spec(
+                        type_name=col.data_type,
+                        type_def=col.column_type,
+                        character_maximum_length=col.character_maximum_length,
+                        numeric_precision=col.numeric_precision,
+                        numeric_scale=col.numeric_scale,
+                        datetime_precision=col.datetime_precision,
+                    ),
+                    bool(col.nullable),
+                    default=col.column_default,
+                    identity="auto_increment" in col.extra,
+                    description=col.column_comment or None,
+                )
+            )
+        return columns
+
+    async def get_referential_constraints(self, table_id: SupportsQualifiedId) -> list[ForeignConstraint]:
+        constraint_meta = await self.conn.query_all(
+            AnsiConstraintMeta,
+            "SELECT\n"
+            "    kcu.constraint_name AS fk_constraint_name,\n"
+            "    kcu.table_schema AS fk_table_schema,\n"
+            "    kcu.table_name AS fk_table_name,\n"
+            "    kcu.column_name AS fk_column_name,\n"
+            "    kcu.ordinal_position AS fk_ordinal_position,\n"
+            "    'PRIMARY' AS uq_constraint_name,\n"
+            "    kcu.referenced_table_schema AS uq_table_schema,\n"
+            "    kcu.referenced_table_name AS uq_table_name,\n"
+            "    kcu.referenced_column_name AS uq_column_name,\n"
+            "    kcu.ordinal_position AS uq_ordinal_position\n"
+            "FROM information_schema.referential_constraints AS ref\n"
+            "    INNER JOIN information_schema.key_column_usage AS kcu\n"
+            "        ON kcu.constraint_catalog = ref.constraint_catalog\n"
+            "            AND kcu.constraint_schema = ref.constraint_schema\n"
+            "            AND kcu.constraint_name = ref.constraint_name\n"
+            f"WHERE ref.table_name = {quote(table_id.local_id)} AND {self._where_table(table_id, 'kcu')}\n",
+        )
+
+        constraints = ForeignFactory()
+        for con in constraint_meta:
+            constraints.add(
+                con.fk_constraint_name,
+                LocalId(con.fk_column_name),
+                self.split_composite_id(con.uq_table_name),
+                LocalId(con.uq_column_name),
+            )
+        return constraints.fetch()
+
+    async def get_table_description(self, table_id: SupportsQualifiedId) -> Optional[str]:
+        return (
+            await self.conn.query_one(
+                str,
+                f"SELECT table_comment\nFROM information_schema.tables AS tab\nWHERE {self._where_table(table_id, 'tab')}",
+            )
+            or None
+        )
+
+    async def get_namespace_current(self) -> Namespace:
+        return await self.get_namespace_flat()
+
+    async def get_namespace(self, namespace_id: LocalId) -> Namespace:
+        return await self.get_namespace_flat(namespace_id)

pysqlsync/dialect/mysql/engine.py

@@ -0,0 +1,20 @@
+from pysqlsync.base import BaseConnection, BaseEngine, BaseGenerator, Explorer
+
+from .connection import MySQLConnection
+from .discovery import MySQLExplorer
+from .generator import MySQLGenerator
+
+
+class MySQLEngine(BaseEngine):
+    @property
+    def name(self) -> str:
+        return "mysql"
+
+    def get_generator_type(self) -> type[BaseGenerator]:
+        return MySQLGenerator
+
+    def get_connection_type(self) -> type[BaseConnection]:
+        return MySQLConnection
+
+    def get_explorer_type(self) -> type[Explorer]:
+        return MySQLExplorer

pysqlsync/dialect/mysql/generator.py

@@ -0,0 +1,140 @@
+import datetime
+import ipaddress
+import uuid
+from typing import Any, Callable, Optional
+
+from pysqlsync.base import BaseGenerator, GeneratorOptions
+from pysqlsync.formation.inspection import is_ip_address_type
+from pysqlsync.formation.object_types import Column, Table
+from pysqlsync.formation.py_to_sql import ArrayMode, DataclassConverter, DataclassConverterOptions, EnumMode, NamespaceMapping, StructMode
+from pysqlsync.model.data_types import SqlFixedBinaryType, SqlIntegerType
+from pysqlsync.model.id_types import LocalId
+from pysqlsync.util.typing import override
+
+from .data_types import MySQLDateTimeType, MySQLVariableCharacterType
+from .mutation import MySQLMutator
+from .object_types import MySQLObjectFactory
+
+
+class MySQLGenerator(BaseGenerator):
+    """
+    Generator for MySQL.
+
+    Assumes configuration `ANSI_QUOTES` and `SET @@session.time_zone = "+00:00"`.
+    """
+
+    def __init__(self, options: GeneratorOptions) -> None:
+        super().__init__(options, MySQLObjectFactory(), MySQLMutator(options.synchronization))
+
+        self.check_enum_mode(exclude=[EnumMode.TYPE])
+        self.check_struct_mode(matches=StructMode.JSON)
+        self.check_array_mode(include=[ArrayMode.JSON, ArrayMode.RELATION])
+
+        self.converter = DataclassConverter(
+            options=DataclassConverterOptions(
+                enum_mode=options.enum_mode or EnumMode.INLINE,
+                struct_mode=options.struct_mode or StructMode.JSON,
+                array_mode=options.array_mode or ArrayMode.JSON,
+                qualified_names=False,
+                namespaces=NamespaceMapping(options.namespaces),
+                foreign_constraints=options.foreign_constraints,
+                initialize_tables=options.initialize_tables,
+                substitutions={
+                    bool: SqlIntegerType(1),
+                    datetime.datetime: MySQLDateTimeType(),
+                    uuid.UUID: SqlFixedBinaryType(16),
+                    str: MySQLVariableCharacterType(16777215),
+                    ipaddress.IPv4Address: SqlFixedBinaryType(4),
+                    ipaddress.IPv6Address: SqlFixedBinaryType(16),
+                },
+                factory=self.factory,
+                skip_annotations=options.skip_annotations,
+            )
+        )
+
+    @override
+    def get_current_schema_stmt(self) -> str:
+        return "DATABASE()"
+
+    @override
+    def placeholder(self, index: int) -> str:
+        return r"%s"
+
+    @override
+    def get_table_insert_stmt(self, table: Table, order: Optional[tuple[str, ...]] = None) -> str:
+        statements: list[str] = []
+        statements.append(f"INSERT INTO {table.name}")
+        columns = [column for column in table.get_columns(order) if not column.identity]
+        column_list = ", ".join(str(column.name) for column in columns)
+        value_list = ", ".join("%s" for _column in columns)
+        statements.append(f"({column_list}) VALUES ({value_list})")
+        statements.append(";")
+        return "\n".join(statements)
+
+    @override
+    def get_table_merge_stmt(self, table: Table, order: Optional[tuple[str, ...]] = None) -> str:
+        statements: list[str] = []
+        statements.append(f"INSERT INTO {table.name}")
+        columns = [column for column in table.get_columns(order) if not column.identity]
+        column_list = ", ".join(str(column.name) for column in columns)
+        value_list = ", ".join("%s" for _column in columns)
+        statements.append(f"({column_list}) VALUES ({value_list})")
+        statements.append("ON DUPLICATE KEY UPDATE")
+        defs = [f"{key} = {key}" for key in table.primary_key]
+        statements.append(",\n".join(defs))
+        statements.append(";")
+        return "\n".join(statements)
+
+    @override
+    def get_table_upsert_stmt(self, table: Table, order: Optional[tuple[str, ...]] = None) -> str:
+        statements: list[str] = []
+        statements.append(f"INSERT INTO {table.name}")
+        columns = [column for column in table.get_columns(order)]
+        statements.append(_field_list([column.name for column in columns]))
+        statements.append("ON DUPLICATE KEY UPDATE")
+        value_columns = table.get_value_columns()
+        if value_columns:
+            defs = [_field_update(column.name) for column in value_columns]
+        else:
+            defs = [_field_update(key) for key in table.primary_key]
+        statements.append(",\n".join(defs))
+        statements.append(";")
+        return "\n".join(statements)
+
+    @override
+    def get_field_extractor(self, column: Column, field_name: str, field_type: type) -> Callable[[Any], Any]:
+        if field_type is uuid.UUID:
+            return lambda obj: getattr(obj, field_name).bytes
+        elif is_ip_address_type(field_type):
+            return lambda obj: getattr(obj, field_name).packed
+
+        return super().get_field_extractor(column, field_name, field_type)
+
+    @override
+    def get_value_transformer(self, column: Column, field_type: type) -> Optional[Callable[[Any], Any]]:
+        if field_type is uuid.UUID:
+            return lambda field: field.bytes
+        elif is_ip_address_type(field_type):
+            return lambda field: field.packed
+
+        return super().get_value_transformer(column, field_type)
+
+
+def _field_list(field_ids: list[LocalId]) -> str:
+    field_list = ", ".join(str(field_id) for field_id in field_ids)
+    value_list = ", ".join("%s" for _ in field_ids)
+    if False:
+        # compatible with MySQL 8.0.19 and later, slow with aiomysql 0.2.0 and earlier
+        return f"({field_list}) VALUES ({value_list}) AS EXCLUDED"  # type: ignore[unreachable]
+    else:
+        # emits a warning with MySQL 8.0.20 and later
+        return f"({field_list}) VALUES ({value_list})"
+
+
+def _field_update(field_id: LocalId) -> str:
+    if False:
+        # compatible with MySQL 8.0.19 and later, slow with aiomysql 0.2.0 and earlier
+        return f"{field_id} = EXCLUDED.{field_id}"  # type: ignore[unreachable]
+    else:
+        # emits a warning with MySQL 8.0.20 and later
+        return f"{field_id} = VALUES({field_id})"