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

sqlspec/_sql.py

@@ -4,17 +4,65 @@ Provides both statement builders (select, insert, update, etc.) and column expre
 """
 
 import logging
-from typing import Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import sqlglot
 from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 from sqlglot.errors import ParseError as SQLGlotParseError
 
-from sqlspec.builder import Column, Delete, Insert, Merge, Select, Truncate, Update
+from sqlspec.builder import (
+    AlterTable,
+    Column,
+    CommentOn,
+    CreateIndex,
+    CreateMaterializedView,
+    CreateSchema,
+    CreateTable,
+    CreateTableAsSelect,
+    CreateView,
+    Delete,
+    DropIndex,
+    DropSchema,
+    DropTable,
+    DropView,
+    Insert,
+    Merge,
+    RenameTable,
+    Select,
+    Truncate,
+    Update,
+)
 from sqlspec.exceptions import SQLBuilderError
 
-__all__ = ("Case", "Column", "Delete", "Insert", "Merge", "SQLFactory", "Select", "Truncate", "Update", "sql")
+if TYPE_CHECKING:
+    from sqlspec.core.statement import SQL
+
+__all__ = (
+    "AlterTable",
+    "Case",
+    "Column",
+    "CommentOn",
+    "CreateIndex",
+    "CreateMaterializedView",
+    "CreateSchema",
+    "CreateTable",
+    "CreateTableAsSelect",
+    "CreateView",
+    "Delete",
+    "DropIndex",
+    "DropSchema",
+    "DropTable",
+    "DropView",
+    "Insert",
+    "Merge",
+    "RenameTable",
+    "SQLFactory",
+    "Select",
+    "Truncate",
+    "Update",
+    "sql",
+)
 
 logger = logging.getLogger("sqlspec")
 
@@ -212,6 +260,174 @@ class SQLFactory:
             return builder.into(table_or_sql)
         return builder
 
+    # ===================
+    # DDL Statement Builders
+    # ===================
+
+    def create_table(self, table_name: str, dialect: DialectType = None) -> "CreateTable":
+        """Create a CREATE TABLE builder.
+
+        Args:
+            table_name: Name of the table to create
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateTable builder instance
+        """
+        builder = CreateTable(table_name)
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def create_table_as_select(self, dialect: DialectType = None) -> "CreateTableAsSelect":
+        """Create a CREATE TABLE AS SELECT builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateTableAsSelect builder instance
+        """
+        builder = CreateTableAsSelect()
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def create_view(self, dialect: DialectType = None) -> "CreateView":
+        """Create a CREATE VIEW builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateView builder instance
+        """
+        builder = CreateView()
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def create_materialized_view(self, dialect: DialectType = None) -> "CreateMaterializedView":
+        """Create a CREATE MATERIALIZED VIEW builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateMaterializedView builder instance
+        """
+        builder = CreateMaterializedView()
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def create_index(self, index_name: str, dialect: DialectType = None) -> "CreateIndex":
+        """Create a CREATE INDEX builder.
+
+        Args:
+            index_name: Name of the index to create
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateIndex builder instance
+        """
+        return CreateIndex(index_name, dialect=dialect or self.dialect)
+
+    def create_schema(self, dialect: DialectType = None) -> "CreateSchema":
+        """Create a CREATE SCHEMA builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            CreateSchema builder instance
+        """
+        builder = CreateSchema()
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def drop_table(self, table_name: str, dialect: DialectType = None) -> "DropTable":
+        """Create a DROP TABLE builder.
+
+        Args:
+            table_name: Name of the table to drop
+            dialect: Optional SQL dialect
+
+        Returns:
+            DropTable builder instance
+        """
+        return DropTable(table_name, dialect=dialect or self.dialect)
+
+    def drop_view(self, dialect: DialectType = None) -> "DropView":
+        """Create a DROP VIEW builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            DropView builder instance
+        """
+        return DropView(dialect=dialect or self.dialect)
+
+    def drop_index(self, index_name: str, dialect: DialectType = None) -> "DropIndex":
+        """Create a DROP INDEX builder.
+
+        Args:
+            index_name: Name of the index to drop
+            dialect: Optional SQL dialect
+
+        Returns:
+            DropIndex builder instance
+        """
+        return DropIndex(index_name, dialect=dialect or self.dialect)
+
+    def drop_schema(self, dialect: DialectType = None) -> "DropSchema":
+        """Create a DROP SCHEMA builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            DropSchema builder instance
+        """
+        return DropSchema(dialect=dialect or self.dialect)
+
+    def alter_table(self, table_name: str, dialect: DialectType = None) -> "AlterTable":
+        """Create an ALTER TABLE builder.
+
+        Args:
+            table_name: Name of the table to alter
+            dialect: Optional SQL dialect
+
+        Returns:
+            AlterTable builder instance
+        """
+        builder = AlterTable(table_name)
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def rename_table(self, dialect: DialectType = None) -> "RenameTable":
+        """Create a RENAME TABLE builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            RenameTable builder instance
+        """
+        builder = RenameTable()
+        builder.dialect = dialect or self.dialect
+        return builder
+
+    def comment_on(self, dialect: DialectType = None) -> "CommentOn":
+        """Create a COMMENT ON builder.
+
+        Args:
+            dialect: Optional SQL dialect
+
+        Returns:
+            CommentOn builder instance
+        """
+        builder = CommentOn()
+        builder.dialect = dialect or self.dialect
+        return builder
+
     # ===================
     # SQL Analysis Helpers
     # ===================
@@ -363,8 +579,8 @@ class SQLFactory:
     # ===================
 
     @staticmethod
-    def raw(sql_fragment: str) -> exp.Expression:
-        """Create a raw SQL expression from a string fragment.
+    def raw(sql_fragment: str, **parameters: Any) -> "Union[exp.Expression, SQL]":
+        """Create a raw SQL expression from a string fragment with optional parameters.
 
         This method makes it explicit that you are passing raw SQL that should
         be parsed and included directly in the query. Useful for complex expressions,
@@ -372,30 +588,30 @@ class SQLFactory:
 
         Args:
             sql_fragment: Raw SQL string to parse into an expression.
+            **parameters: Named parameters for parameter binding.
 
         Returns:
-            SQLGlot expression from the parsed SQL fragment.
+            SQLGlot expression from the parsed SQL fragment (if no parameters).
+            SQL statement object (if parameters provided).
 
         Raises:
             SQLBuilderError: If the SQL fragment cannot be parsed.
 
         Example:
             ```python
-            # Raw column expression with alias
-            query = sql.select(
-                sql.raw("user.id AS u_id"), "name"
-            ).from_("users")
+            # Raw expression without parameters (current behavior)
+            expr = sql.raw("COALESCE(name, 'Unknown')")
 
-            # Raw function call
-            query = sql.select(
-                sql.raw("COALESCE(name, 'Unknown')")
-            ).from_("users")
+            # Raw SQL with named parameters (new functionality)
+            stmt = sql.raw(
+                "LOWER(name) LIKE LOWER(:pattern)", pattern=f"%{query}%"
+            )
 
-            # Raw complex expression
-            query = (
-                sql.select("*")
-                .from_("orders")
-                .where(sql.raw("DATE(created_at) = CURRENT_DATE"))
+            # Raw complex expression with parameters
+            expr = sql.raw(
+                "price BETWEEN :min_price AND :max_price",
+                min_price=100,
+                max_price=500,
             )
 
             # Raw window function
@@ -407,16 +623,23 @@ class SQLFactory:
             ).from_("employees")
             ```
         """
