sqlspec 0.16.0__py3-none-any.whl → 0.16.1__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,36 +118,49 @@ 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 = []
+        value_placeholders: list[exp.Expression] = []
         for i, value in enumerate(values):
-            # Try to use column name if available, otherwise use position-based name
-            if self._columns and i < len(self._columns):
-                column_name = (
-                    str(self._columns[i]).split(".")[-1] if "." in str(self._columns[i]) else str(self._columns[i])
-                )
-                param_name = self._generate_unique_parameter_name(column_name)
+            if isinstance(value, exp.Expression):
+                value_placeholders.append(value)
             else:
-                param_name = self._generate_unique_parameter_name(f"value_{i + 1}")
-            _, param_name = self.add_parameter(value, name=param_name)
-            param_names.append(param_name)
-        value_placeholders = tuple(exp.var(name) for name in param_names)
-
-        current_values_expression = insert_expr.args.get("expression")
-
+                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
@@ -165,10 +183,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])
@@ -222,18 +241,14 @@ class Insert(QueryBuilder, ReturningClauseMixin, InsertValuesMixin, InsertFromSe
             For a more general solution, you might need dialect-specific handling.
         """
         insert_expr = self._get_insert_expression()
-        try:
-            on_conflict = exp.OnConflict(this=None, expressions=[])
-            insert_expr.set("on", on_conflict)
-        except AttributeError:
-            pass
+        insert_expr.set("on", exp.OnConflict(this=None, expressions=[]))
         return self
 
-    def on_duplicate_key_update(self, **set_values: Any) -> "Self":
+    def on_duplicate_key_update(self, **_: Any) -> "Self":
         """Adds an ON DUPLICATE KEY UPDATE clause (MySQL syntax).
 
         Args:
-            **set_values: Column-value pairs to update on duplicate key.
+            **_: Column-value pairs to update on duplicate key.
 
         Returns:
             The current builder instance for method chaining.

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,7 +5,7 @@ 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
 
@@ -33,9 +33,12 @@ def parse_column_expression(column_input: Union[str, exp.Expression, Any]) -> ex
         return column_input
 
     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,7 +105,7 @@ 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)
@@ -129,12 +132,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)

sqlspec/builder/mixins/_cte_and_set_ops.py

@@ -2,6 +2,7 @@
 
 from typing import Any, Optional, Union
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -10,10 +11,21 @@ from sqlspec.exceptions import SQLBuilderError
 __all__ = ("CommonTableExpressionMixin", "SetOperationMixin")
 
 
+@trait
 class CommonTableExpressionMixin:
     """Mixin providing WITH clause (Common Table Expressions) support for SQL builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
+    _with_ctes: Any  # Provided by QueryBuilder
+    dialect: Any  # Provided by QueryBuilder
+
+    def add_parameter(self, value: Any, name: Optional[str] = None) -> tuple[Any, str]:
+        """Add parameter - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
 
     def with_(
         self, name: str, query: Union[Any, str], recursive: bool = False, columns: Optional[list[str]] = None
@@ -42,22 +54,22 @@ class CommonTableExpressionMixin:
 
         cte_expr: Optional[exp.Expression] = None
         if isinstance(query, str):
-            cte_expr = exp.maybe_parse(query, dialect=self.dialect)  # type: ignore[attr-defined]
+            cte_expr = exp.maybe_parse(query, dialect=self.dialect)
         elif isinstance(query, exp.Expression):
             cte_expr = query
         else:
-            built_query = query.to_statement()  # pyright: ignore
+            built_query = query.to_statement()
             cte_sql = built_query.sql
-            cte_expr = exp.maybe_parse(cte_sql, dialect=self.dialect)  # type: ignore[attr-defined]
+            cte_expr = exp.maybe_parse(cte_sql, dialect=self.dialect)
 
             parameters = built_query.parameters
             if parameters:
                 if isinstance(parameters, dict):
                     for param_name, param_value in parameters.items():
-                        self.add_parameter(param_value, name=param_name)  # type: ignore[attr-defined]
+                        self.add_parameter(param_value, name=param_name)
                 elif isinstance(parameters, (list, tuple)):
                     for param_value in parameters:
-                        self.add_parameter(param_value)  # type: ignore[attr-defined]
+                        self.add_parameter(param_value)
 
         if not cte_expr:
             msg = f"Could not parse CTE query: {query}"
@@ -68,29 +80,42 @@ class CommonTableExpressionMixin:
         else:
             cte_alias_expr = exp.alias_(cte_expr, name)
 
-        existing_with = self._expression.args.get("with")  # pyright: ignore
+        existing_with = self._expression.args.get("with")
         if existing_with:
             existing_with.expressions.append(cte_alias_expr)
             if recursive:
                 existing_with.set("recursive", recursive)
         else:
-            self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)  # type: ignore[union-attr]
-            if recursive:
-                with_clause = self._expression.find(exp.With)
-                if with_clause:
-                    with_clause.set("recursive", recursive)
-            self._with_ctes[name] = exp.CTE(this=cte_expr, alias=exp.to_table(name))  # type: ignore[attr-defined]
+            # Only SELECT, INSERT, UPDATE support WITH clauses
+            if hasattr(self._expression, "with_") and isinstance(
+                self._expression, (exp.Select, exp.Insert, exp.Update)
+            ):
+                self._expression = self._expression.with_(cte_alias_expr, as_=name, copy=False)
+                if recursive:
+                    with_clause = self._expression.find(exp.With)
+                    if with_clause:
+                        with_clause.set("recursive", recursive)
+            self._with_ctes[name] = exp.CTE(this=cte_expr, alias=exp.to_table(name))
 
         return self
 
 
