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

sqlspec/adapters/aiosqlite/driver.py

@@ -6,14 +6,14 @@ import aiosqlite
 from sqlglot import exp
 
 from sqlspec.base import AsyncDriverAdapterProtocol
+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 AsyncGenerator, Sequence
+    from collections.abc import AsyncGenerator, Mapping, Sequence  # Added Mapping, Sequence
 
-    from sqlspec.filters import StatementFilter
     from sqlspec.typing import ModelDTOT, StatementParameterType, T
 
 __all__ = ("AiosqliteConnection", "AiosqliteDriver")
@@ -51,7 +51,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         **kwargs: Any,
     ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
@@ -63,17 +62,27 @@ class AiosqliteDriver(
 
         Args:
             sql: SQL statement.
-            parameters: Query parameters.
+            parameters: Query parameters. Can be data or a StatementFilter.
             *filters: Statement filters to apply.
             **kwargs: Additional keyword arguments.
 
         Returns:
             Tuple of processed SQL and parameters.
         """
-        statement = SQLStatement(sql, parameters, kwargs=kwargs, dialect=self.dialect)
+        passed_parameters: Optional[Union[Mapping[str, Any], Sequence[Any]]] = None
+        combined_filters_list: list[StatementFilter] = list(filters)
 
-        # Apply any filters
-        for filter_obj in filters:
+        if parameters is not None:
+            if isinstance(parameters, StatementFilter):
+                combined_filters_list.insert(0, parameters)
+                # _actual_data_params remains None
+            else:
+                # If parameters is not a StatementFilter, it's actual data parameters.
+                passed_parameters = parameters
+
+        statement = SQLStatement(sql, passed_parameters, kwargs=kwargs, dialect=self.dialect)
+
+        for filter_obj in combined_filters_list:
             statement = statement.apply_filter(filter_obj)
 
         processed_sql, processed_params, parsed_expr = statement.process()
@@ -121,7 +130,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -132,7 +140,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -142,7 +149,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -156,25 +162,19 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        results = await cursor.fetchall()
-        if not results:
-            return []
-
-        # Get column names
-        column_names = [column[0] for column in cursor.description]
-
-        # Convert to dicts first
-        dict_results = [dict(zip(column_names, row)) for row in results]
-        return self.to_schema(dict_results, schema_type=schema_type)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters or ())
+            results = await cursor.fetchall()
+            if not results:
+                return []
+            column_names = [column[0] for column in cursor.description]
+            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[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -185,7 +185,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -195,7 +194,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -209,24 +207,20 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        result = await cursor.fetchone()
-        result = self.check_not_found(result)
-
-        # Get column names
-        column_names = [column[0] for column in cursor.description]
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters or ())
+            result = await cursor.fetchone()
+            result = self.check_not_found(result)
 
-        # Convert to dict and then use ResultConverter
-        dict_result = dict(zip(column_names, result))
-        return self.to_schema(dict_result, schema_type=schema_type)
+            # Get column names
+            column_names = [column[0] for column in cursor.description]
+            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[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -237,7 +231,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -247,7 +240,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -261,25 +253,19 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        result = await cursor.fetchone()
-        if result is None:
-            return None
-
-        # Get column names
-        column_names = [column[0] for column in cursor.description]
-
-        # Convert to dict and then use ResultConverter
-        dict_result = dict(zip(column_names, result))
-        return self.to_schema(dict_result, schema_type=schema_type)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters or ())
+            result = await cursor.fetchone()
+            if result is None:
+                return None
+            column_names = [column[0] for column in cursor.description]
+            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[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -290,7 +276,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[T]",
@@ -300,7 +285,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
@@ -314,23 +298,22 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        result = await cursor.fetchone()
-        result = self.check_not_found(result)
+        async with self._with_cursor(connection) as cursor:
+            await cursor.execute(sql, parameters or ())
+            result = await cursor.fetchone()
+            result = self.check_not_found(result)
 
-        # Return first value from the row
-        result_value = result[0]
-        if schema_type is None:
-            return result_value
-        return schema_type(result_value)  # type: ignore[call-arg]
+            # Return first value from the row
+            result_value = result[0]
+            if schema_type is None:
+                return result_value
+            return schema_type(result_value)  # type: ignore[call-arg]
 
     @overload
     async def select_value_or_none(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -341,7 +324,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[T]",
@@ -351,7 +333,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
@@ -365,23 +346,21 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        result = await cursor.fetchone()
-        if result is None:
-            return None
-
-        # Return first value from the row
-        result_value = result[0]
-        if schema_type is None:
-            return result_value
-        return schema_type(result_value)  # type: ignore[call-arg]
+        async with self._with_cursor(connection) as cursor:
+            # Execute the query
+            await cursor.execute(sql, parameters or ())
+            result = await cursor.fetchone()
+            if result is None:
+                return None
+            result_value = result[0]
+            if schema_type is None:
+                return result_value
+            return schema_type(result_value)  # type: ignore[call-arg]
 
     async def insert_update_delete(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         **kwargs: Any,
@@ -393,18 +372,16 @@ class AiosqliteDriver(
         """
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
-
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        await connection.commit()
-        return cursor.rowcount
+        async with self._with_cursor(connection) as cursor:
+            # Execute the query
+            await cursor.execute(sql, parameters or ())
+            return cursor.rowcount
 
     @overload
     async def insert_update_delete_returning(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: None = None,
@@ -415,7 +392,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -425,7 +401,6 @@ class AiosqliteDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AiosqliteConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -439,26 +414,18 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, *filters, **kwargs)
 
-        # Execute the query
-        cursor = await connection.execute(sql, parameters or ())
-        result = await cursor.fetchone()
-        await connection.commit()
-        await cursor.close()
-
-        result = self.check_not_found(result)
-
-        # Get column names
-        column_names = [column[0] for column in cursor.description]
-
-        # Convert to dict and then use ResultConverter
-        dict_result = dict(zip(column_names, result))
-        return self.to_schema(dict_result, schema_type=schema_type)
+        async with self._with_cursor(connection) as cursor:
+            # Execute the query
+            await cursor.execute(sql, parameters or ())
+            result = await cursor.fetchone()
+            result = self.check_not_found(result)
+            column_names = [column[0] for column in cursor.description]
+            return self.to_schema(dict(zip(column_names, result)), schema_type=schema_type)
 
     async def execute_script(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         connection: "Optional[AiosqliteConnection]" = None,
         **kwargs: Any,
     ) -> str:
@@ -470,10 +437,12 @@ class AiosqliteDriver(
         connection = self._connection(connection)
         sql, parameters = self._process_sql_params(sql, parameters, **kwargs)
 
-        # Execute the script
-        await connection.executescript(sql)
-        await connection.commit()
-        return "Script executed successfully."
+        async with self._with_cursor(connection) as cursor:
+            if parameters:
+                await cursor.execute(sql, parameters)
+            else:
+                await cursor.executescript(sql)
+            return "DONE"
 
     def _connection(self, connection: "Optional[AiosqliteConnection]" = None) -> "AiosqliteConnection":
         """Get the connection to use for the operation.

sqlspec/adapters/asyncmy/driver.py

@@ -1,7 +1,7 @@
 # type: ignore
 import logging
 import re
-from collections.abc import AsyncGenerator, Sequence
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from typing import TYPE_CHECKING, Any, Optional, Union, overload
 
@@ -9,14 +9,16 @@ from asyncmy import Connection
 
 from sqlspec.base import AsyncDriverAdapterProtocol
 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.filters import StatementFilter
     from sqlspec.typing import ModelDTOT, StatementParameterType, T
 
 __all__ = ("AsyncmyDriver",)
@@ -55,7 +57,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         **kwargs: Any,
     ) -> "tuple[str, Optional[Union[tuple[Any, ...], list[Any], dict[str, Any]]]]":
@@ -63,7 +64,7 @@ class AsyncmyDriver(
 
         Args:
             sql: The SQL statement to process.
-            parameters: The parameters to bind to the statement.
+            parameters: The parameters to bind to the statement. Can be data or a StatementFilter.
             *filters: Statement filters to apply.
             **kwargs: Additional keyword arguments.
 
@@ -73,41 +74,52 @@ class AsyncmyDriver(
         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 parameters is None:
+            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(parameters):
+            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(parameters, (list, tuple)):
+            if not isinstance(actual_parameters, (list, tuple)):
                 # Scalar parameter case
-                return sql, (parameters,)
+                return sql, (actual_parameters,)
 
             # Sequence parameter case - ensure appropriate length
-            if len(parameters) != mysql_placeholders_count:
-                msg = f"asyncmy: Parameter count mismatch. SQL expects {mysql_placeholders_count} '%s' placeholders, but {len(parameters)} parameters were provided. SQL: {sql}"
+            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(parameters)
+            return sql, tuple(actual_parameters)  # type: ignore[arg-type]
 
         # Create a SQLStatement with MySQL dialect
-        statement = SQLStatement(sql, parameters, kwargs=kwargs, dialect=self.dialect)
+        statement = SQLStatement(sql, actual_parameters, kwargs=kwargs, dialect=self.dialect)
 
         # Apply any filters
-        for filter_obj in filters:
+        for filter_obj in current_filters:  # Use the modified list of filters
             statement = statement.apply_filter(filter_obj)
 
         # Process the statement for execution
@@ -136,7 +148,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
@@ -147,7 +158,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -157,7 +167,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -176,17 +185,13 @@ class AsyncmyDriver(
             if not results:
                 return []
             column_names = [c[0] for c in cursor.description or []]
-
-            # Convert to dicts first
-            dict_results = [dict(zip(column_names, row)) for row in results]
-            return self.to_schema(dict_results, schema_type=schema_type)
+            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,
@@ -197,7 +202,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -207,7 +211,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -225,17 +228,13 @@ class AsyncmyDriver(
             result = await cursor.fetchone()
             result = self.check_not_found(result)
             column_names = [c[0] for c in cursor.description or []]
-
-            # Convert to dict and use ResultConverter
-            dict_result = dict(zip(column_names, result))
-            return self.to_schema(dict_result, schema_type=schema_type)
+            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,
@@ -246,7 +245,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -256,7 +254,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,
@@ -275,17 +272,13 @@ class AsyncmyDriver(
             if result is None:
                 return None
             column_names = [c[0] for c in cursor.description or []]
-
-            # Convert to dict and use ResultConverter
-            dict_result = dict(zip(column_names, result))
-            return self.to_schema(dict_result, schema_type=schema_type)
+            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,
@@ -296,7 +289,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[T]",
@@ -306,7 +298,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
@@ -333,7 +324,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
@@ -344,7 +334,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[T]",
@@ -354,7 +343,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[T]]" = None,
@@ -381,7 +369,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         **kwargs: Any,
@@ -402,7 +389,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: None = None,
@@ -413,7 +399,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "type[ModelDTOT]",
@@ -423,7 +408,6 @@ class AsyncmyDriver(
         self,
         sql: str,
         parameters: "Optional[StatementParameterType]" = None,
-        /,
         *filters: "StatementFilter",
         connection: "Optional[AsyncmyConnection]" = None,
         schema_type: "Optional[type[ModelDTOT]]" = None,