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

sqlspec/adapters/sqlite/config.py

@@ -1,36 +1,60 @@
 """SQLite database configuration with thread-local connections."""
 
+import logging
 import uuid
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, ClassVar, Optional, TypedDict, Union, cast
+from typing import TYPE_CHECKING, Any, ClassVar, TypedDict, cast
 
 from typing_extensions import NotRequired
 
+from sqlspec.adapters.sqlite._type_handlers import register_type_handlers
 from sqlspec.adapters.sqlite._types import SqliteConnection
 from sqlspec.adapters.sqlite.driver import SqliteCursor, SqliteDriver, sqlite_statement_config
 from sqlspec.adapters.sqlite.pool import SqliteConnectionPool
 from sqlspec.config import SyncDatabaseConfig
+from sqlspec.utils.serializers import from_json, to_json
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
     from sqlspec.core.statement import StatementConfig
 
 
-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]
 
 
-__all__ = ("SqliteConfig", "SqliteConnectionParams")
+class SqliteDriverFeatures(TypedDict):
+    """SQLite driver feature configuration.
+
+    Controls optional type handling and serialization features for SQLite connections.
+
+    enable_custom_adapters: Enable custom type adapters for JSON/UUID/datetime conversion.
+        Defaults to True for enhanced Python type support.
+        Set to False only if you need pure SQLite behavior without type conversions.
+    json_serializer: Custom JSON serializer function.
+        Defaults to sqlspec.utils.serializers.to_json.
+    json_deserializer: Custom JSON deserializer function.
+        Defaults to sqlspec.utils.serializers.from_json.
+    """
+
+    enable_custom_adapters: NotRequired[bool]
+    json_serializer: "NotRequired[Callable[[Any], str]]"
+    json_deserializer: "NotRequired[Callable[[str], Any]]"
+
+
+__all__ = ("SqliteConfig", "SqliteConnectionParams", "SqliteDriverFeatures")
 
 
 class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, SqliteDriver]):
@@ -38,15 +62,18 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
 
     driver_type: "ClassVar[type[SqliteDriver]]" = SqliteDriver
     connection_type: "ClassVar[type[SqliteConnection]]" = SqliteConnection
+    supports_transactional_ddl: "ClassVar[bool]" = True
 
     def __init__(
         self,
         *,
-        pool_config: "Optional[Union[SqliteConnectionParams, dict[str, Any]]]" = None,
-        pool_instance: "Optional[SqliteConnectionPool]" = None,
-        migration_config: "Optional[dict[str, Any]]" = None,
-        statement_config: "Optional[StatementConfig]" = None,
-        driver_features: "Optional[dict[str, Any]]" = None,
+        pool_config: "SqliteConnectionParams | dict[str, Any] | None" = None,
+        pool_instance: "SqliteConnectionPool | None" = None,
+        migration_config: "dict[str, Any] | None" = None,
+        statement_config: "StatementConfig | None" = None,
+        driver_features: "SqliteDriverFeatures | dict[str, Any] | None" = None,
+        bind_key: "str | None" = None,
+        extension_config: "dict[str, dict[str, Any]] | None" = None,
     ) -> None:
         """Initialize SQLite configuration.
 
@@ -56,19 +83,43 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
             migration_config: Migration configuration
             statement_config: Default SQL statement configuration
             driver_features: Optional driver feature configuration
+            bind_key: Optional bind key for the configuration
+            extension_config: Extension-specific configuration (e.g., Litestar plugin settings)
         """
         if pool_config is None:
             pool_config = {}
         if "database" not in pool_config or pool_config["database"] == ":memory:":
             pool_config["database"] = f"file:memory_{uuid.uuid4().hex}?mode=memory&cache=private"
             pool_config["uri"] = True
