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

sqlspec/builder/_insert.py

@@ -4,8 +4,7 @@ This module provides a fluent interface for building SQL queries safely,
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any, Final, Optional
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -21,15 +20,14 @@ if TYPE_CHECKING:
 
 __all__ = ("Insert",)
 
-ERR_MSG_TABLE_NOT_SET = "The target table must be set using .into() before adding values."
-ERR_MSG_VALUES_COLUMNS_MISMATCH = (
+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 = "Internal error: expression is not an Insert instance as expected."
-ERR_MSG_EXPRESSION_NOT_INITIALIZED = "Internal error: base expression not initialized."
+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."
 
 
-@dataclass(unsafe_hash=True)
 class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSelectMixin, InsertIntoClauseMixin):
     """Builder for INSERT statements.
 
@@ -37,9 +35,7 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
     in a safe and dialect-agnostic manner with automatic parameter binding.
     """
 
-    _table: "Optional[str]" = field(default=None, init=False)
-    _columns: list[str] = field(default_factory=list, init=False)
-    _values_added_count: int = field(default=0, init=False)
+    __slots__ = ("_columns", "_table", "_values_added_count")
 
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize INSERT with optional table.
@@ -50,9 +46,12 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         """
         super().__init__(**kwargs)
 
-        self._table = None
-        self._columns = []
-        self._values_added_count = 0
+        # Initialize Insert-specific attributes
+        self._table: Optional[str] = None
+        self._columns: list[str] = []
+        self._values_added_count: int = 0
+
+        self._initialize_expression()
 
         if table:
             self.into(table)
@@ -91,16 +90,22 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
             raise SQLBuilderError(ERR_MSG_INTERNAL_EXPRESSION_TYPE)
         return self._expression
 
-    def values(self, *values: Any) -> "Self":
+    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.
@@ -113,25 +118,72 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         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:
+            try:
+                values_0 = values[0]
+                if hasattr(values_0, "items"):
+                    return self.values_from_dict(values_0)
+            except (AttributeError, TypeError):
+                pass
+
         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)
 
-        param_names = [self._add_parameter(value) for value in values]
-        value_placeholders = tuple(exp.var(name) for name in param_names)
-
-        current_values_expression = insert_expr.args.get("expression")
-
+        value_placeholders: list[exp.Expression] = []
+        for i, value in enumerate(values):
+            if isinstance(value, exp.Expression):
+                value_placeholders.append(value)
+            elif hasattr(value, "expression") and hasattr(value, "sql"):
+                # 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
+                    if hasattr(value, "parameters"):
+                        sql_parameters = getattr(value, "parameters", {})
+                        for param_name, param_value in sql_parameters.items():
+                            self.add_parameter(param_value, name=param_name)
+                    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
+                    if hasattr(value, "parameters"):
+                        sql_parameters = getattr(value, "parameters", {})
+                        for param_name, param_value in sql_parameters.items():
+                            self.add_parameter(param_value, name=param_name)
+                    # 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.var(param_name))
+
+        tuple_expr = exp.Tuple(expressions=value_placeholders)
         if self._values_added_count == 0:
-            new_values_node = exp.Values(expressions=[exp.Tuple(expressions=list(value_placeholders))])
-            insert_expr.set("expression", new_values_node)
-        elif isinstance(current_values_expression, exp.Values):
-            current_values_expression.expressions.append(exp.Tuple(expressions=list(value_placeholders)))
+            insert_expr.set("expression", exp.Values(expressions=[tuple_expr]))
         else:
-            new_values_node = exp.Values(expressions=[exp.Tuple(expressions=list(value_placeholders))])
-            insert_expr.set("expression", new_values_node)
+            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
@@ -154,10 +206,11 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
         if not self._table:
             raise SQLBuilderError(ERR_MSG_TABLE_NOT_SET)
 
+        data_keys = list(data.keys())
         if not self._columns:
-            self.columns(*data.keys())
-        elif set(self._columns) != set(data.keys()):
-            msg = f"Dictionary keys {set(data.keys())} do not match existing columns {set(self._columns)}."
+            self.columns(*data_keys)
+        elif set(self._columns) != set(data_keys):
+            msg = f"Dictionary keys {set(data_keys)} do not match existing columns {set(self._columns)}."
             raise SQLBuilderError(msg)
 
         return self.values(*[data[col] for col in self._columns])
@@ -198,33 +251,171 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
 
         return self
 
-    def on_conflict_do_nothing(self) -> "Self":
-        """Adds an ON CONFLICT DO NOTHING clause (PostgreSQL syntax).
+    def on_conflict(self, *columns: str) -> "ConflictBuilder":
+        """Adds an ON CONFLICT clause with specified columns.
 
-        This is used to ignore rows that would cause a conflict.
+        Args:
+            *columns: Column names that define the conflict. If no columns provided,
+                     creates an ON CONFLICT without specific columns (catches all conflicts).
+
+        Returns:
+            A ConflictBuilder instance for chaining conflict resolution methods.
+
+        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()
+            ```
+        """
+        return ConflictBuilder(self, columns)
+
+    def on_conflict_do_nothing(self, *columns: str) -> "Insert":
+        """Adds an ON CONFLICT DO NOTHING clause (convenience method).
+
+        Args:
+            *columns: Column names that define the conflict. If no columns provided,
+                     creates an ON CONFLICT without specific columns.
 
         Returns:
             The current builder instance for method chaining.
 
         Note:
-            This is PostgreSQL-specific syntax. Different databases have different syntax.
-            For a more general solution, you might need dialect-specific handling.
+            This is a convenience method. For more control, use on_conflict().do_nothing().
         """