+@trait
 class SetOperationMixin:
     """Mixin providing set operations (UNION, INTERSECT, EXCEPT) for SELECT builders."""
 
-    _expression: Any = None
+    __slots__ = ()
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
+
     _parameters: dict[str, Any]
     dialect: Any = None
 
+    def build(self) -> Any:
+        """Build the query - provided by QueryBuilder."""
+        msg = "Method must be provided by QueryBuilder subclass"
+        raise NotImplementedError(msg)
+
     def union(self, other: Any, all_: bool = False) -> Self:
         """Combine this query with another using UNION.
 
@@ -104,7 +129,7 @@ class SetOperationMixin:
         Returns:
             The new builder instance for the union query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
@@ -124,9 +149,11 @@ class SetOperationMixin:
                     counter += 1
                     new_param_name = f"{param_name}_right_{counter}"
 
-                def rename_parameter(node: exp.Expression) -> exp.Expression:
-                    if isinstance(node, exp.Placeholder) and node.name == param_name:  # noqa: B023
-                        return exp.Placeholder(this=new_param_name)  # noqa: B023
+                def rename_parameter(
+                    node: exp.Expression, old_name: str = param_name, new_name: str = new_param_name
+                ) -> exp.Expression:
+                    if isinstance(node, exp.Placeholder) and node.name == old_name:
+                        return exp.Placeholder(this=new_name)
                     return node
 
                 right_expr = right_expr.transform(rename_parameter)
@@ -150,7 +177,7 @@ class SetOperationMixin:
         Returns:
             The new builder instance for the intersect query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)
@@ -178,7 +205,7 @@ class SetOperationMixin:
         Returns:
             The new builder instance for the except query.
         """
-        left_query = self.build()  # type: ignore[attr-defined]
+        left_query = self.build()
         right_query = other.build()
         left_expr: Optional[exp.Expression] = exp.maybe_parse(left_query.sql, dialect=self.dialect)
         right_expr: Optional[exp.Expression] = exp.maybe_parse(right_query.sql, dialect=self.dialect)

sqlspec/builder/mixins/_delete_operations.py

@@ -2,6 +2,7 @@
 
 from typing import Optional
 
+from mypy_extensions import trait
 from sqlglot import exp
 from typing_extensions import Self
 
@@ -10,10 +11,14 @@ from sqlspec.exceptions import SQLBuilderError
 __all__ = ("DeleteFromClauseMixin",)
 
 
+@trait
 class DeleteFromClauseMixin:
     """Mixin providing FROM clause for DELETE builders."""
 
-    _expression: Optional[exp.Expression] = None
+    __slots__ = ()
+
+    # Type annotation for PyRight - this will be provided by the base class
+    _expression: Optional[exp.Expression]
 
     def from_(self, table: str) -> Self:
         """Set the target table for the DELETE statement.