sqlspec 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

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,8 +36,12 @@ from sqlspec.builder._expression_wrappers import (
     MathExpression,
     StringExpression,
 )
-from sqlspec.builder.mixins._join_operations import JoinBuilder
-from sqlspec.builder.mixins._select_operations import Case, SubqueryBuilder, WindowFunctionBuilder
+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._select import Case, Select, SubqueryBuilder, WindowFunctionBuilder
+from sqlspec.builder._update import Update
 from sqlspec.core.statement import SQL
 from sqlspec.exceptions import SQLBuilderError
 
@@ -204,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:
@@ -221,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:
@@ -237,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):
@@ -251,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:
@@ -422,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:
@@ -524,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:
@@ -682,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:
@@ -746,7 +746,7 @@ class SQLFactory:
         if isinstance(column, str) and column == "*":
             expr = exp.Count(this=exp.Star(), distinct=distinct)
         else:
-            col_expr = self._extract_expression(column)
+            col_expr = extract_expression(column)
             expr = exp.Count(this=col_expr, distinct=distinct)
         return AggregateExpression(expr)
 
@@ -774,7 +774,7 @@ class SQLFactory:
         Returns:
             SUM expression.
         """
-        col_expr = SQLFactory._extract_expression(column)
+        col_expr = extract_expression(column)
         return AggregateExpression(exp.Sum(this=col_expr, distinct=distinct))
 
     @staticmethod
@@ -787,7 +787,7 @@ class SQLFactory:
         Returns:
             AVG expression.
         """
-        col_expr = SQLFactory._extract_expression(column)
+        col_expr = extract_expression(column)
         return AggregateExpression(exp.Avg(this=col_expr))
 
     @staticmethod
@@ -800,7 +800,7 @@ class SQLFactory:
         Returns:
             MAX expression.
         """
-        col_expr = SQLFactory._extract_expression(column)
+        col_expr = extract_expression(column)
         return AggregateExpression(exp.Max(this=col_expr))
 
     @staticmethod
@@ -813,11 +813,11 @@ class SQLFactory:
         Returns:
             MIN expression.
         """
-        col_expr = SQLFactory._extract_expression(column)
+        col_expr = extract_expression(column)
         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:
@@ -839,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:
@@ -861,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:
@@ -895,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:
@@ -923,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:
@@ -945,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:
@@ -958,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:
@@ -971,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:
@@ -984,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:
@@ -997,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:
@@ -1035,46 +1035,7 @@ class SQLFactory:
         return FunctionExpression(exp.convert(value))
 
     @staticmethod
-    def _to_expression(value: Any) -> exp.Expression:
-        """Convert a Python value to a raw SQLGlot expression.
-
-        Args:
-            value: Python value or SQLGlot expression to convert.
-
-        Returns:
-            Raw SQLGlot expression.
-        """
-        if isinstance(value, exp.Expression):
-            return value
-        return exp.convert(value)
-
-    @staticmethod
-    def _extract_expression(value: Any) -> exp.Expression:
-        """Extract SQLGlot expression from value, handling our wrapper types.
-
-        Args:
-            value: String, SQLGlot expression, or our wrapper type.
-
-        Returns:
-            Raw SQLGlot expression.
-        """
-        from sqlspec.builder._expression_wrappers import ExpressionWrapper
-        from sqlspec.builder.mixins._select_operations import Case
-
-        if isinstance(value, str):
-            return exp.column(value)
-        if isinstance(value, Column):
-            return value.sqlglot_expression
-        if isinstance(value, ExpressionWrapper):
-            return value.expression
-        if isinstance(value, Case):
-            return exp.Case(ifs=value.conditions, default=value.default)
-        if isinstance(value, exp.Expression):
-            return value
-        return 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.
@@ -1109,14 +1070,14 @@ class SQLFactory:
 
         for i in range(0, len(args) - 1, 2):
             if i + 1 >= len(args):