-        try:
-            parsed: Optional[exp.Expression] = exp.maybe_parse(sql_fragment)
-            if parsed is not None:
-                return parsed
-            if sql_fragment.strip().replace("_", "").replace(".", "").isalnum():
-                return exp.to_identifier(sql_fragment)
-            return exp.Literal.string(sql_fragment)
-        except Exception as e:
-            msg = f"Failed to parse raw SQL fragment '{sql_fragment}': {e}"
-            raise SQLBuilderError(msg) from e
+        if not parameters:
+            # Original behavior - return pure expression
+            try:
+                parsed: Optional[exp.Expression] = exp.maybe_parse(sql_fragment)
+                if parsed is not None:
+                    return parsed
+                if sql_fragment.strip().replace("_", "").replace(".", "").isalnum():
+                    return exp.to_identifier(sql_fragment)
+                return exp.Literal.string(sql_fragment)
+            except Exception as e:
+                msg = f"Failed to parse raw SQL fragment '{sql_fragment}': {e}"
+                raise SQLBuilderError(msg) from e
+
+        # New behavior - return SQL statement with parameters
+        from sqlspec.core.statement import SQL
+
+        return SQL(sql_fragment, parameters)
 
     # ===================
     # Aggregate Functions

sqlspec/builder/_insert.py

@@ -119,7 +119,18 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
             msg = ERR_MSG_VALUES_COLUMNS_MISMATCH.format(values_len=len(values), columns_len=len(self._columns))
             raise SQLBuilderError(msg)
 
-        param_names = [self._add_parameter(value) for value in values]
+        param_names = []
+        for i, value in enumerate(values):
+            # Try to use column name if available, otherwise use position-based name
+            if self._columns and i < len(self._columns):
+                column_name = (
+                    str(self._columns[i]).split(".")[-1] if "." in str(self._columns[i]) else str(self._columns[i])
+                )
+                param_name = self._generate_unique_parameter_name(column_name)
+            else:
+                param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
+            _, param_name = self.add_parameter(value, name=param_name)
+            param_names.append(param_name)
         value_placeholders = tuple(exp.var(name) for name in param_names)
 
         current_values_expression = insert_expr.args.get("expression")

sqlspec/builder/_parsing_utils.py

@@ -109,7 +109,11 @@ def parse_condition_expression(
         if value is None:
             return exp.Is(this=column_expr, expression=exp.null())
         if builder and has_parameter_builder(builder):
-            _, param_name = builder.add_parameter(value)
+            from sqlspec.builder.mixins._where_clause import _extract_column_name
+
+            column_name = _extract_column_name(column)
+            param_name = builder._generate_unique_parameter_name(column_name)
+            _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_expr, expression=exp.Placeholder(this=param_name))
         if isinstance(value, str):
             return exp.EQ(this=column_expr, expression=exp.convert(value))

sqlspec/builder/mixins/_insert_operations.py

@@ -78,11 +78,21 @@ class InsertValuesMixin:
         except AttributeError:
             pass
         row_exprs = []
-        for v in values:
+        for i, v in enumerate(values):
             if isinstance(v, exp.Expression):
                 row_exprs.append(v)
             else:
-                _, param_name = self.add_parameter(v)  # type: ignore[attr-defined]
+                # Try to use column name if available, otherwise use position-based name
+                try:
+                    _columns = self._columns  # type: ignore[attr-defined]
+                    if _columns and i < len(_columns):
+                        column_name = str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
+                        param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    else:
+                        param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                except AttributeError:
+                    param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                _, param_name = self.add_parameter(v, name=param_name)  # type: ignore[attr-defined]
                 row_exprs.append(exp.var(param_name))
         values_expr = exp.Values(expressions=[row_exprs])
         self._expression.set("expression", values_expr)

sqlspec/builder/mixins/_merge_operations.py

@@ -172,7 +172,11 @@ class MergeMatchedClauseMixin:
         """
         update_expressions: list[exp.EQ] = []
         for col, val in set_values.items():
-            param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {"matched": True, "then": exp.Update(expressions=update_expressions)}
@@ -270,8 +274,12 @@ class MergeNotMatchedClauseMixin:
                 raise SQLBuilderError(msg)
 
             parameterized_values: list[exp.Expression] = []
-            for val in values:
-                param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            for i, val in enumerate(values):
+                column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
                 parameterized_values.append(exp.var(param_name))
 
             insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
@@ -336,7 +344,11 @@ class MergeNotMatchedBySourceClauseMixin:
         """
         update_expressions: list[exp.EQ] = []
         for col, val in set_values.items():
