sqlspec 0.13.0__tar.gz → 0.14.0__tar.gz

{sqlspec-0.13.0 → sqlspec-0.14.0}/.gitignore

@@ -50,3 +50,7 @@ GEMINI.*.md
 .cursorrules
 CLAUDE*.md
 *CLAUDE*.md
+requirements/*
+tools/*.json
+benchmarks/
+.benchmark

{sqlspec-0.13.0 → sqlspec-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.13.0
+Version: 0.14.0
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/

{sqlspec-0.13.0 → sqlspec-0.14.0}/pyproject.toml

@@ -7,7 +7,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.9, <4.0"
-version = "0.13.0"
+version = "0.14.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -48,6 +48,7 @@ uuid = ["uuid-utils"]
 
 
 [dependency-groups]
+benchmarks = ["sqlalchemy", "psutil", "types-psutil"]
 build = ["bump-my-version"]
 dev = [
   { include-group = "extras" },
@@ -55,6 +56,7 @@ dev = [
   { include-group = "doc" },
   { include-group = "test" },
   { include-group = "build" },
+  { include-group = "benchmarks" },
 ]
 doc = [
   "auto-pytabs[sphinx]>=0.5.0",
@@ -106,6 +108,9 @@ test = [
   "pytest-xdist>=3.6.1",
 ]
 
+[project.scripts]
+sqlspec = "sqlspec.cli:run_cli"
+
 [build-system]
 build-backend = "hatchling.build"
 requires = ["hatchling"]
@@ -126,7 +131,7 @@ packages = ["sqlspec"]
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.13.0"
+current_version = "0.14.0"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

sqlspec-0.14.0/sqlspec/__init__.py

@@ -0,0 +1,67 @@
+"""SQLSpec: Safe and elegant SQL query building for Python."""
+
+from sqlspec import adapters, base, driver, exceptions, extensions, loader, statement, typing, utils
+from sqlspec.__metadata__ import __version__
+from sqlspec._sql import SQLFactory
+from sqlspec.base import SQLSpec
+from sqlspec.config import AsyncDatabaseConfig, SyncDatabaseConfig
+from sqlspec.exceptions import (
+    NotFoundError,
+    ParameterError,
+    SQLBuilderError,
+    SQLFileNotFoundError,
+    SQLFileParseError,
+    SQLParsingError,
+    SQLValidationError,
+)
+from sqlspec.loader import SQLFile, SQLFileLoader
+from sqlspec.statement.builder import Column, ColumnExpression, Delete, FunctionColumn, Insert, Merge, Select, Update
+from sqlspec.statement.result import ArrowResult, SQLResult
+from sqlspec.statement.sql import SQL, SQLConfig
+from sqlspec.typing import ConnectionT, DictRow, ModelDTOT, ModelT, RowT, StatementParameters
+
+sql = SQLFactory()
+
+__all__ = (
+    "SQL",
+    "ArrowResult",
+    "AsyncDatabaseConfig",
+    "Column",
+    "ColumnExpression",
+    "ConnectionT",
+    "Delete",
+    "DictRow",
+    "FunctionColumn",
+    "Insert",
+    "Merge",
+    "ModelDTOT",
+    "ModelT",
+    "NotFoundError",
+    "ParameterError",
+    "RowT",
+    "SQLBuilderError",
+    "SQLConfig",
+    "SQLFile",
+    "SQLFileLoader",
+    "SQLFileNotFoundError",
+    "SQLFileParseError",
+    "SQLParsingError",
+    "SQLResult",
+    "SQLSpec",
+    "SQLValidationError",
+    "Select",
+    "StatementParameters",
+    "SyncDatabaseConfig",
+    "Update",
+    "__version__",
+    "adapters",
+    "base",
+    "driver",
+    "exceptions",
+    "extensions",
+    "loader",
+    "sql",
+    "statement",
+    "typing",
+    "utils",
+)

{sqlspec-0.13.0 → sqlspec-0.14.0}/sqlspec/adapters/adbc/config.py

@@ -69,41 +69,6 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     - Cloud database integrations
     """
 
-    __slots__ = (
-        "_dialect",
-        "account",
-        "adbc_driver_manager_entrypoint",
-        "authorization_header",
-        "autocommit",
-        "batch_size",
-        "conn_kwargs",
-        "connection_timeout",
-        "database",
-        "dataset_id",
-        "db_kwargs",
-        "default_row_type",
-        "driver_name",
-        "extras",
-        "grpc_options",
-        "isolation_level",
-        "on_connection_create",
-        "password",
-        "pool_instance",
-        "project_id",
-        "query_timeout",
-        "role",
-        "schema",
-        "ssl_ca",
-        "ssl_cert",
-        "ssl_key",
-        "ssl_mode",
-        "statement_config",
-        "token",
-        "uri",
-        "username",
-        "warehouse",
-    )
-
     is_async: ClassVar[bool] = False
     supports_connection_pooling: ClassVar[bool] = False
     driver_type: type[AdbcDriver] = AdbcDriver
@@ -114,7 +79,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("qmark",)
     """ADBC parameter styles depend on the underlying driver."""
 
-    preferred_parameter_style: ClassVar[str] = "qmark"
+    default_parameter_style: ClassVar[str] = "qmark"
     """ADBC default parameter style is ? (qmark)."""
 
     def __init__(
@@ -251,7 +216,6 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
         self.on_connection_create = on_connection_create
-        self._dialect: DialectType = None
         super().__init__()
 
     def _resolve_driver_name(self) -> str:
@@ -381,7 +345,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
         """Get parameter styles based on the underlying driver.
 
         Returns:
-            Tuple of (supported_parameter_styles, preferred_parameter_style)
+            Tuple of (supported_parameter_styles, default_parameter_style)
         """
         try:
             driver_path = self._resolve_driver_name()
@@ -400,7 +364,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
 
         except Exception:
             # If we can't determine driver, use defaults
-            return (self.supported_parameter_styles, self.preferred_parameter_style)
+            return (self.supported_parameter_styles, self.default_parameter_style)
         return (("qmark",), "qmark")
 
     def create_connection(self) -> AdbcConnection:
@@ -467,7 +431,7 @@ class AdbcConfig(NoPoolSyncConfig[AdbcConnection, AdbcDriver]):
                         statement_config = replace(
                             statement_config,
                             allowed_parameter_styles=supported_styles,
-                            target_parameter_style=preferred_style,
+                            default_parameter_style=preferred_style,
                         )
 
                 driver = self.driver_type(connection=connection, config=statement_config)

{sqlspec-0.13.0 → sqlspec-0.14.0}/sqlspec/adapters/adbc/driver.py

@@ -12,12 +12,13 @@ from sqlspec.driver import SyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_sync
 from sqlspec.driver.mixins import (
     SQLTranslatorMixin,
+    SyncAdapterCacheMixin,
     SyncPipelinedExecutionMixin,
     SyncStorageMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.exceptions import wrap_exceptions
 from sqlspec.statement.parameters import ParameterStyle
 from sqlspec.statement.result import ArrowResult, SQLResult
@@ -37,6 +38,7 @@ AdbcConnection = Connection
 
 class AdbcDriver(
     SyncDriverAdapterProtocol["AdbcConnection", RowT],
+    SyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     SyncStorageMixin,
@@ -60,7 +62,6 @@ class AdbcDriver(
     supports_native_arrow_export: ClassVar[bool] = True
     supports_native_parquet_export: ClassVar[bool] = False  # Not implemented yet
     supports_native_parquet_import: ClassVar[bool] = True
-    __slots__ = ("default_parameter_style", "dialect", "supported_parameter_styles")
 
     def __init__(
         self,
@@ -181,7 +182,7 @@ class AdbcDriver(
         self, statement: SQL, connection: Optional["AdbcConnection"] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = {p.style for p in statement.parameter_info}
@@ -197,7 +198,7 @@ class AdbcDriver(
                     target_style = style
                     break
 
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
         params = self._process_parameters(params)
         if statement.is_many:
             return self._execute_many(sql, params, connection=connection, **kwargs)
@@ -211,17 +212,18 @@ class AdbcDriver(
         conn = connection if connection is not None else self._connection(None)
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
-            normalized_params = normalize_parameter_sequence(parameters)
-            if normalized_params is not None and not isinstance(normalized_params, (list, tuple)):
-                cursor_params = [normalized_params]
+            converted_params = convert_parameter_sequence(parameters)
+            if converted_params is not None and not isinstance(converted_params, (list, tuple)):
+                cursor_params = [converted_params]
             else:
-                cursor_params = normalized_params
+                cursor_params = converted_params
 
             with self._get_cursor(txn_conn) as cursor:
                 try:
                     cursor.execute(sql, cursor_params or [])
                 except Exception as e:
-                    # Rollback transaction on error for PostgreSQL to avoid "current transaction is aborted" errors
+                    # Rollback transaction on error for PostgreSQL to avoid
+                    # "current transaction is aborted" errors
                     if self.dialect == "postgres":
                         with contextlib.suppress(Exception):
                             cursor.execute("ROLLBACK")
@@ -261,11 +263,11 @@ class AdbcDriver(
 
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
+            converted_param_list = convert_parameter_sequence(param_list)
 
             with self._get_cursor(txn_conn) as cursor:
                 try:
-                    cursor.executemany(sql, normalized_param_list or [])
+                    cursor.executemany(sql, converted_param_list or [])
                 except Exception as e:
                     if self.dialect == "postgres":
                         with contextlib.suppress(Exception):
@@ -290,18 +292,28 @@ class AdbcDriver(
         with managed_transaction_sync(conn, auto_commit=True) as txn_conn:
             # ADBC drivers don't support multiple statements in a single execute
             statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
 
             executed_count = 0
+            total_rows = 0
             with self._get_cursor(txn_conn) as cursor:
                 for statement in statements:
                     if statement.strip():
-                        self._execute_single_script_statement(cursor, statement)
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement, config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
+                        rows = self._execute_single_script_statement(cursor, statement)
                         executed_count += 1
+                        total_rows += rows
 
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={"status_message": "SCRIPT EXECUTED"},
                 total_statements=executed_count,
@@ -316,18 +328,19 @@ class AdbcDriver(
             statement: The SQL statement to execute
 
         Returns:
-            1 if successful, 0 if failed
+            Number of rows affected
         """
         try:
             cursor.execute(statement)
         except Exception as e:
-            # Rollback transaction on error for PostgreSQL to avoid "current transaction is aborted" errors
+            # Rollback transaction on error for PostgreSQL to avoid
+            # "current transaction is aborted" errors
             if self.dialect == "postgres":
                 with contextlib.suppress(Exception):
                     cursor.execute("ROLLBACK")
             raise e from e
         else:
-            return 1
+            return cursor.rowcount or 0
 
     def _fetch_arrow_table(self, sql: SQL, connection: "Optional[Any]" = None, **kwargs: Any) -> "ArrowResult":
         """ADBC native Arrow table fetching.

{sqlspec-0.13.0 → sqlspec-0.14.0}/sqlspec/adapters/aiosqlite/config.py

@@ -16,8 +16,6 @@ from sqlspec.typing import DictRow, Empty
 if TYPE_CHECKING:
     from typing import Literal
 
-    from sqlglot.dialects.dialect import DialectType
-
 
 __all__ = ("CONNECTION_FIELDS", "AiosqliteConfig")
 
@@ -34,21 +32,6 @@ class AiosqliteConfig(AsyncDatabaseConfig[AiosqliteConnection, None, AiosqliteDr
     Note: Aiosqlite doesn't support connection pooling, so pool_instance is always None.
     """
 
-    __slots__ = (
-        "_dialect",
-        "cached_statements",
-        "check_same_thread",
-        "database",
-        "default_row_type",
-        "detect_types",
-        "extras",
-        "isolation_level",
-        "pool_instance",
-        "statement_config",
-        "timeout",
-        "uri",
-    )
-
     is_async: ClassVar[bool] = True
     supports_connection_pooling: ClassVar[bool] = False
 
@@ -59,7 +42,7 @@ class AiosqliteConfig(AsyncDatabaseConfig[AiosqliteConnection, None, AiosqliteDr
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("qmark", "named_colon")
     """AIOSQLite supports ? (qmark) and :name (named_colon) parameter styles."""
 
-    preferred_parameter_style: ClassVar[str] = "qmark"
+    default_parameter_style: ClassVar[str] = "qmark"
     """AIOSQLite's native parameter style is ? (qmark)."""
 
     def __init__(
@@ -102,7 +85,6 @@ class AiosqliteConfig(AsyncDatabaseConfig[AiosqliteConnection, None, AiosqliteDr
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self._dialect: DialectType = None
 
         super().__init__()
 
@@ -179,10 +161,23 @@ class AiosqliteConfig(AsyncDatabaseConfig[AiosqliteConnection, None, AiosqliteDr
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             yield self.driver_type(connection=connection, config=statement_config)
 
     async def provide_pool(self, *args: Any, **kwargs: Any) -> None:
         """Aiosqlite doesn't support pooling."""
         return
+
+    def get_signature_namespace(self) -> "dict[str, type[Any]]":
+        """Get the signature namespace for Aiosqlite types.
+
+        This provides all Aiosqlite-specific types that Litestar needs to recognize
+        to avoid serialization attempts.
+
+        Returns:
+            Dictionary mapping type names to types.
+        """
+        namespace = super().get_signature_namespace()
+        namespace.update({"AiosqliteConnection": AiosqliteConnection})
+        return namespace

{sqlspec-0.13.0 → sqlspec-0.14.0}/sqlspec/adapters/aiosqlite/driver.py

@@ -10,13 +10,14 @@ import aiosqlite
 from sqlspec.driver import AsyncDriverAdapterProtocol
 from sqlspec.driver.connection import managed_transaction_async
 from sqlspec.driver.mixins import (
+    AsyncAdapterCacheMixin,
     AsyncPipelinedExecutionMixin,
     AsyncStorageMixin,
     SQLTranslatorMixin,
     ToSchemaMixin,
     TypeCoercionMixin,
 )
-from sqlspec.driver.parameters import normalize_parameter_sequence
+from sqlspec.driver.parameters import convert_parameter_sequence
 from sqlspec.statement.parameters import ParameterStyle, ParameterValidator
 from sqlspec.statement.result import SQLResult
 from sqlspec.statement.sql import SQL, SQLConfig
@@ -35,6 +36,7 @@ AiosqliteConnection = aiosqlite.Connection
 
 class AiosqliteDriver(
     AsyncDriverAdapterProtocol[AiosqliteConnection, RowT],
+    AsyncAdapterCacheMixin,
     SQLTranslatorMixin,
     TypeCoercionMixin,
     AsyncStorageMixin,
@@ -46,7 +48,6 @@ class AiosqliteDriver(
     dialect: "DialectType" = "sqlite"
     supported_parameter_styles: "tuple[ParameterStyle, ...]" = (ParameterStyle.QMARK, ParameterStyle.NAMED_COLON)
     default_parameter_style: ParameterStyle = ParameterStyle.QMARK
-    __slots__ = ()
 
     def __init__(
         self,
@@ -101,7 +102,7 @@ class AiosqliteDriver(
         self, statement: SQL, connection: Optional[AiosqliteConnection] = None, **kwargs: Any
     ) -> SQLResult[RowT]:
         if statement.is_script:
-            sql, _ = statement.compile(placeholder_style=ParameterStyle.STATIC)
+            sql, _ = self._get_compiled_sql(statement, ParameterStyle.STATIC)
             return await self._execute_script(sql, connection=connection, **kwargs)
 
         detected_styles = set()
@@ -124,13 +125,13 @@ class AiosqliteDriver(
                     break
 
         if statement.is_many:
-            sql, params = statement.compile(placeholder_style=target_style)
+            sql, params = self._get_compiled_sql(statement, target_style)
 
             params = self._process_parameters(params)
 
             return await self._execute_many(sql, params, connection=connection, **kwargs)
 
-        sql, params = statement.compile(placeholder_style=target_style)
+        sql, params = self._get_compiled_sql(statement, target_style)
 
         params = self._process_parameters(params)
 
@@ -142,13 +143,10 @@ class AiosqliteDriver(
         conn = self._connection(connection)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
-            normalized_params = normalize_parameter_sequence(parameters)
+            converted_params = convert_parameter_sequence(parameters)
 
-            # Extract the actual parameters from the normalized list
-            if normalized_params and len(normalized_params) == 1:
-                actual_params = normalized_params[0]
-            else:
-                actual_params = normalized_params
+            # Extract the actual parameters from the converted list
+            actual_params = converted_params[0] if converted_params and len(converted_params) == 1 else converted_params
 
             # AIOSQLite expects tuple or dict - handle parameter conversion
             if ":param_" in sql or (isinstance(actual_params, dict)):
@@ -193,11 +191,11 @@ class AiosqliteDriver(
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
             # Normalize parameter list using consolidated utility
-            normalized_param_list = normalize_parameter_sequence(param_list)
+            converted_param_list = convert_parameter_sequence(param_list)
 
             params_list: list[tuple[Any, ...]] = []
-            if normalized_param_list and isinstance(normalized_param_list, Sequence):
-                for param_set in normalized_param_list:
+            if converted_param_list and isinstance(converted_param_list, Sequence):
+                for param_set in converted_param_list:
                     if isinstance(param_set, (list, tuple)):
                         params_list.append(tuple(param_set))
                     elif param_set is None:
@@ -220,16 +218,36 @@ class AiosqliteDriver(
         conn = connection if connection is not None else self._connection(None)
 
         async with managed_transaction_async(conn, auto_commit=True) as txn_conn:
+            # Split script into individual statements for validation
+            statements = self._split_script_statements(script)
+            suppress_warnings = kwargs.get("_suppress_warnings", False)
+
+            executed_count = 0
+            total_rows = 0
+
+            # Execute each statement individually for better control and validation
             async with self._get_cursor(txn_conn) as cursor:
-                await cursor.executescript(script)
+                for statement in statements:
+                    if statement.strip():
+                        # Validate each statement unless warnings suppressed
+                        if not suppress_warnings:
+                            # Run validation through pipeline
+                            temp_sql = SQL(statement, config=self.config)
+                            temp_sql._ensure_processed()
+                            # Validation errors are logged as warnings by default
+
+                        await cursor.execute(statement)
+                        executed_count += 1
+                        total_rows += cursor.rowcount or 0
+
             return SQLResult(
                 statement=SQL(script, _dialect=self.dialect).as_script(),
                 data=[],
-                rows_affected=0,
+                rows_affected=total_rows,
                 operation_type="SCRIPT",
                 metadata={"status_message": "SCRIPT EXECUTED"},
-                total_statements=-1,  # AIOSQLite doesn't provide this info
-                successful_statements=-1,
+                total_statements=executed_count,
+                successful_statements=executed_count,
             )
 
     async def _bulk_load_file(self, file_path: Path, table_name: str, format: str, mode: str, **options: Any) -> int:

{sqlspec-0.13.0 → sqlspec-0.14.0}/sqlspec/adapters/asyncmy/config.py

@@ -6,6 +6,7 @@ from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, ClassVar, Optional, Union
 
 import asyncmy
+from asyncmy.pool import Pool as AsyncmyPool
 
 from sqlspec.adapters.asyncmy.driver import AsyncmyConnection, AsyncmyDriver
 from sqlspec.config import AsyncDatabaseConfig
@@ -15,7 +16,6 @@ from sqlspec.typing import DictRow, Empty
 if TYPE_CHECKING:
     from asyncmy.cursors import Cursor, DictCursor
     from asyncmy.pool import Pool
-    from sqlglot.dialects.dialect import DialectType
 
 
 __all__ = ("CONNECTION_FIELDS", "POOL_FIELDS", "AsyncmyConfig")
@@ -49,34 +49,6 @@ POOL_FIELDS = CONNECTION_FIELDS.union({"minsize", "maxsize", "echo", "pool_recyc
 class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver]):  # pyright: ignore
     """Configuration for Asyncmy database connections with direct field-based configuration."""
 
-    __slots__ = (
-        "_dialect",
-        "autocommit",
-        "charset",
-        "connect_timeout",
-        "cursor_class",
-        "database",
-        "default_row_type",
-        "echo",
-        "extras",
-        "host",
-        "init_command",
-        "local_infile",
-        "maxsize",
-        "minsize",
-        "password",
-        "pool_instance",
-        "pool_recycle",
-        "port",
-        "read_default_file",
-        "read_default_group",
-        "sql_mode",
-        "ssl",
-        "statement_config",
-        "unix_socket",
-        "user",
-    )
-
     is_async: ClassVar[bool] = True
     supports_connection_pooling: ClassVar[bool] = True
     driver_type: type[AsyncmyDriver] = AsyncmyDriver
@@ -86,7 +58,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
     supported_parameter_styles: ClassVar[tuple[str, ...]] = ("pyformat_positional",)
     """AsyncMy only supports %s (pyformat_positional) parameter style."""
 
-    preferred_parameter_style: ClassVar[str] = "pyformat_positional"
+    default_parameter_style: ClassVar[str] = "pyformat_positional"
     """AsyncMy's native parameter style is %s (pyformat_positional)."""
 
     def __init__(
@@ -174,8 +146,6 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
         # Store other config
         self.statement_config = statement_config or SQLConfig()
         self.default_row_type = default_row_type
-        self.pool_instance: Optional[Pool] = pool_instance
-        self._dialect: DialectType = None
 
         super().__init__()  # pyright: ignore
 
@@ -270,7 +240,7 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
                 statement_config = replace(
                     statement_config,
                     allowed_parameter_styles=self.supported_parameter_styles,
-                    target_parameter_style=self.preferred_parameter_style,
+                    default_parameter_style=self.default_parameter_style,
                 )
             yield self.driver_type(connection=connection, config=statement_config)
 
@@ -283,3 +253,16 @@ class AsyncmyConfig(AsyncDatabaseConfig[AsyncmyConnection, "Pool", AsyncmyDriver
         if not self.pool_instance:
             self.pool_instance = await self.create_pool()
         return self.pool_instance
+
+    def get_signature_namespace(self) -> "dict[str, type[Any]]":
+        """Get the signature namespace for Asyncmy types.
+
+        This provides all Asyncmy-specific types that Litestar needs to recognize
+        to avoid serialization attempts.
+
+        Returns:
+            Dictionary mapping type names to types.
+        """
+        namespace = super().get_signature_namespace()
+        namespace.update({"AsyncmyConnection": AsyncmyConnection, "AsyncmyPool": AsyncmyPool})
+        return namespace