sqlspec 0.12.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

sqlspec/statement/builder/mixins/_select_columns.py

@@ -7,7 +7,8 @@ from sqlspec.exceptions import SQLBuilderError
 from sqlspec.statement.builder._parsing_utils import parse_column_expression
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.protocols import BuilderProtocol
+    from sqlspec.protocols import SQLBuilderProtocol
+    from sqlspec.statement.builder.column import Column, FunctionColumn
 
 __all__ = ("SelectColumnsMixin",)
 
@@ -15,7 +16,7 @@ __all__ = ("SelectColumnsMixin",)
 class SelectColumnsMixin:
     """Mixin providing SELECT column and DISTINCT clauses for SELECT builders."""
 
-    def select(self, *columns: Union[str, exp.Expression]) -> Self:
+    def select(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn"]) -> Self:
         """Add columns to SELECT clause.
 
         Raises:
@@ -24,7 +25,7 @@ class SelectColumnsMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        builder = cast("BuilderProtocol", self)
+        builder = cast("SQLBuilderProtocol", self)
         if builder._expression is None:
             builder._expression = exp.Select()
         if not isinstance(builder._expression, exp.Select):
@@ -34,7 +35,7 @@ class SelectColumnsMixin:
             builder._expression = builder._expression.select(parse_column_expression(column), copy=False)
         return cast("Self", builder)
 
-    def distinct(self, *columns: Union[str, exp.Expression]) -> Self:
+    def distinct(self, *columns: Union[str, exp.Expression, "Column", "FunctionColumn"]) -> Self:
         """Add DISTINCT clause to SELECT.
 
         Args:
@@ -46,7 +47,7 @@ class SelectColumnsMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        builder = cast("BuilderProtocol", self)
+        builder = cast("SQLBuilderProtocol", self)
         if builder._expression is None:
             builder._expression = exp.Select()
         if not isinstance(builder._expression, exp.Select):

sqlspec/statement/builder/mixins/_unpivot.py

@@ -5,13 +5,13 @@ from sqlglot import exp
 if TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
 
-    from sqlspec.statement.builder.select import SelectBuilder
+    from sqlspec.statement.builder.select import Select
 
 __all__ = ("UnpivotClauseMixin",)
 
 
 class UnpivotClauseMixin:
-    """Mixin class to add UNPIVOT functionality to a SelectBuilder."""
+    """Mixin class to add UNPIVOT functionality to a Select."""
 
     _expression: "Optional[exp.Expression]" = None
     dialect: "DialectType" = None
@@ -22,7 +22,7 @@ class UnpivotClauseMixin:
         name_column_name: str,
         columns_to_unpivot: list[Union[str, exp.Expression]],
         alias: Optional[str] = None,
-    ) -> "SelectBuilder":
+    ) -> "Select":
         """Adds an UNPIVOT clause to the SELECT statement.
 
         Example:
@@ -38,12 +38,12 @@ class UnpivotClauseMixin:
             TypeError: If the current expression is not a Select expression.
 
         Returns:
-            The SelectBuilder instance for chaining.
+            The Select instance for chaining.
         """
         current_expr = self._expression
         if not isinstance(current_expr, exp.Select):
             # SelectBuilder's __init__ ensures _expression is exp.Select.
-            msg = "Unpivot can only be applied to a Select expression managed by SelectBuilder."
+            msg = "Unpivot can only be applied to a Select expression managed by Select."
             raise TypeError(msg)
 
         value_col_ident = exp.to_identifier(value_column_name)
@@ -59,7 +59,6 @@ class UnpivotClauseMixin:
                 # Fallback for other types, should ideally be an error or more specific handling
                 unpivot_cols_exprs.append(exp.column(str(col_name_or_expr)))
 
-        # Create the unpivot expression (stored as Pivot with unpivot=True)
         in_expr = exp.In(this=name_col_ident, expressions=unpivot_cols_exprs)
 
         unpivot_node = exp.Pivot(expressions=[value_col_ident], fields=[in_expr], unpivot=True)
@@ -67,14 +66,12 @@ class UnpivotClauseMixin:
         if alias:
             unpivot_node.set("alias", exp.TableAlias(this=exp.to_identifier(alias)))
 
