sqlspec 0.61.0__tar.gz → 0.62.0__tar.gz

{sqlspec-0.61.0 → sqlspec-0.62.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: sqlspec
-Version: 0.61.0
+Version: 0.62.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.61.0 → sqlspec-0.62.0}/pyproject.toml

@@ -24,7 +24,7 @@ maintainers = [{ name = "Litestar Developers", email = "hello@litestar.dev" }]
 name = "sqlspec"
 readme = "README.md"
 requires-python = ">=3.10, <4.0"
-version = "0.61.0"
+version = "0.62.0"
 
 [project.urls]
 Discord = "https://discord.gg/litestar"
@@ -331,7 +331,7 @@ opt_level = "3"   # Maximum optimization (0-3)
 allow_dirty = true
 commit = false
 commit_args = "--no-verify"
-current_version = "0.61.0"
+current_version = "0.61.1"
 ignore_missing_files = false
 ignore_missing_version = false
 message = "chore(release): bump to v{new_version}"

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/adbc/adk/store.py

@@ -5,7 +5,7 @@ import re
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any, Final, Literal
 
-from sqlspec.extensions.adk import BaseSyncADKStore, StoredEvent, StoredSession
+from sqlspec.extensions.adk import BaseSyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory.store import BaseSyncADKMemoryStore
 from sqlspec.utils.logging import get_logger
 from sqlspec.utils.serializers import from_json, to_json
@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from sqlspec.adapters.adbc.config import AdbcConfig
-    from sqlspec.extensions.adk import StoredMemory
+    from sqlspec.extensions.adk import SessionOrderBy, StoredMemory
 
 __all__ = ("AdbcADKMemoryStore", "AdbcADKStore")
 
@@ -96,9 +96,20 @@ class AdbcADKStore(BaseSyncADKStore["AdbcConfig"]):
         """Update session state."""
         self._update_session_state(app_name, user_id, session_id, state)
 
-    def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[StoredSession]":
+    def list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List sessions for an app."""
-        return self._list_sessions(app_name, user_id)
+        return self._list_sessions(
+            app_name, user_id, order_by=order_by, descending=descending, limit=limit, offset=offset
+        )
 
     def delete_session(self, app_name: str, user_id: str, session_id: str) -> None:
         """Delete session and associated events."""
@@ -607,6 +618,33 @@ class AdbcADKStore(BaseSyncADKStore["AdbcConfig"]):
         """Execute parameterized SQL using the current ADBC dialect's placeholder style."""
         return cursor.execute(self._format_sql(sql), params)
 
+    def _session_list_query(
+        self, app_name: str, user_id: "str | None", column: str, direction: str, limit: "int | None", offset: int
+    ) -> "tuple[str, tuple[Any, ...]]":
+        """Return the bounded session-list query in the current dialect's page grammar."""
+        params: list[Any] = [app_name]
+        where_clause = "app_name = ?"
+        if user_id is not None:
+            params.append(user_id)
+            where_clause = f"{where_clause} AND user_id = ?"
+
+        page_clause = ""
+        if limit is not None:
+            if self._dialect == DIALECT_GENERIC:
+                params.extend((offset, limit))
+                page_clause = "\n            OFFSET ? ROWS FETCH NEXT ? ROWS ONLY"
+            else:
+                params.extend((limit, offset))
+                page_clause = "\n            LIMIT ? OFFSET ?"
+
+        sql = f"""
+        SELECT id, app_name, user_id, state, create_time, update_time
+        FROM {self._session_table}
+        WHERE {where_clause}
+        ORDER BY {column} {direction}, id {direction}{page_clause}
+        """
+        return sql, tuple(params)
+
     def _json_placeholder(self) -> str:
         """Return a JSON parameter placeholder for the current dialect."""
         if self._dialect == DIALECT_POSTGRESQL:
@@ -775,32 +813,34 @@ class AdbcADKStore(BaseSyncADKStore["AdbcConfig"]):
             finally:
                 cursor.close()
 
-    def _list_sessions(self, app_name: str, user_id: str | None = None) -> "list[StoredSession]":
+    def _list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
             user_id: User identifier. If None, lists all sessions for the app.
+            order_by: Timestamp column to sort on.
+            descending: Sort direction for the timestamp column and the id tie-break.
+            limit: Maximum number of sessions to return.
+            offset: Number of leading rows to skip.
 
         Returns:
-            List of session records ordered by update_time DESC.
+            List of session records.
         """
-        if user_id is None:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = ?
-            ORDER BY update_time DESC
-            """
-            params: tuple[str, ...] = (app_name,)
-        else:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = ? AND user_id = ?
-            ORDER BY update_time DESC
-            """
-            params = (app_name, user_id)
+        column, direction, page_limit, page_offset = normalize_session_list_options(order_by, descending, limit, offset)
+        if page_limit == 0:
+            return []
+
+        sql, params = self._session_list_query(app_name, user_id, column, direction, page_limit, page_offset)
 
         try:
             with self._config.provide_connection() as conn:

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/aiomysql/adk/store.py

@@ -9,7 +9,7 @@ from typing_extensions import NotRequired
 
 from sqlspec.adapters.aiomysql._typing import AiomysqlCursor, AiomysqlRawCursor
 from sqlspec.config import ADKConfig
-from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession
+from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory.store import BaseAsyncADKMemoryStore
 from sqlspec.utils.serializers import from_json, to_json
 
@@ -18,7 +18,7 @@ if TYPE_CHECKING:
     from datetime import datetime, timedelta
 
     from sqlspec.adapters.aiomysql.config import AiomysqlConfig
-    from sqlspec.extensions.adk import StoredMemory
+    from sqlspec.extensions.adk import SessionOrderBy, StoredMemory
 
 
 __all__ = ("AiomysqlADKConfig", "AiomysqlADKMemoryStore", "AiomysqlADKStore")
@@ -164,24 +164,24 @@ class AiomysqlADKStore(BaseAsyncADKStore["AiomysqlConfig"]):
             await cursor.execute(sql, (to_json(state), app_name, user_id, session_id))
             await conn.commit()
 
-    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[StoredSession]":
+    async def list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List sessions for an app, optionally filtered by user."""
-        if user_id is None:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = %s
-            ORDER BY update_time DESC
-            """
-            params: tuple[Any, ...] = (app_name,)
-        else:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = %s AND user_id = %s
-            ORDER BY update_time DESC
-            """
-            params = (app_name, user_id)
+        column, direction, page_limit, page_offset = normalize_session_list_options(order_by, descending, limit, offset)
+        if page_limit == 0:
+            return []
+
+        sql, params = _session_list_query(
+            self._session_table, app_name, user_id, column, direction, page_limit, page_offset
+        )
 
         try:
             async with (
@@ -953,3 +953,33 @@ def _build_mysql_scope_where(
     if scope_filter == "user":
         return "app_name = %s AND scope = 'user' AND user_id = %s", (app_name, user_id)
     return "app_name = %s AND scope = 'app'", (app_name,)
+
+
+def _session_list_query(
+    session_table: str,
+    app_name: str,
+    user_id: "str | None",
+    column: str,
+    direction: str,
+    limit: "int | None",
+    offset: int,
+) -> "tuple[str, tuple[Any, ...]]":
+    """Return the bounded session-list query and its bound values."""
+    params: list[Any] = [app_name]
+    where_clause = "app_name = %s"
+    if user_id is not None:
+        params.append(user_id)
+        where_clause = f"{where_clause} AND user_id = %s"
+
+    page_clause = ""
+    if limit is not None:
+        params.extend((limit, offset))
+        page_clause = "\n            LIMIT %s OFFSET %s"
+
+    sql = f"""
+    SELECT id, app_name, user_id, state, create_time, update_time
+    FROM {session_table}
+    WHERE {where_clause}
+    ORDER BY {column} {direction}, id {direction}{page_clause}
+    """
+    return sql, tuple(params)

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/aiomysql/core.py

@@ -190,21 +190,21 @@ class AiomysqlStreamSource:
         self._row_plan: tuple[list[str], list[int] | None] | None = None
 
     async def start(self) -> None:
-        from aiomysql import SSCursor
-
         handler = self._driver.handle_database_exceptions()
-        async with handler:
-            cursor = await self._driver.connection.cursor(SSCursor)
-            self._cursor = cursor
-            await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
-            self._row_plan = resolve_row_plan(self._cursor.description, self._json_type_codes)
+        await self._driver._run_with_exception_handler(handler, self._start)
         self._driver._check_pending_exception(handler)
 
+    async def _start(self) -> None:
+        from aiomysql import SSCursor
+
+        cursor = await self._driver.connection.cursor(SSCursor)
+        self._cursor = cursor
+        await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
+        self._row_plan = resolve_row_plan(self._cursor.description, self._json_type_codes)
+
     async def fetch_chunk(self) -> "list[dict[str, Any]]":
         handler = self._driver.handle_database_exceptions()
-        rows: list[Any] = []
-        async with handler:
-            rows = await self._cursor.fetchmany(self._chunk_size)
+        rows = await self._driver._run_with_exception_handler(handler, self._cursor.fetchmany, self._chunk_size)
         self._driver._check_pending_exception(handler)
         if not rows:
             return []

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/aiosqlite/adk/store.py

@@ -11,7 +11,7 @@ from typing_extensions import NotRequired
 from sqlspec.adapters.aiosqlite.config import _render_pragmas
 from sqlspec.config import ADKConfig
 from sqlspec.exceptions import ImproperConfigurationError
-from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession
+from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory.store import BaseAsyncADKMemoryStore
 from sqlspec.utils.serializers import from_json, to_json
 
@@ -19,7 +19,7 @@ if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from sqlspec.adapters.aiosqlite.config import AiosqliteConfig
-    from sqlspec.extensions.adk import StoredMemory
+    from sqlspec.extensions.adk import SessionOrderBy, StoredMemory
 
 __all__ = ("AiosqliteADKConfig", "AiosqliteADKMemoryStore", "AiosqliteADKStore")
 
@@ -208,32 +208,36 @@ class AiosqliteADKStore(BaseAsyncADKStore["AiosqliteConfig"]):
             await conn.execute(sql, (state_json, now_julian, app_name, user_id, session_id))
             await conn.commit()
 
-    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[StoredSession]":
+    async def list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List sessions for an app, optionally filtered by user.
 
         Args:
             app_name: Application name.
             user_id: User identifier. If None, lists all sessions for the app.
+            order_by: Timestamp column to sort on.
+            descending: Sort direction for the timestamp column and the id tie-break.
+            limit: Maximum number of sessions to return.
+            offset: Number of leading rows to skip.
 
         Returns:
-            List of session records ordered by update_time DESC.
+            List of session records.
         """
-        if user_id is None:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = ?
-            ORDER BY update_time DESC
-            """
-            params: tuple[str, ...] = (app_name,)
-        else:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = ? AND user_id = ?
-            ORDER BY update_time DESC
-            """
-            params = (app_name, user_id)
+        column, direction, page_limit, page_offset = normalize_session_list_options(order_by, descending, limit, offset)
+        if page_limit == 0:
+            return []
+
+        sql, params = _session_list_query(
+            self._session_table, app_name, user_id, column, direction, page_limit, page_offset
+        )
 
         try:
             async with self._config.provide_connection() as conn:
@@ -1110,3 +1114,33 @@ def _build_sqlite_scope_clause(
     if scope_filter == "user":
         return f"{prefix}app_name = ? AND {prefix}scope = 'user' AND {prefix}user_id = ?", (app_name, user_id)
     return f"{prefix}app_name = ? AND {prefix}scope = 'app'", (app_name,)
+
+
+def _session_list_query(
+    session_table: str,
+    app_name: str,
+    user_id: "str | None",
+    column: str,
+    direction: str,
+    limit: "int | None",
+    offset: int,
+) -> "tuple[str, tuple[Any, ...]]":
+    """Return the bounded session-list query and its bound values."""
+    params: list[Any] = [app_name]
+    where_clause = "app_name = ?"
+    if user_id is not None:
+        params.append(user_id)
+        where_clause = f"{where_clause} AND user_id = ?"
+
+    page_clause = ""
+    if limit is not None:
+        params.extend((limit, offset))
+        page_clause = "\n            LIMIT ? OFFSET ?"
+
+    sql = f"""
+    SELECT id, app_name, user_id, state, create_time, update_time
+    FROM {session_table}
+    WHERE {where_clause}
+    ORDER BY {column} {direction}, id {direction}{page_clause}
+    """
+    return sql, tuple(params)

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/aiosqlite/core.py

@@ -257,18 +257,18 @@ class AiosqliteStreamSource:
 
     async def start(self) -> None:
         handler = self._driver.handle_database_exceptions()
-        async with handler:
-            cursor = await self._driver.connection.cursor()
-            cursor.arraysize = self._chunk_size
-            self._cursor = cursor
-            await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
+        await self._driver._run_with_exception_handler(handler, self._start)
         self._driver._check_pending_exception(handler)
 
+    async def _start(self) -> None:
+        cursor = await self._driver.connection.cursor()
+        cursor.arraysize = self._chunk_size
+        self._cursor = cursor
+        await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
+
     async def fetch_chunk(self) -> "list[dict[str, Any]]":
         handler = self._driver.handle_database_exceptions()
-        rows: list[Any] = []
-        async with handler:
-            rows = await self._cursor.fetchmany(self._chunk_size)
+        rows = await self._driver._run_with_exception_handler(handler, self._cursor.fetchmany, self._chunk_size)
         self._driver._check_pending_exception(handler)
         if not rows:
             return []

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/arrow_odbc/adk/store.py

@@ -7,7 +7,7 @@ from typing_extensions import NotRequired
 
 from sqlspec.config import ADKConfig
 from sqlspec.exceptions import SQLSpecError
-from sqlspec.extensions.adk import BaseSyncADKStore, StoredEvent, StoredSession
+from sqlspec.extensions.adk import BaseSyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory import BaseSyncADKMemoryStore, StoredMemory
 from sqlspec.utils.serializers import from_json, to_json
 
@@ -16,6 +16,7 @@ if TYPE_CHECKING:
     from datetime import timedelta
 
     from sqlspec.adapters.arrow_odbc.config import ArrowOdbcConfig
+    from sqlspec.extensions.adk import SessionOrderBy
 else:
     ArrowOdbcConfig = Any
 
@@ -130,24 +131,24 @@ class ArrowOdbcADKStore(BaseSyncADKStore["ArrowOdbcConfig"]):
             commit=True,
         )
 
-    def list_sessions(self, app_name: str, user_id: "str | None" = None) -> "list[StoredSession]":
+    def list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List ADK sessions for an application, optionally scoped to a user."""
-        if user_id is None:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {_table_ref(self._session_table)}
-            WHERE app_name = ?
-            ORDER BY update_time DESC
-            """
-            params: tuple[Any, ...] = (app_name,)
-        else:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {_table_ref(self._session_table)}
-            WHERE app_name = ? AND user_id = ?
-            ORDER BY update_time DESC
-            """
-            params = (app_name, user_id)
+        column, direction, page_limit, page_offset = normalize_session_list_options(order_by, descending, limit, offset)
+        if page_limit == 0:
+            return []
+
+        sql, params = _session_list_query(
+            self._session_table, app_name, user_id, column, direction, page_limit, page_offset
+        )
         try:
             rows = self._execute_fetchall(sql, params)
         except SQLSpecError as exc:
@@ -912,3 +913,33 @@ def _build_arrow_odbc_scope_where(
     if scope_filter == "user":
         return "app_name = ? AND scope = 'user' AND user_id = ?", (app_name, user_id)
     return "app_name = ? AND scope = 'app'", (app_name,)
+
+
+def _session_list_query(
+    session_table: str,
+    app_name: str,
+    user_id: "str | None",
+    column: str,
+    direction: str,
+    limit: "int | None",
+    offset: int,
+) -> "tuple[str, tuple[Any, ...]]":
+    """Return the bounded session-list query and its bound values."""
+    params: list[Any] = [app_name]
+    where_clause = "app_name = ?"
+    if user_id is not None:
+        params.append(user_id)
+        where_clause = f"{where_clause} AND user_id = ?"
+
+    page_clause = ""
+    if limit is not None:
+        params.extend((offset, limit))
+        page_clause = "\n            OFFSET ? ROWS FETCH NEXT ? ROWS ONLY"
+
+    sql = f"""
+    SELECT id, app_name, user_id, state, create_time, update_time
+    FROM {_table_ref(session_table)}
+    WHERE {where_clause}
+    ORDER BY {column} {direction}, id {direction}{page_clause}
+    """
+    return sql, tuple(params)

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/asyncmy/adk/store.py

@@ -8,7 +8,7 @@ import asyncmy
 from typing_extensions import NotRequired
 
 from sqlspec.config import ADKConfig
-from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession
+from sqlspec.extensions.adk import BaseAsyncADKStore, StoredEvent, StoredSession, normalize_session_list_options
 from sqlspec.extensions.adk.memory.store import BaseAsyncADKMemoryStore
 from sqlspec.utils.serializers import from_json, to_json
 
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
     from datetime import datetime, timedelta
 
     from sqlspec.adapters.asyncmy.config import AsyncmyConfig
-    from sqlspec.extensions.adk import StoredMemory
+    from sqlspec.extensions.adk import SessionOrderBy, StoredMemory
 
 
 __all__ = ("AsyncmyADKConfig", "AsyncmyADKMemoryStore", "AsyncmyADKStore")
@@ -147,24 +147,24 @@ class AsyncmyADKStore(BaseAsyncADKStore["AsyncmyConfig"]):
             await cursor.execute(sql, (to_json(state), app_name, user_id, session_id))
             await conn.commit()
 
-    async def list_sessions(self, app_name: str, user_id: str | None = None) -> "list[StoredSession]":
+    async def list_sessions(
+        self,
+        app_name: str,
+        user_id: "str | None" = None,
+        *,
+        order_by: "SessionOrderBy" = "update_time",
+        descending: bool = True,
+        limit: "int | None" = None,
+        offset: "int | None" = None,
+    ) -> "list[StoredSession]":
         """List sessions for an app, optionally filtered by user."""
-        if user_id is None:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = %s
-            ORDER BY update_time DESC
-            """
-            params: tuple[Any, ...] = (app_name,)
-        else:
-            sql = f"""
-            SELECT id, app_name, user_id, state, create_time, update_time
-            FROM {self._session_table}
-            WHERE app_name = %s AND user_id = %s
-            ORDER BY update_time DESC
-            """
-            params = (app_name, user_id)
+        column, direction, page_limit, page_offset = normalize_session_list_options(order_by, descending, limit, offset)
+        if page_limit == 0:
+            return []
+
+        sql, params = _session_list_query(
+            self._session_table, app_name, user_id, column, direction, page_limit, page_offset
+        )
 
         try:
             async with self._config.provide_connection() as conn, conn.cursor() as cursor:
@@ -890,3 +890,33 @@ def _build_mysql_scope_where(
     if scope_filter == "user":
         return "app_name = %s AND scope = 'user' AND user_id = %s", (app_name, user_id)
     return "app_name = %s AND scope = 'app'", (app_name,)
+
+
+def _session_list_query(
+    session_table: str,
+    app_name: str,
+    user_id: "str | None",
+    column: str,
+    direction: str,
+    limit: "int | None",
+    offset: int,
+) -> "tuple[str, tuple[Any, ...]]":
+    """Return the bounded session-list query and its bound values."""
+    params: list[Any] = [app_name]
+    where_clause = "app_name = %s"
+    if user_id is not None:
+        params.append(user_id)
+        where_clause = f"{where_clause} AND user_id = %s"
+
+    page_clause = ""
+    if limit is not None:
+        params.extend((limit, offset))
+        page_clause = "\n            LIMIT %s OFFSET %s"
+
+    sql = f"""
+    SELECT id, app_name, user_id, state, create_time, update_time
+    FROM {session_table}
+    WHERE {where_clause}
+    ORDER BY {column} {direction}, id {direction}{page_clause}
+    """
+    return sql, tuple(params)

{sqlspec-0.61.0 → sqlspec-0.62.0}/sqlspec/adapters/asyncmy/core.py

@@ -162,21 +162,21 @@ class AsyncmyStreamSource:
         self._row_plan: tuple[list[str], list[int] | None] | None = None
 
     async def start(self) -> None:
-        from asyncmy.cursors import SSCursor
-
         handler = self._driver.handle_database_exceptions()
-        async with handler:
-            cursor = self._driver.connection.cursor(SSCursor)
-            self._cursor = cursor
-            await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
-            self._row_plan = resolve_row_plan(self._cursor.description, self._json_type_codes)
+        await self._driver._run_with_exception_handler(handler, self._start)
         self._driver._check_pending_exception(handler)
 
+    async def _start(self) -> None:
+        from asyncmy.cursors import SSCursor
+
+        cursor = self._driver.connection.cursor(SSCursor)
+        self._cursor = cursor
+        await cursor.execute(self._sql, normalize_execute_parameters(self._parameters))
+        self._row_plan = resolve_row_plan(self._cursor.description, self._json_type_codes)
+
     async def fetch_chunk(self) -> "list[dict[str, Any]]":
         handler = self._driver.handle_database_exceptions()
-        rows: list[Any] = []
-        async with handler:
-            rows = await self._cursor.fetchmany(self._chunk_size)
+        rows = await self._driver._run_with_exception_handler(handler, self._cursor.fetchmany, self._chunk_size)
         self._driver._check_pending_exception(handler)
         if not rows:
             return []