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

sqlspec/builder/_column.py

@@ -5,6 +5,7 @@ SQL conditions with parameter binding.
 """
 
 from collections.abc import Iterable
+from datetime import date, datetime
 from typing import Any, Optional, cast
 
 from sqlglot import exp
@@ -14,6 +15,24 @@ from sqlspec.utils.type_guards import has_sql_method
 __all__ = ("Column", "ColumnExpression", "FunctionColumn")
 
 
+def _convert_value(value: Any) -> exp.Expression:
+    """Convert a Python value to a SQLGlot expression.
+
+    Special handling for datetime objects to prevent SQLGlot from
+    converting them to TIME_STR_TO_TIME function calls. Datetime
+    objects should be passed as parameters, not converted to SQL functions.
+
+    Args:
+        value: The value to convert
+
+    Returns:
+        A SQLGlot expression representing the value
+    """
+    if isinstance(value, (datetime, date)):
+        return exp.Literal(this=value, is_string=False)
+    return exp.convert(value)
+
+
 class ColumnExpression:
     """Base class for column expressions that can be combined with operators."""
 
@@ -67,33 +86,37 @@ class Column:
         else:
             self._expression = exp.Column(this=exp.Identifier(this=name))
 
+    def _convert_value(self, value: Any) -> exp.Expression:
+        """Convert a Python value to a SQLGlot expression."""
+        return _convert_value(value)
+
     def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
         """Equal to (==)."""
         if other is None:
             return ColumnExpression(exp.Is(this=self._expression, expression=exp.Null()))
-        return ColumnExpression(exp.EQ(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.EQ(this=self._expression, expression=self._convert_value(other)))
 
     def __ne__(self, other: object) -> ColumnExpression:  # type: ignore[override]
         """Not equal to (!=)."""
         if other is None:
             return ColumnExpression(exp.Not(this=exp.Is(this=self._expression, expression=exp.Null())))
-        return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.NEQ(this=self._expression, expression=self._convert_value(other)))
 
     def __gt__(self, other: Any) -> ColumnExpression:
         """Greater than (>)."""
-        return ColumnExpression(exp.GT(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.GT(this=self._expression, expression=self._convert_value(other)))
 
     def __ge__(self, other: Any) -> ColumnExpression:
         """Greater than or equal (>=)."""
-        return ColumnExpression(exp.GTE(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.GTE(this=self._expression, expression=self._convert_value(other)))
 
     def __lt__(self, other: Any) -> ColumnExpression:
         """Less than (<)."""
-        return ColumnExpression(exp.LT(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.LT(this=self._expression, expression=self._convert_value(other)))
 
     def __le__(self, other: Any) -> ColumnExpression:
         """Less than or equal (<=)."""
-        return ColumnExpression(exp.LTE(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.LTE(this=self._expression, expression=self._convert_value(other)))
 
     def __invert__(self) -> ColumnExpression:
         """Apply NOT operator (~)."""
@@ -102,18 +125,20 @@ class Column:
     def like(self, pattern: str, escape: Optional[str] = None) -> ColumnExpression:
         """SQL LIKE pattern matching."""
         if escape:
-            like_expr = exp.Like(this=self._expression, expression=exp.convert(pattern), escape=exp.convert(escape))
+            like_expr = exp.Like(
+                this=self._expression, expression=self._convert_value(pattern), escape=self._convert_value(escape)
+            )
         else:
-            like_expr = exp.Like(this=self._expression, expression=exp.convert(pattern))
+            like_expr = exp.Like(this=self._expression, expression=self._convert_value(pattern))
         return ColumnExpression(like_expr)
 
     def ilike(self, pattern: str) -> ColumnExpression:
         """Case-insensitive LIKE."""
-        return ColumnExpression(exp.ILike(this=self._expression, expression=exp.convert(pattern)))
+        return ColumnExpression(exp.ILike(this=self._expression, expression=self._convert_value(pattern)))
 
     def in_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL IN clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.In(this=self._expression, expressions=converted_values))
 
     def not_in(self, values: Iterable[Any]) -> ColumnExpression:
@@ -122,7 +147,9 @@ class Column:
 
     def between(self, start: Any, end: Any) -> ColumnExpression:
         """SQL BETWEEN clause."""
-        return ColumnExpression(exp.Between(this=self._expression, low=exp.convert(start), high=exp.convert(end)))
+        return ColumnExpression(
+            exp.Between(this=self._expression, low=self._convert_value(start), high=self._convert_value(end))
+        )
 
     def is_null(self) -> ColumnExpression:
         """SQL IS NULL."""
@@ -142,12 +169,12 @@ class Column:
 
     def any_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL = ANY(...) clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.EQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
     def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL <> ANY(...) clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
     def lower(self) -> "FunctionColumn":
@@ -186,14 +213,14 @@ class Column:
 
     def substring(self, start: int, length: Optional[int] = None) -> "FunctionColumn":
         """SQL SUBSTRING() function."""
-        args = [exp.convert(start)]
+        args = [self._convert_value(start)]
         if length is not None:
-            args.append(exp.convert(length))
+            args.append(self._convert_value(length))
         return FunctionColumn(exp.Substring(this=self._expression, expressions=args))
 
     def coalesce(self, *values: Any) -> "FunctionColumn":
         """SQL COALESCE() function."""
-        expressions = [self._expression] + [exp.convert(v) for v in values]
+        expressions = [self._expression] + [self._convert_value(v) for v in values]
         return FunctionColumn(exp.Coalesce(expressions=expressions))
 
     def cast(self, data_type: str) -> "FunctionColumn":
@@ -272,22 +299,26 @@ class FunctionColumn:
     def __init__(self, expression: exp.Expression) -> None:
         self._expression = expression
 
+    def _convert_value(self, value: Any) -> exp.Expression:
+        """Convert a Python value to a SQLGlot expression."""
+        return _convert_value(value)
+
     def __eq__(self, other: object) -> ColumnExpression:  # type: ignore[override]
-        return ColumnExpression(exp.EQ(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.EQ(this=self._expression, expression=self._convert_value(other)))
 
     def __ne__(self, other: object) -> ColumnExpression:  # type: ignore[override]
-        return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.convert(other)))
+        return ColumnExpression(exp.NEQ(this=self._expression, expression=self._convert_value(other)))
 
     def like(self, pattern: str) -> ColumnExpression:
-        return ColumnExpression(exp.Like(this=self._expression, expression=exp.convert(pattern)))
+        return ColumnExpression(exp.Like(this=self._expression, expression=self._convert_value(pattern)))
 
     def ilike(self, pattern: str) -> ColumnExpression:
         """Case-insensitive LIKE."""
-        return ColumnExpression(exp.ILike(this=self._expression, expression=exp.convert(pattern)))
+        return ColumnExpression(exp.ILike(this=self._expression, expression=self._convert_value(pattern)))
 
     def in_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL IN clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.In(this=self._expression, expressions=converted_values))
 
     def not_in_(self, values: Iterable[Any]) -> ColumnExpression:
@@ -304,7 +335,9 @@ class FunctionColumn:
 
     def between(self, start: Any, end: Any) -> ColumnExpression:
         """SQL BETWEEN clause."""
-        return ColumnExpression(exp.Between(this=self._expression, low=exp.convert(start), high=exp.convert(end)))
+        return ColumnExpression(
+            exp.Between(this=self._expression, low=self._convert_value(start), high=self._convert_value(end))
+        )
 
     def is_null(self) -> ColumnExpression:
         """SQL IS NULL."""
@@ -316,12 +349,12 @@ class FunctionColumn:
 
     def any_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL = ANY(...) clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.EQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
     def not_any_(self, values: Iterable[Any]) -> ColumnExpression:
         """SQL <> ANY(...) clause."""
-        converted_values = [exp.convert(v) for v in values]
+        converted_values = [self._convert_value(v) for v in values]
         return ColumnExpression(exp.NEQ(this=self._expression, expression=exp.Any(expressions=converted_values)))
 
     def alias(self, alias_name: str) -> exp.Expression:

sqlspec/builder/_ddl.py

@@ -11,12 +11,14 @@ from sqlglot.dialects.dialect import DialectType
 from typing_extensions import Self
 
 from sqlspec.builder._base import QueryBuilder, SafeQuery
+from sqlspec.builder._select import Select
 from sqlspec.core.result import SQLResult
+from sqlspec.core.statement import SQL
 from sqlspec.utils.type_guards import has_sqlglot_expression, has_with_method
 
 if TYPE_CHECKING:
     from sqlspec.builder._column import ColumnExpression
-    from sqlspec.core.statement import SQL, StatementConfig
+    from sqlspec.core.statement import StatementConfig
 
 __all__ = (
     "AlterOperation",
@@ -39,6 +41,37 @@ __all__ = (
     "Truncate",
 )
 
+CONSTRAINT_TYPE_PRIMARY_KEY = "PRIMARY KEY"
+CONSTRAINT_TYPE_FOREIGN_KEY = "FOREIGN KEY"
+CONSTRAINT_TYPE_UNIQUE = "UNIQUE"
+CONSTRAINT_TYPE_CHECK = "CHECK"
+
+FOREIGN_KEY_ACTION_CASCADE = "CASCADE"
+FOREIGN_KEY_ACTION_SET_NULL = "SET NULL"
+FOREIGN_KEY_ACTION_SET_DEFAULT = "SET DEFAULT"
+FOREIGN_KEY_ACTION_RESTRICT = "RESTRICT"
+FOREIGN_KEY_ACTION_NO_ACTION = "NO ACTION"
+
+VALID_FOREIGN_KEY_ACTIONS = {
+    FOREIGN_KEY_ACTION_CASCADE,
+    FOREIGN_KEY_ACTION_SET_NULL,
+    FOREIGN_KEY_ACTION_SET_DEFAULT,
+    FOREIGN_KEY_ACTION_RESTRICT,
+    FOREIGN_KEY_ACTION_NO_ACTION,
+    None,
+}
+
+VALID_CONSTRAINT_TYPES = {
+    CONSTRAINT_TYPE_PRIMARY_KEY,
+    CONSTRAINT_TYPE_FOREIGN_KEY,
+    CONSTRAINT_TYPE_UNIQUE,
+    CONSTRAINT_TYPE_CHECK,
+}
+
+CURRENT_TIMESTAMP_KEYWORD = "CURRENT_TIMESTAMP"
+CURRENT_DATE_KEYWORD = "CURRENT_DATE"
+CURRENT_TIME_KEYWORD = "CURRENT_TIME"
+
 
 def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
     """Build SQLGlot expression for a column definition."""
@@ -59,11 +92,11 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
         default_expr: Optional[exp.Expression] = None
         if isinstance(col.default, str):
             default_upper = col.default.upper()
-            if default_upper == "CURRENT_TIMESTAMP":
+            if default_upper == CURRENT_TIMESTAMP_KEYWORD:
                 default_expr = exp.CurrentTimestamp()
-            elif default_upper == "CURRENT_DATE":
+            elif default_upper == CURRENT_DATE_KEYWORD:
                 default_expr = exp.CurrentDate()
-            elif default_upper == "CURRENT_TIME":
+            elif default_upper == CURRENT_TIME_KEYWORD:
                 default_expr = exp.CurrentTime()
             elif "(" in col.default:
                 default_expr = exp.maybe_parse(col.default)
@@ -96,14 +129,14 @@ def build_column_expression(col: "ColumnDefinition") -> "exp.Expression":
 
 def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional[exp.Expression]":
     """Build SQLGlot expression for a table constraint."""
-    if constraint.constraint_type == "PRIMARY KEY":
+    if constraint.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY:
         pk_constraint = exp.PrimaryKey(expressions=[exp.to_identifier(col) for col in constraint.columns])
 
         if constraint.name:
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=pk_constraint)
         return pk_constraint
 
-    if constraint.constraint_type == "FOREIGN KEY":
+    if constraint.constraint_type == CONSTRAINT_TYPE_FOREIGN_KEY:
         fk_constraint = exp.ForeignKey(
             expressions=[exp.to_identifier(col) for col in constraint.columns],
             reference=exp.Reference(
@@ -118,14 +151,14 @@ def build_constraint_expression(constraint: "ConstraintDefinition") -> "Optional
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=fk_constraint)
         return fk_constraint
 
-    if constraint.constraint_type == "UNIQUE":
+    if constraint.constraint_type == CONSTRAINT_TYPE_UNIQUE:
         unique_constraint = exp.UniqueKeyProperty(expressions=[exp.to_identifier(col) for col in constraint.columns])
 
         if constraint.name:
             return exp.Constraint(this=exp.to_identifier(constraint.name), expression=unique_constraint)
         return unique_constraint
 
-    if constraint.constraint_type == "CHECK":
+    if constraint.constraint_type == CONSTRAINT_TYPE_CHECK:
         check_expr = exp.Check(this=exp.maybe_parse(constraint.condition) if constraint.condition else None)
 
         if constraint.name:
@@ -356,7 +389,7 @@ class CreateTable(DDLBuilder):
 
         self._columns.append(column_def)
 
-        if primary_key and not any(c.constraint_type == "PRIMARY KEY" for c in self._constraints):
+        if primary_key and not self._has_primary_key_constraint():
             self.primary_key_constraint([name])
 
         return self
@@ -368,13 +401,13 @@ class CreateTable(DDLBuilder):
         if not col_list:
             self._raise_sql_builder_error("Primary key must include at least one column")
 
-        existing_pk = next((c for c in self._constraints if c.constraint_type == "PRIMARY KEY"), None)
+        existing_pk = self._find_primary_key_constraint()
         if existing_pk:
             for col in col_list:
                 if col not in existing_pk.columns:
                     existing_pk.columns.append(col)
         else:
-            constraint = ConstraintDefinition(constraint_type="PRIMARY KEY", name=name, columns=col_list)
+            constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_PRIMARY_KEY, name=name, columns=col_list)
             self._constraints.append(constraint)
 
         return self
@@ -398,14 +431,11 @@ class CreateTable(DDLBuilder):
         if len(col_list) != len(ref_col_list):
             self._raise_sql_builder_error("Foreign key columns and referenced columns must have same length")
 
-        valid_actions = {"CASCADE", "SET NULL", "SET DEFAULT", "RESTRICT", "NO ACTION", None}
-        if on_delete and on_delete.upper() not in valid_actions:
-            self._raise_sql_builder_error(f"Invalid ON DELETE action: {on_delete}")
-        if on_update and on_update.upper() not in valid_actions:
-            self._raise_sql_builder_error(f"Invalid ON UPDATE action: {on_update}")
+        self._validate_foreign_key_action(on_delete, "ON DELETE")
+        self._validate_foreign_key_action(on_update, "ON UPDATE")
 
         constraint = ConstraintDefinition(
-            constraint_type="FOREIGN KEY",
+            constraint_type=CONSTRAINT_TYPE_FOREIGN_KEY,
             name=name,
             columns=col_list,
             references_table=references_table,
@@ -426,7 +456,7 @@ class CreateTable(DDLBuilder):
         if not col_list:
             self._raise_sql_builder_error("Unique constraint must include at least one column")
 
-        constraint = ConstraintDefinition(constraint_type="UNIQUE", name=name, columns=col_list)
+        constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_UNIQUE, name=name, columns=col_list)
 
         self._constraints.append(constraint)
         return self
@@ -443,7 +473,7 @@ class CreateTable(DDLBuilder):
         else:
             condition_str = str(condition)
 
-        constraint = ConstraintDefinition(constraint_type="CHECK", name=name, condition=condition_str)
+        constraint = ConstraintDefinition(constraint_type=CONSTRAINT_TYPE_CHECK, name=name, condition=condition_str)
 
         self._constraints.append(constraint)
         return self
@@ -484,10 +514,8 @@ class CreateTable(DDLBuilder):
             column_defs.append(col_expr)
 
         for constraint in self._constraints:
-            if constraint.constraint_type == "PRIMARY KEY" and len(constraint.columns) == 1:
-                col_name = constraint.columns[0]
-                if any(c.name == col_name and c.primary_key for c in self._columns):
-                    continue
+            if self._is_redundant_single_column_primary_key(constraint):
+                continue
 
             constraint_expr = build_constraint_expression(constraint)
             if constraint_expr:
@@ -531,6 +559,27 @@ class CreateTable(DDLBuilder):
             like=like_expr,
         )
 
+    def _has_primary_key_constraint(self) -> bool:
+        """Check if table already has a primary key constraint."""
+        return any(c.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY for c in self._constraints)
+
+    def _find_primary_key_constraint(self) -> "Optional[ConstraintDefinition]":
+        """Find existing primary key constraint."""
+        return next((c for c in self._constraints if c.constraint_type == CONSTRAINT_TYPE_PRIMARY_KEY), None)
+
+    def _validate_foreign_key_action(self, action: "Optional[str]", action_type: str) -> None:
+        """Validate foreign key action (ON DELETE or ON UPDATE)."""
+        if action and action.upper() not in VALID_FOREIGN_KEY_ACTIONS:
+            self._raise_sql_builder_error(f"Invalid {action_type} action: {action}")
+
+    def _is_redundant_single_column_primary_key(self, constraint: "ConstraintDefinition") -> bool:
+        """Check if constraint is a redundant single-column primary key."""
+        if constraint.constraint_type != CONSTRAINT_TYPE_PRIMARY_KEY or len(constraint.columns) != 1:
+            return False
+
+        col_name = constraint.columns[0]
+        return any(c.name == col_name and c.primary_key for c in self._columns)
+
 
 class DropTable(DDLBuilder):
     """Builder for DROP TABLE [IF EXISTS] ... [CASCADE|RESTRICT]."""
@@ -966,8 +1015,6 @@ class CreateTableAsSelect(DDLBuilder):
 
         select_expr = None
         select_parameters = None
-        from sqlspec.builder._select import Select
-        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
@@ -1093,8 +1140,6 @@ class CreateMaterializedView(DDLBuilder):
 
         select_expr = None
         select_parameters = None
-        from sqlspec.builder._select import Select
-        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
@@ -1191,8 +1236,6 @@ class CreateView(DDLBuilder):
 
         select_expr = None
         select_parameters = None
-        from sqlspec.builder._select import Select
-        from sqlspec.core.statement import SQL
 
         if isinstance(self._select_query, SQL):
             select_expr = self._select_query.expression
@@ -1347,8 +1390,7 @@ class AlterTable(DDLBuilder):
             on_delete: Foreign key ON DELETE action
             on_update: Foreign key ON UPDATE action
         """