-        # Add unpivot to the table in the FROM clause
         from_clause = current_expr.args.get("from")
         if from_clause and isinstance(from_clause, exp.From):
             table = from_clause.this
             if isinstance(table, exp.Table):
-                # Add to pivots array
                 existing_pivots = table.args.get("pivots", [])
                 existing_pivots.append(unpivot_node)
                 table.set("pivots", existing_pivots)
 
-        return cast("SelectBuilder", self)
+        return cast("Select", self)

sqlspec/statement/builder/mixins/_update_from.py

@@ -4,6 +4,7 @@ from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
+from sqlspec.utils.type_guards import has_query_builder_parameters
 
 __all__ = ("UpdateFromClauseMixin",)
 
@@ -30,7 +31,7 @@ class UpdateFromClauseMixin:
         table_expr: exp.Expression
         if isinstance(table, str):
             table_expr = exp.to_table(table, alias=alias)
-        elif hasattr(table, "build"):
+        elif has_query_builder_parameters(table):
             subquery_builder_params = getattr(table, "_parameters", None)
             if subquery_builder_params:
                 for p_name, p_value in subquery_builder_params.items():

sqlspec/statement/builder/mixins/_update_set.py

@@ -5,6 +5,7 @@ from sqlglot import exp
 from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
+from sqlspec.utils.type_guards import has_query_builder_parameters
 
 __all__ = ("UpdateSetClauseMixin",)
 
@@ -49,14 +50,15 @@ class UpdateSetClauseMixin:
             # If value is an expression, use it directly
             if isinstance(val, exp.Expression):
                 value_expr = val
-            elif hasattr(val, "_expression") and hasattr(val, "build"):
+            elif has_query_builder_parameters(val):
                 # It's a builder (like SelectBuilder), convert to subquery
                 subquery = val.build()
                 # Parse the SQL and use as expression
-                value_expr = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                 # Merge parameters from subquery
-                if hasattr(val, "_parameters"):
-                    for p_name, p_value in val._parameters.items():
+                if has_query_builder_parameters(val):
+                    for p_name, p_value in val.parameters.items():
                         self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             else:
                 param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]
@@ -69,14 +71,15 @@ class UpdateSetClauseMixin:
                 # If value is an expression, use it directly
                 if isinstance(val, exp.Expression):
                     value_expr = val
-                elif hasattr(val, "_expression") and hasattr(val, "build"):
+                elif has_query_builder_parameters(val):
                     # It's a builder (like SelectBuilder), convert to subquery
                     subquery = val.build()
                     # Parse the SQL and use as expression
-                    value_expr = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect", None)))
+                    sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                    value_expr = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect", None)))
                     # Merge parameters from subquery
-                    if hasattr(val, "_parameters"):
-                        for p_name, p_value in val._parameters.items():
+                    if has_query_builder_parameters(val):
+                        for p_name, p_value in val.parameters.items():
                             self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
                 else:
                     param_name = self.add_parameter(val)[1]  # type: ignore[attr-defined]

sqlspec/statement/builder/mixins/_where.py

@@ -6,9 +6,11 @@ from typing_extensions import Self
 
 from sqlspec.exceptions import SQLBuilderError
 from sqlspec.statement.builder._parsing_utils import parse_column_expression, parse_condition_expression
+from sqlspec.utils.type_guards import has_query_builder_parameters, is_iterable_parameters
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.protocols import BuilderProtocol
+    from sqlspec.protocols import SQLBuilderProtocol
+    from sqlspec.statement.builder.column import ColumnExpression
 
 __all__ = ("WhereClauseMixin",)
 
@@ -17,7 +19,8 @@ class WhereClauseMixin:
     """Mixin providing WHERE clause methods for SELECT, UPDATE, and DELETE builders."""
 
     def where(
-        self, condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any]]
+        self,
+        condition: Union[str, exp.Expression, exp.Condition, tuple[str, Any], tuple[str, str, Any], "ColumnExpression"],
     ) -> Self:
         """Add a WHERE clause to the statement.
 
@@ -34,14 +37,14 @@ class WhereClauseMixin:
         Returns:
             The current builder instance for method chaining.
         """
