sqlspec 0.15.0__py3-none-any.whl → 0.16.1__py3-none-any.whl

sqlspec/driver/_sync.py

@@ -5,7 +5,7 @@ including connection management, transaction support, and result processing.
 """
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Final, NoReturn, Optional, Union, cast, overload
 
 from sqlspec.core import SQL
 from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult
@@ -20,14 +20,15 @@ if TYPE_CHECKING:
 
     from sqlspec.builder import QueryBuilder
     from sqlspec.core import SQLResult, Statement, StatementConfig, StatementFilter
-    from sqlspec.typing import ModelDTOT, ModelT, RowT, StatementParameters
+    from sqlspec.typing import ModelDTOT, StatementParameters
 
-logger = get_logger("sqlspec")
+_LOGGER_NAME: Final[str] = "sqlspec"
+logger = get_logger(_LOGGER_NAME)
 
 __all__ = ("SyncDriverAdapterBase",)
 
 
-EMPTY_FILTERS: "list[StatementFilter]" = []
+EMPTY_FILTERS: Final["list[StatementFilter]"] = []
 
 
 class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToSchemaMixin):
@@ -128,12 +129,16 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         sql, prepared_parameters = self._get_compiled_sql(statement, self.statement_config)
         statements = self.split_script_statements(sql, self.statement_config, strip_trailing_semicolon=True)
 
+        statement_count: int = len(statements)
+        successful_count: int = 0
+
         for stmt in statements:
             single_stmt = statement.copy(statement=stmt, parameters=prepared_parameters)
             self._execute_statement(cursor, single_stmt)
+            successful_count += 1
 
         return self.create_execution_result(
-            cursor, statement_count=len(statements), successful_statements=len(statements), is_script_result=True
+            cursor, statement_count=statement_count, successful_statements=successful_count, is_script_result=True
         )
 
     @abstractmethod
@@ -214,8 +219,8 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         By default, validates each statement and logs warnings for dangerous
         operations. Use suppress_warnings=True for migrations and admin scripts.
         """
-        script_config = statement_config or self.statement_config
-        sql_statement = self.prepare_statement(statement, parameters, statement_config=script_config, kwargs=kwargs)
+        config = statement_config or self.statement_config
+        sql_statement = self.prepare_statement(statement, parameters, statement_config=config, kwargs=kwargs)
 
         return self.dispatch_statement_execution(statement=sql_statement.as_script(), connection=self.connection)
 
