sqlspec 0.12.2__py3-none-any.whl → 0.13.1__py3-none-any.whl

sqlspec/statement/builder/mixins/_update_set.py

@@ -5,6 +5,7 @@ from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
+from sqlspec.utils.type_guards import has_query_builder_parameters
 
 __all__ = ("UpdateSetClauseMixin",)
 
@@ -49,14 +50,15 @@ class UpdateSetClauseMixin:
             # If value is an expression, use it directly
             if isinstance(val, exp.Expression):
                 value_expr = val
-            elif hasattr(val, "_expression") and hasattr(val, "build"):
+            elif has_query_builder_parameters(val):
                 # It's a builder (like SelectBuilder), convert to subquery
                 subquery = val.build()
                 # Parse the SQL and use as expression
-                value_expr = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                 # Merge parameters from subquery
-                if hasattr(val, "_parameters"):
-                    for p_name, p_value in val._parameters.items():
+                if has_query_builder_parameters(val):
+                    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]
@@ -69,14 +71,15 @@ class UpdateSetClauseMixin:
                 # If value is an expression, use it directly
                 if isinstance(val, exp.Expression):
                     value_expr = val
-                elif hasattr(val, "_expression") and hasattr(val, "build"):
+                elif has_query_builder_parameters(val):
                     # It's a builder (like SelectBuilder), convert to subquery
                     subquery = val.build()
                     # Parse the SQL and use as expression
-                    value_expr = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect", None)))
+                    sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                    value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                     # Merge parameters from subquery
-                    if hasattr(val, "_parameters"):
-                        for p_name, p_value in val._parameters.items():
+                    if has_query_builder_parameters(val):
+                        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]

sqlspec/statement/builder/mixins/_where.py

@@ -6,9 +6,11 @@ from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.statement.builder._parsing_utils import parse_column_expression, parse_condition_expression
+from sqlspec.utils.type_guards import has_query_builder_parameters, is_iterable_parameters
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.protocols import BuilderProtocol
+    from sqlspec.protocols import SQLBuilderProtocol
+    from sqlspec.statement.builder.column import ColumnExpression
 
 __all__ = ("WhereClauseMixin",)
 
