sqlspec 0.26.0__py3-none-any.whl → 0.28.0__py3-none-any.whl

sqlspec/builder/_dml.py

@@ -0,0 +1,388 @@
+"""Reusable mixins for INSERT/UPDATE/DELETE builders."""
+
+from collections.abc import Mapping, Sequence
+from typing import Any, cast
+
+from mypy_extensions import trait
+from sqlglot import exp
+from typing_extensions import Self
+
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
+from sqlspec.exceptions import SQLBuilderError
+from sqlspec.protocols import SQLBuilderProtocol
+from sqlspec.utils.type_guards import has_expression_and_sql, has_query_builder_parameters
+
+__all__ = (
+    "DeleteFromClauseMixin",
+    "InsertFromSelectMixin",
+    "InsertIntoClauseMixin",
+    "InsertValuesMixin",
+    "UpdateFromClauseMixin",
+    "UpdateSetClauseMixin",
+    "UpdateTableClauseMixin",
+)
+
+ARG_PAIR_COUNT = 2
+SINGLE_VALUE_COUNT = 1
+
+
+# ---------------------------------------------------------------------------
+# DELETE helpers
+# ---------------------------------------------------------------------------
+
+
+@trait
+class DeleteFromClauseMixin:
+    """Mixin providing FROM clause support for DELETE builders."""
+
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    def from_(self, table: str) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Delete())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Delete):
+            msg = f"Base expression for Delete is {type(current_expr).__name__}, expected Delete."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        setattr(self, "_table", table)
+        current_expr.set("this", exp.to_table(table))
+        return self
+
+
+# ---------------------------------------------------------------------------
+# INSERT helpers
+# ---------------------------------------------------------------------------
+
+
+@trait
+class InsertIntoClauseMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    def into(self, table: str) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
+            msg = "Cannot set target table on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        setattr(self, "_table", table)
+        current_expr.set("this", exp.to_table(table))
+        return self
+
+
+@trait
+class InsertValuesMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    _columns: Any
+
+    def add_parameter(self, value: Any, name: str | None = None) -> tuple[Any, str]:
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def columns(self, *columns: str | exp.Expression) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
+            msg = "Cannot set columns on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        current_this = current_expr.args.get("this")
+        if current_this is None:
+            msg = "Table must be set using .into() before setting columns."
+            raise SQLBuilderError(msg)
+
+        if columns:
+            identifiers = [exp.to_identifier(col) if isinstance(col, str) else col for col in columns]
+            table_name = current_this.this
+            current_expr.set("this", exp.Schema(this=table_name, expressions=identifiers))
+        elif isinstance(current_this, exp.Schema):
+            table_name = current_this.this
+            current_expr.set("this", exp.Table(this=table_name))
+
+        try:
+            cols = self._columns
+            if not columns:
+                cols.clear()
+            else:
+                cols[:] = [col if isinstance(col, str) else str(col) for col in columns]
+        except AttributeError:
+            pass
+        return self
+
+    def values(self, *values: Any, **kwargs: Any) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
+            msg = "Cannot add values to a non-INSERT expression."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        table_name = cast("str | None", self._table)  # type: ignore[attr-defined]
+        if not table_name:
+            msg = "The target table must be set using .into() before adding values."
+            raise SQLBuilderError(msg)
+
+        positional_values = list(values)
+        if len(positional_values) == SINGLE_VALUE_COUNT and hasattr(positional_values[0], "items") and not kwargs:
+            kwargs = cast("dict[str, Any]", positional_values[0])
+            positional_values = []
+
+        if kwargs and positional_values:
+            msg = "Cannot mix positional values with keyword values."
+            raise SQLBuilderError(msg)
+
+        row_expressions: list[exp.Expression] = []
+        column_defs = cast("list[str]", self._columns or [])
+
+        if kwargs:
+            if not column_defs:
+                self.columns(*kwargs.keys())
+                column_defs = cast("list[str]", self._columns)
+            for col, val in kwargs.items():
+                if isinstance(val, exp.Expression):
+                    row_expressions.append(val)
+                    continue
+                if has_expression_and_sql(val):
+                    row_expressions.append(extract_sql_object_expression(val, builder=self))
+                    continue
+                column_name = str(col).split(".")[-1]
+                unique_name = self._generate_unique_parameter_name(column_name)
+                _, unique_name = self.add_parameter(val, name=unique_name)
+                row_expressions.append(exp.Placeholder(this=unique_name))
+        else:
+            if column_defs and len(positional_values) != len(column_defs):
+                msg = (
+                    f"Number of values ({len(positional_values)}) does not match the number of specified columns "
+                    f"({len(column_defs)})."
+                )
+                raise SQLBuilderError(msg)
+
+            for index, raw_value in enumerate(positional_values):
+                if isinstance(raw_value, exp.Expression):
+                    row_expressions.append(raw_value)
+                elif has_expression_and_sql(raw_value):
+                    row_expressions.append(extract_sql_object_expression(raw_value, builder=self))
+                else:
+                    if column_defs and index < len(column_defs):
+                        column_token = column_defs[index]
+                        column_name = column_token.rsplit(".", maxsplit=1)[-1]
+                    else:
+                        column_name = f"value_{index + 1}"
+                    unique_name = self._generate_unique_parameter_name(column_name)
+                    _, unique_name = self.add_parameter(raw_value, name=unique_name)
+                    row_expressions.append(exp.Placeholder(this=unique_name))
+
+        values_node = current_expr.args.get("expression")
+        tuple_expression = exp.Tuple(expressions=row_expressions)
+        if isinstance(values_node, exp.Values):
+            values_node.expressions.append(tuple_expression)
+        else:
+            current_expr.set("expression", exp.Values(expressions=[tuple_expression]))
+        return self
+
+    def add_values(self, values: Sequence[Any]) -> Self:
+        return self.values(*values)
+
+
+@trait
+class InsertFromSelectMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    _table: Any
+
+    def add_parameter(self, value: Any, name: str | None = None) -> tuple[Any, str]:
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def from_select(self, select_builder: SQLBuilderProtocol) -> Self:
+        if not getattr(self, "_table", None):
+            msg = "The target table must be set using .into() before adding values."
+            raise SQLBuilderError(msg)
+
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Insert())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Insert):
+            msg = "Cannot set INSERT source on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        subquery_parameters = getattr(select_builder, "_parameters", None)
+        if isinstance(subquery_parameters, dict):
+            builder_with_params = cast("SQLBuilderProtocol", self)
+            for param_name, param_value in subquery_parameters.items():
+                builder_with_params.add_parameter(param_value, name=param_name)
+
+        select_expr = getattr(select_builder, "_expression", None)
+        if select_expr and isinstance(select_expr, exp.Select):
+            current_expr.set("expression", select_expr.copy())
+        else:
+            msg = "SelectBuilder must have a valid SELECT expression."
+            raise SQLBuilderError(msg)
+        return self
+
+
+# ---------------------------------------------------------------------------
+# UPDATE helpers
+# ---------------------------------------------------------------------------
+
+
+@trait
+class UpdateTableClauseMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    def table(self, table_name: str, alias: str | None = None) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Update):
+            self.set_expression(exp.Update(this=None, expressions=[], joins=[]))
+            current_expr = self.get_expression()
+
+        assert current_expr is not None
+
+        table_expr: exp.Expression = exp.to_table(table_name, alias=alias)
+        current_expr.set("this", table_expr)
+        setattr(self, "_table", table_name)
+        return self
+
+
+@trait
+class UpdateSetClauseMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    def add_parameter(self, value: Any, name: str | None = None) -> tuple[Any, str]:
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _generate_unique_parameter_name(self, base_name: str) -> str:
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
+    def _process_update_value(self, val: Any, col: Any) -> exp.Expression:
+        if isinstance(val, exp.Expression):
+            return val
+        if has_query_builder_parameters(val):
+            subquery = val.build()
+            sql_text = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+            value_expr = exp.paren(exp.maybe_parse(sql_text, dialect=getattr(self, "dialect", None)))
+            for p_name, p_value in getattr(val, "parameters", {}).items():
+                self.add_parameter(p_value, name=p_name)
+            return value_expr
+        if hasattr(val, "expression") and hasattr(val, "sql"):
+            return extract_sql_object_expression(val, builder=self)
+        column_name = col if isinstance(col, str) else str(col)
+        if "." in column_name:
+            column_name = column_name.split(".")[-1]
+        param_name = self._generate_unique_parameter_name(column_name)
+        param_name = self.add_parameter(val, name=param_name)[1]
+        return exp.Placeholder(this=param_name)
+
+    def set(self, *args: Any, **kwargs: Any) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None:
+            self.set_expression(exp.Update())
+            current_expr = self.get_expression()
+
+        if not isinstance(current_expr, exp.Update):
+            msg = "Cannot add SET clause to non-UPDATE expression."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+
+        assignments: list[exp.Expression] = []
+        if len(args) == ARG_PAIR_COUNT and not kwargs:
+            col, val = args
+            col_expr = col if isinstance(col, exp.Column) else exp.column(col)
+            assignments.append(exp.EQ(this=col_expr, expression=self._process_update_value(val, col)))
+        elif (len(args) == SINGLE_VALUE_COUNT and isinstance(args[0], Mapping)) or kwargs:
+            all_values = dict(args[0] if args else {}, **kwargs)
+            for col, val in all_values.items():
+                assignments.append(exp.EQ(this=exp.column(col), expression=self._process_update_value(val, col)))
+        else:
+            msg = "Invalid arguments for set(): use (column, value), mapping, or kwargs."
+            raise SQLBuilderError(msg)
+
+        existing = current_expr.args.get("expressions", [])
+        current_expr.set("expressions", existing + assignments)
+        return self
+
+
+@trait
+class UpdateFromClauseMixin:
+    __slots__ = ()
+
+    def get_expression(self) -> exp.Expression | None: ...
+    def set_expression(self, expression: exp.Expression) -> None: ...
+
+    def from_(self, table: str | exp.Expression | Any, alias: str | None = None) -> Self:
+        current_expr = self.get_expression()
+        if current_expr is None or not isinstance(current_expr, exp.Update):
+            msg = "Cannot add FROM clause to non-UPDATE expression. Set the main table first."
+            raise SQLBuilderError(msg)
+
+        assert current_expr is not None
+        table_expr: exp.Expression
+        if isinstance(table, str):
+            table_expr = exp.to_table(table, alias=alias)
+        elif has_query_builder_parameters(table):
+            subquery_params = getattr(table, "_parameters", None)
+            if isinstance(subquery_params, dict):
+                builder_with_params = cast("SQLBuilderProtocol", self)
+                for param_name, param_value in subquery_params.items():
+                    builder_with_params.add_parameter(param_value, name=param_name)
+            raw_expression = getattr(table, "_expression", None)
+            subquery_source = raw_expression if isinstance(raw_expression, exp.Expression) else exp.select()
+            subquery_exp = exp.paren(subquery_source)
+            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)
+
+        from_clause = current_expr.args.get("from")
+        if from_clause is None:
+            from_clause = exp.From(expressions=[])
+            current_expr.set("from", from_clause)
+
+        from_clause.append("expressions", table_expr)
+        return self