-                default = SQLFactory._to_expression(args[i])
+                default = to_expression(args[i])
                 break
 
             search_val = args[i]
             result_val = args[i + 1]
 
-            search_expr = SQLFactory._to_expression(search_val)
-            result_expr = SQLFactory._to_expression(result_val)
+            search_expr = to_expression(search_val)
+            result_expr = to_expression(result_val)
 
             condition = exp.EQ(this=col_expr, expression=search_expr)
             conditions.append(exp.If(this=condition, true=result_expr))
@@ -1124,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:
@@ -1138,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:
@@ -1151,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:
@@ -1164,14 +1123,14 @@ class SQLFactory:
             COALESCE expression equivalent to NVL.
         """
         col_expr = exp.column(column) if isinstance(column, str) else column
-        sub_expr = SQLFactory._to_expression(substitute_value)
+        sub_expr = to_expression(substitute_value)
         return ConversionExpression(exp.Coalesce(expressions=[col_expr, sub_expr]))
 
     @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.
 
@@ -1192,8 +1151,8 @@ class SQLFactory:
             ```
         """
         col_expr = exp.column(column) if isinstance(column, str) else column
-        not_null_expr = SQLFactory._to_expression(value_if_not_null)
-        null_expr = SQLFactory._to_expression(value_if_null)
+        not_null_expr = to_expression(value_if_not_null)
+        null_expr = to_expression(value_if_null)
 
         is_null = exp.Is(this=col_expr, expression=exp.Null())
         condition = exp.Not(this=is_null)
@@ -1284,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.
 
@@ -1300,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.
 
@@ -1316,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.
 
@@ -1334,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.
 

sqlspec/builder/_insert.py

@@ -4,13 +4,15 @@ Provides a fluent interface for building SQL INSERT queries with
 parameter binding and validation.
 """
 
-from typing import TYPE_CHECKING, Any, Final, Optional
+from typing import TYPE_CHECKING, Any, Final
 
 from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.builder._base import QueryBuilder
-from sqlspec.builder.mixins import InsertFromSelectMixin, InsertIntoClauseMixin, InsertValuesMixin, ReturningClauseMixin
+from sqlspec.builder._dml import InsertFromSelectMixin, InsertIntoClauseMixin, InsertValuesMixin
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
+from sqlspec.builder._select import ReturningClauseMixin
 from sqlspec.core.result import SQLResult
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.utils.type_guards import has_expression_and_sql
@@ -22,9 +24,6 @@ if TYPE_CHECKING:
 __all__ = ("Insert",)
 
 ERR_MSG_TABLE_NOT_SET: Final[str] = "The target table must be set using .into() before adding values."
-ERR_MSG_VALUES_COLUMNS_MISMATCH: Final[str] = (
-    "Number of values ({values_len}) does not match the number of specified columns ({columns_len})."
-)
 ERR_MSG_INTERNAL_EXPRESSION_TYPE: Final[str] = "Internal error: expression is not an Insert instance as expected."
 ERR_MSG_EXPRESSION_NOT_INITIALIZED: Final[str] = "Internal error: base expression not initialized."
 
@@ -37,7 +36,7 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
 
     __slots__ = ("_columns", "_table", "_values_added_count")
 
-    def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
+    def __init__(self, table: str | None = None, **kwargs: Any) -> None:
         """Initialize INSERT with optional table.
 
         Args:
@@ -46,8 +45,7 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         """
         super().__init__(**kwargs)
 
-        # Initialize Insert-specific attributes
-        self._table: Optional[str] = None
+        self._table: str | None = None
         self._columns: list[str] = []
         self._values_added_count: int = 0
 
@@ -94,95 +92,6 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         """Get the insert expression (public API)."""
         return self._get_insert_expression()
 
-    def values(self, *values: Any, **kwargs: Any) -> "Self":
-        """Adds a row of values to the INSERT statement.
-
-        This method can be called multiple times to insert multiple rows,
-        resulting in a multi-row INSERT statement like `VALUES (...), (...)`.
-
-        Supports:
-        - values(val1, val2, val3)
-        - values(col1=val1, col2=val2)
-        - values(mapping)
-
-        Args:
-            *values: The values for the row to be inserted. The number of values
-                     must match the number of columns set by `columns()`, if `columns()` was called
-                     and specified any non-empty list of columns.
-            **kwargs: Column-value pairs for named values.
-
-        Returns:
-            The current builder instance for method chaining.
-
-        Raises:
-            SQLBuilderError: If `into()` has not been called to set the table,
-                             or if `columns()` was called with a non-empty list of columns
-                             and the number of values does not match the number of specified columns.
-        """
-        if not self._table:
-            raise SQLBuilderError(ERR_MSG_TABLE_NOT_SET)
-
-        if kwargs:
-            if values:
-                msg = "Cannot mix positional values with keyword values."
-                raise SQLBuilderError(msg)
-            return self.values_from_dict(kwargs)
-
-        if len(values) == 1:
-            values_0 = values[0]
-            if hasattr(values_0, "items") and hasattr(values_0, "keys"):
-                return self.values_from_dict(values_0)
-
-        insert_expr = self.get_insert_expression()
-
-        if self._columns and len(values) != len(self._columns):
-            msg = ERR_MSG_VALUES_COLUMNS_MISMATCH.format(values_len=len(values), columns_len=len(self._columns))
-            raise SQLBuilderError(msg)
-
-        value_placeholders: list[exp.Expression] = []
-        for i, value in enumerate(values):
-            if isinstance(value, exp.Expression):
-                value_placeholders.append(value)
-            elif has_expression_and_sql(value):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(value, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    self._merge_sql_object_parameters(value)
-                    value_placeholders.append(expression)
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(value, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    self._merge_sql_object_parameters(value)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(value)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
-                    value_placeholders.append(value_expr)
-            else:
-                if self._columns and i < len(self._columns):
-                    column_str = str(self._columns[i])
-                    column_name = column_str.rsplit(".", maxsplit=1)[-1] if "." in column_str else column_str
-                    param_name = self.generate_unique_parameter_name(column_name)
-                else:
-                    param_name = self.generate_unique_parameter_name(f"value_{i + 1}")
-                _, param_name = self.add_parameter(value, name=param_name)
-                value_placeholders.append(exp.Placeholder(this=param_name))
-
-        tuple_expr = exp.Tuple(expressions=value_placeholders)
-        if self._values_added_count == 0:
-            insert_expr.set("expression", exp.Values(expressions=[tuple_expr]))
-        else:
-            current_values = insert_expr.args.get("expression")
-            if isinstance(current_values, exp.Values):
-                current_values.expressions.append(tuple_expr)
-            else:
-                insert_expr.set("expression", exp.Values(expressions=[tuple_expr]))
-
-        self._values_added_count += 1
-        return self
-
     def values_from_dict(self, data: "Mapping[str, Any]") -> "Self":
         """Adds a row of values from a dictionary.
 
@@ -258,17 +167,14 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
 
         Example:
             ```python
-            # ON CONFLICT (id) DO NOTHING
             sql.insert("users").values(id=1, name="John").on_conflict(
                 "id"
             ).do_nothing()
 
-            # ON CONFLICT (email, username) DO UPDATE SET updated_at = NOW()
             sql.insert("users").values(...).on_conflict(
                 "email", "username"
             ).do_update(updated_at=sql.raw("NOW()"))
 
-            # ON CONFLICT DO NOTHING (catches all conflicts)
             sql.insert("users").values(...).on_conflict().do_nothing()
             ```
         """
@@ -290,22 +196,41 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         return self.on_conflict(*columns).do_nothing()
 
     def on_duplicate_key_update(self, **kwargs: Any) -> "Insert":
-        """Adds conflict resolution using the ON CONFLICT syntax (cross-database compatible).
+        """Adds MySQL-style ON DUPLICATE KEY UPDATE clause.
 
         Args:
-            **kwargs: Column-value pairs to update on conflict.
+            **kwargs: Column-value pairs to update on duplicate key.
 
         Returns:
             The current builder instance for method chaining.
 
         Note:
-            This method uses PostgreSQL-style ON CONFLICT syntax but SQLGlot will
-            transpile it to the appropriate syntax for each database (MySQL's
-            ON DUPLICATE KEY UPDATE, etc.).
+            This method creates MySQL-specific ON DUPLICATE KEY UPDATE syntax.
+            For PostgreSQL, use on_conflict() instead.
         """
         if not kwargs:
             return self