+        elif "database" in pool_config:
+            database_path = str(pool_config["database"])
+            if database_path.startswith("file:") and not pool_config.get("uri"):
+                logger.debug(
+                    "Database URI detected (%s) but uri=True not set. "
+                    "Auto-enabling URI mode to prevent physical file creation.",
+                    database_path,
+                )
+                pool_config["uri"] = True
+
+        processed_driver_features: dict[str, Any] = dict(driver_features) if driver_features else {}
+
+        if "enable_custom_adapters" not in processed_driver_features:
+            processed_driver_features["enable_custom_adapters"] = True
+
+        if "json_serializer" not in processed_driver_features:
+            processed_driver_features["json_serializer"] = to_json
+
+        if "json_deserializer" not in processed_driver_features:
+            processed_driver_features["json_deserializer"] = from_json
 
         super().__init__(
+            bind_key=bind_key,
             pool_instance=pool_instance,
             pool_config=cast("dict[str, Any]", pool_config),
             migration_config=migration_config,
             statement_config=statement_config or sqlite_statement_config,
-            driver_features=driver_features or {},
+            driver_features=processed_driver_features,
+            extension_config=extension_config,
         )
 
     def _get_connection_config_dict(self) -> "dict[str, Any]":
@@ -81,7 +132,24 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
         """Create connection pool from configuration."""
         config_dict = self._get_connection_config_dict()
 
-        return SqliteConnectionPool(connection_parameters=config_dict, **self.pool_config)
+        pool = SqliteConnectionPool(connection_parameters=config_dict, **self.pool_config)
+
+        if self.driver_features.get("enable_custom_adapters", False):
+            self._register_type_adapters()
+
+        return pool
+
+    def _register_type_adapters(self) -> None:
+        """Register custom type adapters and converters for SQLite.
+
+        Called once during pool creation if enable_custom_adapters is True.
+        Registers JSON serialization handlers if configured.
+        """
+        if self.driver_features.get("enable_custom_adapters", False):
+            register_type_handlers(
+                json_serializer=self.driver_features.get("json_serializer"),
+                json_deserializer=self.driver_features.get("json_deserializer"),
+            )
 
     def _close_pool(self) -> None:
         """Close the connection pool."""
@@ -110,7 +178,7 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
 
     @contextmanager
     def provide_session(
-        self, *args: "Any", statement_config: "Optional[StatementConfig]" = None, **kwargs: "Any"
+        self, *args: "Any", statement_config: "StatementConfig | None" = None, **kwargs: "Any"
     ) -> "Generator[SqliteDriver, None, None]":
         """Provide a SQLite driver session.
 
@@ -118,7 +186,11 @@ class SqliteConfig(SyncDatabaseConfig[SqliteConnection, SqliteConnectionPool, Sq
             SqliteDriver: A driver instance with thread-local connection
         """
         with self.provide_connection(*args, **kwargs) as connection:
-            yield self.driver_type(connection=connection, statement_config=statement_config or self.statement_config)
+            yield self.driver_type(
+                connection=connection,
+                statement_config=statement_config or self.statement_config,
+                driver_features=self.driver_features,
+            )
 
     def get_signature_namespace(self) -> "dict[str, type[Any]]":
         """Get the signature namespace for SQLite types.

sqlspec/adapters/sqlite/data_dictionary.py

@@ -0,0 +1,149 @@
+"""SQLite-specific data dictionary for metadata queries."""
+
+import re
+from typing import TYPE_CHECKING, Any, cast
+
+from sqlspec.driver import SyncDataDictionaryBase, SyncDriverAdapterBase, VersionInfo
+from sqlspec.utils.logging import get_logger
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from sqlspec.adapters.sqlite.driver import SqliteDriver
+
+logger = get_logger("adapters.sqlite.data_dictionary")
+
+# Compiled regex patterns
+SQLITE_VERSION_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)")
+
+__all__ = ("SqliteSyncDataDictionary",)
+
+
+class SqliteSyncDataDictionary(SyncDataDictionaryBase):
+    """SQLite-specific sync data dictionary."""
+
+    def get_version(self, driver: SyncDriverAdapterBase) -> "VersionInfo | None":
+        """Get SQLite database version information.
+
+        Args:
+            driver: Sync database driver instance
+
+        Returns:
+            SQLite version information or None if detection fails
+        """
+        version_str = cast("SqliteDriver", driver).select_value("SELECT sqlite_version()")
+        if not version_str:
+            logger.warning("No SQLite version information found")
+            return None
+
+        # Parse version like "3.45.0"
+        version_match = SQLITE_VERSION_PATTERN.match(str(version_str))
+        if not version_match:
+            logger.warning("Could not parse SQLite version: %s", version_str)
+            return None
+
+        major, minor, patch = map(int, version_match.groups())
+        version_info = VersionInfo(major, minor, patch)
+        logger.debug("Detected SQLite version: %s", version_info)
+        return version_info
+
+    def get_feature_flag(self, driver: SyncDriverAdapterBase, feature: str) -> bool:
+        """Check if SQLite database supports a specific feature.
+
+        Args:
+            driver: SQLite driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+        version_info = self.get_version(driver)
+        if not version_info:
+            return False
+
+        feature_checks: dict[str, Callable[[VersionInfo], bool]] = {
+            "supports_json": lambda v: v >= VersionInfo(3, 38, 0),
+            "supports_returning": lambda v: v >= VersionInfo(3, 35, 0),
+            "supports_upsert": lambda v: v >= VersionInfo(3, 24, 0),
+            "supports_window_functions": lambda v: v >= VersionInfo(3, 25, 0),
+            "supports_cte": lambda v: v >= VersionInfo(3, 8, 3),
+            "supports_transactions": lambda _: True,
+            "supports_prepared_statements": lambda _: True,
+            "supports_schemas": lambda _: False,  # SQLite has ATTACH but not schemas
+            "supports_arrays": lambda _: False,
+            "supports_uuid": lambda _: False,
+        }
+
+        if feature in feature_checks:
+            return bool(feature_checks[feature](version_info))
+
+        return False
+
+    def get_optimal_type(self, driver: SyncDriverAdapterBase, type_category: str) -> str:
+        """Get optimal SQLite type for a category.
+
+        Args:
+            driver: SQLite driver instance
+            type_category: Type category
+
+        Returns:
+            SQLite-specific type name
+        """
+        version_info = self.get_version(driver)
+
+        if type_category == "json":
+            if version_info and version_info >= VersionInfo(3, 38, 0):
+                return "JSON"
+            return "TEXT"
+
+        type_map = {"uuid": "TEXT", "boolean": "INTEGER", "timestamp": "TIMESTAMP", "text": "TEXT", "blob": "BLOB"}
+        return type_map.get(type_category, "TEXT")
+
+    def get_columns(
+        self, driver: SyncDriverAdapterBase, table: str, schema: "str | None" = None
+    ) -> "list[dict[str, Any]]":
+        """Get column information for a table using SQLite PRAGMA.
+
+        Args:
+            driver: SQLite driver instance
+            table: Table name to query columns for
+            schema: Schema name (unused in SQLite)
+
+        Returns:
+            List of column metadata dictionaries with keys:
+                - column_name: Name of the column
+                - data_type: SQLite data type
+                - nullable: Whether column allows NULL
+                - default_value: Default value if any
+        """
+        sqlite_driver = cast("SqliteDriver", driver)
+        result = sqlite_driver.execute(f"PRAGMA table_info({table})")
+
+        return [
+            {
+                "column_name": row["name"] if isinstance(row, dict) else row[1],
+                "data_type": row["type"] if isinstance(row, dict) else row[2],
+                "nullable": not (row["notnull"] if isinstance(row, dict) else row[3]),
+                "default_value": row["dflt_value"] if isinstance(row, dict) else row[4],
+            }
+            for row in result.data or []
+        ]
+
+    def list_available_features(self) -> "list[str]":
+        """List available SQLite feature flags.
+
+        Returns:
+            List of supported feature names
+        """
+        return [
+            "supports_json",
+            "supports_returning",
+            "supports_upsert",
+            "supports_window_functions",
+            "supports_cte",
+            "supports_transactions",
+            "supports_prepared_statements",
+            "supports_schemas",
+            "supports_arrays",
+            "supports_uuid",
+        ]

sqlspec/adapters/sqlite/driver.py

