sqlspec 0.16.0__cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

sqlspec/builder/mixins/_insert_operations.py

@@ -0,0 +1,152 @@
+"""Insert operation mixins for SQL builders."""
+
+from collections.abc import Sequence
+from typing import Any, Optional, Union
+
+from sqlglot import exp
+from typing_extensions import Self
+
+from sqlspec.exceptions import SQLBuilderError
+
+__all__ = ("InsertFromSelectMixin", "InsertIntoClauseMixin", "InsertValuesMixin")
+
+
+class InsertIntoClauseMixin:
+    """Mixin providing INTO clause for INSERT builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def into(self, table: str) -> Self:
+        """Set the target table for the INSERT statement.
+
+        Args:
+            table: The name of the table to insert data into.
+
+        Raises:
+            SQLBuilderError: If the current expression is not an INSERT statement.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        if self._expression is None:
+            self._expression = exp.Insert()
+        if not isinstance(self._expression, exp.Insert):
+            msg = "Cannot set target table on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+
+        setattr(self, "_table", table)
+        self._expression.set("this", exp.to_table(table))
+        return self
+
+
+class InsertValuesMixin:
+    """Mixin providing VALUES and columns methods for INSERT builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def columns(self, *columns: Union[str, exp.Expression]) -> Self:
+        """Set the columns for the INSERT statement and synchronize the _columns attribute on the builder."""
+        if self._expression is None:
+            self._expression = exp.Insert()
+        if not isinstance(self._expression, exp.Insert):
+            msg = "Cannot set columns on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+        column_exprs = [exp.column(col) if isinstance(col, str) else col for col in columns]
+        self._expression.set("columns", column_exprs)
+        try:
+            cols = self._columns  # type: ignore[attr-defined]
+            if not columns:
+                cols.clear()
+            else:
+                cols[:] = [col.name if isinstance(col, exp.Column) else str(col) for col in columns]
+        except AttributeError:
+            pass
+        return self
+
+    def values(self, *values: Any) -> Self:
+        """Add a row of values to the INSERT statement, validating against _columns if set."""
+        if self._expression is None:
+            self._expression = exp.Insert()
+        if not isinstance(self._expression, exp.Insert):
+            msg = "Cannot add values to a non-INSERT expression."
+            raise SQLBuilderError(msg)
+        try:
+            _columns = self._columns  # type: ignore[attr-defined]
+            if _columns and len(values) != len(_columns):
+                msg = f"Number of values ({len(values)}) does not match the number of specified columns ({len(_columns)})."
+                raise SQLBuilderError(msg)
+        except AttributeError:
+            pass
+        row_exprs = []
+        for i, v in enumerate(values):
+            if isinstance(v, exp.Expression):
+                row_exprs.append(v)
+            else:
+                # Try to use column name if available, otherwise use position-based name
+                try:
+                    _columns = self._columns  # type: ignore[attr-defined]
+                    if _columns and i < len(_columns):
+                        column_name = str(_columns[i]).split(".")[-1] if "." in str(_columns[i]) else str(_columns[i])
+                        param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                    else:
+                        param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                except AttributeError:
+                    param_name = self._generate_unique_parameter_name(f"value_{i + 1}")  # type: ignore[attr-defined]
+                _, param_name = self.add_parameter(v, name=param_name)  # type: ignore[attr-defined]
+                row_exprs.append(exp.var(param_name))
+        values_expr = exp.Values(expressions=[row_exprs])
+        self._expression.set("expression", values_expr)
+        return self
+
+    def add_values(self, values: Sequence[Any]) -> Self:
+        """Add a row of values to the INSERT statement (alternative signature).
+
+        Args:
+            values: Sequence of values for the row.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        return self.values(*values)
+
+
+class InsertFromSelectMixin:
+    """Mixin providing INSERT ... SELECT support for INSERT builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def from_select(self, select_builder: Any) -> Self:
+        """Sets the INSERT source to a SELECT statement.
+
+        Args:
+            select_builder: A SelectBuilder instance representing the SELECT query.
+
+        Returns:
+            The current builder instance for method chaining.
+
+        Raises:
+            SQLBuilderError: If the table is not set or the select_builder is invalid.
+        """
+        try:
+            if not self._table:  # type: ignore[attr-defined]
+                msg = "The target table must be set using .into() before adding values."
+                raise SQLBuilderError(msg)
+        except AttributeError:
+            msg = "The target table must be set using .into() before adding values."
+            raise SQLBuilderError(msg)
+        if self._expression is None:
+            self._expression = exp.Insert()
+        if not isinstance(self._expression, exp.Insert):
+            msg = "Cannot set INSERT source on a non-INSERT expression."
+            raise SQLBuilderError(msg)
+        subquery_parameters = select_builder._parameters  # pyright: ignore[attr-defined]
+        if subquery_parameters:
+            for p_name, p_value in subquery_parameters.items():
+                self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+        select_expr = select_builder._expression  # pyright: ignore[attr-defined]
+        if select_expr and isinstance(select_expr, exp.Select):
+            self._expression.set("expression", select_expr.copy())
+        else:
+            msg = "SelectBuilder must have a valid SELECT expression."
+            raise SQLBuilderError(msg)
+        return self

sqlspec/builder/mixins/_join_operations.py

@@ -0,0 +1,115 @@
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
+
+from sqlglot import exp
+from typing_extensions import Self
+
+from sqlspec.builder._parsing_utils import parse_table_expression
+from sqlspec.exceptions import SQLBuilderError
+from sqlspec.utils.type_guards import has_query_builder_parameters
+
+if TYPE_CHECKING:
+    from sqlspec.protocols import SQLBuilderProtocol
+
+__all__ = ("JoinClauseMixin",)
+
+
+class JoinClauseMixin:
+    """Mixin providing JOIN clause methods for SELECT builders."""
+
+    def join(
+        self,
+        table: Union[str, exp.Expression, Any],
+        on: Optional[Union[str, exp.Expression]] = None,
+        alias: Optional[str] = None,
+        join_type: str = "INNER",
+    ) -> Self:
+        builder = cast("SQLBuilderProtocol", self)
+        if builder._expression is None:
+            builder._expression = exp.Select()
+        if not isinstance(builder._expression, exp.Select):
+            msg = "JOIN clause is only supported for SELECT statements."
+            raise SQLBuilderError(msg)
+        table_expr: exp.Expression
+        if isinstance(table, str):
+            table_expr = parse_table_expression(table, alias)
+        elif has_query_builder_parameters(table):
+            if hasattr(table, "_expression") and getattr(table, "_expression", None) is not None:
+                table_expr_value = getattr(table, "_expression", None)
+                if table_expr_value is not None:
+                    subquery_exp = exp.paren(table_expr_value.copy())  # pyright: ignore
+                else:
+                    subquery_exp = exp.paren(exp.Anonymous(this=""))
+                table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
+            else:
+                subquery = table.build()  # pyright: ignore
+                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(builder, "dialect", None)))
+                table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
+        else:
+            table_expr = table
+        on_expr: Optional[exp.Expression] = None
+        if on is not None:
+            on_expr = exp.condition(on) if isinstance(on, str) else on
+        join_type_upper = join_type.upper()
+        if join_type_upper == "INNER":
+            join_expr = exp.Join(this=table_expr, on=on_expr)
+        elif join_type_upper == "LEFT":
+            join_expr = exp.Join(this=table_expr, on=on_expr, side="LEFT")
+        elif join_type_upper == "RIGHT":
+            join_expr = exp.Join(this=table_expr, on=on_expr, side="RIGHT")
+        elif join_type_upper == "FULL":
+            join_expr = exp.Join(this=table_expr, on=on_expr, side="FULL", kind="OUTER")
+        else:
+            msg = f"Unsupported join type: {join_type}"
+            raise SQLBuilderError(msg)
+        builder._expression = builder._expression.join(join_expr, copy=False)
+        return cast("Self", builder)
+
+    def inner_join(
+        self, table: Union[str, exp.Expression, Any], on: Union[str, exp.Expression], alias: Optional[str] = None
+    ) -> Self:
+        return self.join(table, on, alias, "INNER")
+
+    def left_join(
+        self, table: Union[str, exp.Expression, Any], on: Union[str, exp.Expression], alias: Optional[str] = None
+    ) -> Self:
+        return self.join(table, on, alias, "LEFT")
+
+    def right_join(
+        self, table: Union[str, exp.Expression, Any], on: Union[str, exp.Expression], alias: Optional[str] = None
+    ) -> Self:
+        return self.join(table, on, alias, "RIGHT")
+
+    def full_join(
+        self, table: Union[str, exp.Expression, Any], on: Union[str, exp.Expression], alias: Optional[str] = None
+    ) -> Self:
+        return self.join(table, on, alias, "FULL")
+
+    def cross_join(self, table: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
+        builder = cast("SQLBuilderProtocol", self)
+        if builder._expression is None:
+            builder._expression = exp.Select()
+        if not isinstance(builder._expression, exp.Select):
+            msg = "Cannot add cross join to a non-SELECT expression."
+            raise SQLBuilderError(msg)
+        table_expr: exp.Expression
+        if isinstance(table, str):
+            table_expr = parse_table_expression(table, alias)
+        elif has_query_builder_parameters(table):
+            if hasattr(table, "_expression") and getattr(table, "_expression", None) is not None:
+                table_expr_value = getattr(table, "_expression", None)
+                if table_expr_value is not None:
+                    subquery_exp = exp.paren(table_expr_value.copy())  # pyright: ignore
+                else:
+                    subquery_exp = exp.paren(exp.Anonymous(this=""))
+                table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
+            else:
+                subquery = table.build()  # pyright: ignore
+                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(builder, "dialect", None)))
+                table_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
+        else:
+            table_expr = table
+        join_expr = exp.Join(this=table_expr, kind="CROSS")
+        builder._expression = builder._expression.join(join_expr, copy=False)
+        return cast("Self", builder)

sqlspec/builder/mixins/_merge_operations.py

@@ -0,0 +1,416 @@
+"""Merge operation mixins for SQL builders."""
+
+from typing import Any, Optional, Union
+
+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__ = (
+    "MergeIntoClauseMixin",
+    "MergeMatchedClauseMixin",
+    "MergeNotMatchedBySourceClauseMixin",
+    "MergeNotMatchedClauseMixin",
+    "MergeOnClauseMixin",
+    "MergeUsingClauseMixin",
+)
+
+
+class MergeIntoClauseMixin:
+    """Mixin providing INTO clause for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def into(self, table: Union[str, exp.Expression], alias: Optional[str] = None) -> Self:
+        """Set the target table for the MERGE operation (INTO clause).
+
+        Args:
+            table: The target table name or expression for the MERGE operation.
+                   Can be a string (table name) or an sqlglot Expression.
+            alias: Optional alias for the target table.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        if self._expression is None:
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # pyright: ignore
+        if not isinstance(self._expression, exp.Merge):  # pyright: ignore
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))  # pyright: ignore
+        self._expression.set("this", exp.to_table(table, alias=alias) if isinstance(table, str) else table)
+        return self
+
+
+class MergeUsingClauseMixin:
+    """Mixin providing USING clause for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def using(self, source: Union[str, exp.Expression, Any], alias: Optional[str] = None) -> Self:
+        """Set the source data for the MERGE operation (USING clause).
+
+        Args:
+            source: The source data for the MERGE operation.
+                    Can be a string (table name), an sqlglot Expression, or a SelectBuilder instance.
+            alias: Optional alias for the source table.
+
+        Returns:
+            The current builder instance for method chaining.
+
+        Raises:
+            SQLBuilderError: If the current expression is not a MERGE statement or if the source type is unsupported.
+        """
+        if self._expression is None:
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        if not isinstance(self._expression, exp.Merge):
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+
+        source_expr: exp.Expression
+        if isinstance(source, str):
+            source_expr = exp.to_table(source, alias=alias)
+        elif has_query_builder_parameters(source) and hasattr(source, "_expression"):
+            subquery_builder_parameters = source.parameters
+            if subquery_builder_parameters:
+                for p_name, p_value in subquery_builder_parameters.items():
+                    self.add_parameter(p_value, name=p_name)  # type: ignore[attr-defined]
+
+            subquery_exp = exp.paren(getattr(source, "_expression", exp.select()))
+            source_expr = exp.alias_(subquery_exp, alias) if alias else subquery_exp
+        elif isinstance(source, exp.Expression):
+            source_expr = source
+            if alias:
+                source_expr = exp.alias_(source_expr, alias)
+        else:
+            msg = f"Unsupported source type for USING clause: {type(source)}"
+            raise SQLBuilderError(msg)
+
+        self._expression.set("using", source_expr)
+        return self
+
+
+class MergeOnClauseMixin:
+    """Mixin providing ON clause for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def on(self, condition: Union[str, exp.Expression]) -> Self:
+        """Set the join condition for the MERGE operation (ON clause).
+
+        Args:
+            condition: The join condition for the MERGE operation.
+                       Can be a string (SQL condition) or an sqlglot Expression.
+
+        Returns:
+            The current builder instance for method chaining.
+
+        Raises:
+            SQLBuilderError: If the current expression is not a MERGE statement or if the condition type is unsupported.
+        """
+        if self._expression is None:
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        if not isinstance(self._expression, exp.Merge):
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+
+        condition_expr: exp.Expression
+        if isinstance(condition, str):
+            parsed_condition: Optional[exp.Expression] = exp.maybe_parse(
+                condition, dialect=getattr(self, "dialect", None)
+            )
+            if not parsed_condition:
+                msg = f"Could not parse ON condition: {condition}"
+                raise SQLBuilderError(msg)
+            condition_expr = parsed_condition
+        elif isinstance(condition, exp.Expression):
+            condition_expr = condition
+        else:
+            msg = f"Unsupported condition type for ON clause: {type(condition)}"
+            raise SQLBuilderError(msg)
+
+        self._expression.set("on", condition_expr)
+        return self
+
+
+class MergeMatchedClauseMixin:
+    """Mixin providing WHEN MATCHED THEN ... clauses for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def _add_when_clause(self, when_clause: exp.When) -> None:
+        """Helper to add a WHEN clause to the MERGE statement.
+
+        Args:
+            when_clause: The WHEN clause to add.
+        """
+        if self._expression is None:
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+        if not isinstance(self._expression, exp.Merge):
+            self._expression = exp.Merge(this=None, using=None, on=None, whens=exp.Whens(expressions=[]))
+
+        whens = self._expression.args.get("whens")
+        if not whens:
+            whens = exp.Whens(expressions=[])
+            self._expression.set("whens", whens)
+
+        whens.append("expressions", when_clause)
+
+    def when_matched_then_update(
+        self, set_values: dict[str, Any], condition: Optional[Union[str, exp.Expression]] = None
+    ) -> Self:
+        """Define the UPDATE action for matched rows.
+
+        Args:
+            set_values: A dictionary of column names and their new values to set.
+                        The values will be parameterized.
+            condition: An optional additional condition for this specific action.
+
+        Raises:
+            SQLBuilderError: If the condition type is unsupported.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        update_expressions: list[exp.EQ] = []
+        for col, val in set_values.items():
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+            update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
+
+        when_args: dict[str, Any] = {"matched": True, "then": exp.Update(expressions=update_expressions)}
+
+        if condition:
+            condition_expr: exp.Expression
+            if isinstance(condition, str):
+                parsed_cond: Optional[exp.Expression] = exp.maybe_parse(
+                    condition, dialect=getattr(self, "dialect", None)
+                )
+                if not parsed_cond:
+                    msg = f"Could not parse WHEN clause condition: {condition}"
+                    raise SQLBuilderError(msg)
+                condition_expr = parsed_cond
+            elif isinstance(condition, exp.Expression):
+                condition_expr = condition
+            else:
+                msg = f"Unsupported condition type for WHEN clause: {type(condition)}"
+                raise SQLBuilderError(msg)
+            when_args["this"] = condition_expr
+
+        when_clause = exp.When(**when_args)
+        self._add_when_clause(when_clause)
+        return self
+
+    def when_matched_then_delete(self, condition: Optional[Union[str, exp.Expression]] = None) -> Self:
+        """Define the DELETE action for matched rows.
+
+        Args:
+            condition: An optional additional condition for this specific action.
+
+        Raises:
+            SQLBuilderError: If the condition type is unsupported.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        when_args: dict[str, Any] = {"matched": True, "then": exp.Delete()}
+
+        if condition:
+            condition_expr: exp.Expression
+            if isinstance(condition, str):
+                parsed_cond: Optional[exp.Expression] = exp.maybe_parse(
+                    condition, dialect=getattr(self, "dialect", None)
+                )
+                if not parsed_cond:
+                    msg = f"Could not parse WHEN clause condition: {condition}"
+                    raise SQLBuilderError(msg)
+                condition_expr = parsed_cond
+            elif isinstance(condition, exp.Expression):
+                condition_expr = condition
+            else:
+                msg = f"Unsupported condition type for WHEN clause: {type(condition)}"
+                raise SQLBuilderError(msg)
+            when_args["this"] = condition_expr
+
+        when_clause = exp.When(**when_args)
+        self._add_when_clause(when_clause)
+        return self
+
+
+class MergeNotMatchedClauseMixin:
+    """Mixin providing WHEN NOT MATCHED THEN ... clauses for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def when_not_matched_then_insert(
+        self,
+        columns: Optional[list[str]] = None,
+        values: Optional[list[Any]] = None,
+        condition: Optional[Union[str, exp.Expression]] = None,
+        by_target: bool = True,
+    ) -> Self:
+        """Define the INSERT action for rows not matched.
+
+        Args:
+            columns: A list of column names to insert into. If None, implies INSERT DEFAULT VALUES or matching source columns.
+            values: A list of values corresponding to the columns.
+                    These values will be parameterized. If None, implies INSERT DEFAULT VALUES or subquery source.
+            condition: An optional additional condition for this specific action.
+            by_target: If True (default), condition is "WHEN NOT MATCHED [BY TARGET]".
+                       If False, condition is "WHEN NOT MATCHED BY SOURCE".
+
+        Returns:
+            The current builder instance for method chaining.
+
+        Raises:
+            SQLBuilderError: If columns and values are provided but do not match in length,
+                             or if columns are provided without values.
+        """
+        insert_args: dict[str, Any] = {}
+        if columns and values:
+            if len(columns) != len(values):
+                msg = "Number of columns must match number of values for INSERT."
+                raise SQLBuilderError(msg)
+
+            parameterized_values: list[exp.Expression] = []
+            for i, val in enumerate(values):
+                column_name = columns[i] if isinstance(columns[i], str) else str(columns[i])
+                if "." in column_name:
+                    column_name = column_name.split(".")[-1]
+                param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+                param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+                parameterized_values.append(exp.var(param_name))
+
+            insert_args["this"] = exp.Tuple(expressions=[exp.column(c) for c in columns])
+            insert_args["expression"] = exp.Tuple(expressions=parameterized_values)
+        elif columns and not values:
+            msg = "Specifying columns without values for INSERT action is complex and not fully supported yet. Consider providing full expressions."
+            raise SQLBuilderError(msg)
+        elif not columns and not values:
+            pass
+        else:
+            msg = "Cannot specify values without columns for INSERT action."
+            raise SQLBuilderError(msg)
+
+        when_args: dict[str, Any] = {"matched": False, "then": exp.Insert(**insert_args)}
+
+        if not by_target:
+            when_args["source"] = True
+
+        if condition:
+            condition_expr: exp.Expression
+            if isinstance(condition, str):
+                parsed_cond: Optional[exp.Expression] = exp.maybe_parse(
+                    condition, dialect=getattr(self, "dialect", None)
+                )
+                if not parsed_cond:
+                    msg = f"Could not parse WHEN clause condition: {condition}"
+                    raise SQLBuilderError(msg)
+                condition_expr = parsed_cond
+            elif isinstance(condition, exp.Expression):
+                condition_expr = condition
+            else:
+                msg = f"Unsupported condition type for WHEN clause: {type(condition)}"
+                raise SQLBuilderError(msg)
+            when_args["this"] = condition_expr
+
+        when_clause = exp.When(**when_args)
+        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        return self
+
+
+class MergeNotMatchedBySourceClauseMixin:
+    """Mixin providing WHEN NOT MATCHED BY SOURCE THEN ... clauses for MERGE builders."""
+
+    _expression: Optional[exp.Expression] = None
+
+    def when_not_matched_by_source_then_update(
+        self, set_values: dict[str, Any], condition: Optional[Union[str, exp.Expression]] = None
+    ) -> Self:
+        """Define the UPDATE action for rows not matched by source.
+
+        This is useful for handling rows that exist in the target but not in the source.
+
+        Args:
+            set_values: A dictionary of column names and their new values to set.
+            condition: An optional additional condition for this specific action.
+
+        Raises:
+            SQLBuilderError: If the condition type is unsupported.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        update_expressions: list[exp.EQ] = []
+        for col, val in set_values.items():
+            column_name = col if isinstance(col, str) else str(col)
+            if "." in column_name:
+                column_name = column_name.split(".")[-1]
+            param_name = self._generate_unique_parameter_name(column_name)  # type: ignore[attr-defined]
+            param_name = self.add_parameter(val, name=param_name)[1]  # type: ignore[attr-defined]
+            update_expressions.append(exp.EQ(this=exp.column(col), expression=exp.var(param_name)))
+
+        when_args: dict[str, Any] = {
+            "matched": False,
+            "source": True,
+            "then": exp.Update(expressions=update_expressions),
+        }
+
+        if condition:
+            condition_expr: exp.Expression
+            if isinstance(condition, str):
+                parsed_cond: Optional[exp.Expression] = exp.maybe_parse(
+                    condition, dialect=getattr(self, "dialect", None)
+                )
+                if not parsed_cond:
+                    msg = f"Could not parse WHEN clause condition: {condition}"
+                    raise SQLBuilderError(msg)
+                condition_expr = parsed_cond
+            elif isinstance(condition, exp.Expression):
+                condition_expr = condition
+            else:
+                msg = f"Unsupported condition type for WHEN clause: {type(condition)}"
+                raise SQLBuilderError(msg)
+            when_args["this"] = condition_expr
+
+        when_clause = exp.When(**when_args)
+        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        return self
+
+    def when_not_matched_by_source_then_delete(self, condition: Optional[Union[str, exp.Expression]] = None) -> Self:
+        """Define the DELETE action for rows not matched by source.
+
+        This is useful for cleaning up rows that exist in the target but not in the source.
+
+        Args:
+            condition: An optional additional condition for this specific action.
+
+        Raises:
+            SQLBuilderError: If the condition type is unsupported.
+
+        Returns:
+            The current builder instance for method chaining.
+        """
+        when_args: dict[str, Any] = {"matched": False, "source": True, "then": exp.Delete()}
+
+        if condition:
+            condition_expr: exp.Expression
+            if isinstance(condition, str):
+                parsed_cond: Optional[exp.Expression] = exp.maybe_parse(
+                    condition, dialect=getattr(self, "dialect", None)
+                )
+                if not parsed_cond:
+                    msg = f"Could not parse WHEN clause condition: {condition}"
+                    raise SQLBuilderError(msg)
+                condition_expr = parsed_cond
+            elif isinstance(condition, exp.Expression):
+                condition_expr = condition
+            else:
+                msg = f"Unsupported condition type for WHEN clause: {type(condition)}"
+                raise SQLBuilderError(msg)
+            when_args["this"] = condition_expr
+
+        when_clause = exp.When(**when_args)
+        self._add_when_clause(when_clause)  # type: ignore[attr-defined]
+        return self