@@ -17,7 +19,8 @@ class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
     def where(
-        self, condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any]]
+        self,
+        condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression"],
     ) -> Self:
         """Add a WHERE clause to the statement.
 
@@ -34,14 +37,14 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        # Special case: if this is an UpdateBuilder and _expression is not exp.Update, raise the expected error for test coverage
+        # Special case: if this is an Update and _expression is not exp.Update, raise the expected error for test coverage
 
-        if self.__class__.__name__ == "UpdateBuilder" and not (
+        if self.__class__.__name__ == "Update" and not (
             hasattr(self, "_expression") and isinstance(getattr(self, "_expression", None), exp.Update)
         ):
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
-        builder = cast("BuilderProtocol", self)
+        builder = cast("SQLBuilderProtocol", self)
         if builder._expression is None:
             msg = "Cannot add WHERE clause: expression is not initialized."
             raise SQLBuilderError(msg)
@@ -50,7 +53,6 @@ class WhereClauseMixin:
             msg = f"Cannot add WHERE clause to unsupported expression type: {type(builder._expression).__name__}."
             raise SQLBuilderError(msg)
 
-        # Check if table is set for DELETE queries
         if isinstance(builder._expression, exp.Delete) and not builder._expression.args.get("this"):
             msg = "WHERE clause requires a table to be set. Use from() to set the table first."
             raise SQLBuilderError(msg)
@@ -58,7 +60,6 @@ class WhereClauseMixin:
         # Normalize the condition using enhanced parsing
         condition_expr: exp.Expression
         if isinstance(condition, tuple):
-            # Handle tuple format with proper parameter binding
             if len(condition) == 2:
                 # 2-tuple: (column, value) -> column = value
                 param_name = builder.add_parameter(condition[1])[1]
@@ -87,7 +88,6 @@ class WhereClauseMixin:
                     "any": exp.Any,
                 }
                 operator = operator.lower()
-                # Handle special cases for NOT operators
                 if operator == "not like":
                     condition_expr = exp.Not(this=exp.Like(this=col_expr, expression=placeholder_expr))
                 elif operator == "not in":
@@ -104,7 +104,20 @@ class WhereClauseMixin:
             else:
                 msg = f"WHERE tuple must have 2 or 3 elements, got {len(condition)}"
                 raise SQLBuilderError(msg)
+        # Handle ColumnExpression objects
+        elif hasattr(condition, "sqlglot_expression"):
+            # This is a ColumnExpression from our new Column syntax
+            raw_expr = getattr(condition, "sqlglot_expression", None)
+            if raw_expr is not None:
+                condition_expr = builder._parameterize_expression(raw_expr)
+            else:
+                # Fallback if attribute exists but is None
+                condition_expr = parse_condition_expression(str(condition))
         else:
+            # Existing logic for strings and raw SQLGlot expressions
+            # Convert to string if it's not a recognized type
+            if not isinstance(condition, (str, exp.Expression, tuple)):
+                condition = str(condition)
             condition_expr = parse_condition_expression(condition)
 
         # Use dialect if available for Delete
@@ -194,13 +207,16 @@ class WhereClauseMixin:
 
     def where_exists(self, subquery: "Union[str, Any]") -> "Self":
         sub_expr: exp.Expression
-        if hasattr(subquery, "_parameters") and hasattr(subquery, "build"):
-            subquery_builder_params: dict[str, Any] = subquery._parameters  # pyright: ignore
+        if has_query_builder_parameters(subquery):
+            subquery_builder_params: dict[str, Any] = subquery.parameters
             if subquery_builder_params:
                 for p_name, p_value in subquery_builder_params.items():
                     self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=getattr(self, "dialect_name", None))
+            sql_str = (
+                sub_sql_obj.sql if hasattr(sub_sql_obj, "sql") and not callable(sub_sql_obj.sql) else str(sub_sql_obj)
+            )
+            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None))
         else:
             sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(self, "dialect_name", None))
 
@@ -213,13 +229,16 @@ class WhereClauseMixin:
 
     def where_not_exists(self, subquery: "Union[str, Any]") -> "Self":
         sub_expr: exp.Expression
-        if hasattr(subquery, "_parameters") and hasattr(subquery, "build"):
-            subquery_builder_params: dict[str, Any] = subquery._parameters  # pyright: ignore
+        if has_query_builder_parameters(subquery):
+            subquery_builder_params: dict[str, Any] = subquery.parameters
             if subquery_builder_params:
                 for p_name, p_value in subquery_builder_params.items():
                     self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=getattr(self, "dialect_name", None))
+            sql_str = (
+                sub_sql_obj.sql if hasattr(sub_sql_obj, "sql") and not callable(sub_sql_obj.sql) else str(sub_sql_obj)
+            )
+            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None))
         else:
             sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(self, "dialect_name", None))
 
@@ -238,16 +257,18 @@ class WhereClauseMixin:
         """Add a WHERE ... IN (...) clause. Supports subqueries and iterables."""
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         # Subquery support
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = col_expr.isin(subquery_exp)
             return self.where(condition)
         # Iterable of values
-        if not hasattr(values, "__iter__") or isinstance(values, (str, bytes)):
+        if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
         params = []
@@ -260,15 +281,17 @@ class WhereClauseMixin:
     def where_not_in(self, column: "Union[str, exp.Column]", values: Any) -> "Self":
         """Add a WHERE ... NOT IN (...) clause. Supports subqueries and iterables."""
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.Not(this=col_expr.isin(subquery_exp))
             return self.where(condition)
-        if not hasattr(values, "__iter__") or isinstance(values, (str, bytes)):
+        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)
         params = []
@@ -294,12 +317,14 @@ class WhereClauseMixin:
             The current builder instance for method chaining.
         """
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
             return self.where(condition)
         if isinstance(values, str):
@@ -317,7 +342,7 @@ class WhereClauseMixin:
             # If parsing fails, fall through to error
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
-        if not hasattr(values, "__iter__") or isinstance(values, bytes):
+        if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
         params = []
@@ -339,12 +364,14 @@ class WhereClauseMixin:
             The current builder instance for method chaining.
         """
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
             return self.where(condition)
         if isinstance(values, str):
@@ -362,7 +389,7 @@ class WhereClauseMixin:
             # If parsing fails, fall through to error
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
-        if not hasattr(values, "__iter__") or isinstance(values, bytes):
+        if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
         params = []

sqlspec/statement/builder/select.py

@@ -6,7 +6,7 @@ with automatic parameter binding and validation.
 
 import re
 from dataclasses import dataclass, field
-from typing import Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -32,11 +32,11 @@ from sqlspec.statement.builder.mixins import (
 from sqlspec.statement.result import SQLResult
 from sqlspec.typing import RowT
 
-__all__ = ("SelectBuilder",)
+__all__ = ("Select",)
 
 
 @dataclass
-class SelectBuilder(
+class Select(
     QueryBuilder[RowT],
     WhereClauseMixin,
     OrderByClauseMixin,
@@ -77,16 +77,37 @@ class SelectBuilder(
         _schema: The schema/model class for row typing, if set via as_schema().
     """
 
