sqlspec 0.46.2__py3-none-any.whl → 0.47.0__py3-none-any.whl

sqlspec/_typing.py

@@ -1,5 +1,10 @@
 # ruff: noqa: RUF100, PLR0913, A002, DOC201, PLR6301, PLR0917, ARG004, ARG002, ARG001
-"""Wrapper around library classes for compatibility when libraries are installed."""
+"""Private implementation for SQLSpec typing and optional dependency shims.
+
+Public consumers should import from :mod:`sqlspec.typing`. This module is kept
+private because it centralizes optional dependency fallbacks, compatibility
+aliases, and mypyc-excluded type boundaries used by the package internals.
+"""
 
 import enum
 from collections.abc import Iterable, Mapping
@@ -150,6 +155,11 @@ def convert_stub(  # noqa: PLR0913
     return {}
 
 
+def msgspec_fields_stub(type_: Any, /) -> "tuple[Any, ...]":  # noqa: ARG001
+    """Placeholder implementation."""
+    return ()
+
+
 class UnsetTypeStub(enum.Enum):
     UNSET = "UNSET"
 
@@ -162,16 +172,19 @@ try:
     from msgspec import Struct as _RealStruct
     from msgspec import UnsetType as _RealUnsetType
     from msgspec import convert as _real_convert
+    from msgspec.structs import fields as _real_msgspec_fields
 
     Struct = _RealStruct
     UnsetType = _RealUnsetType
     UNSET = _REAL_UNSET
     convert = _real_convert
+    msgspec_fields = _real_msgspec_fields
 except ImportError:
     Struct = StructStub  # type: ignore[assignment,misc]
     UnsetType = UnsetTypeStub  # type: ignore[assignment,misc]
     UNSET = UNSET_STUB  # type: ignore[assignment] # pyright: ignore[reportConstantRedefinition]
     convert = convert_stub
+    msgspec_fields = msgspec_fields_stub  # type: ignore[assignment]
 
 
 try:
@@ -695,5 +708,7 @@ __all__ = (
     "convert",
     "convert_stub",
     "module_available",
+    "msgspec_fields",
+    "msgspec_fields_stub",
     "trace",
 )

sqlspec/adapters/adbc/adk/store.py

@@ -714,12 +714,14 @@ class AdbcADKStore(BaseAsyncADKStore["AdbcConfig"]):
 
     def _append_event_and_update_state(
         self, event_record: "EventRecord", session_id: str, state: "dict[str, Any]"
-    ) -> None:
+    ) -> SessionRecord:
         """Atomically insert an event and update the session's durable state.
 
-        The event insert and state update are executed within a single
-        connection and committed together.  If either statement fails the
-        transaction is rolled back so the two writes remain consistent.
+        The event insert, state update, and refresh-SELECT are executed within
+        a single connection and committed together.  ADBC drivers wrap a
+        variety of backends (Postgres, SQLite, DuckDB, ...) so we use a
+        SELECT-after-UPDATE rather than relying on RETURNING which not every
+        backend supports.
 
         Args:
             event_record: Event record to store.
@@ -737,6 +739,11 @@ class AdbcADKStore(BaseAsyncADKStore["AdbcConfig"]):
         SET state = ?, update_time = CURRENT_TIMESTAMP
         WHERE id = ?
         """
+        select_sql = f"""
+        SELECT id, app_name, user_id, state, create_time, update_time
+        FROM {self._session_table}
+        WHERE id = ?
+        """
         state_json = self._serialize_state(state)
         event_json = self._serialize_json_field(event_record["event_json"])
 
@@ -754,6 +761,8 @@ class AdbcADKStore(BaseAsyncADKStore["AdbcConfig"]):
                     ),
                 )
                 cursor.execute(update_sql, (state_json, session_id))
+                cursor.execute(select_sql, (session_id,))
+                row = cursor.fetchone()
                 conn.commit()
             except Exception:
                 with contextlib.suppress(Exception):