@@ -239,7 +244,7 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT, dict[str, Any]]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "dict[str, Any]": ...
 
     def select_one(
         self,
@@ -249,23 +254,20 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[ModelT, RowT, ModelDTOT]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[dict[str, Any], ModelDTOT]":
         """Execute a select statement and return exactly one row.
 
         Raises an exception if no rows or more than one row is returned.
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
-            msg = "No rows found"
-            raise NotFoundError(msg)
-        if len(data) > 1:
-            msg = f"Expected exactly one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast(
-            "Union[ModelT, RowT, ModelDTOT]",
-            self.to_schema(data[0], schema_type=schema_type) if schema_type else data[0],
-        )
+        data_len: int = len(data)
+        if data_len == 0:
+            self._raise_no_rows_found()
+        if data_len > 1:
+            self._raise_expected_one_row(data_len)
+        first_row = data[0]
+        return self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row
 
     @overload
     def select_one_or_none(
@@ -287,7 +289,7 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[dict[str, Any]]": ...
 
     def select_one_or_none(
         self,
@@ -297,7 +299,7 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Optional[Union[ModelT, ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Optional[Union[dict[str, Any], ModelDTOT]]":
         """Execute a select statement and return at most one row.
 
         Returns None if no rows are found.
@@ -305,12 +307,16 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
-            raise ValueError(msg)
-        return cast("Optional[Union[ModelT, ModelDTOT]]", self.to_schema(data[0], schema_type=schema_type))
+        if data_len > 1:
+            self._raise_expected_at_most_one_row(data_len)
+        first_row = data[0]
+        return cast(
+            "Optional[Union[dict[str, Any], ModelDTOT]]",
+            self.to_schema(first_row, schema_type=schema_type) if schema_type else first_row,
+        )
 
     @overload
     def select(
@@ -332,7 +338,7 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: None = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "list[ModelT]": ...  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "list[dict[str, Any]]": ...
 
     def select(
         self,
@@ -342,12 +348,11 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         schema_type: "Optional[type[ModelDTOT]]" = None,
         statement_config: "Optional[StatementConfig]" = None,
         **kwargs: Any,
-    ) -> "Union[list[ModelT], list[ModelDTOT]]":  # pyright: ignore[reportInvalidTypeVarUse]
+    ) -> "Union[list[dict[str, Any]], list[ModelDTOT]]":
         """Execute a select statement and return all rows."""
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         return cast(
-            "Union[list[ModelT], list[ModelDTOT]]",
-            self.to_schema(cast("list[ModelT]", result.get_data()), schema_type=schema_type),
+            "Union[list[dict[str, Any]], list[ModelDTOT]]", self.to_schema(result.get_data(), schema_type=schema_type)
         )
 
     def select_value(
@@ -367,23 +372,19 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         try:
             row = result.one()
         except ValueError as e:
-            msg = "No rows found"
-            raise NotFoundError(msg) from e
+            self._raise_no_rows_found_from_exception(e)
         if not row:
-            msg = "No rows found"
-            raise NotFoundError(msg)
+            self._raise_no_rows_found()
         if is_dict_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return next(iter(row.values()))
         if is_indexable_row(row):
             if not row:
-                msg = "Row has no columns"
-                raise ValueError(msg)
+                self._raise_row_no_columns()
             return row[0]
-        msg = f"Unexpected row type: {type(row)}"
-        raise ValueError(msg)
+        self._raise_unexpected_row_type(type(row))
+        return None
 
     def select_value_or_none(
         self,
@@ -401,10 +402,11 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         """
         result = self.execute(statement, *parameters, statement_config=statement_config, **kwargs)
         data = result.get_data()
-        if not data:
+        data_len: int = len(data)
+        if data_len == 0:
             return None
-        if len(data) > 1:
-            msg = f"Expected at most one row, found {len(data)}"
+        if data_len > 1:
+            msg = f"Expected at most one row, found {data_len}"
             raise ValueError(msg)
         row = data[0]
         if isinstance(row, dict):
@@ -471,3 +473,31 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         select_result = self.execute(sql_statement)
 
         return (self.to_schema(select_result.get_data(), schema_type=schema_type), count_result.scalar())
+
+    def _raise_no_rows_found(self) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg)
+
+    def _raise_no_rows_found_from_exception(self, e: ValueError) -> NoReturn:
+        msg = "No rows found"
+        raise NotFoundError(msg) from e
+
+    def _raise_expected_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected exactly one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_expected_at_most_one_row(self, data_len: int) -> NoReturn:
+        msg = f"Expected at most one row, found {data_len}"
+        raise ValueError(msg)
+
+    def _raise_row_no_columns(self) -> NoReturn:
+        msg = "Row has no columns"
+        raise ValueError(msg)
+
+    def _raise_unexpected_row_type(self, row_type: type) -> NoReturn:
+        msg = f"Unexpected row type: {row_type}"
+        raise ValueError(msg)
+
+    def _raise_cannot_extract_value_from_row_type(self, type_name: str) -> NoReturn:
+        msg = f"Cannot extract value from row type {type_name}"
+        raise TypeError(msg)

sqlspec/driver/mixins/_result_tools.py

@@ -5,16 +5,14 @@ from collections.abc import Sequence
 from enum import Enum
 from functools import partial
 from pathlib import Path, PurePath
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
+from typing import Any, Callable, Final, Optional, overload
 from uuid import UUID
 
 from mypy_extensions import trait
 
-from sqlspec.exceptions import SQLSpecError, wrap_exceptions
+from sqlspec.exceptions import SQLSpecError
 from sqlspec.typing import (
     CATTRS_INSTALLED,
-    DataclassProtocol,
-    DictLike,
     ModelDTOT,
     ModelT,
     attrs_asdict,
@@ -25,14 +23,16 @@ from sqlspec.typing import (
 )
 from sqlspec.utils.type_guards import is_attrs_schema, is_dataclass, is_msgspec_struct, is_pydantic_model
 
-if TYPE_CHECKING:
-    from sqlspec._typing import AttrsInstanceStub, BaseModelStub, StructStub
-
 __all__ = ("_DEFAULT_TYPE_DECODERS", "_default_msgspec_deserializer")
 
 
 logger = logging.getLogger(__name__)
-_DEFAULT_TYPE_DECODERS: list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]] = [
+
+# Constants for performance optimization
+_DATETIME_TYPES: Final[set[type]] = {datetime.datetime, datetime.date, datetime.time}
+_PATH_TYPES: Final[tuple[type, ...]] = (Path, PurePath, UUID)
+
+_DEFAULT_TYPE_DECODERS: Final[list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]]] = [
     (lambda x: x is UUID, lambda t, v: t(v.hex)),
     (lambda x: x is datetime.datetime, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.date, lambda t, v: t(v.isoformat())),
@@ -53,17 +53,32 @@ def _default_msgspec_deserializer(
         for predicate, decoder in type_decoders:
             if predicate(target_type):
                 return decoder(target_type, value)
+
+    # Fast path checks using type identity and isinstance
     if target_type is UUID and isinstance(value, UUID):
         return value.hex
-    if target_type in {datetime.datetime, datetime.date, datetime.time}:
-        with wrap_exceptions(suppress=AttributeError):
+
+    # Use pre-computed set for faster lookup
+    if target_type in _DATETIME_TYPES:
+        try:
             return value.isoformat()
+        except AttributeError:
+            pass
+
     if isinstance(target_type, type) and issubclass(target_type, Enum) and isinstance(value, Enum):
         return value.value
+
     if isinstance(value, target_type):
         return value
-    if issubclass(target_type, (Path, PurePath, UUID)):
-        return target_type(value)
+
+    # Check for path types using pre-computed tuple
+    if isinstance(target_type, type):
+        try:
+            if issubclass(target_type, (Path, PurePath)) or issubclass(target_type, UUID):
+                return target_type(str(value))
+        except (TypeError, ValueError):
+            pass
+
     return value
 
 
@@ -74,36 +89,37 @@ class ToSchemaMixin:
     # Schema conversion overloads - handle common cases first
     @overload
     @staticmethod
+    def to_schema(data: "list[dict[str, Any]]") -> "list[dict[str, Any]]": ...
+    @overload
+    @staticmethod
     def to_schema(data: "list[dict[str, Any]]", *, schema_type: "type[ModelDTOT]") -> "list[ModelDTOT]": ...
     @overload
     @staticmethod
     def to_schema(data: "list[dict[str, Any]]", *, schema_type: None = None) -> "list[dict[str, Any]]": ...
     @overload
     @staticmethod
+    def to_schema(data: "dict[str, Any]") -> "dict[str, Any]": ...
+    @overload
+    @staticmethod
     def to_schema(data: "dict[str, Any]", *, schema_type: "type[ModelDTOT]") -> "ModelDTOT": ...
     @overload
     @staticmethod
     def to_schema(data: "dict[str, Any]", *, schema_type: None = None) -> "dict[str, Any]": ...
     @overload
     @staticmethod
+    def to_schema(data: "list[ModelT]") -> "list[ModelT]": ...
+    @overload
+    @staticmethod
     def to_schema(data: "list[ModelT]", *, schema_type: "type[ModelDTOT]") -> "list[ModelDTOT]": ...
     @overload
     @staticmethod
     def to_schema(data: "list[ModelT]", *, schema_type: None = None) -> "list[ModelT]": ...
     @overload
     @staticmethod
-    def to_schema(
-        data: "Union[DictLike, StructStub, BaseModelStub, DataclassProtocol, AttrsInstanceStub]",
-        *,
-        schema_type: "type[ModelDTOT]",
-    ) -> "ModelDTOT": ...
+    def to_schema(data: "ModelT") -> "ModelT": ...
     @overload
     @staticmethod
-    def to_schema(
-        data: "Union[DictLike, StructStub, BaseModelStub, DataclassProtocol, AttrsInstanceStub]",
-        *,
-        schema_type: None = None,
-    ) -> "Union[DictLike, StructStub, BaseModelStub, DataclassProtocol, AttrsInstanceStub]": ...
+    def to_schema(data: Any, *, schema_type: None = None) -> Any: ...
 
     @staticmethod
     def to_schema(data: Any, *, schema_type: "Optional[type[ModelDTOT]]" = None) -> Any:
@@ -123,46 +139,55 @@ class ToSchemaMixin:
             return data
         if is_dataclass(schema_type):
             if isinstance(data, list):
-                return [schema_type(**dict(item) if hasattr(item, "keys") else item) for item in data]  # type: ignore[operator]
+                result: list[Any] = []
+                for item in data:
+                    if hasattr(item, "keys"):
+                        result.append(schema_type(**dict(item)))  # type: ignore[operator]
+                    else:
+                        result.append(item)
+                return result
             if hasattr(data, "keys"):
                 return schema_type(**dict(data))  # type: ignore[operator]
             if isinstance(data, dict):
                 return schema_type(**data)  # type: ignore[operator]
-            # Fallback for other types
             return data
         if is_msgspec_struct(schema_type):
+            # Cache the deserializer to avoid repeated partial() calls
+            deserializer = partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS)
             if not isinstance(data, Sequence):
-                return convert(
-                    obj=data,
-                    type=schema_type,
-                    from_attributes=True,
-                    dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
-                )
+                return convert(obj=data, type=schema_type, from_attributes=True, dec_hook=deserializer)
             return convert(
                 obj=data,
                 type=list[schema_type],  # type: ignore[valid-type]  # pyright: ignore
                 from_attributes=True,
-                dec_hook=partial(_default_msgspec_deserializer, type_decoders=_DEFAULT_TYPE_DECODERS),
+                dec_hook=deserializer,
             )
         if is_pydantic_model(schema_type):
             if not isinstance(data, Sequence):
-                return get_type_adapter(schema_type).validate_python(data, from_attributes=True)  # pyright: ignore
-            return get_type_adapter(list[schema_type]).validate_python(data, from_attributes=True)  # type: ignore[valid-type]  # pyright: ignore
+                adapter = get_type_adapter(schema_type)
+                return adapter.validate_python(data, from_attributes=True)  # pyright: ignore
+            list_adapter = get_type_adapter(list[schema_type])  # type: ignore[valid-type]  # pyright: ignore
+            return list_adapter.validate_python(data, from_attributes=True)
         if is_attrs_schema(schema_type):
             if CATTRS_INSTALLED:
                 if isinstance(data, Sequence):
                     return cattrs_structure(data, list[schema_type])  # type: ignore[valid-type]  # pyright: ignore
-                # If data is already structured (attrs instance), unstructure it first
                 if hasattr(data, "__attrs_attrs__"):
-                    data = cattrs_unstructure(data)
+                    unstructured_data = cattrs_unstructure(data)
+                    return cattrs_structure(unstructured_data, schema_type)  # pyright: ignore
                 return cattrs_structure(data, schema_type)  # pyright: ignore
             if isinstance(data, list):
-                return [schema_type(**dict(item) if hasattr(item, "keys") else attrs_asdict(item)) for item in data]
+                attrs_result: list[Any] = []
+                for item in data:
+                    if hasattr(item, "keys"):
+                        attrs_result.append(schema_type(**dict(item)))
+                    else:
+                        attrs_result.append(schema_type(**attrs_asdict(item)))
+                return attrs_result
             if hasattr(data, "keys"):
                 return schema_type(**dict(data))
             if isinstance(data, dict):
                 return schema_type(**data)
-            # Fallback for other types
             return data
         msg = "`schema_type` should be a valid Dataclass, Pydantic model, Msgspec struct, or Attrs class"
         raise SQLSpecError(msg)

sqlspec/driver/mixins/_sql_translator.py

@@ -1,3 +1,5 @@
+from typing import Final, NoReturn, Optional
+
 from mypy_extensions import trait
 from sqlglot import exp, parse_one
 from sqlglot.dialects.dialect import DialectType
@@ -7,6 +9,9 @@ from sqlspec.exceptions import SQLConversionError
 
 __all__ = ("SQLTranslatorMixin",)
 
+# Constants for better performance
+_DEFAULT_PRETTY: Final[bool] = True
+
 
 @trait
 class SQLTranslatorMixin:
@@ -14,23 +19,68 @@ class SQLTranslatorMixin:
 
     __slots__ = ()
 
-    def convert_to_dialect(self, statement: "Statement", to_dialect: DialectType = None, pretty: bool = True) -> str:
+    def convert_to_dialect(
+        self, statement: "Statement", to_dialect: "Optional[DialectType]" = None, pretty: bool = _DEFAULT_PRETTY
+    ) -> str:
+        """Convert a statement to a target SQL dialect.
+
+        Args:
+            statement: SQL statement to convert
+            to_dialect: Target dialect (defaults to current dialect)
+            pretty: Whether to format the output SQL
+
+        Returns:
+            SQL string in target dialect
+
+        Raises:
+            SQLConversionError: If parsing or conversion fails
+        """
+        # Fast path: get the parsed expression with minimal allocations
+        parsed_expression: Optional[exp.Expression] = None
+
         if statement is not None and isinstance(statement, SQL):
             if statement.expression is None:
-                msg = "Statement could not be parsed"
-                raise SQLConversionError(msg)
+                self._raise_statement_parse_error()
             parsed_expression = statement.expression
         elif isinstance(statement, exp.Expression):
             parsed_expression = statement
         else:
-            try:
-                parsed_expression = parse_one(statement, dialect=self.dialect)  # type: ignore[attr-defined]
-            except Exception as e:
-                error_msg = f"Failed to parse SQL statement: {e!s}"
-                raise SQLConversionError(error_msg) from e
+            parsed_expression = self._parse_statement_safely(statement)
+
+        # Get target dialect with fallback
         target_dialect = to_dialect or self.dialect  # type: ignore[attr-defined]
+
+        # Generate SQL with error handling
+        return self._generate_sql_safely(parsed_expression, target_dialect, pretty)
+
+    def _parse_statement_safely(self, statement: "Statement") -> "exp.Expression":
+        """Parse statement with copy=False optimization and proper error handling."""
+        try:
+            # Convert statement to string if needed
+            sql_string = str(statement)
+            # Use copy=False for better performance
+            return parse_one(sql_string, dialect=self.dialect, copy=False)  # type: ignore[attr-defined]
+        except Exception as e:
+            self._raise_parse_error(e)
+
+    def _generate_sql_safely(self, expression: "exp.Expression", dialect: DialectType, pretty: bool) -> str:
+        """Generate SQL with proper error handling."""
         try:
-            return parsed_expression.sql(dialect=target_dialect, pretty=pretty)
+            return expression.sql(dialect=dialect, pretty=pretty)
         except Exception as e:
-            error_msg = f"Failed to convert SQL expression to {target_dialect}: {e!s}"
-            raise SQLConversionError(error_msg) from e
+            self._raise_conversion_error(dialect, e)
+
+    def _raise_statement_parse_error(self) -> NoReturn:
+        """Raise error for unparsable statements."""
+        msg = "Statement could not be parsed"
+        raise SQLConversionError(msg)
+
+    def _raise_parse_error(self, e: Exception) -> NoReturn:
+        """Raise error for parsing failures."""
+        error_msg = f"Failed to parse SQL statement: {e!s}"
+        raise SQLConversionError(error_msg) from e
+
+    def _raise_conversion_error(self, dialect: DialectType, e: Exception) -> NoReturn:
+        """Raise error for conversion failures."""
+        error_msg = f"Failed to convert SQL expression to {dialect}: {e!s}"
+        raise SQLConversionError(error_msg) from e

sqlspec/extensions/litestar/cli.py

@@ -39,7 +39,7 @@ def get_database_migration_plugin(app: "Litestar") -> "SQLSpec":
     raise ImproperConfigurationError(msg)
 
 
-@click.group(cls=LitestarGroup, name="database")
+@click.group(cls=LitestarGroup, name="db")
 def database_group(ctx: "click.Context") -> None:
     """Manage SQLSpec database components."""
     ctx.obj = {"app": ctx.obj, "configs": get_database_migration_plugin(ctx.obj.app).config}

sqlspec/extensions/litestar/plugin.py

@@ -1,7 +1,7 @@
 from typing import TYPE_CHECKING, Any, Union
 
 from litestar.di import Provide
-from litestar.plugins import InitPluginProtocol
+from litestar.plugins import CLIPlugin, InitPluginProtocol
 
 from sqlspec.base import SQLSpec as SQLSpecBase
 from sqlspec.config import AsyncConfigT, DatabaseConfigProtocol, DriverT, SyncConfigT
@@ -17,7 +17,7 @@ if TYPE_CHECKING:
 logger = get_logger("extensions.litestar")
 
 
-class SQLSpec(InitPluginProtocol, SQLSpecBase):
+class SQLSpec(InitPluginProtocol, CLIPlugin, SQLSpecBase):
     """Litestar plugin for SQLSpec database integration."""
 
     __slots__ = ("_config", "_plugin_configs")

sqlspec/protocols.py

@@ -371,6 +371,9 @@ class SQLBuilderProtocol(Protocol):
     _expression: "Optional[exp.Expression]"
     _parameters: dict[str, Any]
     _parameter_counter: int
+    _columns: Any  # Optional attribute for some builders
+    _table: Any  # Optional attribute for some builders
+    _with_ctes: Any  # Optional attribute for some builders
     dialect: Any
     dialect_name: "Optional[str]"
 
@@ -383,6 +386,10 @@ class SQLBuilderProtocol(Protocol):
         """Add a parameter to the builder."""
         ...
 
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        """Generate a unique parameter name."""
+        ...
+
     def _parameterize_expression(self, expression: "exp.Expression") -> "exp.Expression":
         """Replace literal values in an expression with bound parameters."""
         ...

sqlspec/utils/sync_tools.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 try:
     import uvloop  # pyright: ignore[reportMissingImports]
 except ImportError:
-    uvloop = None
+    uvloop = None  # type: ignore[assignment,unused-ignore]
 
 
 ReturnT = TypeVar("ReturnT")

sqlspec/utils/type_guards.py

@@ -841,9 +841,13 @@ def has_sql_method(obj: Any) -> "TypeGuard[HasSQLMethodProtocol]":
 
 def has_query_builder_parameters(obj: Any) -> "TypeGuard[SQLBuilderProtocol]":
     """Check if an object is a query builder with parameters property."""
-    from sqlspec.protocols import SQLBuilderProtocol
-
-    return isinstance(obj, SQLBuilderProtocol)
+    return (
+        hasattr(obj, "build")
+        and callable(getattr(obj, "build", None))
+        and hasattr(obj, "parameters")
+        and hasattr(obj, "add_parameter")
+        and callable(getattr(obj, "add_parameter", None))
+    )
 
 
 def is_object_store_item(obj: Any) -> "TypeGuard[ObjectStoreItemProtocol]":

{sqlspec-0.15.0.dist-info → sqlspec-0.16.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlspec
-Version: 0.15.0
+Version: 0.16.1
 Summary: SQL Experiments in Python
 Project-URL: Discord, https://discord.gg/litestar
 Project-URL: Issue, https://github.com/litestar-org/sqlspec/issues/