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

sqlspec/adapters/sqlite/litestar/store.py

@@ -0,0 +1,318 @@
+"""SQLite sync 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
+from sqlspec.utils.sync_tools import async_
+
+if TYPE_CHECKING:
+    from sqlspec.adapters.sqlite.config import SqliteConfig
+
+logger = get_logger("adapters.sqlite.litestar.store")
+
+SECONDS_PER_DAY = 86400.0
+JULIAN_EPOCH = 2440587.5
+
+__all__ = ("SQLiteStore",)
+
+
+class SQLiteStore(BaseSQLSpecStore["SqliteConfig"]):
+    """SQLite session store using synchronous SQLite driver.
+
+    Implements server-side session storage for Litestar using SQLite
+    via the synchronous sqlite3 driver. Uses Litestar's sync_to_thread
+    utility to provide an async interface compatible with the Store protocol.
+
+    Provides efficient session management with:
+    - Sync operations wrapped for async compatibility
+    - INSERT OR REPLACE for UPSERT functionality
+    - Automatic expiration handling
+    - Efficient cleanup of expired sessions
+
+    Args:
+        config: SqliteConfig instance.
+
+    Example:
+        from sqlspec.adapters.sqlite import SqliteConfig
+        from sqlspec.adapters.sqlite.litestar.store import SQLiteStore
+
+        config = SqliteConfig(database=":memory:")
+        store = SQLiteStore(config)
+        await store.create_table()
+    """
+
+    __slots__ = ()
+
+    def __init__(self, config: "SqliteConfig") -> None:
+        """Initialize SQLite session store.
+
+        Args:
+            config: SqliteConfig instance.
+
+        Notes:
+            Table name is read from config.extension_config["litestar"]["session_table"].
+        """
+        super().__init__(config)
+
+    def _get_create_table_sql(self) -> str:
+        """Get SQLite CREATE TABLE SQL.
+
+        Returns:
+            SQL statement to create the sessions table with proper indexes.
+
+        Notes:
+            - Uses REAL type for expires_at (stores Julian Day number)
+            - Julian Day enables direct comparison with julianday('now')
+            - Partial index WHERE expires_at IS NOT NULL reduces index size
+            - This approach ensures the index is actually used by query optimizer
+        """
+        return f"""
+        CREATE TABLE IF NOT EXISTS {self._table_name} (
+            session_id TEXT PRIMARY KEY,
+            data BLOB NOT NULL,
+            expires_at REAL
+        );
+        CREATE INDEX IF NOT EXISTS idx_{self._table_name}_expires_at
+        ON {self._table_name}(expires_at) WHERE expires_at IS NOT NULL;
+        """
+
+    def _get_drop_table_sql(self) -> "list[str]":
+        """Get SQLite 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}"]
+
+    def _datetime_to_julian(self, dt: "datetime | None") -> "float | None":
+        """Convert datetime to Julian Day number for SQLite storage.
+
+        Args:
+            dt: Datetime to convert (must be UTC-aware).
+
+        Returns:
+            Julian Day number as REAL, or None if dt is None.
+
+        Notes:
+            Julian Day number is days since November 24, 4714 BCE (proleptic Gregorian).
+            This enables direct comparison with julianday('now') in SQL queries.
+        """
+        if dt is None:
+            return None
+
+        epoch = datetime(1970, 1, 1, tzinfo=timezone.utc)
+        delta_days = (dt - epoch).total_seconds() / SECONDS_PER_DAY
+        return JULIAN_EPOCH + delta_days
+
+    def _julian_to_datetime(self, julian: "float | None") -> "datetime | None":
+        """Convert Julian Day number back to datetime.
+
+        Args:
+            julian: Julian Day number.
+
+        Returns:
+            UTC-aware datetime, or None if julian is None.
+        """
+        if julian is None:
+            return None
+
+        days_since_epoch = julian - JULIAN_EPOCH
+        timestamp = days_since_epoch * SECONDS_PER_DAY
+        return datetime.fromtimestamp(timestamp, tz=timezone.utc)
+
+    def _create_table(self) -> None:
+        """Synchronous implementation of create_table."""
+        sql = self._get_create_table_sql()
+        with self._config.provide_session() as driver:
+            driver.execute_script(sql)
+        logger.debug("Created session table: %s", self._table_name)
+
+    async def create_table(self) -> None:
+        """Create the session table if it doesn't exist."""
+        await async_(self._create_table)()
+
+    def _get(self, key: str, renew_for: "int | timedelta | None" = None) -> "bytes | None":
+        """Synchronous implementation of get."""
+        sql = f"""
+        SELECT data, expires_at FROM {self._table_name}
+        WHERE session_id = ?
+        AND (expires_at IS NULL OR julianday(expires_at) > julianday('now'))
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.execute(sql, (key,))
+            row = cursor.fetchone()
+
+            if row is None:
+                return None
+
+            data, expires_at_julian = row
+
+            if renew_for is not None and expires_at_julian is not None:
+                new_expires_at = self._calculate_expires_at(renew_for)
+                new_expires_at_julian = self._datetime_to_julian(new_expires_at)
+                if new_expires_at_julian is not None:
+                    update_sql = f"""
+                    UPDATE {self._table_name}
+                    SET expires_at = ?
+                    WHERE session_id = ?
+                    """
+                    conn.execute(update_sql, (new_expires_at_julian, key))
+                    conn.commit()
+
+            return bytes(data)
+
+    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.
+        """
+        return await async_(self._get)(key, renew_for)
+
+    def _set(self, key: str, value: "str | bytes", expires_in: "int | timedelta | None" = None) -> None:
+        """Synchronous implementation of set.
+
+        Notes:
+            Stores expires_at as Julian Day number (REAL) for optimal index usage.
+        """
+        data = self._value_to_bytes(value)
+        expires_at = self._calculate_expires_at(expires_in)
+        expires_at_julian = self._datetime_to_julian(expires_at)
+
+        sql = f"""
+        INSERT OR REPLACE INTO {self._table_name} (session_id, data, expires_at)
+        VALUES (?, ?, ?)
+        """
+
+        with self._config.provide_connection() as conn:
+            conn.execute(sql, (key, data, expires_at_julian))
+            conn.commit()
+
+    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.
+        """
+        await async_(self._set)(key, value, expires_in)
+
+    def _delete(self, key: str) -> None:
+        """Synchronous implementation of delete."""
+        sql = f"DELETE FROM {self._table_name} WHERE session_id = ?"
+
+        with self._config.provide_connection() as conn:
+            conn.execute(sql, (key,))
+            conn.commit()
+
+    async def delete(self, key: str) -> None:
+        """Delete a session by key.
+
+        Args:
+            key: Session ID to delete.
+        """
+        await async_(self._delete)(key)
+
+    def _delete_all(self) -> None:
+        """Synchronous implementation of delete_all."""
+        sql = f"DELETE FROM {self._table_name}"
+
+        with self._config.provide_connection() as conn:
+            conn.execute(sql)
+            conn.commit()
+        logger.debug("Deleted all sessions from table: %s", self._table_name)
+
+    async def delete_all(self) -> None:
+        """Delete all sessions from the store."""
+        await async_(self._delete_all)()
+
+    def _exists(self, key: str) -> bool:
+        """Synchronous implementation of exists."""
+        sql = f"""
+        SELECT 1 FROM {self._table_name}
+        WHERE session_id = ?
+        AND (expires_at IS NULL OR julianday(expires_at) > julianday('now'))
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.execute(sql, (key,))
+            result = cursor.fetchone()
+            return result is not None
+
+    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.
+        """
+        return await async_(self._exists)(key)
+
+    def _expires_in(self, key: str) -> "int | None":
+        """Synchronous implementation of expires_in."""
+        sql = f"""
+        SELECT expires_at FROM {self._table_name}
+        WHERE session_id = ?
+        """
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.execute(sql, (key,))
+            row = cursor.fetchone()
+
+            if row is None or row[0] is None:
+                return None
+
+            expires_at_julian = row[0]
+            expires_at = self._julian_to_datetime(expires_at_julian)
+
+            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 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.
+        """
+        return await async_(self._expires_in)(key)
+
+    def _delete_expired(self) -> int:
+        """Synchronous implementation of delete_expired."""
+        sql = f"DELETE FROM {self._table_name} WHERE julianday(expires_at) <= julianday('now')"
+
+        with self._config.provide_connection() as conn:
+            cursor = conn.execute(sql)
+            conn.commit()
+            count = cursor.rowcount
+            if count > 0:
+                logger.debug("Cleaned up %d expired sessions", count)
+            return count
+
+    async def delete_expired(self) -> int:
+        """Delete all expired sessions.
+
+        Returns:
+            Number of sessions deleted.
+        """
+        return await async_(self._delete_expired)()