-        insert_expr = self._get_insert_expression()
-        try:
-            on_conflict = exp.OnConflict(this=None, expressions=[])
-            insert_expr.set("on", on_conflict)
-        except AttributeError:
-            pass
-        return self
+        return self.on_conflict(*columns).do_nothing()
 
-    def on_duplicate_key_update(self, **set_values: Any) -> "Self":
-        """Adds an ON DUPLICATE KEY UPDATE clause (MySQL syntax).
+    def on_duplicate_key_update(self, **kwargs: Any) -> "Insert":
+        """Adds conflict resolution using the ON CONFLICT syntax (cross-database compatible).
 
         Args:
-            **set_values: Column-value pairs to update on duplicate key.
+            **kwargs: Column-value pairs to update on conflict.
 
         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.).
         """
-        return self
+        if not kwargs:
+            return self
+        return self.on_conflict().do_update(**kwargs)
+
+
+class ConflictBuilder:
+    """Builder for ON CONFLICT clauses in INSERT statements.
+
+    This builder provides a fluent interface for constructing conflict resolution
+    clauses using PostgreSQL-style syntax, which SQLGlot can transpile to other dialects.
+    """
+
+    __slots__ = ("_columns", "_insert_builder")
+
+    def __init__(self, insert_builder: "Insert", columns: tuple[str, ...]) -> None:
+        """Initialize ConflictBuilder.
+
+        Args:
+            insert_builder: The parent Insert builder
+            columns: Column names that define the conflict
+        """
+        self._insert_builder = insert_builder
+        self._columns = columns
+
+    def do_nothing(self) -> "Insert":
+        """Add DO NOTHING conflict resolution.
+
+        Returns:
+            The parent Insert builder for method chaining.
+
+        Example:
+            ```python
+            sql.insert("users").values(id=1, name="John").on_conflict(
+                "id"
+            ).do_nothing()
+            ```
+        """
+        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"))
+
+        insert_expr.set("conflict", on_conflict)
+        return self._insert_builder
+
+    def do_update(self, **kwargs: Any) -> "Insert":
+        """Add DO UPDATE conflict resolution with SET clauses.
+
+        Args:
+            **kwargs: Column-value pairs to update on conflict.
+
+        Returns:
+            The parent Insert builder for method chaining.
+
+        Example:
+            ```python
+            sql.insert("users").values(id=1, name="John").on_conflict(
+                "id"
+            ).do_update(
+                name="Updated Name", updated_at=sql.raw("NOW()")
+            )
+            ```
+        """
+        insert_expr = self._insert_builder._get_insert_expression()
+
+        # Create SET expressions for the UPDATE
+        set_expressions = []
+        for col, val in kwargs.items():
+            if hasattr(val, "expression") and hasattr(val, "sql"):
+                # 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))
+            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 if set_expressions else None,
+        )
+
+        insert_expr.set("conflict", on_conflict)
+        return self._insert_builder

sqlspec/builder/_merge.py

@@ -4,7 +4,7 @@ This module provides a fluent interface for building SQL queries safely,
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass
+from typing import Any, Optional
 
 from sqlglot import exp
 
@@ -22,7 +22,6 @@ from sqlspec.core.result import SQLResult
 __all__ = ("Merge",)
 
 
-@dataclass(unsafe_hash=True)
 class Merge(
     QueryBuilder,
     MergeUsingClauseMixin,
@@ -38,6 +37,22 @@ class Merge(
     (also known as UPSERT in some databases) with automatic parameter binding and validation.
     """
 
