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

sqlspec/statement/builder/mixins/_update_from.py

@@ -1,55 +0,0 @@
-from typing import Any, Optional, Union
-
-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__ = ("UpdateFromClauseMixin",)
-
-
-class UpdateFromClauseMixin:
-    """Mixin providing FROM clause for UPDATE builders (e.g., PostgreSQL style)."""
-
-    def from_(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
-        """Add a FROM clause to the UPDATE statement.
-
-        Args:
-            table: The table name, expression, or subquery to add to the FROM clause.
-            alias: Optional alias for the table in the FROM clause.
-
-        Returns:
-            The current builder instance for method chaining.
-
-        Raises:
-            SQLBuilderError: If the current expression is not an UPDATE statement.
-        """
-        if self._expression is None or not isinstance(self._expression, exp.Update):  # type: ignore[attr-defined]
-            msg = "Cannot add FROM clause to non-UPDATE expression. Set the main table first."
-            raise SQLBuilderError(msg)
-        table_expr: exp.Expression
-        if isinstance(table, str):
-            table_expr = exp.to_table(table, alias=alias)
-        elif has_query_builder_parameters(table):
-            subquery_builder_params = getattr(table, "_parameters", None)
-            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]
-            subquery_exp = exp.paren(getattr(table, "_expression", exp.select()))
-            table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
-        elif isinstance(table, exp.Expression):
-            table_expr = exp.alias_(table, alias) if alias else table
-        else:
-            msg = f"Unsupported table type for FROM clause: {type(table)}"
-            raise SQLBuilderError(msg)
-        if self._expression.args.get("from") is None:  # type: ignore[attr-defined]
-            self._expression.set("from", exp.From(expressions=[]))  # type: ignore[attr-defined]
-        from_clause = self._expression.args["from"]  # type: ignore[attr-defined]
-        if hasattr(from_clause, "append"):
-            from_clause.append("expressions", table_expr)
-        else:
-            if not from_clause.expressions:
-                from_clause.expressions = []
-            from_clause.expressions.append(table_expr)
-        return self

sqlspec/statement/builder/mixins/_update_set.py

@@ -1,94 +0,0 @@
-from collections.abc import Mapping
-from typing import Any, Optional
-
-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",)
-
-MIN_SET_ARGS = 2
-
-
-class UpdateSetClauseMixin:
-    """Mixin providing SET clause for UPDATE builders."""
-
-    _expression: Optional[exp.Expression] = None
-
-    def set(self, *args: Any, **kwargs: Any) -> Self:
-        """Set columns and values for the UPDATE statement.
-
-        Supports:
-        - set(column, value)
-        - set(mapping)
-        - set(**kwargs)
-        - set(mapping, **kwargs)
-
-        Args:
-            *args: Either (column, value) or a mapping.
-            **kwargs: Column-value pairs to set.
-
-        Raises:
-            SQLBuilderError: If the current expression is not an UPDATE statement or usage is invalid.
-
-        Returns:
-            The current builder instance for method chaining.
-        """
-
-        if self._expression is None:
-            self._expression = exp.Update()
-        if not isinstance(self._expression, exp.Update):
-            msg = "Cannot add SET clause to non-UPDATE expression."
-            raise SQLBuilderError(msg)
-        assignments = []
-        # (column, value) signature
-        if len(args) == MIN_SET_ARGS and not kwargs:
-            col, val = args
-            col_expr = col if isinstance(col, exp.Column) else exp.column(col)
-            # If value is an expression, use it directly
-            if isinstance(val, exp.Expression):
-                value_expr = val
-            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
-                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 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]
-                value_expr = exp.Placeholder(this=param_name)
-            assignments.append(exp.EQ(this=col_expr, expression=value_expr))
-        # mapping and/or kwargs
-        elif (len(args) == 1 and isinstance(args[0], Mapping)) or kwargs:
-            all_values = dict(args[0] if args else {}, **kwargs)
-            for col, val in all_values.items():
-                # If value is an expression, use it directly
-                if isinstance(val, exp.Expression):
-                    value_expr = val
-                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
-                    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 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]
-                    value_expr = exp.Placeholder(this=param_name)
-                assignments.append(exp.EQ(this=exp.column(col), expression=value_expr))
-        else:
-            msg = "Invalid arguments for set(): use (column, value), mapping, or kwargs."
-            raise SQLBuilderError(msg)
-        # Append to existing expressions instead of replacing
-        existing = self._expression.args.get("expressions", [])
-        self._expression.set("expressions", existing + assignments)
-        return self