-        # Special case: if this is an UpdateBuilder and _expression is not exp.Update, raise the expected error for test coverage
+        # Special case: if this is an Update and _expression is not exp.Update, raise the expected error for test coverage
 
-        if self.__class__.__name__ == "UpdateBuilder" and not (
+        if self.__class__.__name__ == "Update" and not (
             hasattr(self, "_expression") and isinstance(getattr(self, "_expression", None), exp.Update)
         ):
             msg = "Cannot add WHERE clause to non-UPDATE expression"
             raise SQLBuilderError(msg)
-        builder = cast("BuilderProtocol", self)
+        builder = cast("SQLBuilderProtocol", self)
         if builder._expression is None:
             msg = "Cannot add WHERE clause: expression is not initialized."
             raise SQLBuilderError(msg)
@@ -50,7 +53,6 @@ class WhereClauseMixin:
             msg = f"Cannot add WHERE clause to unsupported expression type: {type(builder._expression).__name__}."
             raise SQLBuilderError(msg)
 
-        # Check if table is set for DELETE queries
         if isinstance(builder._expression, exp.Delete) and not builder._expression.args.get("this"):
             msg = "WHERE clause requires a table to be set. Use from() to set the table first."
             raise SQLBuilderError(msg)
@@ -58,7 +60,6 @@ class WhereClauseMixin:
         # Normalize the condition using enhanced parsing
         condition_expr: exp.Expression
         if isinstance(condition, tuple):
-            # Handle tuple format with proper parameter binding
             if len(condition) == 2:
                 # 2-tuple: (column, value) -> column = value
                 param_name = builder.add_parameter(condition[1])[1]
@@ -87,7 +88,6 @@ class WhereClauseMixin:
                     "any": exp.Any,
                 }
                 operator = operator.lower()
-                # Handle special cases for NOT operators
                 if operator == "not like":
                     condition_expr = exp.Not(this=exp.Like(this=col_expr, expression=placeholder_expr))
                 elif operator == "not in":
@@ -104,7 +104,20 @@ class WhereClauseMixin:
             else:
                 msg = f"WHERE tuple must have 2 or 3 elements, got {len(condition)}"
                 raise SQLBuilderError(msg)
+        # Handle ColumnExpression objects
+        elif hasattr(condition, "sqlglot_expression"):
+            # This is a ColumnExpression from our new Column syntax
+            raw_expr = getattr(condition, "sqlglot_expression", None)
+            if raw_expr is not None:
+                condition_expr = builder._parameterize_expression(raw_expr)
+            else:
+                # Fallback if attribute exists but is None
+                condition_expr = parse_condition_expression(str(condition))
         else:
+            # Existing logic for strings and raw SQLGlot expressions
+            # Convert to string if it's not a recognized type
+            if not isinstance(condition, (str, exp.Expression, tuple)):
+                condition = str(condition)
             condition_expr = parse_condition_expression(condition)
 
         # Use dialect if available for Delete
@@ -194,13 +207,16 @@ class WhereClauseMixin:
 
     def where_exists(self, subquery: "Union[str, Any]") -> "Self":
         sub_expr: exp.Expression
-        if hasattr(subquery, "_parameters") and hasattr(subquery, "build"):
-            subquery_builder_params: dict[str, Any] = subquery._parameters  # pyright: ignore
+        if has_query_builder_parameters(subquery):
+            subquery_builder_params: dict[str, Any] = subquery.parameters
             if subquery_builder_params:
                 for p_name, p_value in subquery_builder_params.items():
                     self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=getattr(self, "dialect_name", None))
+            sql_str = (
+                sub_sql_obj.sql if hasattr(sub_sql_obj, "sql") and not callable(sub_sql_obj.sql) else str(sub_sql_obj)
+            )
+            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None))
         else:
             sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(self, "dialect_name", None))
 
@@ -213,13 +229,16 @@ class WhereClauseMixin:
 
     def where_not_exists(self, subquery: "Union[str, Any]") -> "Self":
         sub_expr: exp.Expression