-        return self.on_conflict().do_update(**kwargs)
+
+        insert_expr = self._get_insert_expression()
+
+        set_expressions = []
+        for col, val in kwargs.items():
+            if has_expression_and_sql(val):
+                value_expr = extract_sql_object_expression(val, builder=self)
+            elif isinstance(val, exp.Expression):
+                value_expr = val
+            else:
+                param_name = self.generate_unique_parameter_name(col)
+                _, param_name = self.add_parameter(val, name=param_name)
+                value_expr = exp.Placeholder(this=param_name)
+
+            set_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))
+
+        on_conflict = exp.OnConflict(duplicate=True, action=exp.var("UPDATE"), expressions=set_expressions or None)
+
+        insert_expr.set("conflict", on_conflict)
+
+        return self
 
 
 class ConflictBuilder:
@@ -342,7 +267,6 @@ class ConflictBuilder:
         """
         insert_expr = self._insert_builder.get_insert_expression()
 
-        # Create ON CONFLICT with proper structure
         conflict_keys = [exp.to_identifier(col) for col in self._columns] if self._columns else None
         on_conflict = exp.OnConflict(conflict_keys=conflict_keys, action=exp.var("DO NOTHING"))
 
@@ -369,42 +293,19 @@ class ConflictBuilder:
         """
         insert_expr = self._insert_builder.get_insert_expression()
 
-        # Create SET expressions for the UPDATE
         set_expressions = []
         for col, val in kwargs.items():
             if has_expression_and_sql(val):
-                # Handle SQL objects (from sql.raw with parameters)
-                expression = getattr(val, "expression", None)
-                if expression is not None and isinstance(expression, exp.Expression):
-                    # Merge parameters from SQL object into builder
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self._insert_builder.add_parameter(param_value, name=param_name)
-                    value_expr = expression
-                else:
-                    # If expression is None, fall back to parsing the raw SQL
-                    sql_text = getattr(val, "sql", "")
-                    # Merge parameters even when parsing raw SQL
-                    if hasattr(val, "parameters"):
-                        sql_parameters = getattr(val, "parameters", {})
-                        for param_name, param_value in sql_parameters.items():
-                            self._insert_builder.add_parameter(param_value, name=param_name)
-                    # Check if sql_text is callable (like Expression.sql method)
-                    if callable(sql_text):
-                        sql_text = str(val)
-                    value_expr = exp.maybe_parse(sql_text) or exp.convert(str(sql_text))
+                value_expr = extract_sql_object_expression(val, builder=self._insert_builder)
             elif isinstance(val, exp.Expression):
                 value_expr = val
             else:
-                # Create parameter for regular values
                 param_name = self._insert_builder.generate_unique_parameter_name(col)
                 _, param_name = self._insert_builder.add_parameter(val, name=param_name)
                 value_expr = exp.Placeholder(this=param_name)
 
             set_expressions.append(exp.EQ(this=exp.column(col), expression=value_expr))
 
-        # Create ON CONFLICT with proper structure
         conflict_keys = [exp.to_identifier(col) for col in self._columns] if self._columns else None
         on_conflict = exp.OnConflict(
             conflict_keys=conflict_keys, action=exp.var("DO UPDATE"), expressions=set_expressions or None