sqlspec/adapters/sqlite/pool.py

@@ -4,7 +4,7 @@ import contextlib
 import sqlite3
 import threading
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Optional, TypedDict, cast
+from typing import TYPE_CHECKING, Any, TypedDict, cast
 
 from typing_extensions import NotRequired
 
@@ -14,15 +14,15 @@ if TYPE_CHECKING:
     from collections.abc import Generator
 
 
-class SqliteConnectionParams(TypedDict, total=False):
+class SqliteConnectionParams(TypedDict):
     """SQLite connection parameters."""
 
     database: NotRequired[str]
     timeout: NotRequired[float]
     detect_types: NotRequired[int]
-    isolation_level: "NotRequired[Optional[str]]"
+    isolation_level: "NotRequired[str | None]"
     check_same_thread: NotRequired[bool]
-    factory: "NotRequired[Optional[type[SqliteConnection]]]"
+    factory: "NotRequired[type[SqliteConnection] | None]"
     cached_statements: NotRequired[int]
     uri: NotRequired[bool]
 
@@ -62,7 +62,7 @@ class SqliteConnectionPool:
 
         if self._enable_optimizations:
             database = self._connection_parameters.get("database", ":memory:")
-            is_memory = database == ":memory:" or database.startswith("file::memory:")
+            is_memory = database == ":memory:" or "mode=memory" in database
 
             if not is_memory:
                 connection.execute("PRAGMA journal_mode = DELETE")