-        if hasattr(subquery, "_parameters") and hasattr(subquery, "build"):
-            subquery_builder_params: dict[str, Any] = subquery._parameters  # pyright: ignore
+        if has_query_builder_parameters(subquery):
+            subquery_builder_params: dict[str, Any] = subquery.parameters
             if subquery_builder_params:
                 for p_name, p_value in subquery_builder_params.items():
                     self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
             sub_sql_obj = subquery.build()  # pyright: ignore
-            sub_expr = exp.maybe_parse(sub_sql_obj.sql, dialect=getattr(self, "dialect_name", None))
+            sql_str = (
+                sub_sql_obj.sql if hasattr(sub_sql_obj, "sql") and not callable(sub_sql_obj.sql) else str(sub_sql_obj)
+            )
+            sub_expr = exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None))
         else:
             sub_expr = exp.maybe_parse(str(subquery), dialect=getattr(self, "dialect_name", None))
 
@@ -238,16 +257,18 @@ class WhereClauseMixin:
         """Add a WHERE ... IN (...) clause. Supports subqueries and iterables."""
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
         # Subquery support
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = col_expr.isin(subquery_exp)
             return self.where(condition)
         # Iterable of values
-        if not hasattr(values, "__iter__") or isinstance(values, (str, bytes)):
+        if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Unsupported type for 'values' in WHERE IN"
             raise SQLBuilderError(msg)
         params = []
@@ -260,15 +281,17 @@ class WhereClauseMixin:
     def where_not_in(self, column: "Union[str, exp.Column]", values: Any) -> "Self":
         """Add a WHERE ... NOT IN (...) clause. Supports subqueries and iterables."""
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.Not(this=col_expr.isin(subquery_exp))
             return self.where(condition)
-        if not hasattr(values, "__iter__") or isinstance(values, (str, bytes)):
+        if not is_iterable_parameters(values) or isinstance(values, (str, bytes)):
             msg = "Values for where_not_in must be a non-string iterable or subquery."
             raise SQLBuilderError(msg)
         params = []
@@ -294,12 +317,14 @@ class WhereClauseMixin:
             The current builder instance for method chaining.
         """
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.EQ(this=col_expr, expression=exp.Any(this=subquery_exp))
             return self.where(condition)
         if isinstance(values, str):
@@ -317,7 +342,7 @@ class WhereClauseMixin:
             # If parsing fails, fall through to error
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
-        if not hasattr(values, "__iter__") or isinstance(values, bytes):
+        if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE ANY"
             raise SQLBuilderError(msg)
         params = []
@@ -339,12 +364,14 @@ class WhereClauseMixin:
             The current builder instance for method chaining.
         """
         col_expr = parse_column_expression(column) if not isinstance(column, exp.Column) else column
-        if hasattr(values, "build") or isinstance(values, exp.Expression):
-            if hasattr(values, "build"):
+        if has_query_builder_parameters(values) or isinstance(values, exp.Expression):
+            subquery_exp: exp.Expression
+            if has_query_builder_parameters(values):
                 subquery = values.build()  # pyright: ignore
-                subquery_exp = exp.paren(exp.maybe_parse(subquery.sql, dialect=getattr(self, "dialect_name", None)))
+                sql_str = subquery.sql if hasattr(subquery, "sql") and not callable(subquery.sql) else str(subquery)
+                subquery_exp = exp.paren(exp.maybe_parse(sql_str, dialect=getattr(self, "dialect_name", None)))
             else:
-                subquery_exp = values
+                subquery_exp = values  # type: ignore[assignment]
             condition = exp.NEQ(this=col_expr, expression=exp.Any(this=subquery_exp))
             return self.where(condition)
         if isinstance(values, str):
@@ -362,7 +389,7 @@ class WhereClauseMixin:
             # If parsing fails, fall through to error
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
-        if not hasattr(values, "__iter__") or isinstance(values, bytes):
+        if not is_iterable_parameters(values) or isinstance(values, bytes):
             msg = "Unsupported type for 'values' in WHERE NOT ANY"
             raise SQLBuilderError(msg)
         params = []

sqlspec/statement/builder/select.py

@@ -6,7 +6,7 @@ with automatic parameter binding and validation.
 
 import re
 from dataclasses import dataclass, field