sqlspec/{_sql.py → builder/_factory.py}

@@ -4,16 +4,16 @@ Provides statement builders (select, insert, update, etc.) and column expression
 """
 
 import logging
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import sqlglot
 from sqlglot import exp
 from sqlglot.dialects.dialect import DialectType
 from sqlglot.errors import ParseError as SQLGlotParseError
 
-from sqlspec.builder import (
+from sqlspec.builder._column import Column
+from sqlspec.builder._ddl import (
     AlterTable,
-    Column,
     CommentOn,
     CreateIndex,
     CreateMaterializedView,
@@ -21,18 +21,14 @@ from sqlspec.builder import (
     CreateTable,
     CreateTableAsSelect,
     CreateView,
-    Delete,
     DropIndex,
     DropSchema,
     DropTable,
     DropView,
-    Insert,
-    Merge,
     RenameTable,
-    Select,
     Truncate,
-    Update,
 )
+from sqlspec.builder._delete import Delete
 from sqlspec.builder._expression_wrappers import (
     AggregateExpression,
     ConversionExpression,
@@ -40,9 +36,12 @@ from sqlspec.builder._expression_wrappers import (
     MathExpression,
     StringExpression,
 )
+from sqlspec.builder._insert import Insert
+from sqlspec.builder._join import JoinBuilder
+from sqlspec.builder._merge import Merge
 from sqlspec.builder._parsing_utils import extract_expression, to_expression
-from sqlspec.builder.mixins._join_operations import JoinBuilder
-from sqlspec.builder.mixins._select_operations import Case, SubqueryBuilder, WindowFunctionBuilder
+from sqlspec.builder._select import Case, Select, SubqueryBuilder, WindowFunctionBuilder
+from sqlspec.builder._update import Update
 from sqlspec.core.statement import SQL
 from sqlspec.exceptions import SQLBuilderError
 
@@ -205,7 +204,7 @@ class SQLFactory:
             select_builder.select(*columns_or_sql)
         return select_builder
 
-    def insert(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Insert":
+    def insert(self, table_or_sql: str | None = None, dialect: DialectType = None) -> "Insert":
         builder_dialect = dialect or self.dialect
         builder = Insert(dialect=builder_dialect)
         if table_or_sql:
@@ -222,7 +221,7 @@ class SQLFactory:
             return builder.into(table_or_sql)
         return builder
 
-    def update(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Update":
+    def update(self, table_or_sql: str | None = None, dialect: DialectType = None) -> "Update":
         builder_dialect = dialect or self.dialect
         builder = Update(dialect=builder_dialect)
         if table_or_sql:
@@ -238,7 +237,7 @@ class SQLFactory:
             return builder.table(table_or_sql)
         return builder
 
-    def delete(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Delete":
+    def delete(self, table_or_sql: str | None = None, dialect: DialectType = None) -> "Delete":
         builder_dialect = dialect or self.dialect
         builder = Delete(dialect=builder_dialect)
         if table_or_sql and self._looks_like_sql(table_or_sql):
@@ -252,7 +251,7 @@ class SQLFactory:
             return self._populate_delete_from_sql(builder, table_or_sql)
         return builder
 
-    def merge(self, table_or_sql: Optional[str] = None, dialect: DialectType = None) -> "Merge":
+    def merge(self, table_or_sql: str | None = None, dialect: DialectType = None) -> "Merge":
         builder_dialect = dialect or self.dialect
         builder = Merge(dialect=builder_dialect)
         if table_or_sql:
@@ -423,7 +422,7 @@ class SQLFactory:
         return CommentOn(dialect=dialect or self.dialect)
 
     @staticmethod
-    def _looks_like_sql(candidate: str, expected_type: Optional[str] = None) -> bool:
+    def _looks_like_sql(candidate: str, expected_type: str | None = None) -> bool:
         """Determine if a string looks like SQL.
 
         Args:
@@ -525,7 +524,7 @@ class SQLFactory:
             logger.warning("Failed to parse MERGE SQL, falling back to traditional mode: %s", e)
         return builder
 
-    def column(self, name: str, table: Optional[str] = None) -> Column:
+    def column(self, name: str, table: str | None = None) -> Column:
         """Create a column reference.
 
         Args:
@@ -683,7 +682,7 @@ class SQLFactory:
         return Column(name)
 
     @staticmethod
-    def raw(sql_fragment: str, **parameters: Any) -> "Union[exp.Expression, SQL]":
+    def raw(sql_fragment: str, **parameters: Any) -> "exp.Expression | SQL":
         """Create a raw SQL expression from a string fragment with optional parameters.
 
         Args:
@@ -818,7 +817,7 @@ class SQLFactory:
         return AggregateExpression(exp.Min(this=col_expr))
 
     @staticmethod
-    def rollup(*columns: Union[str, exp.Expression]) -> FunctionExpression:
+    def rollup(*columns: str | exp.Expression) -> FunctionExpression:
         """Create a ROLLUP expression for GROUP BY clauses.
 
         Args:
@@ -840,7 +839,7 @@ class SQLFactory:
         return FunctionExpression(exp.Rollup(expressions=column_exprs))
 
     @staticmethod
-    def cube(*columns: Union[str, exp.Expression]) -> FunctionExpression:
+    def cube(*columns: str | exp.Expression) -> FunctionExpression:
         """Create a CUBE expression for GROUP BY clauses.
 
         Args:
@@ -862,7 +861,7 @@ class SQLFactory:
         return FunctionExpression(exp.Cube(expressions=column_exprs))
 
     @staticmethod
-    def grouping_sets(*column_sets: Union[tuple[str, ...], list[str]]) -> FunctionExpression:
+    def grouping_sets(*column_sets: tuple[str, ...] | list[str]) -> FunctionExpression:
         """Create a GROUPING SETS expression for GROUP BY clauses.
 
         Args:
@@ -896,7 +895,7 @@ class SQLFactory:
         return FunctionExpression(exp.GroupingSets(expressions=set_expressions))
 
     @staticmethod
-    def any(values: Union[list[Any], exp.Expression, str]) -> FunctionExpression:
+    def any(values: list[Any] | exp.Expression | str) -> FunctionExpression:
         """Create an ANY expression for use with comparison operators.
 
         Args:
@@ -924,7 +923,7 @@ class SQLFactory:
         return FunctionExpression(exp.Any(this=values))
 
     @staticmethod
-    def not_any_(values: Union[list[Any], exp.Expression, str]) -> FunctionExpression:
+    def not_any_(values: list[Any] | exp.Expression | str) -> FunctionExpression:
         """Create a NOT ANY expression for use with comparison operators.
 
         Args:
@@ -946,7 +945,7 @@ class SQLFactory:
         return SQLFactory.any(values)
 
     @staticmethod
-    def concat(*expressions: Union[str, exp.Expression]) -> StringExpression:
+    def concat(*expressions: str | exp.Expression) -> StringExpression:
         """Create a CONCAT expression.
 
         Args:
@@ -959,7 +958,7 @@ class SQLFactory:
         return StringExpression(exp.Concat(expressions=exprs))
 
     @staticmethod
-    def upper(column: Union[str, exp.Expression]) -> StringExpression:
+    def upper(column: str | exp.Expression) -> StringExpression:
         """Create an UPPER expression.
 
         Args:
@@ -972,7 +971,7 @@ class SQLFactory:
         return StringExpression(exp.Upper(this=col_expr))
 
     @staticmethod
-    def lower(column: Union[str, exp.Expression]) -> StringExpression:
+    def lower(column: str | exp.Expression) -> StringExpression:
         """Create a LOWER expression.
 
         Args:
@@ -985,7 +984,7 @@ class SQLFactory:
         return StringExpression(exp.Lower(this=col_expr))
 
     @staticmethod
-    def length(column: Union[str, exp.Expression]) -> StringExpression:
+    def length(column: str | exp.Expression) -> StringExpression:
         """Create a LENGTH expression.
 
         Args:
@@ -998,7 +997,7 @@ class SQLFactory:
         return StringExpression(exp.Length(this=col_expr))
 
     @staticmethod
-    def round(column: Union[str, exp.Expression], decimals: int = 0) -> MathExpression:
+    def round(column: str | exp.Expression, decimals: int = 0) -> MathExpression:
         """Create a ROUND expression.
 
         Args:
@@ -1036,7 +1035,7 @@ class SQLFactory:
         return FunctionExpression(exp.convert(value))
 
     @staticmethod