-            param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
             update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
 
         when_args: dict[str, Any] = {

sqlspec/builder/mixins/_select_operations.py

@@ -563,7 +563,8 @@ class CaseBuilder:
             CaseBuilder: The current builder instance for method chaining.
         """
         cond_expr = exp.condition(condition) if isinstance(condition, str) else condition
-        param_name = self._parent.add_parameter(value)[1]
+        param_name = self._parent._generate_unique_parameter_name("case_when_value")
+        param_name = self._parent.add_parameter(value, name=param_name)[1]
         value_expr = exp.Placeholder(this=param_name)
 
         when_clause = exp.When(this=cond_expr, then=value_expr)
@@ -582,7 +583,8 @@ class CaseBuilder:
         Returns:
             CaseBuilder: The current builder instance for method chaining.
         """
-        param_name = self._parent.add_parameter(value)[1]
+        param_name = self._parent._generate_unique_parameter_name("case_else_value")
+        param_name = self._parent.add_parameter(value, name=param_name)[1]
         value_expr = exp.Placeholder(this=param_name)
         self._case_expr.set("default", value_expr)
         return self

sqlspec/builder/mixins/_update_operations.py

@@ -81,7 +81,12 @@ class UpdateSetClauseMixin:
                     for p_name, p_value in val.parameters.items():
                         self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             else:
-                param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+                column_name = col if isinstance(col, str) else str(col)
+                # Extract just the column part if table.column format
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
                 value_expr = exp.Placeholder(this=param_name)
             assignments.append(exp.EQ(this=col_expr, expression=value_expr))
         elif (len(args) == 1 and isinstance(args[0], Mapping)) or kwargs:
@@ -97,7 +102,12 @@ class UpdateSetClauseMixin:
                         for p_name, p_value in val.parameters.items():
                             self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
                 else:
-                    param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
+                    # Extract column name for parameter naming
+                    column_name = col if isinstance(col, str) else str(col)
+                    if "." in column_name:
+                        column_name = column_name.split(".")[-1]
+                    param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
                     value_expr = exp.Placeholder(this=param_name)
                 assignments.append(exp.EQ(this=exp.column(col), expression=value_expr))
         else:

sqlspec/builder/mixins/_where_clause.py

@@ -10,6 +10,29 @@ from sqlspec.builder._parsing_utils import parse_column_expression, parse_condit
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_query_builder_parameters, has_sqlglot_expression, is_iterable_parameters
 
+
+def _extract_column_name(column: Union[str, exp.Column]) -> str:
+    """Extract column name from column expression for parameter naming.
+
+    Args:
+        column: Column expression (string or SQLGlot Column)
+
+    Returns:
+        Column name as string for use as parameter name
+    """
+    if isinstance(column, str):
+        # Handle simple column names and table.column references
+        if "." in column:
+            return column.split(".")[-1]  # Return just the column part
+        return column
+    if isinstance(column, exp.Column):
+        # Extract the column name from SQLGlot Column expression
+        if column.this and hasattr(column.this, "this"):
+            return str(column.this.this)
+        return str(column.this) if column.this else "column"
+    return "column"
+
+
 if TYPE_CHECKING:
     from sqlspec.builder._column import ColumnExpression
     from sqlspec.protocols import SQLBuilderProtocol
@@ -20,28 +43,42 @@ __all__ = ("HavingClauseMixin", "WhereClauseMixin")
 class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
-    def _handle_in_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_in_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle IN operator."""
         builder = cast("SQLBuilderProtocol", self)
         if is_iterable_parameters(value):
             placeholders = []
-            for v in value:
-                _, param_name = builder.add_parameter(v)
+            for i, v in enumerate(value):
+                if len(value) == 1:
+                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                else:
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.In(this=column_exp, expressions=placeholders)
-        _, param_name = builder.add_parameter(value)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         return exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)])
 
-    def _handle_not_in_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_not_in_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle NOT IN operator."""
         builder = cast("SQLBuilderProtocol", self)
         if is_iterable_parameters(value):
             placeholders = []
-            for v in value:
-                _, param_name = builder.add_parameter(v)
+            for i, v in enumerate(value):
+                if len(value) == 1:
+                    param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                else:
+                    param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(v, name=param_name)
                 placeholders.append(exp.Placeholder(this=param_name))
             return exp.Not(this=exp.In(this=column_exp, expressions=placeholders))
-        _, param_name = builder.add_parameter(value)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         return exp.Not(this=exp.In(this=column_exp, expressions=[exp.Placeholder(this=param_name)]))
 
     def _handle_is_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
@@ -54,26 +91,34 @@ class WhereClauseMixin:
         value_expr = exp.Null() if value is None else exp.convert(value)
         return exp.Not(this=exp.Is(this=column_exp, expression=value_expr))
 
-    def _handle_between_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_between_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle BETWEEN operator."""
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            _, low_param = builder.add_parameter(low)
-            _, high_param = builder.add_parameter(high)
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            _, low_param = builder.add_parameter(low, name=low_param)
+            _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Between(
                 this=column_exp, low=exp.Placeholder(this=low_param), high=exp.Placeholder(this=high_param)
             )
         msg = f"BETWEEN operator requires a tuple of two values, got {type(value).__name__}"
         raise SQLBuilderError(msg)
 
-    def _handle_not_between_operator(self, column_exp: exp.Expression, value: Any) -> exp.Expression:
+    def _handle_not_between_operator(
+        self, column_exp: exp.Expression, value: Any, column_name: str = "column"
+    ) -> exp.Expression:
         """Handle NOT BETWEEN operator."""
         if is_iterable_parameters(value) and len(value) == 2:
             builder = cast("SQLBuilderProtocol", self)
             low, high = value
-            _, low_param = builder.add_parameter(low)
-            _, high_param = builder.add_parameter(high)
+            low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
+            high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+            _, low_param = builder.add_parameter(low, name=low_param)
+            _, high_param = builder.add_parameter(high, name=high_param)
             return exp.Not(
                 this=exp.Between(
                     this=column_exp, low=exp.Placeholder(this=low_param), high=exp.Placeholder(this=high_param)
@@ -85,13 +130,15 @@ class WhereClauseMixin:
     def _process_tuple_condition(self, condition: tuple) -> exp.Expression:
         """Process tuple-based WHERE conditions."""
         builder = cast("SQLBuilderProtocol", self)
-        column_name = str(condition[0])
-        column_exp = parse_column_expression(column_name)
+        column_name_raw = str(condition[0])
+        column_exp = parse_column_expression(column_name_raw)
+        column_name = _extract_column_name(column_name_raw)
 
         if len(condition) == 2:
             # (column, value) tuple for equality
             value = condition[1]
-            _, param_name = builder.add_parameter(value)
+            param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
 
         if len(condition) == 3:
@@ -100,42 +147,50 @@ class WhereClauseMixin:
             value = condition[2]
 
             if operator == "=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.EQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator in {"!=", "<>"}:
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.NEQ(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == ">=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.GTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LT(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "<=":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.LTE(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "LIKE":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
             if operator == "NOT LIKE":
-                _, param_name = builder.add_parameter(value)
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                _, param_name = builder.add_parameter(value, name=param_name)
                 return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
             if operator == "IN":
-                return self._handle_in_operator(column_exp, value)
+                return self._handle_in_operator(column_exp, value, column_name)
             if operator == "NOT IN":
-                return self._handle_not_in_operator(column_exp, value)
+                return self._handle_not_in_operator(column_exp, value, column_name)
             if operator == "IS":
                 return self._handle_is_operator(column_exp, value)
             if operator == "IS NOT":
                 return self._handle_is_not_operator(column_exp, value)
             if operator == "BETWEEN":
-                return self._handle_between_operator(column_exp, value)
+                return self._handle_between_operator(column_exp, value, column_name)
             if operator == "NOT BETWEEN":
-                return self._handle_not_between_operator(column_exp, value)
+                return self._handle_not_between_operator(column_exp, value, column_name)
 
             msg = f"Unsupported operator: {operator}"
             raise SQLBuilderError(msg)
@@ -218,86 +273,107 @@ class WhereClauseMixin:
     def where_eq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column = value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.eq(exp.var(param_name))
+        condition: exp.Expression = col_expr.eq(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_neq(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column != value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.neq(exp.var(param_name))
+        condition: exp.Expression = col_expr.neq(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_lt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column < value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.LT(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.LT(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_lte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column <= value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.LTE(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_gt(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column > value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.GT(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.GT(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_gte(self, column: Union[str, exp.Column], value: Any) -> Self:
         """Add WHERE column >= value clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(value)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(value, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.var(param_name))
+        condition: exp.Expression = exp.GTE(this=col_expr, expression=exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_between(self, column: Union[str, exp.Column], low: Any, high: Any) -> Self:
         """Add WHERE column BETWEEN low AND high clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, low_param = builder.add_parameter(low)
-        _, high_param = builder.add_parameter(high)
+        column_name = _extract_column_name(column)
+        low_param = builder._generate_unique_parameter_name(f"{column_name}_low")  # type: ignore[attr-defined]
+        high_param = builder._generate_unique_parameter_name(f"{column_name}_high")  # type: ignore[attr-defined]
+        _, low_param = builder.add_parameter(low, name=low_param)
+        _, high_param = builder.add_parameter(high, name=high_param)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.between(exp.var(low_param), exp.var(high_param))
+        condition: exp.Expression = col_expr.between(exp.Placeholder(this=low_param), exp.Placeholder(this=high_param))
         return self.where(condition)
 
     def where_like(self, column: Union[str, exp.Column], pattern: str, escape: Optional[str] = None) -> Self:
         """Add WHERE column LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         if escape is not None:
-            cond = exp.Like(this=col_expr, expression=exp.var(param_name), escape=exp.convert(str(escape)))
+            cond = exp.Like(this=col_expr, expression=exp.Placeholder(this=param_name), escape=exp.convert(str(escape)))
         else:
-            cond = col_expr.like(exp.var(param_name))
+            cond = col_expr.like(exp.Placeholder(this=param_name))
         condition: exp.Expression = cond
         return self.where(condition)
 
     def where_not_like(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column NOT LIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.like(exp.var(param_name)).not_()
+        condition: exp.Expression = col_expr.like(exp.Placeholder(this=param_name)).not_()
         return self.where(condition)
 
     def where_ilike(self, column: Union[str, exp.Column], pattern: str) -> Self:
         """Add WHERE column ILIKE pattern clause."""
         builder = cast("SQLBuilderProtocol", self)
-        _, param_name = builder.add_parameter(pattern)
+        column_name = _extract_column_name(column)
+        param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+        _, param_name = builder.add_parameter(pattern, name=param_name)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.ilike(exp.var(param_name))
+        condition: exp.Expression = col_expr.ilike(exp.Placeholder(this=param_name))
         return self.where(condition)
 
     def where_is_null(self, column: Union[str, exp.Column]) -> Self:
@@ -322,6 +398,10 @@ class WhereClauseMixin:
                 subquery = values.build()  # pyright: ignore
                 sql_str = subquery.sql
                 subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=builder.dialect_name))  # pyright: ignore
+                # Merge subquery parameters into parent builder
+                if hasattr(subquery, "parameters"):
+                    for param_name, param_value in subquery.parameters.items():  # pyright: ignore[reportAttributeAccessIssue]
+                        builder.add_parameter(param_value, name=param_name)
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = col_expr.isin(subquery_exp)
@@ -329,10 +409,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         condition = col_expr.isin(*parameters)
         return self.where(condition)
 
@@ -353,10 +438,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Values for where_not_in must be a non-string iterable or subquery."
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_{i + 1}")  # type: ignore[attr-defined]
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         condition = exp.Not(this=col_expr.isin(*parameters))
         return self.where(condition)
 
@@ -438,10 +528,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_any_{i + 1}")  # type: ignore[attr-defined]
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.EQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)
@@ -473,10 +568,15 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
+        column_name = _extract_column_name(column)
         parameters = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            parameters.append(exp.var(param_name))