-from typing import Optional, Union, cast
+from typing import Any, Optional, Union, cast
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -32,11 +32,11 @@ from sqlspec.statement.builder.mixins import (
 from sqlspec.statement.result import SQLResult
 from sqlspec.typing import RowT
 
-__all__ = ("SelectBuilder",)
+__all__ = ("Select",)
 
 
 @dataclass
-class SelectBuilder(
+class Select(
     QueryBuilder[RowT],
     WhereClauseMixin,
     OrderByClauseMixin,
@@ -77,16 +77,37 @@ class SelectBuilder(
         _schema: The schema/model class for row typing, if set via as_schema().
     """
 
-    _with_parts: "dict[str, Union[exp.CTE, SelectBuilder]]" = field(default_factory=dict, init=False)
+    _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)
     _schema: Optional[type[RowT]] = None
     _hints: "list[dict[str, object]]" = field(default_factory=list, init=False, repr=False)
 
-    def __post_init__(self) -> "None":
-        super().__post_init__()
+    def __init__(self, *columns: str, **kwargs: Any) -> None:
+        """Initialize SELECT with optional columns.
+
+        Args:
+            *columns: Column names to select (e.g., "id", "name", "u.email")
+            **kwargs: Additional QueryBuilder arguments (dialect, schema, etc.)
+
+        Examples:
+            Select("id", "name")  # Shorthand for Select().select("id", "name")
+            Select()              # Same as SelectBuilder() - start empty
+        """
+        super().__init__(**kwargs)
+
+        # Initialize fields from dataclass
+        self._with_parts = {}
+        self._expression = None
+        self._schema = None
+        self._hints = []
+
         if self._expression is None:
             self._create_base_expression()
 
+        # Add columns if provided - just a shorthand for .select()
+        if columns:
+            self.select(*columns)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult[RowT]]":
         """Get the expected result type for SELECT operations.
@@ -102,8 +123,8 @@ class SelectBuilder(
         # At this point, self._expression is exp.Select
         return self._expression
 
-    def as_schema(self, schema: "type[RowT]") -> "SelectBuilder[RowT]":
-        """Return a new SelectBuilder instance parameterized with the given schema/model type.
+    def as_schema(self, schema: "type[RowT]") -> "Select[RowT]":
+        """Return a new Select instance parameterized with the given schema/model type.
 
         This enables type-safe result mapping: the returned builder will carry the schema type
         for static analysis and IDE autocompletion. The schema should be a class such as a Pydantic
@@ -113,15 +134,15 @@ class SelectBuilder(
             schema: The schema/model class to use for row typing (e.g., a Pydantic model, dataclass, or msgspec.Struct).
 
         Returns:
-            SelectBuilder[RowT]: A new SelectBuilder instance with RowT set to the provided schema/model type.
+            Select[RowT]: A new Select instance with RowT set to the provided schema/model type.
         """
-        new_builder = SelectBuilder()
+        new_builder = Select()
         new_builder._expression = self._expression.copy() if self._expression is not None else None
         new_builder._parameters = self._parameters.copy()
         new_builder._parameter_counter = self._parameter_counter
         new_builder.dialect = self.dialect
         new_builder._schema = schema  # type: ignore[assignment]
-        return cast("SelectBuilder[RowT]", new_builder)
+        return cast("Select[RowT]", new_builder)
 
     def with_hint(
         self,
@@ -151,15 +172,12 @@ class SelectBuilder(
         Returns:
             SafeQuery: A dataclass containing the SQL string and parameters.
         """
-        # Call parent build method which handles CTEs and optimization
         safe_query = super().build()
 
-        # Apply hints using SQLGlot's proper hint support (more robust than regex)
         if hasattr(self, "_hints") and self._hints:
             modified_expr = self._expression.copy() if self._expression else None
 
             if modified_expr and isinstance(modified_expr, exp.Select):
-                # Apply statement-level hints using SQLGlot's Hint expression
                 statement_hints = [h["hint"] for h in self._hints if h.get("location") == "statement"]
                 if statement_hints:
                     # Parse each hint and create proper hint expressions
@@ -172,12 +190,10 @@ class SelectBuilder(
                             if hint_expr:
                                 hint_expressions.append(hint_expr)
                             else:
-                                # Create a raw identifier for unparsable hints
                                 hint_expressions.append(exp.Anonymous(this=hint_str))
                         except Exception:  # noqa: PERF203
                             hint_expressions.append(exp.Anonymous(this=str(hint)))
 
-                    # Create a Hint node and attach to SELECT
                     if hint_expressions:
                         hint_node = exp.Hint(expressions=hint_expressions)
                         modified_expr.set("hint", hint_node)
@@ -186,7 +202,6 @@ class SelectBuilder(
                 # since SQLGlot doesn't have a standard way to attach hints to individual tables
                 modified_sql = modified_expr.sql(dialect=self.dialect_name, pretty=True)
 
-                # Apply table-level hints via string manipulation (as fallback)
                 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:

sqlspec/statement/builder/update.py

@@ -5,7 +5,7 @@ with automatic parameter binding and validation.
 """
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 from sqlglot import exp
 from typing_extensions import Self
@@ -23,13 +23,13 @@ from sqlspec.statement.result import SQLResult
 from sqlspec.typing import RowT
 
 if TYPE_CHECKING:
-    from sqlspec.statement.builder.select import SelectBuilder
+    from sqlspec.statement.builder.select import Select
 
-__all__ = ("UpdateBuilder",)
+__all__ = ("Update",)
 
 
 @dataclass(unsafe_hash=True)
-class UpdateBuilder(
+class Update(
     QueryBuilder[RowT],
     WhereClauseMixin,
     ReturningClauseMixin,
@@ -46,16 +46,21 @@ class UpdateBuilder(
         ```python
         # Basic UPDATE
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users")
             .set(name="John Doe")
             .set(email="john@example.com")
             .where("id = 1")
         )
 
+        # Even more concise with constructor
+        update_query = (
+            Update("users").set(name="John Doe").where("id = 1")
+        )
+
         # UPDATE with parameterized conditions
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users")
             .set(status="active")
             .where_eq("id", 123)
@@ -63,7 +68,7 @@ class UpdateBuilder(
 
         # UPDATE with FROM clause (PostgreSQL style)
         update_query = (
-            UpdateBuilder()
+            Update()
             .table("users", "u")
             .set(name="Updated Name")
             .from_("profiles", "p")
@@ -72,6 +77,18 @@ class UpdateBuilder(
         ```
     """
 
+    def __init__(self, table: Optional[str] = None, **kwargs: Any) -> None:
+        """Initialize UPDATE with optional table.
+
+        Args:
+            table: Target table name
+            **kwargs: Additional QueryBuilder arguments
+        """
+        super().__init__(**kwargs)
+
+        if table:
+            self.table(table)
+
     @property
     def _expected_result_type(self) -> "type[SQLResult[RowT]]":
         """Return the expected result type for this builder."""
@@ -87,7 +104,7 @@ class UpdateBuilder(
 
     def join(
         self,
-        table: "Union[str, exp.Expression, SelectBuilder[RowT]]",
+        table: "Union[str, exp.Expression, Select[RowT]]",
         on: "Union[str, exp.Expression]",
         alias: "Optional[str]" = None,
         join_type: str = "INNER",
@@ -141,7 +158,6 @@ class UpdateBuilder(
             msg = f"Unsupported join type: {join_type}"
             raise SQLBuilderError(msg)
 
-        # Add join to the UPDATE expression
         if not self._expression.args.get("joins"):
             self._expression.set("joins", [])
         self._expression.args["joins"].append(join_expr)
@@ -165,12 +181,10 @@ class UpdateBuilder(
             msg = "No UPDATE expression to build or expression is of the wrong type."
             raise SQLBuilderError(msg)
 
-        # Check that the table is set
         if getattr(self._expression, "this", None) is None:
             msg = "No table specified for UPDATE statement."
             raise SQLBuilderError(msg)
 
-        # Check that at least one SET expression exists
         if not self._expression.args.get("expressions"):
             msg = "At least one SET clause must be specified for UPDATE statement."
             raise SQLBuilderError(msg)