sqlspec 0.10.1__py3-none-any.whl → 0.11.1__py3-none-any.whl

sqlspec/adapters/asyncmy/driver.py

@@ -1,14 +1,22 @@
 # type: ignore
-from collections.abc import AsyncGenerator, Sequence
+import logging
+import re
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Optional, Union, overload
 
 from asyncmy import Connection
 
 from sqlspec.base import AsyncDriverAdapterProtocol
-from sqlspec.mixins import SQLTranslatorMixin
+from sqlspec.exceptions import ParameterStyleMismatchError
+from sqlspec.filters import StatementFilter
+from sqlspec.mixins import ResultConverter, SQLTranslatorMixin
+from sqlspec.statement import SQLStatement
+from sqlspec.typing import is_dict
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
     from asyncmy.cursors import Cursor
 
     from sqlspec.typing import ModelDTOT, StatementParameterType, T
@@ -17,10 +25,16 @@ __all__ = ("AsyncmyDriver",)
 
 AsyncmyConnection = Connection
 
+logger = logging.getLogger("sqlspec")
+
+# Pattern to identify MySQL-style placeholders (%s) for proper conversion
+MYSQL_PLACEHOLDER_PATTERN = re.compile(r"(?<!%)%s")
+
 
 class AsyncmyDriver(
     SQLTranslatorMixin["AsyncmyConnection"],
     AsyncDriverAdapterProtocol["AsyncmyConnection"],
+    ResultConverter,
 ):
     """Asyncmy MySQL/MariaDB Driver Adapter."""
 