sqlspec/statement/builder/mixins/_update_table.py

@@ -1,29 +0,0 @@
-from typing import Optional
-
-from sqlglot import exp
-from typing_extensions import Self
-
-__all__ = ("UpdateTableClauseMixin",)
-
-
-class UpdateTableClauseMixin:
-    """Mixin providing TABLE clause for UPDATE builders."""
-
-    _expression: Optional[exp.Expression] = None
-
-    def table(self, table_name: str, alias: Optional[str] = None) -> Self:
-        """Set the table to update.
-
-        Args:
-            table_name: The name of the table.
-            alias: Optional alias for the table.
-
-        Returns:
-            The current builder instance for method chaining.
-        """
-        if self._expression is None or not isinstance(self._expression, exp.Update):
-            self._expression = exp.Update(this=None, expressions=[], joins=[])
-        table_expr: exp.Expression = exp.to_table(table_name, alias=alias)
-        self._expression.set("this", table_expr)
-        setattr(self, "_table", table_name)
-        return self

sqlspec/statement/builder/mixins/_where.py

@@ -1,401 +0,0 @@
-# ruff: noqa: PLR2004
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
-
-from sqlglot import exp, parse_one
-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.protocols import SQLBuilderProtocol
-    from sqlspec.statement.builder.column import ColumnExpression
-
-__all__ = ("WhereClauseMixin",)
-
-
-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], "ColumnExpression"],
-    ) -> Self:
-        """Add a WHERE clause to the statement.
-
-        Args:
-            condition: The condition for the WHERE clause. Can be:
-                - A string condition
-                - A sqlglot Expression or Condition
-                - A 2-tuple (column, value) for equality comparison
-                - A 3-tuple (column, operator, value) for custom comparison
-
-        Raises:
-            SQLBuilderError: If the current expression is not a supported statement type.
-
-        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)
-        ):
-            msg = "Cannot add WHERE clause to non-UPDATE expression"
-            raise SQLBuilderError(msg)
-        builder = cast("SQLBuilderProtocol", self)
-        if builder._expression is None:
-            msg = "Cannot add WHERE clause: expression is not initialized."
-            raise SQLBuilderError(msg)
-        valid_types = (exp.Select, exp.Update, exp.Delete)
-        if not isinstance(builder._expression, valid_types):
-            msg = f"Cannot add WHERE clause to unsupported expression type: {type(builder._expression).__name__}."
-            raise SQLBuilderError(msg)
-
-        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)
-
-        # Normalize the condition using enhanced parsing
-        condition_expr: exp.Expression
-        if isinstance(condition, tuple):
-            if len(condition) == 2:
-                # 2-tuple: (column, value) -> column = value
-                param_name = builder.add_parameter(condition[1])[1]
-                condition_expr = exp.EQ(
-                    this=parse_column_expression(condition[0]), expression=exp.Placeholder(this=param_name)
-                )
-            elif len(condition) == 3:
-                # 3-tuple: (column, operator, value) -> column operator value
-                column, operator, value = condition
-                param_name = builder.add_parameter(value)[1]
-                col_expr = parse_column_expression(column)
-                placeholder_expr = exp.Placeholder(this=param_name)
-
-                # Map operator strings to sqlglot expression types
-                operator_map = {
-                    "=": exp.EQ,
-                    "==": exp.EQ,
-                    "!=": exp.NEQ,
-                    "<>": exp.NEQ,
-                    "<": exp.LT,
-                    "<=": exp.LTE,
-                    ">": exp.GT,
-                    ">=": exp.GTE,
-                    "like": exp.Like,
-                    "in": exp.In,
-                    "any": exp.Any,
-                }
-                operator = operator.lower()
-                if operator == "not like":
-                    condition_expr = exp.Not(this=exp.Like(this=col_expr, expression=placeholder_expr))
-                elif operator == "not in":
-                    condition_expr = exp.Not(this=exp.In(this=col_expr, expression=placeholder_expr))
-                elif operator == "not any":
-                    condition_expr = exp.Not(this=exp.Any(this=col_expr, expression=placeholder_expr))
-                else:
-                    expr_class = operator_map.get(operator)
-                    if expr_class is None:
-                        msg = f"Unsupported operator in WHERE condition: {operator}"
-                        raise SQLBuilderError(msg)
-
-                    condition_expr = expr_class(this=col_expr, expression=placeholder_expr)
-            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
-        if isinstance(builder._expression, exp.Delete):
-            builder._expression = builder._expression.where(
-                condition_expr, dialect=getattr(builder, "dialect_name", None)
-            )
-        else:
-            builder._expression = builder._expression.where(condition_expr, copy=False)
-        return cast("Self", builder)
-
-    # The following methods are moved from the old WhereClauseMixin in _base.py
-    def where_eq(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.eq(exp.var(param_name))
-        return self.where(condition)
-
-    def where_neq(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.neq(exp.var(param_name))
-        return self.where(condition)
-
-    def where_lt(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        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))
-        return self.where(condition)
-
-    def where_lte(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        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))
-        return self.where(condition)
-
-    def where_gt(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        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))
-        return self.where(condition)
-
-    def where_gte(self, column: "Union[str, exp.Column]", value: Any) -> "Self":
-        _, param_name = self.add_parameter(value)  # type: ignore[attr-defined]
-        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))
-        return self.where(condition)
-
-    def where_between(self, column: "Union[str, exp.Column]", low: Any, high: Any) -> "Self":
-        _, low_param = self.add_parameter(low)  # type: ignore[attr-defined]
-        _, high_param = self.add_parameter(high)  # type: ignore[attr-defined]
-        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))
-        return self.where(condition)
-
-    def where_like(self, column: "Union[str, exp.Column]", pattern: str, escape: Optional[str] = None) -> "Self":
-        _, param_name = self.add_parameter(pattern)  # type: ignore[attr-defined]
-        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)))
-        else:
-            cond = col_expr.like(exp.var(param_name))
-        condition: exp.Expression = cond
-        return self.where(condition)
-
-    def where_not_like(self, column: "Union[str, exp.Column]", pattern: str) -> "Self":
-        _, param_name = self.add_parameter(pattern)  # type: ignore[attr-defined]
-        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_()
-        return self.where(condition)
-
-    def where_ilike(self, column: "Union[str, exp.Column]", pattern: str) -> "Self":
-        _, param_name = self.add_parameter(pattern)  # type: ignore[attr-defined]
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.ilike(exp.var(param_name))
-        return self.where(condition)
-
-    def where_is_null(self, column: "Union[str, exp.Column]") -> "Self":
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.is_(exp.null())
-        return self.where(condition)
-
-    def where_is_not_null(self, column: "Union[str, exp.Column]") -> "Self":
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.is_(exp.null()).not_()
-        return self.where(condition)
-
-    def where_exists(self, subquery: "Union[str, Any]") -> "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():
-                    self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
-            sub_sql_obj = subquery.build()  # pyright: ignore
-            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))
-
-        if sub_expr is None:
-            msg = "Could not parse subquery for EXISTS"
-            raise SQLBuilderError(msg)
-
-        exists_expr = exp.Exists(this=sub_expr)
-        return self.where(exists_expr)
-
-    def where_not_exists(self, subquery: "Union[str, Any]") -> "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():
-                    self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
-            sub_sql_obj = subquery.build()  # pyright: ignore
-            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))
-
-        if sub_expr is None:
-            msg = "Could not parse subquery for NOT EXISTS"
-            raise SQLBuilderError(msg)
-
-        not_exists_expr = exp.Not(this=exp.Exists(this=sub_expr))
-        return self.where(not_exists_expr)
-
-    def where_not_null(self, column: "Union[str, exp.Column]") -> "Self":
-        """Alias for where_is_not_null for compatibility with test expectations."""
-        return self.where_is_not_null(column)
-
-    def where_in(self, column: "Union[str, exp.Column]", values: Any) -> "Self":
-        """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 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 = 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  # type: ignore[assignment]
-            condition = col_expr.isin(subquery_exp)
-            return self.where(condition)
-        # Iterable of values
-        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 = self.add_parameter(v)  # type: ignore[attr-defined]
-            params.append(exp.var(param_name))
-        condition = col_expr.isin(*params)
-        return self.where(condition)
-
-    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 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 = 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  # type: ignore[assignment]
-            condition = exp.Not(this=col_expr.isin(subquery_exp))
-            return self.where(condition)
-        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 = self.add_parameter(v)  # type: ignore[attr-defined]
-            params.append(exp.var(param_name))
-        condition = exp.Not(this=col_expr.isin(*params))
-        return self.where(condition)
-
-    def where_null(self, column: "Union[str, exp.Column]") -> "Self":
-        col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        condition: exp.Expression = col_expr.is_(exp.null())
-        return self.where(condition)
-
-    def where_any(self, column: "Union[str, exp.Column]", values: Any) -> "Self":
-        """Add a WHERE ... = ANY (...) clause. Supports subqueries and iterables.
-
-        Args:
-            column: The column to compare.
-            values: A subquery or iterable of values.
-
-        Returns:
-            The current builder instance for method chaining.
-        """
-        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 = 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  # type: ignore[assignment]
-            condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
-            return self.where(condition)
-        if isinstance(values, str):
-            # Try to parse as subquery expression with enhanced parsing
-            try:
-                # Parse as a subquery expression
-                parsed_expr = parse_one(values)
-                if isinstance(parsed_expr, (exp.Select, exp.Union, exp.Subquery)):
-                    subquery_exp = exp.paren(parsed_expr)
-                    condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
-                    return self.where(condition)
-            except Exception:  # noqa: S110
-                # Subquery parsing failed for WHERE ANY
-                pass
-            # If parsing fails, fall through to error
-            msg = "Unsupported type for 'values' in WHERE ANY"
-            raise SQLBuilderError(msg)
-        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 = self.add_parameter(v)  # type: ignore[attr-defined]
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
-        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 a WHERE ... <> ANY (...) (or NOT = ANY) clause. Supports subqueries and iterables.
-
-        Args:
-            column: The column to compare.
-            values: A subquery or iterable of values.
-
-        Returns:
-            The current builder instance for method chaining.
-        """
-        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 = 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  # type: ignore[assignment]
-            condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
-            return self.where(condition)
-        if isinstance(values, str):
-            # Try to parse as subquery expression with enhanced parsing
-            try:
-                # Parse as a subquery expression
-                parsed_expr = parse_one(values)
-                if isinstance(parsed_expr, (exp.Select, exp.Union, exp.Subquery)):
-                    subquery_exp = exp.paren(parsed_expr)
-                    condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
-                    return self.where(condition)
-            except Exception:  # noqa: S110
-                # Subquery parsing failed for WHERE NOT ANY
-                pass
-            # If parsing fails, fall through to error
-            msg = "Unsupported type for 'values' in WHERE NOT ANY"
-            raise SQLBuilderError(msg)
-        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 = self.add_parameter(v)  # type: ignore[attr-defined]
-            params.append(exp.var(param_name))
-        tuple_expr = exp.Tuple(expressions=params)
-        condition = exp.NEQ(this=col_expr, expression=exp.Any(this=tuple_expr))
-        return self.where(condition)

sqlspec/statement/builder/mixins/_window_functions.py

@@ -1,86 +0,0 @@
-from typing import Any, Optional, Union
-
-from sqlglot import exp
-from typing_extensions import Self
-
-from sqlspec.exceptions import SQLBuilderError
-
-__all__ = ("WindowFunctionsMixin",)
-
-
-class WindowFunctionsMixin:
-    """Mixin providing window function methods for SQL builders."""
-
-    _expression: Optional[exp.Expression] = None
-
-    def window(
-        self,
-        function_expr: Union[str, exp.Expression],
-        partition_by: Optional[Union[str, list[str], exp.Expression, list[exp.Expression]]] = None,
-        order_by: Optional[Union[str, list[str], exp.Expression, list[exp.Expression]]] = None,
-        frame: Optional[str] = None,
-        alias: Optional[str] = None,
-    ) -> Self:
-        """Add a window function to the SELECT clause.
-
-        Args:
-            function_expr: The window function expression (e.g., "COUNT(*)", "ROW_NUMBER()").
-            partition_by: Column(s) to partition by.
-            order_by: Column(s) to order by within the window.
-            frame: Window frame specification (e.g., "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW").
-            alias: Optional alias for the window function.
-
-        Raises:
-            SQLBuilderError: If the current expression is not a SELECT statement or function parsing fails.
-
-        Returns:
-            The current builder instance for method chaining.
-        """
-        if self._expression is None:
-            self._expression = exp.Select()
-        if not isinstance(self._expression, exp.Select):
-            msg = "Cannot add window function to a non-SELECT expression."
-            raise SQLBuilderError(msg)
-
-        func_expr_parsed: exp.Expression
-        if isinstance(function_expr, str):
-            parsed: Optional[exp.Expression] = exp.maybe_parse(function_expr, dialect=getattr(self, "dialect", None))
-            if not parsed:
-                msg = f"Could not parse function expression: {function_expr}"
-                raise SQLBuilderError(msg)
-            func_expr_parsed = parsed
-        else:
-            func_expr_parsed = function_expr
-
-        over_args: dict[str, Any] = {}  # Stringified dict
-        if partition_by:
-            if isinstance(partition_by, str):
-                over_args["partition_by"] = [exp.column(partition_by)]
-            elif isinstance(partition_by, list):  # Check for list
-                over_args["partition_by"] = [exp.column(col) if isinstance(col, str) else col for col in partition_by]
-            elif isinstance(partition_by, exp.Expression):  # Check for exp.Expression
-                over_args["partition_by"] = [partition_by]
-
-        if order_by:
-            if isinstance(order_by, str):
-                over_args["order"] = exp.column(order_by).asc()
-            elif isinstance(order_by, list):
-                # Properly handle multiple ORDER BY columns using Order expression
-                order_expressions: list[Union[exp.Expression, exp.Column]] = []
-                for col in order_by:
-                    if isinstance(col, str):
-                        order_expressions.append(exp.column(col).asc())
-                    else:
-                        order_expressions.append(col)
-                over_args["order"] = exp.Order(expressions=order_expressions)
-            elif isinstance(order_by, exp.Expression):
-                over_args["order"] = order_by
-
-        if frame:
-            frame_expr: Optional[exp.Expression] = exp.maybe_parse(frame, dialect=getattr(self, "dialect", None))
-            if frame_expr:
-                over_args["frame"] = frame_expr
-
-        window_expr = exp.Window(this=func_expr_parsed, **over_args)
-        self._expression.select(exp.alias_(window_expr, alias) if alias else window_expr, copy=False)
-        return self