+        for i, v in enumerate(values):
+            if len(values) == 1:
+                param_name = builder._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            else:
+                param_name = builder._generate_unique_parameter_name(f"{column_name}_not_any_{i + 1}")  # type: ignore[attr-defined]
+            _, param_name = builder.add_parameter(v, name=param_name)
+            parameters.append(exp.Placeholder(this=param_name))
         tuple_expr = exp.Tuple(expressions=parameters)
         condition = exp.NEQ(this=col_expr, expression=exp.Any(this=tuple_expr))
         return self.where(condition)

sqlspec/core/filters.py

@@ -558,6 +558,7 @@ class LimitOffsetFilter(PaginationFilter):
         return [], {self._limit_param_name: self.limit, self._offset_param_name: self.offset}
 
     def append_to_statement(self, statement: "SQL") -> "SQL":
+        import sqlglot
         from sqlglot import exp
 
         # Resolve parameter name conflicts
@@ -567,17 +568,18 @@ class LimitOffsetFilter(PaginationFilter):
         limit_placeholder = exp.Placeholder(this=limit_param_name)
         offset_placeholder = exp.Placeholder(this=offset_param_name)
 
-        if statement._statement is None:
-            new_statement = exp.Select().limit(limit_placeholder)
-        else:
-            new_statement = (
-                statement._statement.limit(limit_placeholder)
-                if isinstance(statement._statement, exp.Select)
-                else exp.Select().from_(statement._statement).limit(limit_placeholder)
-            )
+        # Parse the current SQL to get the statement structure
+        try:
+            current_statement = sqlglot.parse_one(statement._raw_sql, dialect=getattr(statement, "_dialect", None))
+        except Exception:
+            # Fallback to wrapping in subquery if parsing fails
+            current_statement = exp.Select().from_(f"({statement._raw_sql})")
 
-        if isinstance(new_statement, exp.Select):
-            new_statement = new_statement.offset(offset_placeholder)
+        if isinstance(current_statement, exp.Select):
+            new_statement = current_statement.limit(limit_placeholder).offset(offset_placeholder)
+        else:
+            # Wrap non-SELECT statements in a subquery
+            new_statement = exp.Select().from_(current_statement).limit(limit_placeholder).offset(offset_placeholder)
 
         result = statement.copy(statement=new_statement)
 

sqlspec/core/statement.py

@@ -368,6 +368,10 @@ class SQL:
         new_sql = SQL(
             self._raw_sql, *self._original_parameters, statement_config=self._statement_config, is_many=self._is_many
         )
+        # Preserve accumulated parameters when marking as script
+        new_sql._named_parameters.update(self._named_parameters)
+        new_sql._positional_parameters = self._positional_parameters.copy()
+        new_sql._filters = self._filters.copy()
         new_sql._is_script = True
         return new_sql
 