@@ -762,11 +771,24 @@ class AdbcADKStore(BaseAsyncADKStore["AdbcConfig"]):
             finally:
                 cursor.close()
 
+        if row is None:
+            msg = f"Session {session_id} not found during append_event_and_update_state."
+            raise ValueError(msg)
+
+        return SessionRecord(
+            id=row[0],
+            app_name=row[1],
+            user_id=row[2],
+            state=self._deserialize_state(row[3]),
+            create_time=row[4],
+            update_time=row[5],
+        )
+
     async def append_event_and_update_state(
         self, event_record: EventRecord, session_id: str, state: "dict[str, Any]"
-    ) -> None:
+    ) -> SessionRecord:
         """Atomically append an event and update the session's durable state."""
-        await async_(self._append_event_and_update_state)(event_record, session_id, state)
+        return await async_(self._append_event_and_update_state)(event_record, session_id, state)
 
     def _get_events(
         self, session_id: str, after_timestamp: "datetime | None" = None, limit: "int | None" = None

sqlspec/adapters/adbc/data_dictionary.py

@@ -11,6 +11,14 @@ from sqlspec.data_dictionary import (
     list_registered_dialects,
     normalize_dialect_name,
 )
+from sqlspec.data_dictionary.dialects.bigquery import (
+    format_bigquery_information_schema_tables,
+    format_bigquery_schema_prefix,
+)
+from sqlspec.data_dictionary.dialects.cockroachdb import resolve_cockroachdb_json_type
+from sqlspec.data_dictionary.dialects.mysql import resolve_mysql_json_type
+from sqlspec.data_dictionary.dialects.postgres import resolve_postgres_json_type
+from sqlspec.data_dictionary.dialects.sqlite import resolve_sqlite_json_type
 from sqlspec.driver import SyncDataDictionaryBase
 from sqlspec.exceptions import SQLFileNotFoundError
 from sqlspec.typing import ColumnMetadata, ForeignKeyMetadata, IndexMetadata, TableMetadata, VersionInfo
@@ -138,8 +146,17 @@ class AdbcDataDictionary(SyncDataDictionaryBase):
             return self.get_default_type_mapping().get(type_category, "TEXT")
 
         if type_category == "json":
-            json_version = config.get_feature_version("supports_json")
             version_info = self.get_version(driver)
+            if dialect == "postgres":
+                return resolve_postgres_json_type(version_info)
+            if dialect == "sqlite":
+                return resolve_sqlite_json_type(version_info)
+            if dialect == "mysql":
+                return resolve_mysql_json_type(version_info)
+            if dialect == "cockroachdb":
+                return resolve_cockroachdb_json_type(version_info)
+
+            json_version = config.get_feature_version("supports_json")
             if json_version and (version_info is None or version_info < json_version):
                 return "TEXT"
 
@@ -152,14 +169,7 @@ class AdbcDataDictionary(SyncDataDictionaryBase):
         self._log_schema_introspect(driver, schema_name=schema_name, table_name=None, operation="tables")
 
         if dialect == "bigquery":
-            if schema_name:
-                tables_table = f"`{schema_name}.INFORMATION_SCHEMA.TABLES`"
-                kcu_table = f"`{schema_name}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE`"
-                rc_table = f"`{schema_name}.INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS`"
-            else:
-                tables_table = "INFORMATION_SCHEMA.TABLES"
-                kcu_table = "INFORMATION_SCHEMA.KEY_COLUMN_USAGE"
-                rc_table = "INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS"
+            tables_table, kcu_table, rc_table = format_bigquery_information_schema_tables(schema_name)
             query_text = self._get_query_text(dialect, "tables_by_schema").format(
                 tables_table=tables_table, kcu_table=kcu_table, rc_table=rc_table
             )
@@ -186,7 +196,7 @@ class AdbcDataDictionary(SyncDataDictionaryBase):
             self._log_table_describe(driver, schema_name=schema_name, table_name=table, operation="columns")
 
         if dialect == "bigquery":
-            schema_prefix = f"`{schema_name}`." if schema_name else ""
+            schema_prefix = format_bigquery_schema_prefix(schema_name)
             if table is None:
                 query_text = self._get_query_text(dialect, "columns_by_schema").format(schema_prefix=schema_prefix)
                 return driver.select(query_text, schema_name=schema_name, schema_type=ColumnMetadata)
@@ -293,12 +303,7 @@ class AdbcDataDictionary(SyncDataDictionaryBase):
             self._log_table_describe(driver, schema_name=schema_name, table_name=table, operation="foreign_keys")
 
         if dialect == "bigquery":
-            if schema_name:
-                kcu_table = f"`{schema_name}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE`"
-                rc_table = f"`{schema_name}.INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS`"
-            else:
-                kcu_table = "INFORMATION_SCHEMA.KEY_COLUMN_USAGE"
-                rc_table = "INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS"
+            _, kcu_table, rc_table = format_bigquery_information_schema_tables(schema_name)
             if table is None:
                 query_text = self._get_query_text(dialect, "foreign_keys_by_schema").format(
                     kcu_table=kcu_table, rc_table=rc_table

sqlspec/adapters/aiomysql/adk/store.py

@@ -346,11 +346,12 @@ class AiomysqlADKStore(BaseAsyncADKStore["AiomysqlConfig"]):
 
     async def append_event_and_update_state(
         self, event_record: EventRecord, session_id: str, state: "dict[str, Any]"
-    ) -> None:
+    ) -> SessionRecord:
         """Atomically append an event and update the session's durable state.
 
-        The event insert and state update succeed together or fail together
-        within a single transaction.
+        MySQL doesn't support UPDATE...RETURNING; we follow the UPDATE with a
+        SELECT inside the same transaction so callers get the refreshed row
+        in a single round-trip pair (no separate connection acquisition).
 
         Args:
             event_record: Event record to store.
@@ -373,6 +374,12 @@ class AiomysqlADKStore(BaseAsyncADKStore["AiomysqlConfig"]):
         WHERE id = %s
         """
 
+        select_sql = f"""
+        SELECT id, app_name, user_id, state, create_time, update_time
+        FROM {self._session_table}
+        WHERE id = %s
+        """
+
         async with (
             self._config.provide_connection() as conn,
             AiomysqlCursor(conn, cursor_class=AiomysqlRawCursor) as cursor,
@@ -388,8 +395,24 @@ class AiomysqlADKStore(BaseAsyncADKStore["AiomysqlConfig"]):
                 ),
             )
             await cursor.execute(update_sql, (state_json, session_id))
