sqlspec 0.13.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

sqlspec/{service/base.py → driver/mixins/_query_tools.py}

@@ -1,10 +1,15 @@
-# mypy: disable-error-code="arg-type,misc,type-var"
-# pyright: reportCallIssue=false, reportArgumentType=false
-from typing import TYPE_CHECKING, Any, Generic, Optional, TypeVar, Union, overload
+# pyright: reportCallIssue=false, reportAttributeAccessIssue=false, reportArgumentType=false
+import logging
+from abc import ABC
+from typing import TYPE_CHECKING, Any, Generic, Optional, Union, overload
 
 from sqlglot import exp, parse_one
+from typing_extensions import Self
 
-from sqlspec.typing import ConnectionT
+from sqlspec.exceptions import NotFoundError
+from sqlspec.statement.filters import LimitOffsetFilter, OffsetPagination
+from sqlspec.statement.sql import SQL
+from sqlspec.typing import ConnectionT, ModelDTOT, RowT
 from sqlspec.utils.type_guards import (
     is_dict_row,
     is_indexable_row,
@@ -14,43 +19,37 @@ from sqlspec.utils.type_guards import (
 )
 
 if TYPE_CHECKING:
-    from sqlspec.driver import AsyncDriverAdapterProtocol, SyncDriverAdapterProtocol
-    from sqlspec.service.pagination import OffsetPagination
-    from sqlspec.statement import SQLConfig, Statement, StatementFilter
-    from sqlspec.statement.builder import Delete, Insert, QueryBuilder, Select, Update
-    from sqlspec.statement.sql import SQL
-    from sqlspec.typing import ModelDTOT, RowT, StatementParameters
+    from sqlglot.dialects.dialect import DialectType
 
-__all__ = ("SQLSpecAsyncService", "SQLSpecSyncService")
+    from sqlspec.statement import Statement, StatementFilter
+    from sqlspec.statement.builder import Select
+    from sqlspec.statement.sql import SQLConfig
+    from sqlspec.typing import StatementParameters
 
+__all__ = ("AsyncQueryMixin", "SyncQueryMixin")
 
-T = TypeVar("T")
-SyncDriverT = TypeVar("SyncDriverT", bound="SyncDriverAdapterProtocol[Any]")
-AsyncDriverT = TypeVar("AsyncDriverT", bound="AsyncDriverAdapterProtocol[Any]")
+logger = logging.getLogger(__name__)
 
+WINDOWS_PATH_MIN_LENGTH = 3
 
-class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
-    """Sync Service for database operations."""
 
-    def __init__(self, driver: "SyncDriverT", connection: "ConnectionT") -> None:
-        self._driver = driver
-        self._connection = connection
+class QueryBase(ABC, Generic[ConnectionT]):
+    """Base class with common query functionality."""
 
-    @classmethod
-    def new(cls, driver: "SyncDriverT", connection: "ConnectionT") -> "SQLSpecSyncService[SyncDriverT, ConnectionT]":
-        return cls(driver=driver, connection=connection)
-
-    @property
-    def driver(self) -> "SyncDriverT":
-        """Get the driver instance."""
-        return self._driver
+    config: Any
+    _connection: Any
+    dialect: "DialectType"
 
     @property
     def connection(self) -> "ConnectionT":
         """Get the connection instance."""
-        return self._connection
+        return self._connection  # type: ignore[no-any-return]
+
+    @classmethod
+    def new(cls, connection: "ConnectionT") -> Self:
+        return cls(connection)  # type: ignore[call-arg]
 
-    def _normalize_statement(
+    def _transform_to_sql(
         self,
         statement: "Union[Statement, Select]",
         params: "Optional[dict[str, Any]]" = None,
@@ -64,9 +63,8 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
             config: Optional SQL configuration
 
         Returns:
-            A normalized SQL object
+            A converted SQL object
         """
-        from sqlspec.statement.sql import SQL
 
         if is_select_builder(statement):
             # Select has its own parameters via build(), ignore external params
@@ -84,106 +82,9 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         msg = f"Unsupported statement type: {type(statement).__name__}"
         raise TypeError(msg)
 
-    @overload
-    def execute(
-        self,
-        statement: "Select",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "type[ModelDTOT]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[ModelDTOT]": ...
-
-    @overload
-    def execute(
-        self,
-        statement: "Select",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: None = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    @overload
-    def execute(
-        self,
-        statement: "Union[Insert, Update, Delete]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    @overload
-    def execute(
-        self,
-        statement: "Union[str, SQL]",  # exp.Expression
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "type[ModelDTOT]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[ModelDTOT]": ...
-
-    @overload
-    def execute(
-        self,
-        statement: "Union[str, SQL]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: None = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    def execute(
-        self,
-        statement: "Union[Statement, QueryBuilder[Any]]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "Optional[type[ModelDTOT]]" = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a statement and return the result."""
-        result = self.driver.execute(
-            statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
-        )
-        return result.get_data()
-
-    def execute_many(
-        self,
-        statement: "Union[Statement, QueryBuilder[Any]]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a statement multiple times and return the result."""
-        result = self.driver.execute_many(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
-        return result.get_data()
 
-    def execute_script(
-        self,
-        statement: "Statement",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a script statement."""
-        result = self.driver.execute_script(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
-        return result.get_data()
+class SyncQueryMixin(QueryBase[ConnectionT]):
+    """Unified storage operations for synchronous drivers."""
 
     @overload
     def select_one(
@@ -207,7 +108,7 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> "RowT": ...
+    ) -> "RowT": ...  # type: ignore[type-var]
 
     def select_one(
         self,
@@ -218,26 +119,25 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> "Union[RowT, ModelDTOT]":
         """Execute a select statement and return exactly one row.
 
         Raises an exception if no rows or more than one row is returned.
         """
-        result = self.driver.execute(
+        result = self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
         data = result.get_data()
-        # For select operations, data should be a list
         if not isinstance(data, list):
             msg = "Expected list result from select operation"
             raise TypeError(msg)
         if not data:
             msg = "No rows found"
-            raise ValueError(msg)
+            raise NotFoundError(msg)
         if len(data) > 1:
             msg = f"Expected exactly one row, found {len(data)}"
             raise ValueError(msg)
-        return data[0]
+        return data[0]  # type: ignore[no-any-return]
 
     @overload
     def select_one_or_none(
@@ -271,14 +171,14 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         schema_type: "Optional[type[ModelDTOT]]" = None,
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
+        **kwargs: "Optional[Union[RowT, ModelDTOT]]",
     ) -> Any:
         """Execute a select statement and return at most one row.
 
         Returns None if no rows are found.
         Raises an exception if more than one row is returned.
         """
-        result = self.driver.execute(
+        result = self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
         data = result.get_data()
@@ -326,9 +226,9 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> Union[list[RowT], list[ModelDTOT]]:
         """Execute a select statement and return all rows."""
-        result = self.driver.execute(
+        result = self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
         data = result.get_data()
@@ -352,7 +252,7 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         Expects exactly one row with one column.
         Raises an exception if no rows or more than one row/column is returned.
         """
-        result = self.driver.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
+        result = self.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)  # type: ignore[attr-defined]
         data = result.get_data()
         # For select operations, data should be a list
         if not isinstance(data, list):
@@ -360,7 +260,7 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
             raise TypeError(msg)
         if not data:
             msg = "No rows found"
-            raise ValueError(msg)
+            raise NotFoundError(msg)
         if len(data) > 1:
             msg = f"Expected exactly one row, found {len(data)}"
             raise ValueError(msg)
@@ -371,7 +271,6 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
                 raise ValueError(msg)
             return next(iter(row.values()))
         if is_indexable_row(row):
-            # Tuple or list-like row
             if not row:
                 msg = "Row has no columns"
                 raise ValueError(msg)
@@ -394,7 +293,7 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         Expects at most one row with one column.
         Raises an exception if more than one row is returned.
         """
-        result = self.driver.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
+        result = self.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)  # type: ignore[attr-defined]
         data = result.get_data()
         # For select operations, data should be a list
         if not isinstance(data, list):
@@ -452,7 +351,7 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> "Union[OffsetPagination[RowT], OffsetPagination[ModelDTOT]]":
         """Execute a paginated query with automatic counting.
 
         This method performs two queries:
@@ -513,15 +412,12 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
             ...     schema_type=User,
             ... )
         """
-        from sqlspec.service.pagination import OffsetPagination
-        from sqlspec.statement.sql import SQL
 
         # Separate filters from parameters
         filters: list[StatementFilter] = []
         params: list[Any] = []
 
         for p in parameters:
-            # Use type guard to check if it implements the StatementFilter protocol
             if is_statement_filter(p):
                 filters.append(p)
             else:
@@ -546,198 +442,46 @@ class SQLSpecSyncService(Generic[SyncDriverT, ConnectionT]):
             msg = "Pagination requires either a LimitOffsetFilter in parameters or 'limit' and 'offset' in kwargs."
             raise ValueError(msg)
 
-        base_stmt = self._normalize_statement(statement, params, _config)
+        base_stmt = self._transform_to_sql(statement, params, _config)  # type: ignore[arg-type]
 
         filtered_stmt = base_stmt
         for filter_obj in other_filters:
             filtered_stmt = filter_obj.append_to_statement(filtered_stmt)
 
         sql_str = filtered_stmt.to_sql()
-
-        # Parse and transform the AST to create a count query
         parsed = parse_one(sql_str)
 
         # Using exp.Subquery to properly wrap the parsed expression
         subquery = exp.Subquery(this=parsed, alias="_count_subquery")
         count_ast = exp.Select().select(exp.func("COUNT", exp.Star()).as_("total")).from_(subquery)
 
-        count_stmt = SQL(count_ast.sql(), _config=_config)
+        # Preserve parameters from the original statement
+        count_stmt = SQL(count_ast, parameters=filtered_stmt.parameters, _config=_config)
 
         # Execute count query
         total = self.select_value(count_stmt, _connection=_connection, _config=_config, **kwargs)
 
-        data_stmt = self._normalize_statement(statement, params, _config)
+        data_stmt = self._transform_to_sql(statement, params, _config)  # type: ignore[arg-type]
 
         for filter_obj in other_filters:
             data_stmt = filter_obj.append_to_statement(data_stmt)
 
-        data_stmt = data_stmt.limit(limit).offset(offset)
-
-        # Execute data query
-        items = self.select(data_stmt, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs)
-
-        return OffsetPagination(items=items, limit=limit, offset=offset, total=total)
-
-
-class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
-    """Async Service for database operations."""
-
-    def __init__(self, driver: "AsyncDriverT", connection: "ConnectionT") -> None:
-        self._driver = driver
-        self._connection = connection
-
-    @classmethod
-    def new(cls, driver: "AsyncDriverT", connection: "ConnectionT") -> "SQLSpecAsyncService[AsyncDriverT, ConnectionT]":
-        return cls(driver=driver, connection=connection)
-
-    @property
-    def driver(self) -> "AsyncDriverT":
-        """Get the driver instance."""
-        return self._driver
-
-    @property
-    def connection(self) -> "ConnectionT":
-        """Get the connection instance."""
-        return self._connection
-
-    def _normalize_statement(
-        self,
-        statement: "Union[Statement, Select]",
-        params: "Optional[dict[str, Any]]" = None,
-        config: "Optional[SQLConfig]" = None,
-    ) -> "SQL":
-        """Normalize a statement of any supported type into a SQL object.
-
-        Args:
-            statement: The statement to normalize (str, Expression, SQL, or Select)
-            params: Optional parameters (ignored for Select and SQL objects)
-            config: Optional SQL configuration
-
-        Returns:
-            A normalized SQL object
-        """
-        from sqlspec.statement.sql import SQL
-
-        if is_select_builder(statement):
-            # Select has its own parameters via build(), ignore external params
-            safe_query = statement.build()
-            return SQL(safe_query.sql, parameters=safe_query.parameters, config=config)
-
-        if isinstance(statement, SQL):
-            # SQL object is already complete, ignore external params
-            return statement
-
-        if isinstance(statement, (str, exp.Expression)):
-            return SQL(statement, parameters=params, config=config)
-
-        # Fallback for type safety
-        msg = f"Unsupported statement type: {type(statement).__name__}"
-        raise TypeError(msg)
+        # Apply limit and offset using LimitOffsetFilter
+        from sqlspec.statement.filters import LimitOffsetFilter
 
-    @overload
-    async def execute(
-        self,
-        statement: "Select",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "type[ModelDTOT]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[ModelDTOT]": ...
+        limit_offset = LimitOffsetFilter(limit=limit, offset=offset)
+        data_stmt = limit_offset.append_to_statement(data_stmt)
 
-    @overload
-    async def execute(
-        self,
-        statement: "Select",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: None = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    @overload
-    async def execute(
-        self,
-        statement: "Union[Insert, Update, Delete]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    @overload
-    async def execute(
-        self,
-        statement: "Union[str, SQL]",  # exp.Expression
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "type[ModelDTOT]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[ModelDTOT]": ...
-
-    @overload
-    async def execute(
-        self,
-        statement: "Union[str, SQL]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: None = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> "list[RowT]": ...
-
-    async def execute(
-        self,
-        statement: "Union[Statement, QueryBuilder[Any]]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        schema_type: "Optional[type[ModelDTOT]]" = None,
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a statement and return the result."""
-        result = await self.driver.execute(
-            statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
+        # Execute data query
+        items = self.select(
+            data_stmt, params, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
-        return result.get_data()
 
-    async def execute_many(
-        self,
-        statement: "Union[Statement, QueryBuilder[Any]]",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a statement multiple times and return the result."""
-        result = await self.driver.execute_many(
-            statement, *parameters, _connection=_connection, _config=_config, **kwargs
-        )
-        return result.get_data()
+        return OffsetPagination(items=items, limit=limit, offset=offset, total=total)  # pyright: ignore
 
-    async def execute_script(
-        self,
-        statement: "Statement",
-        /,
-        *parameters: "Union[StatementParameters, StatementFilter]",
-        _connection: "Optional[ConnectionT]" = None,
-        _config: "Optional[SQLConfig]" = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Execute a script statement."""
-        result = await self.driver.execute_script(
-            statement, *parameters, _connection=_connection, _config=_config, **kwargs
-        )
-        return result.get_data()
+
+class AsyncQueryMixin(QueryBase[ConnectionT]):
+    """Unified query operations for asynchronous drivers."""
 
     @overload
     async def select_one(
@@ -772,26 +516,22 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> "Union[RowT, ModelDTOT]":
         """Execute a select statement and return exactly one row.
 
         Raises an exception if no rows or more than one row is returned.
         """
-        result = await self.driver.execute(
+        result = await self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
         data = result.get_data()
-        # For select operations, data should be a list
-        if not isinstance(data, list):
-            msg = "Expected list result from select operation"
-            raise TypeError(msg)
         if not data:
             msg = "No rows found"
-            raise ValueError(msg)
+            raise NotFoundError(msg)
         if len(data) > 1:
             msg = f"Expected exactly one row, found {len(data)}"
             raise ValueError(msg)
-        return data[0]
+        return data[0]  # type: ignore[no-any-return]
 
     @overload
     async def select_one_or_none(
@@ -826,26 +566,22 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> "Optional[Union[RowT, ModelDTOT]]":
         """Execute a select statement and return at most one row.
 
         Returns None if no rows are found.
         Raises an exception if more than one row is returned.
         """
-        result = await self.driver.execute(
+        result = await self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
         data = result.get_data()
-        # For select operations, data should be a list
-        if not isinstance(data, list):
-            msg = "Expected list result from select operation"
-            raise TypeError(msg)
         if not data:
             return None
         if len(data) > 1:
             msg = f"Expected at most one row, found {len(data)}"
             raise ValueError(msg)
-        return data[0]
+        return data[0]  # type: ignore[no-any-return]
 
     @overload
     async def select(
@@ -880,17 +616,12 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
+    ) -> "Union[list[RowT], list[ModelDTOT]]":
         """Execute a select statement and return all rows."""
-        result = await self.driver.execute(
+        result = await self.execute(  # type: ignore[attr-defined]
             statement, *parameters, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
-        data = result.get_data()
-        # For select operations, data should be a list
-        if not isinstance(data, list):
-            msg = "Expected list result from select operation"
-            raise TypeError(msg)
-        return data
+        return result.get_data()  # type: ignore[no-any-return]
 
     async def select_value(
         self,
@@ -906,19 +637,11 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         Expects exactly one row with one column.
         Raises an exception if no rows or more than one row/column is returned.
         """
-        result = await self.driver.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
-        data = result.get_data()
-        # For select operations, data should be a list
-        if not isinstance(data, list):
-            msg = "Expected list result from select operation"
-            raise TypeError(msg)
-        if not data:
+        result = await self.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)  # type: ignore[attr-defined]
+        row = result.one()
+        if not row:
             msg = "No rows found"
-            raise ValueError(msg)
-        if len(data) > 1:
-            msg = f"Expected exactly one row, found {len(data)}"
-            raise ValueError(msg)
-        row = data[0]
+            raise NotFoundError(msg)
         if is_dict_row(row):
             if not row:
                 msg = "Row has no columns"
@@ -948,7 +671,9 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         Expects at most one row with one column.
         Raises an exception if more than one row is returned.
         """
-        result = await self.driver.execute(statement, *parameters, _connection=_connection, _config=_config, **kwargs)
+        result = await self.execute(  # type: ignore[attr-defined]
+            statement, *parameters, _connection=_connection, _config=_config, **kwargs
+        )
         data = result.get_data()
         # For select operations, data should be a list
         if not isinstance(data, list):
@@ -1007,65 +732,7 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
         _connection: "Optional[ConnectionT]" = None,
         _config: "Optional[SQLConfig]" = None,
         **kwargs: Any,
-    ) -> Any:
-        """Execute a paginated query with automatic counting.
-
-        This method performs two queries:
-        1. A count query to get the total number of results
-        2. A data query with limit/offset applied
-
-        Pagination can be specified either via LimitOffsetFilter in parameters
-        or via 'limit' and 'offset' in kwargs.
-
-        Args:
-            statement: The SELECT statement to paginate
-            *parameters: Statement parameters and filters (can include LimitOffsetFilter)
-            schema_type: Optional model type for automatic schema conversion
-            _connection: Optional connection to use
-            _config: Optional SQL configuration
-            **kwargs: Additional driver-specific arguments. Can include 'limit' and 'offset'
-                      if LimitOffsetFilter is not provided
-
-        Returns:
-            OffsetPagination object containing items, limit, offset, and total count
-
-        Raises:
-            ValueError: If neither LimitOffsetFilter nor limit/offset kwargs are provided
-
-        Example:
-            >>> # Basic pagination
-            >>> from sqlspec.statement.filters import LimitOffsetFilter
-            >>> result = await service.paginate(
-            ...     sql.select("*").from_("users"),
-            ...     LimitOffsetFilter(limit=10, offset=20),
-            ... )
-            >>> print(
-            ...     f"Showing {len(result.items)} of {result.total} users"
-            ... )
-
-            >>> # With schema conversion
-            >>> result = await service.paginate(
-            ...     sql.select("*").from_("users"),
-            ...     LimitOffsetFilter(limit=10, offset=0),
-            ...     schema_type=User,
-            ... )
-            >>> # result.items is list[User] with proper type inference
-
-            >>> # With multiple filters
-            >>> from sqlspec.statement.filters import (
-            ...     LimitOffsetFilter,
-            ...     OrderByFilter,
-            ... )
-            >>> result = await service.paginate(
-            ...     sql.select("*").from_("users"),
-            ...     OrderByFilter("created_at", "desc"),
-            ...     LimitOffsetFilter(limit=20, offset=40),
-            ...     schema_type=User,
-            ... )
-        """
-        from sqlspec.service.pagination import OffsetPagination
-        from sqlspec.statement.sql import SQL
-
+    ) -> "Union[OffsetPagination[RowT], OffsetPagination[ModelDTOT]]":
         # Separate filters from parameters
         filters: list[StatementFilter] = []
         params: list[Any] = []
@@ -1096,36 +763,34 @@ class SQLSpecAsyncService(Generic[AsyncDriverT, ConnectionT]):
             msg = "Pagination requires either a LimitOffsetFilter in parameters or 'limit' and 'offset' in kwargs."
             raise ValueError(msg)
 
-        base_stmt = self._normalize_statement(statement, params, _config)
+        base_stmt = self._transform_to_sql(statement, params, _config)  # type: ignore[arg-type]
 
         filtered_stmt = base_stmt
         for filter_obj in other_filters:
             filtered_stmt = filter_obj.append_to_statement(filtered_stmt)
-
-        sql_str = filtered_stmt.to_sql()
-
-        # Parse and transform the AST to create a count query
-        parsed = parse_one(sql_str)
+        parsed = parse_one(filtered_stmt.to_sql())
 
         # Using exp.Subquery to properly wrap the parsed expression
         subquery = exp.Subquery(this=parsed, alias="_count_subquery")
         count_ast = exp.Select().select(exp.func("COUNT", exp.Star()).as_("total")).from_(subquery)
 
-        count_stmt = SQL(count_ast.sql(), _config=_config)
+        # Preserve parameters from the original statement
+        count_stmt = SQL(count_ast, *filtered_stmt.parameters, _config=_config)
 
         # Execute count query
         total = await self.select_value(count_stmt, _connection=_connection, _config=_config, **kwargs)
 
-        data_stmt = self._normalize_statement(statement, params, _config)
+        data_stmt = self._transform_to_sql(statement, params, _config)  # type: ignore[arg-type]
 
         for filter_obj in other_filters:
             data_stmt = filter_obj.append_to_statement(data_stmt)
 
-        data_stmt = data_stmt.limit(limit).offset(offset)
+        limit_offset = LimitOffsetFilter(limit=limit, offset=offset)
+        data_stmt = limit_offset.append_to_statement(data_stmt)
 
         # Execute data query
         items = await self.select(
-            data_stmt, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
+            data_stmt, *params, schema_type=schema_type, _connection=_connection, _config=_config, **kwargs
         )
 
-        return OffsetPagination(items=items, limit=limit, offset=offset, total=total)
+        return OffsetPagination(items=items, limit=limit, offset=offset, total=total)  # pyright: ignore