@@ -375,13 +379,19 @@ class SQL:
         self, statement: "Optional[Union[str, exp.Expression]]" = None, parameters: Optional[Any] = None, **kwargs: Any
     ) -> "SQL":
         """Create copy with modifications."""
-        return SQL(
+        new_sql = SQL(
             statement or self._raw_sql,
             *(parameters if parameters is not None else self._original_parameters),
             statement_config=self._statement_config,
             is_many=self._is_many,
             **kwargs,
         )
+        # Only preserve accumulated parameters when no explicit parameters are provided
+        if parameters is None:
+            new_sql._named_parameters.update(self._named_parameters)
+            new_sql._positional_parameters = self._positional_parameters.copy()
+        new_sql._filters = self._filters.copy()
+        return new_sql
 
     def add_named_parameter(self, name: str, value: Any) -> "SQL":
         """Add a named parameter and return a new SQL instance.
@@ -437,9 +447,14 @@ class SQL:
 
         new_sql_text = new_expr.sql(dialect=self._dialect)
 
-        return SQL(
+        new_sql = SQL(
             new_sql_text, *self._original_parameters, statement_config=self._statement_config, is_many=self._is_many
         )
+        # Preserve accumulated named parameters when creating WHERE clause
+        new_sql._named_parameters.update(self._named_parameters)
+        new_sql._positional_parameters = self._positional_parameters.copy()
+        new_sql._filters = self._filters.copy()
+        return new_sql
 
     def __hash__(self) -> int:
         """Hash value."""

sqlspec/driver/mixins/_result_tools.py

@@ -5,7 +5,7 @@ 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, Optional, overload
 from uuid import UUID
 
 from mypy_extensions import trait
@@ -13,8 +13,6 @@ from mypy_extensions import trait
 from sqlspec.exceptions import SQLSpecError, wrap_exceptions
 from sqlspec.typing import (
     CATTRS_INSTALLED,
-    DataclassProtocol,
-    DictLike,
     ModelDTOT,
     ModelT,
     attrs_asdict,
@@ -25,9 +23,6 @@ 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")
 
 
@@ -74,36 +69,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:

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/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-0.15.0.dist-info → sqlspec-0.16.0.dist-info}/METADATA

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

{sqlspec-0.15.0.dist-info → sqlspec-0.16.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ sqlspec/__init__.py,sha256=8_TR9bXd7bkA4qBGCzTHNawH7KXaJ4YlnCJzJwvgud8,2066
 sqlspec/__main__.py,sha256=lXBKZMOXA1uY735Rnsb-GS7aXy0nt22tYmd2X9FcxrY,253
 sqlspec/__metadata__.py,sha256=IUw6MCTy1oeUJ1jAVYbuJLkOWbiAWorZ5W-E-SAD9N4,395
 sqlspec/_serialization.py,sha256=6U5-smk2h2yl0i6am2prtOLJTdu4NJQdcLlSfSUMaUQ,2590
-sqlspec/_sql.py,sha256=GggpMLOqVQxuirCcpSj-wBQX2N89jOqNibP7r88-dMY,39567
+sqlspec/_sql.py,sha256=HbJYrs9NCEUQhFermrcS5fDhm3aRxbabLLESHf2aMQg,45544
 sqlspec/_typing.py,sha256=jv-7QHGLrJLfnP86bR-Xcmj3PDoddNZEKDz_vYRBiAU,22684
 sqlspec/base.py,sha256=lVLzFD-nzEU6QnwnU0kRWh3XWjbvXWX0XnnUViYBoQk,21767
 sqlspec/cli.py,sha256=3ZxPwl4neNWyrAkM9J9ccC_gaFigDJbhuZfx15JVE7E,9903
@@ -59,47 +59,47 @@ sqlspec/builder/_column.py,sha256=sGDoRhgeqNv69M2jIcNDWxTsMV3TKRNtktpDwl_ssSI,13
 sqlspec/builder/_ddl.py,sha256=6TvCMiJAuPBtwXbAupGKnrJ9Wb9-VK5P6cfEFbE9CT8,50284
 sqlspec/builder/_ddl_utils.py,sha256=qlKT9TqlaymwZLiZjHXIVvFofiWekCLNu-AvPFzUiac,4115
 sqlspec/builder/_delete.py,sha256=YCAV7GUutY-j1Z6tQ9Q0CE4K4Z5LbZXldMOpS2uxAi4,2301
-sqlspec/builder/_insert.py,sha256=nsAaJpAWU0g8LnAJynScn5Iqiw8f-bxvKlT-g5yToxw,8489
+sqlspec/builder/_insert.py,sha256=ozqnpsQUcqzjvGvcgaUKzvrH9GKisY2DGYR7EwXdi_E,9089
 sqlspec/builder/_merge.py,sha256=pabh0G7DsMZoOG8cGep0qLLdgnyoxQFRUUglhE5yScE,1570
-sqlspec/builder/_parsing_utils.py,sha256=0Bu2G5VAWOym-tIpdFau3_sa71CMmM-BwZzgDoD89xE,5384
+sqlspec/builder/_parsing_utils.py,sha256=3XRrL2T2eG_aHfF1kQID9dZpxIgVAkB4u8Mzl1Nm-Cs,5617
 sqlspec/builder/_select.py,sha256=oxi-5ezjsAt7n6OQm1FNCSO_wFo8djWBPL9f-kiUo9g,5992
 sqlspec/builder/_update.py,sha256=l9tHwC96VSmk8zGMhzB_S4YuD2_6q4cBXMboqoqvLJ0,5969
 sqlspec/builder/mixins/__init__.py,sha256=YXhAzKmQbQtne5j26SKWY8PUxwosl0RhlhLoahAdkj0,1885
 sqlspec/builder/mixins/_cte_and_set_ops.py,sha256=BPPkDTFo2Feja7Vers0BrC_JIYcpfOYSTZ9GIV_UOZ4,8317
 sqlspec/builder/mixins/_delete_operations.py,sha256=0f8ZZMFx5b53EUx1oF264owLb6aWP45naeB6g-BZQys,1068
-sqlspec/builder/mixins/_insert_operations.py,sha256=0Pz0QSa4bgGIiKT2Y8zPs6C2uxEQPyQqXdhKADttSJ0,5528
+sqlspec/builder/mixins/_insert_operations.py,sha256=O2Au5gnoPXTsLtPrlqtHwonIKgY4MV6nkIdzXr3gySk,6340
 sqlspec/builder/mixins/_join_operations.py,sha256=5qloj7JmRWBi7pFBpAY1acwg_O_1CpcHeYMbzkBKfBE,5507
-sqlspec/builder/mixins/_merge_operations.py,sha256=JpP33NevlhfCHnKMpLQOU8THN2ImFKMUwdWiI6UydPI,16745
+sqlspec/builder/mixins/_merge_operations.py,sha256=AnbZ53hXNsfCXdfOvZvSSLW-359R3XwaQD8y_-EBpZc,17642
 sqlspec/builder/mixins/_order_limit_operations.py,sha256=NuNUb_DJKTdnbjasjOh27zLtbr1JZ4ygS0NH76G4foI,4514
 sqlspec/builder/mixins/_pivot_operations.py,sha256=nkV9kG15rSoX0IWRAmaZjxyY8J7_5sScgxrRtYjddqE,5886
-sqlspec/builder/mixins/_select_operations.py,sha256=-zo75-lp9T3j7D7zRpsa1D3oCd0Jt2xZ_OslhZeumt0,24692
-sqlspec/builder/mixins/_update_operations.py,sha256=N6Lm-BrMhEPfFQz9V3-4ZgvSEsGfWtuQwlWbzdgLVWc,6904
-sqlspec/builder/mixins/_where_clause.py,sha256=lb6iGqbKPX7rInY1YwYpVMQxUlRftRZthZdwDbnYs20,25729
+sqlspec/builder/mixins/_select_operations.py,sha256=VvmMUmz2Fyhsv-J5O-3iLxMi59tupmgekPLCYxACJSg,24896
+sqlspec/builder/mixins/_update_operations.py,sha256=j4jN1gJnFu-9PG14xgoqXOW1-9GMb__1yLs_GXExWMA,7649
+sqlspec/builder/mixins/_where_clause.py,sha256=tQ3n48tOwlI67oqtY2BV0Tuv-TDNP8N9ceyxKL_92yQ,33289
 sqlspec/core/__init__.py,sha256=rU_xGsXhqIOnBbyB2InhJknYePm5NQ2DSWdBigror4g,1775
 sqlspec/core/cache.py,sha256=CQ_xTBQVJaBxB5-ipiw4Oj6JObrcMFtXYRLMSvbXGnE,27130
 sqlspec/core/compiler.py,sha256=we_ifDr7JOAu3EycmWDxynOYq8ufjwcZl9MDXFTf5cQ,13959
-sqlspec/core/filters.py,sha256=J2tpDo8Ton98Gwc9Tx0Ki3X0JgO6xrnbE0_stfBeP3E,31126
+sqlspec/core/filters.py,sha256=X0wRd0vNOFgeOK98ReeTyKt408GCnnmE9p45Bvur3kw,31351
 sqlspec/core/hashing.py,sha256=4KyAFWtFDMYreoBGGPQppEuMWO6_NrRYlw9Lm-qeJqo,10429
 sqlspec/core/parameters.py,sha256=X5e9SKGS1gkn7Sv6qAkzZtllIQDmhuUxAnLFlxBkAns,52833
 sqlspec/core/result.py,sha256=vdPXLApkS0F2Jz-Bq7-A-bKf7g4JIs5_57nAI4O4tC0,21100
 sqlspec/core/splitter.py,sha256=cb2P1B0q5vvALHi3SEJ7VdbRHH2GWsftrmJi9PYMbeE,28089
-sqlspec/core/statement.py,sha256=S_fkqYkG9v2KCsznCBAJIDkR2ASKwub5Y3dNlRYkLec,24231
+sqlspec/core/statement.py,sha256=XdS8YUMEVR1qVjE48a0dIh8554Tm8lTLsa4z7sgM2vE,25117
 sqlspec/driver/__init__.py,sha256=QVpDRQGd1GreIP199en6qDbq-cZJcEF5go68DINagUk,569
 sqlspec/driver/_async.py,sha256=0P3VlBYXfythkh9c1wCE3oZMwQa0NtbW_6SljPxpcAw,18858
 sqlspec/driver/_common.py,sha256=go-SZRYlx_qEh8A9BGFl_BVByEdnLvtSXi6bqA6wOmU,25553
 sqlspec/driver/_sync.py,sha256=UZKCTrKh48lzRONk-eX5q6qKBLZOawODaPN_28ObACE,18586
 sqlspec/driver/mixins/__init__.py,sha256=gN4pQyJXxNy0xi91dcMJGA7DQ7TbjGjQI24SSpZc6Go,248
-sqlspec/driver/mixins/_result_tools.py,sha256=wI8bGfDrGrG8nexPWiJdvgy1yi1_z643yKPsgMzBqiY,6915
+sqlspec/driver/mixins/_result_tools.py,sha256=s1NWsE_Tiq7R_f6rSqjbPm6SFVYpRBdSdCb0ejlX66c,6733
 sqlspec/driver/mixins/_sql_translator.py,sha256=zpaJsS0_-zVvm3u2yCQ8VkILrZ7j28925SyZe1ChvlM,1491
 sqlspec/extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sqlspec/extensions/aiosql/__init__.py,sha256=-9cefc9pYPf9vCgALoB-y1DtmcgRjKe2azfl6RIarAA,414
 sqlspec/extensions/aiosql/adapter.py,sha256=CXkNZaZq86ZhfYFGx4IFbkHmbIFQKMd9CS6Q2jkMCok,16009
 sqlspec/extensions/litestar/__init__.py,sha256=tOmQ7RHSWOot7p30gk0efxxuP0OCq1opyyZqNmQY7FE,320
 sqlspec/extensions/litestar/_utils.py,sha256=o-FuUj1_WkDrLxQxiP6hXDak66XfyRP3QLyEVKrIRjI,1954
-sqlspec/extensions/litestar/cli.py,sha256=NYjPIWe0jESBgS0AG-3bdpcC5YM4RmZeeeTeFQK5Yqo,1362
+sqlspec/extensions/litestar/cli.py,sha256=X4DlAx3Ry-ccOjAQSxe8SMtyJKCFJVLTbENPU_efKuU,1356
 sqlspec/extensions/litestar/config.py,sha256=3UI_vhtbupCLsf1nhUgUpRlCoUS5c0GsAjWvegT0c3c,4462
 sqlspec/extensions/litestar/handlers.py,sha256=3LreU8rZvuHaJnKlN09ttu4wSorWJedsuKgeLT-cOEc,9993
-sqlspec/extensions/litestar/plugin.py,sha256=lojdLit4Uop6fpJWGXgpWrbGUBgCWR_khOK4CdRYpKM,5615
+sqlspec/extensions/litestar/plugin.py,sha256=I0aRnL4oZPUYk7pYhZSL3yikl7ViM0kr33kVmH4W-MU,5637
 sqlspec/extensions/litestar/providers.py,sha256=5LRb5JvRV_XZdNOKkdaIy3j5x-dFCcAi1ea1pgwuapI,18882
 sqlspec/migrations/__init__.py,sha256=n9y2yLQb02zMz36bPXnrInsSIMLunwHvO7e8UvCYBJc,1061
 sqlspec/migrations/base.py,sha256=D5-k0m4SnmVU0QRRPcMCvMAyEoAaceYYmD8JprSozDA,13251
@@ -123,12 +123,12 @@ sqlspec/utils/logging.py,sha256=ZEaj7J8oALrs_-p535vSUFo2tfrHkOEcL5pK2JGGFgM,3708
 sqlspec/utils/module_loader.py,sha256=m5PSN9NwOLd0ZJBuqMVYVi-vaIQMBCVd25vnM3-rv3k,2823
 sqlspec/utils/serializers.py,sha256=TKsRryRcYMnb8Z8MGkYGClIxcYvC8CW7MsrPQTJqEcY,154
 sqlspec/utils/singleton.py,sha256=SKnszJi1NPeERgX7IjVIGYAYx4XqR1E_rph3bU6olAU,1047
-sqlspec/utils/sync_tools.py,sha256=Iv1Msj1tb24iJhhulL_wcNsyjRComzAkyUNlefVci3w,7348
+sqlspec/utils/sync_tools.py,sha256=WRuk1ZEhb_0CRrumAdnmi-i-dV6qVd3cgJyZw8RY9QQ,7390
 sqlspec/utils/text.py,sha256=n5K0gvXvyCc8jNteNKsBOymwf_JnQ65f3lu0YaYq4Ys,2898
 sqlspec/utils/type_guards.py,sha256=AJKSQ323mNfhRbytI2e4N2cy2P6MMG7fp75foVnz328,30339
-sqlspec-0.15.0.dist-info/METADATA,sha256=GFcTBVzGgY-1_Wc-fL_9l_lt2JN1i__L4uN9uT6rOhw,16822
-sqlspec-0.15.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sqlspec-0.15.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
-sqlspec-0.15.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
-sqlspec-0.15.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
-sqlspec-0.15.0.dist-info/RECORD,,
+sqlspec-0.16.0.dist-info/METADATA,sha256=YmaZ4D_0DDG-phbhQMQFcP0lEYVPCpTtd7rJdzEL0BU,16822
+sqlspec-0.16.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sqlspec-0.16.0.dist-info/entry_points.txt,sha256=G-ZqY1Nuuw3Iys7nXw23f6ILenk_Lt47VdK2mhJCWHg,53
+sqlspec-0.16.0.dist-info/licenses/LICENSE,sha256=MdujfZ6l5HuLz4mElxlu049itenOR3gnhN1_Nd3nVcM,1078
+sqlspec-0.16.0.dist-info/licenses/NOTICE,sha256=Lyir8ozXWov7CyYS4huVaOCNrtgL17P-bNV-5daLntQ,1634
+sqlspec-0.16.0.dist-info/RECORD,,