-    def decode(column: Union[str, exp.Expression], *args: Union[str, exp.Expression, Any]) -> FunctionExpression:
+    def decode(column: str | exp.Expression, *args: str | exp.Expression | Any) -> FunctionExpression:
         """Create a DECODE expression (Oracle-style conditional logic).
 
         DECODE compares column to each search value and returns the corresponding result.
@@ -1086,7 +1085,7 @@ class SQLFactory:
         return FunctionExpression(exp.Case(ifs=conditions, default=default))
 
     @staticmethod
-    def cast(column: Union[str, exp.Expression], data_type: str) -> ConversionExpression:
+    def cast(column: str | exp.Expression, data_type: str) -> ConversionExpression:
         """Create a CAST expression for type conversion.
 
         Args:
@@ -1100,7 +1099,7 @@ class SQLFactory:
         return ConversionExpression(exp.Cast(this=col_expr, to=exp.DataType.build(data_type)))
 
     @staticmethod
-    def coalesce(*expressions: Union[str, exp.Expression]) -> ConversionExpression:
+    def coalesce(*expressions: str | exp.Expression) -> ConversionExpression:
         """Create a COALESCE expression.
 
         Args:
@@ -1113,9 +1112,7 @@ class SQLFactory:
         return ConversionExpression(exp.Coalesce(expressions=exprs))
 
     @staticmethod
-    def nvl(
-        column: Union[str, exp.Expression], substitute_value: Union[str, exp.Expression, Any]
-    ) -> ConversionExpression:
+    def nvl(column: str | exp.Expression, substitute_value: str | exp.Expression | Any) -> ConversionExpression:
         """Create an NVL (Oracle-style) expression using COALESCE.
 
         Args:
@@ -1131,9 +1128,9 @@ class SQLFactory:
 
     @staticmethod
     def nvl2(
-        column: Union[str, exp.Expression],
-        value_if_not_null: Union[str, exp.Expression, Any],
-        value_if_null: Union[str, exp.Expression, Any],
+        column: str | exp.Expression,
+        value_if_not_null: str | exp.Expression | Any,
+        value_if_null: str | exp.Expression | Any,
     ) -> ConversionExpression:
         """Create an NVL2 (Oracle-style) expression using CASE.
 
@@ -1246,8 +1243,8 @@ class SQLFactory:
 
     def row_number(
         self,
-        partition_by: Optional[Union[str, list[str], exp.Expression]] = None,
-        order_by: Optional[Union[str, list[str], exp.Expression]] = None,
+        partition_by: str | list[str] | exp.Expression | None = None,
+        order_by: str | list[str] | exp.Expression | None = None,
     ) -> FunctionExpression:
         """Create a ROW_NUMBER() window function.
 
@@ -1262,8 +1259,8 @@ class SQLFactory:
 
     def rank(
         self,
-        partition_by: Optional[Union[str, list[str], exp.Expression]] = None,
-        order_by: Optional[Union[str, list[str], exp.Expression]] = None,
+        partition_by: str | list[str] | exp.Expression | None = None,
+        order_by: str | list[str] | exp.Expression | None = None,
     ) -> FunctionExpression:
         """Create a RANK() window function.
 
@@ -1278,8 +1275,8 @@ class SQLFactory:
 
     def dense_rank(
         self,
-        partition_by: Optional[Union[str, list[str], exp.Expression]] = None,
-        order_by: Optional[Union[str, list[str], exp.Expression]] = None,
+        partition_by: str | list[str] | exp.Expression | None = None,
+        order_by: str | list[str] | exp.Expression | None = None,
     ) -> FunctionExpression:
         """Create a DENSE_RANK() window function.
 
@@ -1296,8 +1293,8 @@ class SQLFactory:
     def _create_window_function(
         func_name: str,
         func_args: list[exp.Expression],
-        partition_by: Optional[Union[str, list[str], exp.Expression]] = None,
-        order_by: Optional[Union[str, list[str], exp.Expression]] = None,
+        partition_by: str | list[str] | exp.Expression | None = None,
+        order_by: str | list[str] | exp.Expression | None = None,
     ) -> FunctionExpression:
         """Helper to create window function expressions.