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

sqlspec/{statement/builder → builder}/mixins/_where_clause.py

@@ -1,74 +1,84 @@
 # ruff: noqa: PLR2004
 """Consolidated WHERE and HAVING clause mixins."""
 
-from typing import TYPE_CHECKING, Any, Callable, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from sqlglot import exp
 from typing_extensions import Self
 
+from sqlspec.builder._parsing_utils import parse_column_expression, parse_condition_expression
 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, has_sqlglot_expression, is_iterable_parameters
 
-if TYPE_CHECKING:
-    from sqlspec.protocols import SQLBuilderProtocol
-    from sqlspec.statement.builder._column import ColumnExpression
-
-__all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
+def _extract_column_name(column: Union[str, exp.Column]) -> str:
+    """Extract column name from column expression for parameter naming.
 
-class WhereClauseMixin:
-    """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
+    Args:
+        column: Column expression (string or SQLGlot Column)
 
-    def _create_operator_handler(self, operator_class: type[exp.Expression]) -> Callable:
-        """Create a handler that properly parameterizes values."""
+    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"
 
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return operator_class(this=column_exp, expression=exp.Placeholder(this=param_name))
 
-        return handler
-
-    def _create_like_handler(self) -> Callable:
-        """Create LIKE handler."""
-
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name))
-
-        return handler
+if TYPE_CHECKING:
+    from sqlspec.builder._column import ColumnExpression
+    from sqlspec.protocols import SQLBuilderProtocol
 
-    def _create_not_like_handler(self) -> Callable:
-        """Create NOT LIKE handler."""
+__all__ = ("HavingClauseMixin", "WhereClauseMixin")
 
-        def handler(self: "SQLBuilderProtocol", column_exp: exp.Expression, value: Any) -> exp.Expression:
-            _, param_name = self.add_parameter(value)
-            return exp.Not(this=exp.Like(this=column_exp, expression=exp.Placeholder(this=param_name)))
 
-        return handler
+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:
@@ -81,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)
@@ -112,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:
@@ -126,45 +146,51 @@ class WhereClauseMixin:
             operator = str(condition[1]).upper()
             value = condition[2]
 
-            # Handle simple operators
             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)))
 
-            # Handle complex operators
             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)