sqlspec/base.py

@@ -1,7 +1,7 @@
 import asyncio
 import atexit
 from collections.abc import Awaitable, Coroutine
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Union, cast, overload
 
 from sqlspec.config import (
     AsyncConfigT,
@@ -42,11 +42,11 @@ class SQLSpec:
 
     __slots__ = ("_configs", "_instance_cache_config", "_sql_loader")
 
-    def __init__(self, *, loader: "Optional[SQLFileLoader]" = None) -> None:
+    def __init__(self, *, loader: "SQLFileLoader | None" = None) -> None:
         self._configs: dict[Any, DatabaseConfigProtocol[Any, Any, Any]] = {}
         atexit.register(self._cleanup_sync_pools)
-        self._instance_cache_config: Optional[CacheConfig] = None
-        self._sql_loader: Optional[SQLFileLoader] = loader
+        self._instance_cache_config: CacheConfig | None = None
+        self._sql_loader: SQLFileLoader | None = loader
 
     @staticmethod
     def _get_config_name(obj: Any) -> str:
@@ -117,7 +117,7 @@ class SQLSpec:
     def add_config(self, config: "AsyncConfigT") -> "type[AsyncConfigT]":  # pyright: ignore[reportInvalidTypeVarUse]
         ...
 
-    def add_config(self, config: "Union[SyncConfigT, AsyncConfigT]") -> "type[Union[SyncConfigT, AsyncConfigT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    def add_config(self, config: "SyncConfigT | AsyncConfigT") -> "type[SyncConfigT | AsyncConfigT]":  # pyright: ignore[reportInvalidTypeVarUse]
         """Add a configuration instance to the registry.
 
         Args:
@@ -139,7 +139,7 @@ class SQLSpec:
     def get_config(self, name: "type[AsyncConfigT]") -> "AsyncConfigT": ...
 
     def get_config(
-        self, name: "Union[type[DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]], Any]"
+        self, name: "type[DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]] | Any"
     ) -> "DatabaseConfigProtocol[ConnectionT, PoolT, DriverT]":
         """Retrieve a configuration instance by its type or a key.
 
@@ -161,6 +161,15 @@ class SQLSpec:
         logger.debug("Retrieved configuration: %s", self._get_config_name(name))
         return config
 
+    @property
+    def configs(self) -> "dict[type, DatabaseConfigProtocol[Any, Any, Any]]":
+        """Access the registry of database configurations.
+
+        Returns:
+            Dictionary mapping config types to config instances.
+        """
+        return self._configs
+
     @overload
     def get_connection(
         self,
@@ -195,7 +204,7 @@ class SQLSpec:
             "NoPoolAsyncConfig[ConnectionT, DriverT]",
             "AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
         ],
-    ) -> "Union[ConnectionT, Awaitable[ConnectionT]]":
+    ) -> "ConnectionT | Awaitable[ConnectionT]":
         """Get a database connection for the specified configuration.
 
         Args:
@@ -248,7 +257,7 @@ class SQLSpec:
             "SyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
             "AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
         ],
-    ) -> "Union[DriverT, Awaitable[DriverT]]":
+    ) -> "DriverT | Awaitable[DriverT]":
         """Get a database session (driver adapter) for the specified configuration.
 
         Args:
@@ -273,13 +282,23 @@ class SQLSpec:
             async def _create_driver_async() -> "DriverT":
                 resolved_connection = await connection_obj  # pyright: ignore
                 return cast(  # pyright: ignore
-                    "DriverT", config.driver_type(connection=resolved_connection)
+                    "DriverT",
+                    config.driver_type(
+                        connection=resolved_connection,
+                        statement_config=config.statement_config,
+                        driver_features=config.driver_features,
+                    ),
                 )
 
             return _create_driver_async()
 
         return cast(  # pyright: ignore
-            "DriverT", config.driver_type(connection=connection_obj)
+            "DriverT",
+            config.driver_type(
+                connection=connection_obj,
+                statement_config=config.statement_config,
+                driver_features=config.driver_features,
+            ),
         )
 
     @overload
@@ -322,7 +341,7 @@ class SQLSpec:
         ],
         *args: Any,
         **kwargs: Any,
-    ) -> "Union[AbstractContextManager[ConnectionT], AbstractAsyncContextManager[ConnectionT]]":
+    ) -> "AbstractContextManager[ConnectionT] | AbstractAsyncContextManager[ConnectionT]":
         """Create and provide a database connection from the specified configuration.
 
         Args:
@@ -383,7 +402,7 @@ class SQLSpec:
         ],
         *args: Any,
         **kwargs: Any,
-    ) -> "Union[AbstractContextManager[DriverT], AbstractAsyncContextManager[DriverT]]":
+    ) -> "AbstractContextManager[DriverT] | AbstractAsyncContextManager[DriverT]":
         """Create and provide a database session from the specified configuration.
 
         Args:
@@ -407,17 +426,17 @@ class SQLSpec:
     @overload
     def get_pool(
         self,
-        name: "Union[type[Union[NoPoolSyncConfig[ConnectionT, DriverT], NoPoolAsyncConfig[ConnectionT, DriverT]]], NoPoolSyncConfig[ConnectionT, DriverT], NoPoolAsyncConfig[ConnectionT, DriverT]]",
+        name: "type[NoPoolSyncConfig[ConnectionT, DriverT] | NoPoolAsyncConfig[ConnectionT, DriverT]] | NoPoolSyncConfig[ConnectionT, DriverT] | NoPoolAsyncConfig[ConnectionT, DriverT]",
     ) -> "None": ...
     @overload
     def get_pool(
         self,
-        name: "Union[type[SyncDatabaseConfig[ConnectionT, PoolT, DriverT]], SyncDatabaseConfig[ConnectionT, PoolT, DriverT]]",
+        name: "type[SyncDatabaseConfig[ConnectionT, PoolT, DriverT]] | SyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
     ) -> "type[PoolT]": ...
     @overload
     def get_pool(
         self,
-        name: "Union[type[AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]],AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]]",
+        name: "type[AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]] | AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
     ) -> "Awaitable[type[PoolT]]": ...
 
     def get_pool(
@@ -432,7 +451,7 @@ class SQLSpec:
             "SyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
             "AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
         ],
-    ) -> "Union[type[PoolT], Awaitable[type[PoolT]], None]":
+    ) -> "type[PoolT] | Awaitable[type[PoolT]] | None":
         """Get the connection pool for the specified configuration.
 
         Args:
@@ -450,7 +469,7 @@ class SQLSpec:
 
         if config.supports_connection_pooling:
             logger.debug("Getting pool for config: %s", config_name, extra={"config_type": config_name})
-            return cast("Union[type[PoolT], Awaitable[type[PoolT]]]", config.create_pool())
+            return cast("type[PoolT] | Awaitable[type[PoolT]]", config.create_pool())
 
         logger.debug("Config %s does not support connection pooling", config_name)
         return None
@@ -489,7 +508,7 @@ class SQLSpec:
             "NoPoolAsyncConfig[ConnectionT, DriverT]",
             "AsyncDatabaseConfig[ConnectionT, PoolT, DriverT]",
         ],
-    ) -> "Optional[Awaitable[None]]":
+    ) -> "Awaitable[None] | None":
         """Close the connection pool for the specified configuration.
 
         Args:
@@ -552,12 +571,12 @@ class SQLSpec:
     @staticmethod
     def configure_cache(
         *,
-        sql_cache_size: Optional[int] = None,
-        fragment_cache_size: Optional[int] = None,
-        optimized_cache_size: Optional[int] = None,
-        sql_cache_enabled: Optional[bool] = None,
-        fragment_cache_enabled: Optional[bool] = None,
-        optimized_cache_enabled: Optional[bool] = None,
+        sql_cache_size: int | None = None,
+        fragment_cache_size: int | None = None,
+        optimized_cache_size: int | None = None,
+        sql_cache_enabled: bool | None = None,
+        fragment_cache_enabled: bool | None = None,
+        optimized_cache_enabled: bool | None = None,
     ) -> None:
         """Update cache configuration with partial values.
 
@@ -591,7 +610,7 @@ class SQLSpec:
             )
         )
 
-    def load_sql_files(self, *paths: "Union[str, Path]") -> None:
+    def load_sql_files(self, *paths: "str | Path") -> None:
         """Load SQL files from paths or directories.
 
         Args:
@@ -605,7 +624,7 @@ class SQLSpec:
         self._sql_loader.load_sql(*paths)
         logger.debug("Loaded SQL files: %s", paths)
 
-    def add_named_sql(self, name: str, sql: str, dialect: "Optional[str]" = None) -> None:
+    def add_named_sql(self, name: str, sql: str, dialect: "str | None" = None) -> None:
         """Add a named SQL query directly.
 
         Args:

sqlspec/builder/__init__.py

@@ -24,21 +24,64 @@ from sqlspec.builder._ddl import (
     Truncate,
 )
 from sqlspec.builder._delete import Delete
+from sqlspec.builder._dml import (
+    DeleteFromClauseMixin,
+    InsertFromSelectMixin,
+    InsertIntoClauseMixin,
+    InsertValuesMixin,
+    UpdateFromClauseMixin,
+    UpdateSetClauseMixin,
+    UpdateTableClauseMixin,
+)
+from sqlspec.builder._expression_wrappers import (
+    AggregateExpression,
+    ConversionExpression,
+    FunctionExpression,
+    MathExpression,
+    StringExpression,
+)
+from sqlspec.builder._factory import SQLFactory, sql
 from sqlspec.builder._insert import Insert
+from sqlspec.builder._join import JoinBuilder
 from sqlspec.builder._merge import Merge
-from sqlspec.builder._select import Select
+from sqlspec.builder._parsing_utils import (
+    extract_expression,
+    parse_column_expression,
+    parse_condition_expression,
+    parse_order_expression,
+    parse_table_expression,
+    to_expression,
+)
+from sqlspec.builder._select import (
+    Case,
+    CaseBuilder,
+    CommonTableExpressionMixin,
+    HavingClauseMixin,
+    LimitOffsetClauseMixin,
+    OrderByClauseMixin,
+    PivotClauseMixin,
+    ReturningClauseMixin,
+    Select,
+    SelectClauseMixin,
+    SetOperationMixin,
+    SubqueryBuilder,
+    UnpivotClauseMixin,
+    WhereClauseMixin,
+    WindowFunctionBuilder,
+)
 from sqlspec.builder._update import Update
-from sqlspec.builder.mixins import WhereClauseMixin
-from sqlspec.builder.mixins._join_operations import JoinBuilder
-from sqlspec.builder.mixins._select_operations import Case, SubqueryBuilder, WindowFunctionBuilder
 from sqlspec.exceptions import SQLBuilderError
 
 __all__ = (
+    "AggregateExpression",
     "AlterTable",
     "Case",
+    "CaseBuilder",
     "Column",
     "ColumnExpression",
     "CommentOn",
+    "CommonTableExpressionMixin",
+    "ConversionExpression",
     "CreateIndex",
     "CreateMaterializedView",
     "CreateSchema",
@@ -47,22 +90,48 @@ __all__ = (
     "CreateView",
     "DDLBuilder",
     "Delete",
+    "DeleteFromClauseMixin",
     "DropIndex",
     "DropSchema",
     "DropTable",
     "DropView",
     "FunctionColumn",
+    "FunctionExpression",
+    "HavingClauseMixin",
     "Insert",
+    "InsertFromSelectMixin",
+    "InsertIntoClauseMixin",
+    "InsertValuesMixin",
     "JoinBuilder",
+    "LimitOffsetClauseMixin",
+    "MathExpression",
     "Merge",
+    "OrderByClauseMixin",
+    "PivotClauseMixin",
     "QueryBuilder",
     "RenameTable",
+    "ReturningClauseMixin",
     "SQLBuilderError",
+    "SQLFactory",
     "SafeQuery",
     "Select",
+    "SelectClauseMixin",
+    "SetOperationMixin",
+    "StringExpression",
     "SubqueryBuilder",
     "Truncate",
+    "UnpivotClauseMixin",
     "Update",
+    "UpdateFromClauseMixin",
+    "UpdateSetClauseMixin",
+    "UpdateTableClauseMixin",
     "WhereClauseMixin",
     "WindowFunctionBuilder",
+    "extract_expression",
+    "parse_column_expression",
+    "parse_condition_expression",
+    "parse_order_expression",
+    "parse_table_expression",
+    "sql",
+    "to_expression",
 )