@@ -4,13 +4,24 @@ import contextlib
 import datetime
 import sqlite3
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 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 SyncDriverAdapterBase
-from sqlspec.exceptions import SQLParsingError, SQLSpecError
+from sqlspec.exceptions import (
+    CheckViolationError,
+    DatabaseConnectionError,
+    DataError,
+    ForeignKeyViolationError,
+    IntegrityError,
+    NotNullViolationError,
+    OperationalError,
+    SQLParsingError,
+    SQLSpecError,
+    UniqueViolationError,
+)
 from sqlspec.utils.serializers import to_json
 
 if TYPE_CHECKING:
@@ -20,9 +31,18 @@ if TYPE_CHECKING:
     from sqlspec.core.result import SQLResult
     from sqlspec.core.statement import SQL
     from sqlspec.driver import ExecutionResult
+    from sqlspec.driver._sync import SyncDataDictionaryBase
 
 __all__ = ("SqliteCursor", "SqliteDriver", "SqliteExceptionHandler", "sqlite_statement_config")
 
+SQLITE_CONSTRAINT_UNIQUE_CODE = 2067
+SQLITE_CONSTRAINT_FOREIGNKEY_CODE = 787
+SQLITE_CONSTRAINT_NOTNULL_CODE = 1811
+SQLITE_CONSTRAINT_CHECK_CODE = 531
+SQLITE_CONSTRAINT_CODE = 19
+SQLITE_CANTOPEN_CODE = 14
+SQLITE_IOERR_CODE = 10
+SQLITE_MISMATCH_CODE = 20
 
 sqlite_statement_config = StatementConfig(
     dialect="sqlite",
@@ -36,6 +56,7 @@ sqlite_statement_config = StatementConfig(
             datetime.datetime: lambda v: v.isoformat(),
             datetime.date: lambda v: v.isoformat(),
             Decimal: str,
+            dict: to_json,
             list: to_json,
         },
         has_native_list_expansion=False,
@@ -64,7 +85,7 @@ class SqliteCursor:
             connection: SQLite database connection
         """
         self.connection = connection
-        self.cursor: Optional[sqlite3.Cursor] = None
+        self.cursor: sqlite3.Cursor | None = None
 
     def __enter__(self) -> "sqlite3.Cursor":
         """Create and return a new cursor.
@@ -75,7 +96,7 @@ class SqliteCursor:
         self.cursor = self.connection.cursor()
         return self.cursor
 
-    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+    def __exit__(self, *_: Any) -> None:
         """Clean up cursor resources.
 
         Args:
@@ -83,7 +104,6 @@ class SqliteCursor:
             exc_val: Exception value if an exception occurred
             exc_tb: Exception traceback if an exception occurred
         """
-        _ = (exc_type, exc_val, exc_tb)
         if self.cursor is not None:
             with contextlib.suppress(Exception):
                 self.cursor.close()
@@ -92,64 +112,113 @@ class SqliteCursor:
 class SqliteExceptionHandler:
     """Context manager for handling SQLite database exceptions.
 
-    Catches SQLite-specific exceptions and converts them to appropriate SQLSpec exceptions.
+    Maps SQLite extended result codes to specific SQLSpec exceptions
+    for better error handling in application code.
     """
 
     __slots__ = ()
 
     def __enter__(self) -> None:
-        """Enter exception handling context.
-
-        Returns:
-            None
-        """
-        return
+        return None
 
     def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Handle exceptions and convert to SQLSpec exceptions.
+        if exc_type is None:
+            return
+        if issubclass(exc_type, sqlite3.Error):
+            self._map_sqlite_exception(exc_val)
+
+    def _map_sqlite_exception(self, e: Any) -> None:
+        """Map SQLite exception to SQLSpec exception.
 
         Args:
-            exc_type: Exception type if an exception occurred
-            exc_val: Exception value if an exception occurred
-            exc_tb: Exception traceback if an exception occurred
+            e: sqlite3.Error instance
 
         Raises:
-            SQLSpecError: For general database errors
-            SQLParsingError: For SQL syntax or parsing errors
+            Specific SQLSpec exception based on error code
         """
-        if exc_type is None:
+        error_code = getattr(e, "sqlite_errorcode", None)
+        error_name = getattr(e, "sqlite_errorname", None)
+        error_msg = str(e).lower()
+
+        if "locked" in error_msg:
+            self._raise_operational_error(e, error_code or 0)
+
+        if not error_code:
+            if "unique constraint" in error_msg:
+                self._raise_unique_violation(e, 0)
+            elif "foreign key constraint" in error_msg:
+                self._raise_foreign_key_violation(e, 0)
+            elif "not null constraint" in error_msg:
+                self._raise_not_null_violation(e, 0)
+            elif "check constraint" in error_msg:
+                self._raise_check_violation(e, 0)
+            elif "syntax" in error_msg:
+                self._raise_parsing_error(e, None)
+            else:
+                self._raise_generic_error(e)
             return
 
-        if issubclass(exc_type, sqlite3.IntegrityError):
-            e = exc_val
-            msg = f"SQLite integrity constraint violation: {e}"
-            raise SQLSpecError(msg) from e
-        if issubclass(exc_type, sqlite3.OperationalError):
-            e = exc_val
-            error_msg = str(e).lower()
-            if "locked" in error_msg:
-                raise
-            if "syntax" in error_msg or "malformed" in error_msg:
-                msg = f"SQLite SQL syntax error: {e}"
-                raise SQLParsingError(msg) from e
-            msg = f"SQLite operational error: {e}"
-            raise SQLSpecError(msg) from e
-        if issubclass(exc_type, sqlite3.DatabaseError):
-            e = exc_val
-            msg = f"SQLite database error: {e}"
-            raise SQLSpecError(msg) from e
-        if issubclass(exc_type, sqlite3.Error):
-            e = exc_val
-            msg = f"SQLite error: {e}"
-            raise SQLSpecError(msg) from e
-        if issubclass(exc_type, Exception):
-            e = exc_val
-            error_msg = str(e).lower()
-            if "parse" in error_msg or "syntax" in error_msg:
-                msg = f"SQL parsing failed: {e}"
-                raise SQLParsingError(msg) from e
-            msg = f"Unexpected database operation error: {e}"
-            raise SQLSpecError(msg) from e
+        if error_code == SQLITE_CONSTRAINT_UNIQUE_CODE or error_name == "SQLITE_CONSTRAINT_UNIQUE":
+            self._raise_unique_violation(e, error_code)
+        elif error_code == SQLITE_CONSTRAINT_FOREIGNKEY_CODE or error_name == "SQLITE_CONSTRAINT_FOREIGNKEY":
+            self._raise_foreign_key_violation(e, error_code)
+        elif error_code == SQLITE_CONSTRAINT_NOTNULL_CODE or error_name == "SQLITE_CONSTRAINT_NOTNULL":
+            self._raise_not_null_violation(e, error_code)
+        elif error_code == SQLITE_CONSTRAINT_CHECK_CODE or error_name == "SQLITE_CONSTRAINT_CHECK":
+            self._raise_check_violation(e, error_code)
+        elif error_code == SQLITE_CONSTRAINT_CODE or error_name == "SQLITE_CONSTRAINT":
+            self._raise_integrity_error(e, error_code)
+        elif error_code == SQLITE_CANTOPEN_CODE or error_name == "SQLITE_CANTOPEN":
+            self._raise_connection_error(e, error_code)
+        elif error_code == SQLITE_IOERR_CODE or error_name == "SQLITE_IOERR":
+            self._raise_operational_error(e, error_code)
+        elif error_code == SQLITE_MISMATCH_CODE or error_name == "SQLITE_MISMATCH":
+            self._raise_data_error(e, error_code)
+        elif error_code == 1 or "syntax" in error_msg:
+            self._raise_parsing_error(e, error_code)
+        else:
+            self._raise_generic_error(e)
+
+    def _raise_unique_violation(self, e: Any, code: int) -> None:
+        msg = f"SQLite unique constraint violation [code {code}]: {e}"
+        raise UniqueViolationError(msg) from e
+
+    def _raise_foreign_key_violation(self, e: Any, code: int) -> None:
+        msg = f"SQLite foreign key constraint violation [code {code}]: {e}"
+        raise ForeignKeyViolationError(msg) from e
+
+    def _raise_not_null_violation(self, e: Any, code: int) -> None:
+        msg = f"SQLite not-null constraint violation [code {code}]: {e}"
+        raise NotNullViolationError(msg) from e
+
+    def _raise_check_violation(self, e: Any, code: int) -> None:
+        msg = f"SQLite check constraint violation [code {code}]: {e}"
+        raise CheckViolationError(msg) from e
+
+    def _raise_integrity_error(self, e: Any, code: int) -> None:
+        msg = f"SQLite integrity constraint violation [code {code}]: {e}"
+        raise IntegrityError(msg) from e
+
+    def _raise_parsing_error(self, e: Any, code: "int | None") -> None:
+        code_str = f"[code {code}]" if code else ""
+        msg = f"SQLite SQL syntax error {code_str}: {e}"
+        raise SQLParsingError(msg) from e
+
+    def _raise_connection_error(self, e: Any, code: int) -> None:
+        msg = f"SQLite connection error [code {code}]: {e}"
+        raise DatabaseConnectionError(msg) from e
+
+    def _raise_operational_error(self, e: Any, code: int) -> None:
+        msg = f"SQLite operational error [code {code}]: {e}"
+        raise OperationalError(msg) from e
+
+    def _raise_data_error(self, e: Any, code: int) -> None:
+        msg = f"SQLite data error [code {code}]: {e}"
+        raise DataError(msg) from e
+
+    def _raise_generic_error(self, e: Any) -> None:
+        msg = f"SQLite database error: {e}"
+        raise SQLSpecError(msg) from e
 
 
 class SqliteDriver(SyncDriverAdapterBase):
@@ -159,14 +228,14 @@ class SqliteDriver(SyncDriverAdapterBase):
     for SQLite databases using the standard sqlite3 module.
     """
 
-    __slots__ = ()
+    __slots__ = ("_data_dictionary",)
     dialect = "sqlite"
 
     def __init__(
         self,
         connection: "SqliteConnection",
-        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:
         """Initialize SQLite driver.
 
@@ -185,6 +254,7 @@ class SqliteDriver(SyncDriverAdapterBase):
             )
 
         super().__init__(connection=connection, statement_config=statement_config, driver_features=driver_features)