@@ -39,14 +53,102 @@ class AsyncmyDriver(
         finally:
             await cursor.close()
 
+    def _process_sql_params(
+        self,
+        sql: str,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        **kwargs: Any,
+    ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
+        """Process SQL and parameters using SQLStatement with dialect support.
+
+        Args:
+            sql: The SQL statement to process.
+            parameters: The parameters to bind to the statement. Can be data or a StatementFilter.
+            *filters: Statement filters to apply.
+            **kwargs: Additional keyword arguments.
+
+        Raises:
+            ParameterStyleMismatchError: If the parameter style is not supported.
+
+        Returns:
+            A tuple of (sql, parameters) ready for execution.
+        """
+        # Convert filters tuple to a list to allow modification
+        current_filters: list[StatementFilter] = list(filters)
+        actual_parameters: Optional[Union[Mapping[str, Any], Sequence[Any]]] = None
+
+        if parameters is not None:
+            if isinstance(parameters, StatementFilter):
+                current_filters.insert(0, parameters)
+                # actual_parameters remains None
+            else:
+                actual_parameters = parameters  # type: ignore[assignment]
+
+        # Handle MySQL-specific placeholders (%s) which SQLGlot doesn't parse well
+        # If %s placeholders are present, handle them directly
+        mysql_placeholders_count = len(MYSQL_PLACEHOLDER_PATTERN.findall(sql))
+
+        if mysql_placeholders_count > 0:
+            # For MySQL format placeholders, minimal processing is needed
+            if actual_parameters is None:
+                if mysql_placeholders_count > 0:
+                    msg = f"asyncmy: SQL statement contains {mysql_placeholders_count} format placeholders ('%s'), but no parameters were provided. SQL: {sql}"
+                    raise ParameterStyleMismatchError(msg)
+                return sql, None
+
+            # Convert dict to tuple if needed
+            if is_dict(actual_parameters):
+                # MySQL's %s placeholders require positional params
+                msg = "asyncmy: Dictionary parameters provided with '%s' placeholders. MySQL format placeholders require tuple/list parameters."
+                raise ParameterStyleMismatchError(msg)
+
+            # Convert to tuple (handles both scalar and sequence cases)
+            if not isinstance(actual_parameters, (list, tuple)):
+                # Scalar parameter case
+                return sql, (actual_parameters,)
+
+            # Sequence parameter case - ensure appropriate length
+            if len(actual_parameters) != mysql_placeholders_count:  # type: ignore[arg-type]
+                msg = f"asyncmy: Parameter count mismatch. SQL expects {mysql_placeholders_count} '%s' placeholders, but {len(actual_parameters)} parameters were provided. SQL: {sql}"  # type: ignore[arg-type]
+                raise ParameterStyleMismatchError(msg)
+
+            return sql, tuple(actual_parameters)  # type: ignore[arg-type]
+
+        # Create a SQLStatement with MySQL dialect
+        statement = SQLStatement(sql, actual_parameters, kwargs=kwargs, dialect=self.dialect)
+
+        # Apply any filters
+        for filter_obj in current_filters:  # Use the modified list of filters
+            statement = statement.apply_filter(filter_obj)
+
+        # Process the statement for execution
+        processed_sql, processed_params, _ = statement.process()
+
+        # Convert parameters to the format expected by MySQL
+        if processed_params is None:
+            return processed_sql, None
+
+        # For MySQL, ensure parameters are in the right format
+        if is_dict(processed_params):
+            # Dictionary parameters are not well supported by asyncmy
+            msg = "asyncmy: Dictionary parameters are not supported for MySQL placeholders. Use sequence parameters."
+            raise ParameterStyleMismatchError(msg)
+
+        # For sequence parameters, ensure they're a tuple
+        if isinstance(processed_params, (list, tuple)):
+            return processed_sql, tuple(processed_params)
+
+        # For scalar parameter, wrap in a tuple
+        return processed_sql, (processed_params,)
+
     # --- Public API Methods --- #
     @overload
     async def select(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -56,8 +158,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
         **kwargs: Any,
@@ -65,37 +166,33 @@ class AsyncmyDriver(
     async def select(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
         **kwargs: Any,
-    ) -> "Sequence[Union[ModelDTOT, dict[str, Any]]]":
+    ) -> "Sequence[Union[dict[str, Any], ModelDTOT]]":
         """Fetch data from the database.
 
         Returns:
             List of row data as either model instances or dictionaries.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             results = await cursor.fetchall()
             if not results:
                 return []
             column_names = [c[0] for c in cursor.description or []]
-            if schema_type is None:
-                return [dict(zip(column_names, row)) for row in results]
-            return [schema_type(**dict(zip(column_names, row))) for row in results]
+            return self.to_schema([dict(zip(column_names, row)) for row in results], schema_type=schema_type)
 
     @overload
     async def select_one(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -105,8 +202,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
         **kwargs: Any,
@@ -114,36 +210,32 @@ class AsyncmyDriver(
     async def select_one(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelDTOT, dict[str, Any]]":
+    ) -> "Union[dict[str, Any], ModelDTOT]":
         """Fetch one row from the database.
 
         Returns:
             The first row of the query results.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             result = await cursor.fetchone()
             result = self.check_not_found(result)
             column_names = [c[0] for c in cursor.description or []]
-            if schema_type is None:
-                return dict(zip(column_names, result))
-            return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))
+            return self.to_schema(dict(zip(column_names, result)), schema_type=schema_type)
 
     @overload
     async def select_one_or_none(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -153,8 +245,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
         **kwargs: Any,
@@ -162,37 +253,33 @@ class AsyncmyDriver(
     async def select_one_or_none(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
         **kwargs: Any,
-    ) -> "Optional[Union[ModelDTOT, dict[str, Any]]]":
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
         """Fetch one row from the database.
 
         Returns:
             The first row of the query results.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             result = await cursor.fetchone()
             if result is None:
                 return None
             column_names = [c[0] for c in cursor.description or []]
-            if schema_type is None:
-                return dict(zip(column_names, result))
-            return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))
+            return self.to_schema(dict(zip(column_names, result)), schema_type=schema_type)
 
     @overload
     async def select_value(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -202,8 +289,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[T]",
         **kwargs: Any,
@@ -212,8 +298,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
         **kwargs: Any,
@@ -221,16 +306,14 @@ class AsyncmyDriver(
         """Fetch a single value from the database.
 
         Returns:
-            The first value from the first row of results, or None if no results.
+            The first value from the first row of results.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
-
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             result = await cursor.fetchone()
             result = self.check_not_found(result)
-
             value = result[0]
             if schema_type is not None:
                 return schema_type(value)  # type: ignore[call-arg]
@@ -241,8 +324,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -252,8 +334,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[T]",
         **kwargs: Any,
@@ -262,8 +343,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
         **kwargs: Any,
@@ -274,15 +354,12 @@ class AsyncmyDriver(
             The first value from the first row of results, or None if no results.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
-
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             result = await cursor.fetchone()
-
             if result is None:
                 return None
-
             value = result[0]
             if schema_type is not None:
                 return schema_type(value)  # type: ignore[call-arg]
@@ -291,10 +368,9 @@ class AsyncmyDriver(
     async def insert_update_delete(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        connection: "Optional[AsyncmyConnection]" = None,
         **kwargs: Any,
     ) -> int:
         """Insert, update, or delete data from the database.
@@ -303,8 +379,7 @@ class AsyncmyDriver(
             Row count affected by the operation.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
-
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
             return cursor.rowcount
@@ -314,8 +389,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
         **kwargs: Any,
@@ -325,8 +399,7 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
-        *,
+        *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
         **kwargs: Any,
@@ -334,21 +407,19 @@ class AsyncmyDriver(
     async def insert_update_delete_returning(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        *filters: "StatementFilter",
+        connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
         **kwargs: Any,
-    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
+    ) -> "Union[dict[str, Any], ModelDTOT]":
         """Insert, update, or delete data from the database and return result.
 
         Returns:
             The first row of results.
         """
         connection = self._connection(connection)
-        sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
-        column_names: list[str] = []
+        sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
@@ -356,17 +427,16 @@ class AsyncmyDriver(
             if result is None:
                 return None
             column_names = [c[0] for c in cursor.description or []]
-            if schema_type is not None:
-                return cast("ModelDTOT", schema_type(**dict(zip(column_names, result))))
-            return dict(zip(column_names, result))
+
+            # Convert to dict and use ResultConverter
+            dict_result = dict(zip(column_names, result))
+            return self.to_schema(dict_result, schema_type=schema_type)
 
     async def execute_script(
         self,
         sql: str,
-        parameters: Optional["StatementParameterType"] = None,
-        /,
-        *,
-        connection: Optional["AsyncmyConnection"] = None,
+        parameters: "Optional[StatementParameterType]" = None,
+        connection: "Optional[AsyncmyConnection]" = None,
         **kwargs: Any,
     ) -> str:
         """Execute a script.
@@ -376,7 +446,17 @@ class AsyncmyDriver(
         """
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
-
         async with self._with_cursor(connection) as cursor:
             await cursor.execute(sql, parameters)
-            return "DONE"
+            return f"Script executed successfully. Rows affected: {cursor.rowcount}"
+
+    def _connection(self, connection: "Optional[AsyncmyConnection]" = None) -> "AsyncmyConnection":
+        """Get the connection to use for the operation.
+
+        Args:
+            connection: Optional connection to use.
+
+        Returns:
+            The connection to use.
+        """
+        return connection or self.connection

sqlspec/adapters/asyncpg/config.py

@@ -83,7 +83,9 @@ class AsyncpgConfig(AsyncDatabaseConfig["AsyncpgConnection", "Pool", "AsyncpgDri
     """For dialects that support the JSON datatype, this is a Python callable that will render a given object as JSON.
     By default, SQLSpec's :attr:`encode_json() <sqlspec._serialization.encode_json>` is used."""
     connection_type: "type[AsyncpgConnection]" = field(
-        hash=False, init=False, default_factory=lambda: PoolConnectionProxy
+        hash=False,
+        init=False,
+        default_factory=lambda: PoolConnectionProxy,  # type: ignore[assignment]
     )
     """Type of the connection object"""
     driver_type: "type[AsyncpgDriver]" = field(hash=False, init=False, default_factory=lambda: AsyncpgDriver)  # type: ignore[type-abstract,unused-ignore]