@@ -175,15 +201,20 @@ class WhereClauseMixin:
     def where(
         self,
         condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression"],
+        value: Optional[Any] = None,
+        operator: Optional[str] = None,
     ) -> Self:
         """Add a WHERE clause to the statement.
 
         Args:
             condition: The condition for the WHERE clause. Can be:
-                - A string condition
+                - A string condition (when value is None)
+                - A string column name (when value is provided)
                 - A sqlglot Expression or Condition
                 - A 2-tuple (column, value) for equality comparison
                 - A 3-tuple (column, operator, value) for custom comparison
+            value: Value for comparison (when condition is a column name)
+            operator: Operator for comparison (when both condition and value provided)
 
         Raises:
             SQLBuilderError: If the current expression is not a supported statement type.
@@ -191,10 +222,7 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        # Special case: if this is an Update and _expression is not exp.Update, raise the expected error for test coverage
-        if self.__class__.__name__ == "Update" and not (
-            hasattr(self, "_expression") and isinstance(getattr(self, "_expression", None), exp.Update)
-        ):
+        if self.__class__.__name__ == "Update" and not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
 
@@ -203,35 +231,38 @@ class WhereClauseMixin:
             msg = "Cannot add WHERE clause: expression is not initialized."
             raise SQLBuilderError(msg)
 
-        # Check if DELETE has a table set
         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)
 
-        # Process different condition types
-        if isinstance(condition, str):
+        if value is not None:
+            if not isinstance(condition, str):
+                msg = "When value is provided, condition must be a column name (string)"
+                raise SQLBuilderError(msg)
+
+            if operator is not None:
+                where_expr = self._process_tuple_condition((condition, operator, value))
+            else:
+                where_expr = self._process_tuple_condition((condition, value))
+        elif isinstance(condition, str):
             where_expr = parse_condition_expression(condition)
         elif isinstance(condition, (exp.Expression, exp.Condition)):
             where_expr = condition
         elif isinstance(condition, tuple):
             where_expr = self._process_tuple_condition(condition)
         elif has_query_builder_parameters(condition):
-            # Handle ColumnExpression objects
             column_expr_obj = cast("ColumnExpression", condition)
             where_expr = column_expr_obj._expression  # pyright: ignore
         elif has_sqlglot_expression(condition):
-            # This is a ColumnExpression from our new Column syntax
-            raw_expr = getattr(condition, "sqlglot_expression", None)
+            raw_expr = condition.sqlglot_expression  # pyright: ignore[attr-defined]
             if raw_expr is not None:
                 where_expr = builder._parameterize_expression(raw_expr)
             else:
-                # Fallback if attribute exists but is None
                 where_expr = parse_condition_expression(str(condition))
         else:
             msg = f"Unsupported condition type: {type(condition).__name__}"
             raise SQLBuilderError(msg)
 
-        # Apply WHERE clause based on statement type
         if isinstance(builder._expression, (exp.Select, exp.Update, exp.Delete)):
             builder._expression = builder._expression.where(where_expr, copy=False)
         else:
@@ -242,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.Literal.string(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:
@@ -344,8 +396,12 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                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)
@@ -353,11 +409,16 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
-        params = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        condition = col_expr.isin(*params)
+        column_name = _extract_column_name(column)
+        parameters = []
+        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)
 
     def where_not_in(self, column: Union[str, exp.Column], values: Any) -> Self:
@@ -368,8 +429,8 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.Not(this=col_expr.isin(subquery_exp))
@@ -377,11 +438,16 @@ 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)
-        params = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        condition = exp.Not(this=col_expr.isin(*params))
+        column_name = _extract_column_name(column)
+        parameters = []
+        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)
 
     def where_null(self, column: Union[str, exp.Column]) -> Self:
@@ -397,15 +463,15 @@ class WhereClauseMixin:
         builder = cast("SQLBuilderProtocol", self)
         sub_expr: exp.Expression
         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():
+            subquery_builder_parameters: dict[str, Any] = subquery.parameters
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
                     builder.add_parameter(p_value, name=p_name)
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sql_str = getattr(sub_sql_obj, "sql", str(sub_sql_obj))
-            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None))
+
+            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=builder.dialect_name)  # pyright: ignore
         else:
-            sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(str(subquery), dialect=builder.dialect_name)
 
         if sub_expr is None:
             msg = "Could not parse subquery for EXISTS"
@@ -419,15 +485,14 @@ class WhereClauseMixin:
         builder = cast("SQLBuilderProtocol", self)
         sub_expr: exp.Expression
         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():
+            subquery_builder_parameters: dict[str, Any] = subquery.parameters
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
                     builder.add_parameter(p_value, name=p_name)
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sql_str = getattr(sub_sql_obj, "sql", str(sub_sql_obj))
-            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=builder.dialect_name)  # pyright: ignore
         else:
-            sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(builder, "dialect_name", None))
+            sub_expr = exp.maybe_parse(str(subquery), dialect=builder.dialect_name)
 
         if sub_expr is None:
             msg = "Could not parse subquery for NOT EXISTS"
@@ -444,8 +509,7 @@ class WhereClauseMixin:
             subquery_exp: exp.Expression
             if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
@@ -464,24 +528,28 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
-        params = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
+        column_name = _extract_column_name(column)
+        parameters = []
+        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)
 
     def where_not_any(self, column: Union[str, exp.Column], values: Any) -> Self:
-        """Add WHERE column != ANY(values) clause."""
+        """Add WHERE column <> ANY(values) clause."""
         builder = cast("SQLBuilderProtocol", self)
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         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
-                sql_str = getattr(subquery, "sql", str(subquery))
-                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(builder, "dialect_name", None)))
+                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=builder.dialect_name))  # pyright: ignore
             else:
                 subquery_exp = values  # type: ignore[assignment]
             condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
@@ -500,11 +568,16 @@ class WhereClauseMixin:
         if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
-        params = []
-        for v in values:
-            _, param_name = builder.add_parameter(v)
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
+        column_name = _extract_column_name(column)
+        parameters = []
+        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)