+        self._data_dictionary: SyncDataDictionaryBase | None = None
 
     def with_cursor(self, connection: "SqliteConnection") -> "SqliteCursor":
         """Create context manager for SQLite cursor.
@@ -205,7 +275,7 @@ class SqliteDriver(SyncDriverAdapterBase):
         """
         return SqliteExceptionHandler()
 
-    def _try_special_handling(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "Optional[SQLResult]":
+    def _try_special_handling(self, cursor: "sqlite3.Cursor", statement: "SQL") -> "SQLResult | None":
         """Hook for SQLite-specific special operations.
 
         Args:
@@ -280,7 +350,7 @@ class SqliteDriver(SyncDriverAdapterBase):
             fetched_data = cursor.fetchall()
             column_names = [col[0] for col in cursor.description or []]
 
-            data = [dict(zip(column_names, row)) for row in fetched_data]
+            data = [dict(zip(column_names, row, strict=False)) for row in fetched_data]
 
             return self.create_execution_result(
                 cursor, selected_data=data, column_names=column_names, data_row_count=len(data), is_select_result=True
@@ -325,3 +395,16 @@ class SqliteDriver(SyncDriverAdapterBase):
         except sqlite3.Error as e:
             msg = f"Failed to commit transaction: {e}"
             raise SQLSpecError(msg) from e
+
+    @property
+    def data_dictionary(self) -> "SyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+        if self._data_dictionary is None:
+            from sqlspec.adapters.sqlite.data_dictionary import SqliteSyncDataDictionary
+
+            self._data_dictionary = SqliteSyncDataDictionary()
+        return self._data_dictionary

sqlspec/adapters/sqlite/litestar/__init__.py

@@ -0,0 +1,5 @@
+"""Litestar integration for SQLite adapter."""
+
+from sqlspec.adapters.sqlite.litestar.store import SQLiteStore
+
+__all__ = ("SQLiteStore",)