-        valid_types = {"PRIMARY KEY", "FOREIGN KEY", "UNIQUE", "CHECK"}
-        if constraint_type.upper() not in valid_types:
+        if constraint_type.upper() not in VALID_CONSTRAINT_TYPES:
             self._raise_sql_builder_error(f"Invalid constraint type: {constraint_type}")
 
         col_list = None
@@ -1361,8 +1403,8 @@ class AlterTable(DDLBuilder):
 
         condition_str: Optional[str] = None
         if condition is not None:
-            if hasattr(condition, "sqlglot_expression"):
-                sqlglot_expr = getattr(condition, "sqlglot_expression", None)
+            if has_sqlglot_expression(condition):
+                sqlglot_expr = condition.sqlglot_expression
                 condition_str = sqlglot_expr.sql(dialect=self.dialect) if sqlglot_expr else str(condition)
             else:
                 condition_str = str(condition)
@@ -1474,7 +1516,7 @@ class AlterTable(DDLBuilder):
             default_val = op.column_definition.default
             default_expr: Optional[exp.Expression]
             if isinstance(default_val, str):
-                if default_val.upper() in {"CURRENT_TIMESTAMP", "CURRENT_DATE", "CURRENT_TIME"} or "(" in default_val:
+                if self._is_sql_function_default(default_val):
                     default_expr = exp.maybe_parse(default_val)
                 else:
                     default_expr = exp.convert(default_val)
