sqlspec 0.26.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

sqlspec/adapters/asyncpg/data_dictionary.py

@@ -1,12 +1,14 @@
 """PostgreSQL-specific data dictionary for metadata queries via asyncpg."""
 
 import re
-from typing import TYPE_CHECKING, Callable, Optional, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from sqlspec.driver import AsyncDataDictionaryBase, AsyncDriverAdapterBase, VersionInfo
 from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from sqlspec.adapters.asyncpg.driver import AsyncpgDriver
 
 logger = get_logger("adapters.asyncpg.data_dictionary")
@@ -20,7 +22,7 @@ __all__ = ("PostgresAsyncDataDictionary",)
 class PostgresAsyncDataDictionary(AsyncDataDictionaryBase):
     """PostgreSQL-specific async data dictionary."""
 
-    async def get_version(self, driver: AsyncDriverAdapterBase) -> "Optional[VersionInfo]":
+    async def get_version(self, driver: AsyncDriverAdapterBase) -> "VersionInfo | None":
         """Get PostgreSQL database version information.
 
         Args:
@@ -112,6 +114,43 @@ class PostgresAsyncDataDictionary(AsyncDataDictionaryBase):
         }
         return type_map.get(type_category, "TEXT")
 
+    async def get_columns(
+        self, driver: AsyncDriverAdapterBase, table: str, schema: "str | None" = None
+    ) -> "list[dict[str, Any]]":
+        """Get column information for a table using information_schema.
+
+        Args:
+            driver: AsyncPG driver instance
+            table: Table name to query columns for
+            schema: Schema name (None for default 'public')
+
+        Returns:
+            List of column metadata dictionaries with keys:
+                - column_name: Name of the column
+                - data_type: PostgreSQL data type
+                - is_nullable: Whether column allows NULL (YES/NO)
+                - column_default: Default value if any
+        """
+        asyncpg_driver = cast("AsyncpgDriver", driver)
+
+        if schema:
+            sql = f"""
+                SELECT column_name, data_type, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_name = '{table}' AND table_schema = '{schema}'
+                ORDER BY ordinal_position
+            """
+        else:
+            sql = f"""
+                SELECT column_name, data_type, is_nullable, column_default
+                FROM information_schema.columns
+                WHERE table_name = '{table}' AND table_schema = 'public'
+                ORDER BY ordinal_position
+            """
+
+        result = await asyncpg_driver.execute(sql)
+        return result.data or []
+
     def list_available_features(self) -> "list[str]":
         """List available PostgreSQL feature flags.
 

sqlspec/adapters/asyncpg/driver.py

@@ -6,7 +6,7 @@ PostgreSQL COPY operation support, and transaction management.
 
 import datetime
 import re
-from typing import TYPE_CHECKING, Any, Final, Optional
+from typing import TYPE_CHECKING, Any, Final
 
 import asyncpg
 
@@ -14,7 +14,19 @@ from sqlspec.core.cache import get_cache_config
 from sqlspec.core.parameters import ParameterStyle, ParameterStyleConfig
 from sqlspec.core.statement import StatementConfig
 from sqlspec.driver import AsyncDriverAdapterBase
-from sqlspec.exceptions import SQLParsingError, SQLSpecError
+from sqlspec.exceptions import (
+    CheckViolationError,
+    DatabaseConnectionError,
+    DataError,
+    ForeignKeyViolationError,
+    IntegrityError,
+    NotNullViolationError,
+    OperationalError,
+    SQLParsingError,
+    SQLSpecError,
+    TransactionError,
+    UniqueViolationError,
+)
 from sqlspec.utils.logging import get_logger
 
 if TYPE_CHECKING:
@@ -31,6 +43,48 @@ __all__ = ("AsyncpgCursor", "AsyncpgDriver", "AsyncpgExceptionHandler", "asyncpg
 logger = get_logger("adapters.asyncpg")
 
 
+def _convert_datetime_param(value: Any) -> Any:
+    """Convert datetime parameter, handling ISO strings.
+
+    Args:
+        value: datetime object or ISO format string
+
+    Returns:
+        datetime object for asyncpg
+    """
+    if isinstance(value, str):
+        return datetime.datetime.fromisoformat(value)
+    return value
+
+
+def _convert_date_param(value: Any) -> Any:
+    """Convert date parameter, handling ISO strings.
+
+    Args:
+        value: date object or ISO format string
+
+    Returns:
+        date object for asyncpg
+    """
+    if isinstance(value, str):
+        return datetime.date.fromisoformat(value)
+    return value
+
+
+def _convert_time_param(value: Any) -> Any:
+    """Convert time parameter, handling ISO strings.
+
+    Args:
+        value: time object or ISO format string
+
+    Returns:
+        time object for asyncpg
+    """
+    if isinstance(value, str):
+        return datetime.time.fromisoformat(value)
+    return value
+
+
 asyncpg_statement_config = StatementConfig(
     dialect="postgres",
     parameter_config=ParameterStyleConfig(
@@ -38,7 +92,11 @@ asyncpg_statement_config = StatementConfig(
         supported_parameter_styles={ParameterStyle.NUMERIC, ParameterStyle.POSITIONAL_PYFORMAT},
         default_execution_parameter_style=ParameterStyle.NUMERIC,
         supported_execution_parameter_styles={ParameterStyle.NUMERIC},
-        type_coercion_map={datetime.datetime: lambda x: x, datetime.date: lambda x: x, datetime.time: lambda x: x},
+        type_coercion_map={
+            datetime.datetime: _convert_datetime_param,
+            datetime.date: _convert_date_param,
+            datetime.time: _convert_time_param,
+        },
         has_native_list_expansion=True,
         needs_static_script_compilation=False,
         preserve_parameter_format=True,
@@ -69,7 +127,11 @@ class AsyncpgCursor:
 
 
 class AsyncpgExceptionHandler:
-    """Async context manager for handling AsyncPG database exceptions."""
+    """Async context manager for handling AsyncPG database exceptions.
+
+    Maps PostgreSQL SQLSTATE error codes to specific SQLSpec exceptions
+    for better error handling in application code.
+    """
 
     __slots__ = ()
 
@@ -80,21 +142,89 @@ class AsyncpgExceptionHandler:
         if exc_type is None:
             return
         if issubclass(exc_type, asyncpg.PostgresError):
-            e = exc_val
-            error_code = getattr(e, "sqlstate", None)
-            if error_code:
-                if error_code.startswith("23"):
-                    msg = f"PostgreSQL integrity constraint violation [{error_code}]: {e}"
-                elif error_code.startswith("42"):
-                    msg = f"PostgreSQL SQL syntax error [{error_code}]: {e}"
-                    raise SQLParsingError(msg) from e
-                elif error_code.startswith("08"):
-                    msg = f"PostgreSQL connection error [{error_code}]: {e}"
-                else:
-                    msg = f"PostgreSQL database error [{error_code}]: {e}"
-            else:
-                msg = f"PostgreSQL database error: {e}"
-            raise SQLSpecError(msg) from e
+            self._map_postgres_exception(exc_val)
+
+    def _map_postgres_exception(self, e: Any) -> None:
+        """Map PostgreSQL exception to SQLSpec exception.
+
+        Args:
+            e: asyncpg.PostgresError instance
+
+        Raises:
+            Specific SQLSpec exception based on SQLSTATE code
+        """
+        error_code = getattr(e, "sqlstate", None)
+
+        if not error_code:
+            self._raise_generic_error(e, None)
+            return
+
+        if error_code == "23505":
+            self._raise_unique_violation(e, error_code)
+        elif error_code == "23503":
+            self._raise_foreign_key_violation(e, error_code)
+        elif error_code == "23502":
+            self._raise_not_null_violation(e, error_code)
+        elif error_code == "23514":
+            self._raise_check_violation(e, error_code)
+        elif error_code.startswith("23"):
+            self._raise_integrity_error(e, error_code)
+        elif error_code.startswith("42"):
+            self._raise_parsing_error(e, error_code)
+        elif error_code.startswith("08"):
+            self._raise_connection_error(e, error_code)
+        elif error_code.startswith("40"):
+            self._raise_transaction_error(e, error_code)
+        elif error_code.startswith("22"):
+            self._raise_data_error(e, error_code)
+        elif error_code.startswith(("53", "54", "55", "57", "58")):
+            self._raise_operational_error(e, error_code)
+        else:
+            self._raise_generic_error(e, error_code)
+
+    def _raise_unique_violation(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL unique constraint violation [{code}]: {e}"
+        raise UniqueViolationError(msg) from e
+
+    def _raise_foreign_key_violation(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL foreign key constraint violation [{code}]: {e}"
+        raise ForeignKeyViolationError(msg) from e
+
+    def _raise_not_null_violation(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL not-null constraint violation [{code}]: {e}"
+        raise NotNullViolationError(msg) from e
+
+    def _raise_check_violation(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL check constraint violation [{code}]: {e}"
+        raise CheckViolationError(msg) from e
+
+    def _raise_integrity_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL integrity constraint violation [{code}]: {e}"
+        raise IntegrityError(msg) from e
+
+    def _raise_parsing_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL SQL syntax error [{code}]: {e}"
+        raise SQLParsingError(msg) from e
+
+    def _raise_connection_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL connection error [{code}]: {e}"
+        raise DatabaseConnectionError(msg) from e
+
+    def _raise_transaction_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL transaction error [{code}]: {e}"
+        raise TransactionError(msg) from e
+
+    def _raise_data_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL data error [{code}]: {e}"
+        raise DataError(msg) from e
+
+    def _raise_operational_error(self, e: Any, code: str) -> None:
+        msg = f"PostgreSQL operational error [{code}]: {e}"
+        raise OperationalError(msg) from e
+
+    def _raise_generic_error(self, e: Any, code: "str | None") -> None:
+        msg = f"PostgreSQL database error [{code}]: {e}" if code else f"PostgreSQL database error: {e}"
+        raise SQLSpecError(msg) from e
 
 
 class AsyncpgDriver(AsyncDriverAdapterBase):
@@ -111,8 +241,8 @@ class AsyncpgDriver(AsyncDriverAdapterBase):
     def __init__(
         self,
         connection: "AsyncpgConnection",
-        statement_config: "Optional[StatementConfig]" = None,
-        driver_features: "Optional[dict[str, Any]]" = None,
+        statement_config: "StatementConfig | None" = None,
+        driver_features: "dict[str, Any] | None" = None,
     ) -> None:
         if statement_config is None:
             cache_config = get_cache_config()
@@ -124,7 +254,7 @@ class AsyncpgDriver(AsyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
-        self._data_dictionary: Optional[AsyncDataDictionaryBase] = None
+        self._data_dictionary: AsyncDataDictionaryBase | None = None
 
     def with_cursor(self, connection: "AsyncpgConnection") -> "AsyncpgCursor":
         """Create context manager for AsyncPG cursor."""
@@ -134,7 +264,7 @@ class AsyncpgDriver(AsyncDriverAdapterBase):
         """Handle database exceptions with PostgreSQL error codes."""
         return AsyncpgExceptionHandler()
 
-    async def _try_special_handling(self, cursor: "AsyncpgConnection", statement: "SQL") -> "Optional[SQLResult]":
+    async def _try_special_handling(self, cursor: "AsyncpgConnection", statement: "SQL") -> "SQLResult | None":
         """Handle PostgreSQL COPY operations and other special cases.
 
         Args:

sqlspec/adapters/asyncpg/litestar/__init__.py

@@ -0,0 +1,5 @@
+"""Litestar integration for AsyncPG adapter."""
+
+from sqlspec.adapters.asyncpg.litestar.store import AsyncpgStore
+
+__all__ = ("AsyncpgStore",)

sqlspec/adapters/asyncpg/litestar/store.py

@@ -0,0 +1,253 @@
+"""AsyncPG session store for Litestar integration."""
+
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING
+
+from sqlspec.extensions.litestar.store import BaseSQLSpecStore
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.asyncpg.config import AsyncpgConfig
+
+logger = get_logger("adapters.asyncpg.litestar.store")
+
+__all__ = ("AsyncpgStore",)
+
+
+class AsyncpgStore(BaseSQLSpecStore["AsyncpgConfig"]):
+    """PostgreSQL session store using AsyncPG driver.
+
+    Implements server-side session storage for Litestar using PostgreSQL
+    via the AsyncPG driver. Provides efficient session management with:
+    - Native async PostgreSQL operations
+    - UPSERT support using ON CONFLICT
+    - Automatic expiration handling
+    - Efficient cleanup of expired sessions
+
+    Args:
+        config: AsyncpgConfig instance with extension_config["litestar"] settings.
+
+    Example:
+        from sqlspec.adapters.asyncpg import AsyncpgConfig
+        from sqlspec.adapters.asyncpg.litestar.store import AsyncpgStore
+
+        config = AsyncpgConfig(
+            pool_config={"dsn": "postgresql://..."},
+            extension_config={"litestar": {"session_table": "my_sessions"}}
+        )
+        store = AsyncpgStore(config)
+        await store.create_table()
+    """
+
+    __slots__ = ()
+
+    def __init__(self, config: "AsyncpgConfig") -> None:
+        """Initialize AsyncPG session store.
+
+        Args:
+            config: AsyncpgConfig instance.
+
+        Notes:
+            Table name is read from config.extension_config["litestar"]["session_table"].
+        """
+        super().__init__(config)
+
+    def _get_create_table_sql(self) -> str:
+        """Get PostgreSQL CREATE TABLE SQL with optimized schema.
+
+        Returns:
+            SQL statement to create the sessions table with proper indexes.
+
+        Notes:
+            - Uses TIMESTAMPTZ for timezone-aware expiration timestamps
+            - Partial index WHERE expires_at IS NOT NULL reduces index size/maintenance
+            - FILLFACTOR 80 leaves space for HOT updates, reducing table bloat
+            - Audit columns (created_at, updated_at) help with debugging
+            - Table name is internally controlled, not user input (S608 suppressed)
+        """
+        return f"""
+        CREATE TABLE IF NOT EXISTS {self._table_name} (
+            session_id TEXT PRIMARY KEY,
+            data BYTEA NOT NULL,
+            expires_at TIMESTAMPTZ,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+        ) WITH (fillfactor = 80);
+
+        CREATE INDEX IF NOT EXISTS idx_{self._table_name}_expires_at
+        ON {self._table_name}(expires_at) WHERE expires_at IS NOT NULL;
+
+        ALTER TABLE {self._table_name} SET (
+            autovacuum_vacuum_scale_factor = 0.05,
+            autovacuum_analyze_scale_factor = 0.02
+        );
+        """
+
+    def _get_drop_table_sql(self) -> "list[str]":
+        """Get PostgreSQL DROP TABLE SQL statements.
+
+        Returns:
+            List of SQL statements to drop indexes and table.
+        """
+        return [f"DROP INDEX IF EXISTS idx_{self._table_name}_expires_at", f"DROP TABLE IF EXISTS {self._table_name}"]
+
+    async def create_table(self) -> None:
+        """Create the session table if it doesn't exist."""
+        sql = self._get_create_table_sql()
+        async with self._config.provide_session() as driver:
+            await driver.execute_script(sql)
+        logger.debug("Created session table: %s", self._table_name)
+
+    async def get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        """Get a session value by key.
+
+        Args:
+            key: Session ID to retrieve.
+            renew_for: If given, renew the expiry time for this duration.
+
+        Returns:
+            Session data as bytes if found and not expired, None otherwise.
+
+        Notes:
+            Uses CURRENT_TIMESTAMP instead of NOW() for SQL standard compliance.
+            The query planner can use the partial index for expires_at > CURRENT_TIMESTAMP.
+        """
+        sql = f"""
+        SELECT data, expires_at FROM {self._table_name}
+        WHERE session_id = $1
+        AND (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)
+        """
+
+        async with self._config.provide_connection() as conn:
+            row = await conn.fetchrow(sql, key)
+
+            if row is None:
+                return None
+
+            if renew_for is not None and row["expires_at"] is not None:
+                new_expires_at = self._calculate_expires_at(renew_for)
+                if new_expires_at is not None:
+                    update_sql = f"""
+                    UPDATE {self._table_name}
+                    SET expires_at = $1, updated_at = CURRENT_TIMESTAMP
+                    WHERE session_id = $2
+                    """
+                    await conn.execute(update_sql, new_expires_at, key)
+
+            return bytes(row["data"])
+
+    async def set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        """Store a session value.
+
+        Args:
+            key: Session ID.
+            value: Session data.
+            expires_in: Time until expiration.
+
+        Notes:
+            Uses EXCLUDED to reference the proposed insert values in ON CONFLICT.
+            Updates updated_at timestamp on every write for audit trail.
+        """
+        data = self._value_to_bytes(value)
+        expires_at = self._calculate_expires_at(expires_in)
+
+        sql = f"""
+        INSERT INTO {self._table_name} (session_id, data, expires_at)
+        VALUES ($1, $2, $3)
+        ON CONFLICT (session_id)
+        DO UPDATE SET
+            data = EXCLUDED.data,
+            expires_at = EXCLUDED.expires_at,
+            updated_at = CURRENT_TIMESTAMP
+        """
+
+        async with self._config.provide_connection() as conn:
+            await conn.execute(sql, key, data, expires_at)
+
+    async def delete(self, key: str) -> None:
+        """Delete a session by key.
+
+        Args:
+            key: Session ID to delete.
+        """
+        sql = f"DELETE FROM {self._table_name} WHERE session_id = $1"
+
+        async with self._config.provide_connection() as conn:
+            await conn.execute(sql, key)
+
+    async def delete_all(self) -> None:
+        """Delete all sessions from the store."""
+        sql = f"DELETE FROM {self._table_name}"
+
+        async with self._config.provide_connection() as conn:
+            await conn.execute(sql)
+        logger.debug("Deleted all sessions from table: %s", self._table_name)
+
+    async def exists(self, key: str) -> bool:
+        """Check if a session key exists and is not expired.
+
+        Args:
+            key: Session ID to check.
+
+        Returns:
+            True if the session exists and is not expired.
+
+        Notes:
+            Uses CURRENT_TIMESTAMP for consistency with get() method.
+        """
+        sql = f"""
+        SELECT 1 FROM {self._table_name}
+        WHERE session_id = $1
+        AND (expires_at IS NULL OR expires_at > CURRENT_TIMESTAMP)
+        """
+
+        async with self._config.provide_connection() as conn:
+            result = await conn.fetchval(sql, key)
+            return result is not None
+
+    async def expires_in(self, key: str) -> "int | None":
+        """Get the time in seconds until the session expires.
+
+        Args:
+            key: Session ID to check.
+
+        Returns:
+            Seconds until expiration, or None if no expiry or key doesn't exist.
+        """
+        sql = f"""
+        SELECT expires_at FROM {self._table_name}
+        WHERE session_id = $1
+        """
+
+        async with self._config.provide_connection() as conn:
+            expires_at = await conn.fetchval(sql, key)
+
+            if expires_at is None:
+                return None
+
+            now = datetime.now(timezone.utc)
+            if expires_at <= now:
+                return 0
+
+            delta = expires_at - now
+            return int(delta.total_seconds())
+
+    async def delete_expired(self) -> int:
+        """Delete all expired sessions.
+
+        Returns:
+            Number of sessions deleted.
+
+        Notes:
+            Uses CURRENT_TIMESTAMP for consistency.
+            For very large tables (10M+ rows), consider batching deletes
+            to avoid holding locks too long.
+        """
+        sql = f"DELETE FROM {self._table_name} WHERE expires_at <= CURRENT_TIMESTAMP"
+
+        async with self._config.provide_connection() as conn:
+            result = await conn.execute(sql)
+            count = int(result.split()[-1])
+            if count > 0:
+                logger.debug("Cleaned up %d expired sessions", count)
+            return count

sqlspec/adapters/bigquery/_types.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING
 from google.cloud.bigquery import Client
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 
     BigQueryConnection: TypeAlias = Client
 else:

sqlspec/adapters/bigquery/adk/__init__.py

@@ -0,0 +1,5 @@
+"""BigQuery ADK store for Google Agent Development Kit session/event storage."""
+
+from sqlspec.adapters.bigquery.adk.store import BigQueryADKStore
+
+__all__ = ("BigQueryADKStore",)