-    _with_parts: "dict[str, Union[exp.CTE, SelectBuilder]]" = field(default_factory=dict, init=False)
+    _with_parts: "dict[str, Union[exp.CTE, Select]]" = field(default_factory=dict, init=False)
     _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
     _schema: Optional[type[RowT]] = None
     _hints: "list[dict[str, object]]" = field(default_factory=list, init=False, repr=False)
 
-    def __post_init__(self) -> "None":
-        super().__post_init__()
+    def __init__(self, *columns: str, **kwargs: Any) -> None:
+        """Initialize SELECT with optional columns.
+
+        Args:
+            *columns: Column names to select (e.g., "id", "name", "u.email")
+            **kwargs: Additional QueryBuilder arguments (dialect, schema, etc.)
+
+        Examples:
+            Select("id", "name")  # Shorthand for Select().select("id", "name")
+            Select()              # Same as SelectBuilder() - start empty
+        """
+        super().__init__(**kwargs)
+
+        # Initialize fields from dataclass
+        self._with_parts = {}
+        self._expression = None
+        self._schema = None
+        self._hints = []
+
         if self._expression is None:
             self._create_base_expression()
 
+        # Add columns if provided - just a shorthand for .select()
+        if columns:
+            self.select(*columns)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult[RowT]]":
         """Get the expected result type for SELECT operations.
@@ -102,8 +123,8 @@ class SelectBuilder(
         # At this point, self._expression is exp.Select
         return self._expression
 
-    def as_schema(self, schema: "type[RowT]") -> "SelectBuilder[RowT]":
-        """Return a new SelectBuilder instance parameterized with the given schema/model type.
+    def as_schema(self, schema: "type[RowT]") -> "Select[RowT]":
+        """Return a new Select instance parameterized with the given schema/model type.
 
         This enables type-safe result mapping: the returned builder will carry the schema type
         for static analysis and IDE autocompletion. The schema should be a class such as a Pydantic
@@ -113,15 +134,15 @@ class SelectBuilder(
             schema: The schema/model class to use for row typing (e.g., a Pydantic model, dataclass, or msgspec.Struct).
 
         Returns:
-            SelectBuilder[RowT]: A new SelectBuilder instance with RowT set to the provided schema/model type.
+            Select[RowT]: A new Select instance with RowT set to the provided schema/model type.
         """
-        new_builder = SelectBuilder()
+        new_builder = Select()
         new_builder._expression = self._expression.copy() if self._expression is not None else None
         new_builder._parameters = self._parameters.copy()
         new_builder._parameter_counter = self._parameter_counter
         new_builder.dialect = self.dialect
         new_builder._schema = schema  # type: ignore[assignment]