@@ -1494,6 +1536,14 @@ class AlterTable(DDLBuilder):
         self._raise_sql_builder_error(f"Unknown operation type: {op.operation_type}")
         raise AssertionError
 
+    def _is_sql_function_default(self, default_val: str) -> bool:
+        """Check if default value is a SQL function or expression."""
+        default_upper = default_val.upper()
+        return (
+            default_upper in {CURRENT_TIMESTAMP_KEYWORD, CURRENT_DATE_KEYWORD, CURRENT_TIME_KEYWORD}
+            or "(" in default_val
+        )
+
 
 class CommentOn(DDLBuilder):
     """Builder for COMMENT ON ... IS ... statements."""

sqlspec/builder/_insert.py

@@ -10,6 +10,7 @@ from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.builder._base import QueryBuilder
+from sqlspec.builder._parsing_utils import extract_sql_object_expression
 from sqlspec.builder.mixins import InsertFromSelectMixin, InsertIntoClauseMixin, InsertValuesMixin, ReturningClauseMixin
 from sqlspec.core.result import SQLResult
 from sqlspec.exceptions import SQLBuilderError
@@ -46,7 +47,6 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         """
         super().__init__(**kwargs)
 
-        # Initialize Insert-specific attributes
         self._table: Optional[str] = None
         self._columns: list[str] = []
         self._values_added_count: int = 0
@@ -130,7 +130,7 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
 
         if len(values) == 1:
             values_0 = values[0]
-            if hasattr(values_0, "items") and hasattr(values_0, "keys"):
+            if isinstance(values_0, dict):
                 return self.values_from_dict(values_0)
 
         insert_expr = self.get_insert_expression()
@@ -144,22 +144,8 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
             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)
+                value_expr = extract_sql_object_expression(value, builder=self)
+                value_placeholders.append(value_expr)
             else:
                 if self._columns and i < len(self._columns):
                     column_str = str(self._columns[i])
@@ -258,17 +244,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 +273,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 +344,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 +370,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