+            await cursor.execute(select_sql, (session_id,))
+            row = await cursor.fetchone()
             await conn.commit()
 
+        if row is None:
+            msg = f"Session {session_id} not found during append_event_and_update_state."
+            raise ValueError(msg)
+
+        state_value = row[3]
+        return SessionRecord(
+            id=row[0],
+            app_name=row[1],
+            user_id=row[2],
+            state=from_json(state_value) if isinstance(state_value, str) else state_value,
+            create_time=row[4],
+            update_time=row[5],
+        )
+
     async def get_events(
         self, session_id: str, after_timestamp: "datetime | None" = None, limit: "int | None" = None
     ) -> "list[EventRecord]":

sqlspec/adapters/aiomysql/config.py

@@ -253,10 +253,6 @@ class AiomysqlConfig(AsyncDatabaseConfig[AiomysqlConnection, "AiomysqlPool", Aio
             await self.connection_instance.wait_closed()
             self.connection_instance = None
 
-    async def close_pool(self) -> None:
-        """Close the connection pool."""
-        await self._close_pool()
-
     async def create_connection(self) -> AiomysqlConnection:
         """Create a single async connection (not from pool).
 

sqlspec/adapters/aiomysql/core.py

@@ -22,7 +22,7 @@ from sqlspec.exceptions import (
 )
 from sqlspec.utils.serializers import from_json, to_json
 from sqlspec.utils.type_converters import build_uuid_coercions
-from sqlspec.utils.type_guards import has_cursor_metadata, has_lastrowid, has_rowcount, has_sqlstate
+from sqlspec.utils.type_guards import has_cursor_metadata, has_lastrowid, has_rowcount
 
 if TYPE_CHECKING:
     from collections.abc import Mapping, Sequence
@@ -67,6 +67,50 @@ MYSQL_CR_CONN_HOST_ERROR = 2003
 MYSQL_CR_UNKNOWN_HOST = 2005
 MYSQL_CR_SERVER_GONE_ERROR = 2006
 MYSQL_CR_SERVER_LOST = 2013
+MYSQL_SYNTAX_ERROR_MIN = 1064
+MYSQL_SYNTAX_ERROR_MAX_EXCLUSIVE = 1100
+
+_MYSQL_MIGRATION_ERROR_CODES = frozenset((1061, 1091))
+_MYSQL_SQLSTATE_EXACT_DISPATCH: dict[str, tuple[type[SQLSpecError], str]] = {
+    "23505": (UniqueViolationError, "unique constraint violation"),
+    "23503": (ForeignKeyViolationError, "foreign key constraint violation"),
+    "23502": (NotNullViolationError, "not-null constraint violation"),
+    "23514": (CheckViolationError, "check constraint violation"),
+}
+_MYSQL_SQLSTATE_PREFIX_DISPATCH: dict[str, tuple[type[SQLSpecError], str]] = {
+    "23": (IntegrityError, "integrity constraint violation"),
+    "28": (PermissionDeniedError, "authorization error"),
+    "40": (TransactionError, "transaction error"),
+    "42": (SQLParsingError, "SQL syntax error"),
+    "08": (DatabaseConnectionError, "connection error"),
+    "22": (DataError, "data error"),
+}
+_MYSQL_CONSTRAINT_ERROR_DISPATCH: dict[int, tuple[type[SQLSpecError], str]] = {
+    MYSQL_ER_DUP_ENTRY: (UniqueViolationError, "unique constraint violation"),
+    1216: (ForeignKeyViolationError, "foreign key constraint violation"),
+    1217: (ForeignKeyViolationError, "foreign key constraint violation"),
+    1451: (ForeignKeyViolationError, "foreign key constraint violation"),
+    1452: (ForeignKeyViolationError, "foreign key constraint violation"),
+    1048: (NotNullViolationError, "not-null constraint violation"),
+    MYSQL_ER_NO_DEFAULT_FOR_FIELD: (NotNullViolationError, "not-null constraint violation"),
+    MYSQL_ER_CHECK_CONSTRAINT_VIOLATED: (CheckViolationError, "check constraint violation"),
+}
+_MYSQL_ACCESS_ERROR_DISPATCH: dict[int, tuple[type[SQLSpecError], str]] = {
+    MYSQL_ER_DBACCESS_DENIED: (PermissionDeniedError, "access denied"),
+    MYSQL_ER_ACCESS_DENIED: (PermissionDeniedError, "access denied"),
+    MYSQL_ER_TABLEACCESS_DENIED: (PermissionDeniedError, "access denied"),
+}
+_MYSQL_TRANSACTION_ERROR_DISPATCH: dict[int, tuple[type[SQLSpecError], str]] = {
+    MYSQL_ER_LOCK_DEADLOCK: (DeadlockError, "deadlock detected"),
+    MYSQL_ER_LOCK_WAIT_TIMEOUT: (QueryTimeoutError, "lock wait timeout"),
+}
+_MYSQL_CONNECTION_ERROR_DISPATCH: dict[int, tuple[type[SQLSpecError], str]] = {
+    MYSQL_CR_SERVER_LOST: (ConnectionTimeoutError, "connection lost"),
+    MYSQL_CR_CONNECTION_ERROR: (DatabaseConnectionError, "connection error"),
+    MYSQL_CR_CONN_HOST_ERROR: (DatabaseConnectionError, "connection error"),
+    MYSQL_CR_UNKNOWN_HOST: (DatabaseConnectionError, "connection error"),
+    MYSQL_CR_SERVER_GONE_ERROR: (DatabaseConnectionError, "connection error"),
+}
 
 
 def _bool_to_int(value: bool) -> int:
@@ -210,66 +254,60 @@ def create_mapped_exception(error: Any, *, logger: Any | None = None) -> "SQLSpe
     Returns:
         True to suppress expected migration errors, or a SQLSpec exception
     """
-    error_code = error.args[0] if len(error.args) >= 1 and isinstance(error.args[0], int) else None
-    sqlstate_attr = error.sqlstate if has_sqlstate(error) else None
-    sqlstate = sqlstate_attr if sqlstate_attr is not None else None
+    error_args = getattr(error, "args", ())
+    error_code = error_args[0] if error_args and isinstance(error_args[0], int) else None
+    sqlstate_attr = getattr(error, "sqlstate", None)
+    sqlstate = sqlstate_attr if isinstance(sqlstate_attr, str) else None
+    sqlstate_prefix = sqlstate[:2] if isinstance(sqlstate, str) and sqlstate else None
 
     # Migration-specific errors to suppress
-    if error_code in {1061, 1091}:
+    if error_code in _MYSQL_MIGRATION_ERROR_CODES:
         if logger is not None:
             logger.warning("aiomysql MySQL expected migration error (ignoring): %s", error)
         return True
 
-    # Integrity constraint violations
-    if sqlstate == "23505" or error_code == MYSQL_ER_DUP_ENTRY:
-        return _create_mysql_error(error, sqlstate, error_code, UniqueViolationError, "unique constraint violation")
-    if sqlstate == "23503" or error_code in {1216, 1217, 1451, 1452}:
-        return _create_mysql_error(
-            error, sqlstate, error_code, ForeignKeyViolationError, "foreign key constraint violation"
-        )
-    if sqlstate == "23502" or error_code in {1048, MYSQL_ER_NO_DEFAULT_FOR_FIELD}:
-        return _create_mysql_error(error, sqlstate, error_code, NotNullViolationError, "not-null constraint violation")
-    if sqlstate == "23514" or error_code == MYSQL_ER_CHECK_CONSTRAINT_VIOLATED:
-        return _create_mysql_error(error, sqlstate, error_code, CheckViolationError, "check constraint violation")
-    if sqlstate and sqlstate.startswith("23"):
-        return _create_mysql_error(error, sqlstate, error_code, IntegrityError, "integrity constraint violation")
-
-    # Permission/access errors (check specific codes first)
-    if error_code in {MYSQL_ER_DBACCESS_DENIED, MYSQL_ER_ACCESS_DENIED, MYSQL_ER_TABLEACCESS_DENIED}:
-        return _create_mysql_error(error, sqlstate, error_code, PermissionDeniedError, "access denied")
-    if sqlstate and sqlstate.startswith("28"):
-        return _create_mysql_error(error, sqlstate, error_code, PermissionDeniedError, "authorization error")
-
-    # Transaction errors (deadlock vs lock wait timeout)
-    if error_code == MYSQL_ER_LOCK_DEADLOCK:
-        return _create_mysql_error(error, sqlstate, error_code, DeadlockError, "deadlock detected")
-    if error_code == MYSQL_ER_LOCK_WAIT_TIMEOUT:
-        return _create_mysql_error(error, sqlstate, error_code, QueryTimeoutError, "lock wait timeout")
-    if sqlstate and sqlstate.startswith("40"):
-        return _create_mysql_error(error, sqlstate, error_code, TransactionError, "transaction error")
-
-    # SQL syntax errors
-    if sqlstate and sqlstate.startswith("42"):
-        return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
-    if error_code in range(1064, 1100):
+    dispatch = _MYSQL_SQLSTATE_EXACT_DISPATCH.get(sqlstate) if sqlstate is not None else None
+    if dispatch is not None:
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    dispatch = _MYSQL_CONSTRAINT_ERROR_DISPATCH.get(error_code) if error_code is not None else None
+    if dispatch is not None:
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    if sqlstate_prefix == "23":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["23"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    dispatch = _MYSQL_ACCESS_ERROR_DISPATCH.get(error_code) if error_code is not None else None
+    if dispatch is not None:
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+    if sqlstate_prefix == "28":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["28"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    dispatch = _MYSQL_TRANSACTION_ERROR_DISPATCH.get(error_code) if error_code is not None else None
+    if dispatch is not None:
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+    if sqlstate_prefix == "40":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["40"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    if sqlstate_prefix == "42":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["42"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+    if isinstance(error_code, int) and MYSQL_SYNTAX_ERROR_MIN <= error_code < MYSQL_SYNTAX_ERROR_MAX_EXCLUSIVE:
         return _create_mysql_error(error, sqlstate, error_code, SQLParsingError, "SQL syntax error")
 
-    # Connection errors
-    if sqlstate and sqlstate.startswith("08"):
-        return _create_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
-    if error_code == MYSQL_CR_SERVER_LOST:
-        return _create_mysql_error(error, sqlstate, error_code, ConnectionTimeoutError, "connection lost")
-    if error_code in {
-        MYSQL_CR_CONNECTION_ERROR,
-        MYSQL_CR_CONN_HOST_ERROR,
-        MYSQL_CR_UNKNOWN_HOST,
-        MYSQL_CR_SERVER_GONE_ERROR,
-    }:
-        return _create_mysql_error(error, sqlstate, error_code, DatabaseConnectionError, "connection error")
-
-    # Data errors
-    if sqlstate and sqlstate.startswith("22"):
-        return _create_mysql_error(error, sqlstate, error_code, DataError, "data error")
+    if sqlstate_prefix == "08":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["08"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+    dispatch = _MYSQL_CONNECTION_ERROR_DISPATCH.get(error_code) if error_code is not None else None
+    if dispatch is not None:
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
+
+    if sqlstate_prefix == "22":
+        dispatch = _MYSQL_SQLSTATE_PREFIX_DISPATCH["22"]
+        return _create_mysql_error(error, sqlstate, error_code, dispatch[0], dispatch[1])
 
     return _create_mysql_error(error, sqlstate, error_code, SQLSpecError, "database error")
 

sqlspec/adapters/aiomysql/data_dictionary.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING, ClassVar
 
 from mypy_extensions import mypyc_attr
 
+from sqlspec.data_dictionary.dialects.mysql import resolve_mysql_json_type
 from sqlspec.driver import AsyncDataDictionaryBase
 from sqlspec.typing import ColumnMetadata, ForeignKeyMetadata, IndexMetadata, TableMetadata, VersionInfo
 
@@ -56,10 +57,7 @@ class AiomysqlDataDictionary(AsyncDataDictionaryBase):
         version_info = await self.get_version(driver)
 
         if type_category == "json":
-            json_version = config.get_feature_version("supports_json")
-            if version_info and json_version and version_info >= json_version:
-                return "JSON"
-            return "TEXT"
+            return resolve_mysql_json_type(version_info)
 
         return config.get_optimal_type(type_category)
 

sqlspec/adapters/aiomysql/driver.py

@@ -306,9 +306,14 @@ class AiomysqlDriver(AsyncDriverAdapterBase):
         columns, records = self._arrow_table_to_rows(arrow_table)
         if records:
             insert_sql = build_insert_statement(table, columns)
+            prepared_records = (
+                self.prepare_driver_parameters(records, self.statement_config, is_many=True)
+                if self._arrow_table_needs_parameter_preparation(arrow_table)
+                else records
+            )
             exc_handler = self.handle_database_exceptions()
             async with exc_handler, self.with_cursor(self.connection) as cursor:
-                await cursor.executemany(insert_sql, records)
+                await cursor.executemany(insert_sql, prepared_records)
             if exc_handler.pending_exception is not None:
                 raise exc_handler.pending_exception from None