+    __slots__ = ()
+    _expression: Optional[exp.Expression]
+
+    def __init__(self, target_table: Optional[str] = None, **kwargs: Any) -> None:
+        """Initialize MERGE with optional target table.
+
+        Args:
+            target_table: Target table name
+            **kwargs: Additional QueryBuilder arguments
+        """
+        super().__init__(**kwargs)
+        self._initialize_expression()
+
+        if target_table:
+            self.into(target_table)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult]":
         """Return the expected result type for this builder.

sqlspec/builder/_parsing_utils.py

@@ -5,14 +5,16 @@ that users might pass as strings to various builder methods.
 """
 
 import contextlib
-from typing import Any, Optional, Union, cast
+from typing import Any, Final, Optional, Union, cast
 
 from sqlglot import exp, maybe_parse, parse_one
 
 from sqlspec.utils.type_guards import has_expression_attr, has_parameter_builder
 
 
-def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> exp.Expression:
+def parse_column_expression(
+    column_input: Union[str, exp.Expression, Any], builder: Optional[Any] = None
+) -> exp.Expression:
     """Parse a column input that might be a complex expression.
 
     Handles cases like:
@@ -22,9 +24,11 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
     - Function calls: "MAX(price)" -> Max(this=Column(price))
     - Complex expressions: "CASE WHEN ... END" -> Case(...)
     - Custom Column objects from our builder
+    - SQL objects with raw SQL expressions
 
     Args:
-        column_input: String, SQLGlot expression, or Column object
+        column_input: String, SQLGlot expression, SQL object, or Column object
+        builder: Optional builder instance for parameter merging
 
     Returns:
         exp.Expression: Parsed SQLGlot expression
@@ -32,10 +36,33 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
     if isinstance(column_input, exp.Expression):
         return column_input
 
+    # Handle SQL objects (from sql.raw with parameters)
+    if hasattr(column_input, "expression") and hasattr(column_input, "sql"):
+        # This is likely a SQL object
+        expression = getattr(column_input, "expression", None)
+        if expression is not None and isinstance(expression, exp.Expression):
+            # Merge parameters from SQL object into builder if available
+            if builder and hasattr(column_input, "parameters") and hasattr(builder, "add_parameter"):
+                sql_parameters = getattr(column_input, "parameters", {})
+                for param_name, param_value in sql_parameters.items():
+                    builder.add_parameter(param_value, name=param_name)
+            return cast("exp.Expression", expression)
+        # If expression is None, fall back to parsing the raw SQL
+        sql_text = getattr(column_input, "sql", "")
+        # Merge parameters even when parsing raw SQL
+        if builder and hasattr(column_input, "parameters") and hasattr(builder, "add_parameter"):
+            sql_parameters = getattr(column_input, "parameters", {})
+            for param_name, param_value in sql_parameters.items():
+                builder.add_parameter(param_value, name=param_name)
+        return exp.maybe_parse(sql_text) or exp.column(str(sql_text))
+
     if has_expression_attr(column_input):
-        attr_value = getattr(column_input, "_expression", None)
-        if isinstance(attr_value, exp.Expression):
-            return attr_value
+        try:
+            attr_value = column_input._expression
+            if isinstance(attr_value, exp.Expression):
+                return attr_value
+        except AttributeError:
+            pass
 
     return exp.maybe_parse(column_input) or exp.column(str(column_input))
 
@@ -102,14 +129,18 @@ def parse_condition_expression(
     if isinstance(condition_input, exp.Expression):
         return condition_input
 
-    tuple_condition_parts = 2
+    tuple_condition_parts: Final[int] = 2
     if isinstance(condition_input, tuple) and len(condition_input) == tuple_condition_parts:
         column, value = condition_input
         column_expr = parse_column_expression(column)
         if value is None:
             return exp.Is(this=column_expr, expression=exp.null())
         if builder and has_parameter_builder(builder):
-            _, param_name = builder.add_parameter(value)
+            from sqlspec.builder.mixins._where_clause import _extract_column_name
+
+            column_name = _extract_column_name(column)
+            param_name = builder._generate_unique_parameter_name(column_name)
+            _, param_name = builder.add_parameter(value, name=param_name)
             return exp.EQ(this=column_expr, expression=exp.Placeholder(this=param_name))
         if isinstance(value, str):
             return exp.EQ(this=column_expr, expression=exp.convert(value))
@@ -125,12 +156,9 @@ def parse_condition_expression(
     except Exception:
         try:
             parsed = exp.maybe_parse(condition_input)  # type: ignore[var-annotated]
-            if parsed:
-                return parsed  # type:ignore[no-any-return]
-        except Exception:  # noqa: S110
-            pass
-
-    return exp.condition(condition_input)
+            return parsed or exp.condition(condition_input)
+        except Exception:
+            return exp.condition(condition_input)
 
 
 __all__ = ("parse_column_expression", "parse_condition_expression", "parse_order_expression", "parse_table_expression")

sqlspec/builder/_select.py

@@ -5,8 +5,7 @@ with automatic parameter binding and validation.
 """
 
 import re