-        return cast("SelectBuilder[RowT]", new_builder)
+        return cast("Select[RowT]", new_builder)
 
     def with_hint(
         self,
@@ -151,15 +172,12 @@ class SelectBuilder(
         Returns:
             SafeQuery: A dataclass containing the SQL string and parameters.
         """
-        # Call parent build method which handles CTEs and optimization
         safe_query = super().build()
 
-        # Apply hints using SQLGlot's proper hint support (more robust than regex)
         if hasattr(self, "_hints") and self._hints:
             modified_expr = self._expression.copy() if self._expression else None
 
             if modified_expr and isinstance(modified_expr, exp.Select):
-                # Apply statement-level hints using SQLGlot's Hint expression
                 statement_hints = [h["hint"] for h in self._hints if h.get("location") == "statement"]
                 if statement_hints:
                     # Parse each hint and create proper hint expressions
@@ -172,12 +190,10 @@ class SelectBuilder(
                             if hint_expr:
                                 hint_expressions.append(hint_expr)
                             else:
-                                # Create a raw identifier for unparsable hints
                                 hint_expressions.append(exp.Anonymous(this=hint_str))
                         except Exception:  # noqa: PERF203
                             hint_expressions.append(exp.Anonymous(this=str(hint)))
 
-                    # Create a Hint node and attach to SELECT
                     if hint_expressions:
                         hint_node = exp.Hint(expressions=hint_expressions)
                         modified_expr.set("hint", hint_node)
@@ -186,7 +202,6 @@ class SelectBuilder(
                 # since SQLGlot doesn't have a standard way to attach hints to individual tables
                 modified_sql = modified_expr.sql(dialect=self.dialect_name, pretty=True)
 
-                # Apply table-level hints via string manipulation (as fallback)
                 table_hints = [h for h in self._hints if h.get("location") == "table" and h.get("table")]
                 if table_hints:
                     for th in table_hints:

sqlspec/statement/builder/update.py

@@ -5,7 +5,7 @@ with automatic parameter binding and validation.
 """
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -23,13 +23,13 @@ from sqlspec.statement.result import SQLResult
 from sqlspec.typing import RowT
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.select import SelectBuilder
+    from sqlspec.statement.builder.select import Select
 
-__all__ = ("UpdateBuilder",)
+__all__ = ("Update",)
 
 
 @dataclass(unsafe_hash=True)
-class UpdateBuilder(
+class Update(
     QueryBuilder[RowT],
     WhereClauseMixin,
     ReturningClauseMixin,
@@ -46,16 +46,21 @@ class UpdateBuilder(
         ```python
         # Basic UPDATE
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users")
             .set(name="John Doe")
             .set(email="john@example.com")
             .where("id = 1")
         )
 
+        # Even more concise with constructor
+        update_query = (
+            Update("users").set(name="John Doe").where("id = 1")
+        )
+
         # UPDATE with parameterized conditions
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users")
             .set(status="active")
             .where_eq("id", 123)
@@ -63,7 +68,7 @@ class UpdateBuilder(
 
         # UPDATE with FROM clause (PostgreSQL style)
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users", "u")
             .set(name="Updated Name")
             .from_("profiles", "p")
@@ -72,6 +77,18 @@ class UpdateBuilder(
         ```
     """
 
+    def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
+        """Initialize UPDATE with optional table.
+
+        Args:
+            table: Target table name
+            **kwargs: Additional QueryBuilder arguments
+        """
+        super().__init__(**kwargs)
+
+        if table:
+            self.table(table)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult[RowT]]":
         """Return the expected result type for this builder."""
@@ -87,7 +104,7 @@ class UpdateBuilder(
 
     def join(
         self,
-        table: "Union[str, exp.Expression, SelectBuilder[RowT]]",
+        table: "Union[str, exp.Expression, Select[RowT]]",
         on: "Union[str, exp.Expression]",
         alias: "Optional[str]" = None,
         join_type: str = "INNER",
@@ -141,7 +158,6 @@ class UpdateBuilder(
             msg = f"Unsupported join type: {join_type}"
             raise SQLBuilderError(msg)
 
-        # Add join to the UPDATE expression
         if not self._expression.args.get("joins"):
             self._expression.set("joins", [])
         self._expression.args["joins"].append(join_expr)
@@ -165,12 +181,10 @@ class UpdateBuilder(
             msg = "No UPDATE expression to build or expression is of the wrong type."
             raise SQLBuilderError(msg)
 
-        # Check that the table is set
         if getattr(self._expression, "this", None) is None:
             msg = "No table specified for UPDATE statement."
             raise SQLBuilderError(msg)
 
-        # Check that at least one SET expression exists
         if not self._expression.args.get("expressions"):
             msg = "At least one SET clause must be specified for UPDATE statement."
             raise SQLBuilderError(msg)

sqlspec/statement/filters.py

@@ -17,6 +17,7 @@ if TYPE_CHECKING:
 __all__ = (
     "AnyCollectionFilter",
     "BeforeAfterFilter",
+    "FilterTypeT",
     "FilterTypes",
     "InAnyFilter",
     "InCollectionFilter",
@@ -112,9 +113,7 @@ class BeforeAfterFilter(StatementFilter):
             final_condition = conditions[0]
             for cond in conditions[1:]:
                 final_condition = exp.And(this=final_condition, expression=cond)
-            # Use the SQL object's where method which handles all cases
             result = statement.where(final_condition)
-            # Add the filter's parameters to the result
             _, named_params = self.extract_parameters()
             for name, value in named_params.items():
                 result = result.add_named_parameter(name, value)
@@ -171,7 +170,6 @@ class OnBeforeAfterFilter(StatementFilter):
             for cond in conditions[1:]:
                 final_condition = exp.And(this=final_condition, expression=cond)
             result = statement.where(final_condition)
-            # Add the filter's parameters to the result
             _, named_params = self.extract_parameters()
             for name, value in named_params.items():
                 result = result.add_named_parameter(name, value)
@@ -229,7 +227,6 @@ class InCollectionFilter(InAnyFilter[T]):
         ]
 
         result = statement.where(exp.In(this=exp.column(self.field_name), expressions=placeholder_expressions))
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)
@@ -273,7 +270,6 @@ class NotInCollectionFilter(InAnyFilter[T]):
         result = statement.where(
             exp.Not(this=exp.In(this=exp.column(self.field_name), expressions=placeholder_expressions))
         )
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)
@@ -323,7 +319,6 @@ class AnyCollectionFilter(InAnyFilter[T]):
         array_expr = exp.Array(expressions=placeholder_expressions)
         # Generates SQL like: self.field_name = ANY(ARRAY[?, ?, ...])
         result = statement.where(exp.EQ(this=exp.column(self.field_name), expression=exp.Any(this=array_expr)))
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)
@@ -372,7 +367,6 @@ class NotAnyCollectionFilter(InAnyFilter[T]):
         # Generates SQL like: NOT (self.field_name = ANY(ARRAY[?, ?, ...]))
         condition = exp.EQ(this=exp.column(self.field_name), expression=exp.Any(this=array_expr))
         result = statement.where(exp.Not(this=condition))
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)
@@ -396,13 +390,48 @@ class LimitOffsetFilter(PaginationFilter):
     offset: int
     """Value for ``OFFSET`` clause of query."""
 
+    def __post_init__(self) -> None:
+        """Initialize parameter names."""
+        # Generate unique parameter names to avoid conflicts
+        import uuid
+
+        unique_suffix = str(uuid.uuid4()).replace("-", "")[:8]
+        self._limit_param_name = f"limit_{unique_suffix}"
+        self._offset_param_name = f"offset_{unique_suffix}"
+
     def extract_parameters(self) -> tuple[list[Any], dict[str, Any]]:
         """Extract filter parameters."""
-        # Return the limit and offset values as named parameters
-        return [], {"limit": self.limit, "offset": self.offset}
+        return [], {self._limit_param_name: self.limit, self._offset_param_name: self.offset}
 
     def append_to_statement(self, statement: "SQL") -> "SQL":
-        return statement.limit(self.limit, use_parameter=True).offset(self.offset, use_parameter=True)
+        # Create limit and offset expressions using our pre-generated parameter names
+        from sqlglot import exp
+
+        limit_placeholder = exp.Placeholder(this=self._limit_param_name)
+        offset_placeholder = exp.Placeholder(this=self._offset_param_name)
+
+        # Apply LIMIT and OFFSET to the statement
+        result = statement
+
+        # Check if the statement supports LIMIT directly
+        if isinstance(result._statement, exp.Select):
+            new_statement = result._statement.limit(limit_placeholder)
+        else:
+            # Wrap in a SELECT if the statement doesn't support LIMIT directly
+            new_statement = exp.Select().from_(result._statement).limit(limit_placeholder)
+
+        # Add OFFSET
+        if isinstance(new_statement, exp.Select):
+            new_statement = new_statement.offset(offset_placeholder)
+
+        result = result.copy(statement=new_statement)
+
+        # Add the parameters to the result
+        _, named_params = self.extract_parameters()
+        for name, value in named_params.items():
+            result = result.add_named_parameter(name, value)
+
+        return result
 
 
 @dataclass
@@ -450,7 +479,6 @@ class SearchFilter(StatementFilter):
             if isinstance(self.field_name, str):
                 self._param_name = f"{self.field_name}_search"
             else:
-                # For multiple fields, use a generic search parameter name
                 self._param_name = "search_value"
 
     def extract_parameters(self) -> tuple[list[Any], dict[str, Any]]:
@@ -484,7 +512,6 @@ class SearchFilter(StatementFilter):
                     final_condition = exp.Or(this=final_condition, expression=cond)
             result = statement.where(final_condition)
 
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)
@@ -502,7 +529,6 @@ class NotInSearchFilter(SearchFilter):
             if isinstance(self.field_name, str):
                 self._param_name = f"{self.field_name}_not_search"
             else:
-                # For multiple fields, use a generic search parameter name
                 self._param_name = "not_search_value"
 
     def extract_parameters(self) -> tuple[list[Any], dict[str, Any]]:
@@ -536,7 +562,6 @@ class NotInSearchFilter(SearchFilter):
                     final_condition = exp.And(this=final_condition, expression=cond)
             result = statement.where(final_condition)
 
-        # Add the filter's parameters to the result
         _, named_params = self.extract_parameters()
         for name, value in named_params.items():
             result = result.add_named_parameter(name, value)