-from dataclasses import dataclass, field
-from typing import Any, Optional, Union
+from typing import Any, Callable, Final, Optional, Union
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -29,10 +28,9 @@ from sqlspec.core.result import SQLResult
 __all__ = ("Select",)
 
 
-TABLE_HINT_PATTERN = r"\b{}\b(\s+AS\s+\w+)?"
+TABLE_HINT_PATTERN: Final[str] = r"\b{}\b(\s+AS\s+\w+)?"
 
 
-@dataclass
 class Select(
     QueryBuilder,
     WhereClauseMixin,
@@ -58,9 +56,8 @@ class Select(
         >>> result = driver.execute(builder)
     """
 
-    _with_parts: "dict[str, Union[exp.CTE, Select]]" = field(default_factory=dict, init=False)
-    _expression: Optional[exp.Expression] = field(default=None, init=False, repr=False, compare=False, hash=False)
-    _hints: "list[dict[str, object]]" = field(default_factory=list, init=False, repr=False)
+    __slots__ = ("_hints", "_with_parts")
+    _expression: Optional[exp.Expression]
 
     def __init__(self, *columns: str, **kwargs: Any) -> None:
         """Initialize SELECT with optional columns.
@@ -75,11 +72,11 @@ class Select(
         """
         super().__init__(**kwargs)
 
-        self._with_parts = {}
-        self._expression = None
-        self._hints = []
+        # Initialize Select-specific attributes
+        self._with_parts: dict[str, Union[exp.CTE, Select]] = {}
+        self._hints: list[dict[str, object]] = []
 
-        self._create_base_expression()
+        self._initialize_expression()
 
         if columns:
             self.select(*columns)
@@ -93,7 +90,8 @@ class Select(
         """
         return SQLResult
 
-    def _create_base_expression(self) -> "exp.Select":
+    def _create_base_expression(self) -> exp.Select:
+        """Create base SELECT expression."""
         if self._expression is None or not isinstance(self._expression, exp.Select):
             self._expression = exp.Select()
         return self._expression
@@ -131,44 +129,42 @@ class Select(
         if not self._hints:
             return safe_query
 
-        modified_expr = self._expression.copy() if self._expression else self._create_base_expression()
+        modified_expr = self._expression or self._create_base_expression()
 
         if isinstance(modified_expr, exp.Select):
             statement_hints = [h["hint"] for h in self._hints if h.get("location") == "statement"]
             if statement_hints:
-                hint_expressions = []
 
-                def parse_hint(hint: Any) -> exp.Expression:
-                    """Parse a single hint."""
+                def parse_hint_safely(hint: Any) -> exp.Expression:
                     try:
-                        hint_str = str(hint)  # Ensure hint is a string
+                        hint_str = str(hint)
                         hint_expr: Optional[exp.Expression] = exp.maybe_parse(hint_str, dialect=self.dialect_name)
-                        if hint_expr:
-                            return hint_expr
-                        return exp.Anonymous(this=hint_str)
+                        return hint_expr or exp.Anonymous(this=hint_str)
                     except Exception:
                         return exp.Anonymous(this=str(hint))
 
-                hint_expressions = [parse_hint(hint) for hint in statement_hints]
+                hint_expressions: list[exp.Expression] = [parse_hint_safely(hint) for hint in statement_hints]
 
                 if hint_expressions:
-                    hint_node = exp.Hint(expressions=hint_expressions)
-                    modified_expr.set("hint", hint_node)
+                    modified_expr.set("hint", exp.Hint(expressions=hint_expressions))
 
         modified_sql = modified_expr.sql(dialect=self.dialect_name, pretty=True)
 
-        table_hints = [h for h in self._hints if h.get("location") == "table" and h.get("table")]
-        if table_hints:
-            for th in table_hints:
-                table = str(th["table"])
-                hint = th["hint"]
+        for hint_dict in self._hints:
+            if hint_dict.get("location") == "table" and hint_dict.get("table"):
+                table = str(hint_dict["table"])
+                hint = str(hint_dict["hint"])
                 pattern = TABLE_HINT_PATTERN.format(re.escape(table))
-                compiled_pattern = re.compile(pattern, re.IGNORECASE)
 
-                def replacement_func(match: re.Match[str]) -> str:
-                    alias_part = match.group(1) or ""
-                    return f"/*+ {hint} */ {table}{alias_part}"  # noqa: B023
+                def make_replacement(hint_val: str, table_val: str) -> "Callable[[re.Match[str]], str]":
+                    def replacement_func(match: re.Match[str]) -> str:
+                        alias_part = match.group(1) or ""
+                        return f"/*+ {hint_val} */ {table_val}{alias_part}"
 
-                modified_sql = compiled_pattern.sub(replacement_func, modified_sql, count=1)
+                    return replacement_func
+
+                modified_sql = re.sub(
+                    pattern, make_replacement(hint, table), modified_sql, count=1, flags=re.IGNORECASE
+                )
 
         return SafeQuery(sql=modified_sql, parameters=safe_query.parameters, dialect=safe_query.dialect)

sqlspec/builder/_update.py

@@ -4,7 +4,6 @@ This module provides a fluent interface for building SQL queries safely,
 with automatic parameter binding and validation.
 """
 
-from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlglot import exp
@@ -27,7 +26,6 @@ if TYPE_CHECKING:
 __all__ = ("Update",)
 
 
-@dataclass(unsafe_hash=True)
 class Update(
     QueryBuilder,
     WhereClauseMixin,
@@ -72,6 +70,9 @@ class Update(
         ```
     """
 
+    __slots__ = ("_table",)
+    _expression: Optional[exp.Expression]
+
     def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
         """Initialize UPDATE with optional table.
 
@@ -80,6 +81,7 @@ class Update(
             **kwargs: Additional QueryBuilder arguments
         """
         super().__init__(**kwargs)
+        self._initialize_expression()
 
         if table:
             self.table(table)