Joined-source UPDATE / DELETE FROM: extends the EF7+ ExecuteUpdate / ExecuteDelete path to support multi-source FROM clauses with INNER/LEFT/CROSS JOIN and CROSS/OUTER APPLY by reusing the SELECT-side join driver. Target source is identified by matching the leading identifier against each FromSource.Qualifier (Msg 208 if unbound); each unique target row is processed exactly once — heap (page, slot) is recovered via a byte[]→address side-channel map populated by a wrapper around the target source's row enumerator. Selection.ParseSourcesAndJoins / FindSourceColumn / EnumerateJoinedRows promoted to internal. OUTPUT in alias-form multi-source raises NotSupportedException (EF Core 10 doesn't combine those).

Author: RyanLamansky

CLAUDE.md

@@ -254,7 +254,8 @@ Identity counters and the database-scoped rowversion counter bypass the log —
 
 ### UPDATE / DELETE
 - `UPDATE table SET col = expr [, col = expr]* [WHERE pred]` and `DELETE [FROM] table [WHERE pred]`.
-- Multi-table-syntax form (`UPDATE alias SET alias.col = expr FROM table AS alias [WHERE pred]`, `DELETE FROM alias FROM table AS alias [WHERE pred]`) is the EF7+ `ExecuteUpdate` / `ExecuteDelete` shape. Single-source-only — additional sources or joins on the FROM clause raise `NotSupportedException`. Two-pass parsing: collect raw `(columnName, expr)` pairs without resolving ordinals, then bind to the FROM-clause table once known. SET LHS supports both bare `col = expr` and alias-qualified `[a].[col] = expr`; the alias prefix is accepted verbatim and not cross-checked against the FROM-clause's alias since the simulator's row resolvers use `name.Leaf` (the alias is moot for single-source). OUTPUT is only supported on the single-table form (EF doesn't combine OUTPUT with multi-table-syntax) — see `Simulation.Update.cs` / `Simulation.Delete.cs` for the deferred-table-binding pattern.
+- Multi-table-syntax form (`UPDATE alias SET alias.col = expr FROM <sources> [WHERE pred]`, `DELETE FROM alias FROM <sources> [WHERE pred]`) is the EF7+ `ExecuteUpdate` / `ExecuteDelete` shape. Both single-source (`FROM table AS alias`) and joined-source forms (`FROM t AS alias INNER|LEFT|CROSS JOIN u AS b ON ...`, plus `CROSS APPLY` / `OUTER APPLY`) are supported by routing through the SELECT-side `Selection.ParseSourcesAndJoins` + `Selection.EnumerateJoinedRows` machinery. The target source is identified by matching the leading-identifier (alias OR table name) against each source's `FromSource.Qualifier`; missing match → **Msg 208** `"Invalid object name 'X'."` (probe-confirmed against SQL Server 2025; distinct from Msg 4104's multi-part-identifier wording). Two-pass parsing: collect raw `(columnName, expr)` pairs without resolving ordinals, then bind to the target table once known. SET LHS supports both bare `col = expr` and alias-qualified `[a].[col] = expr`; the alias prefix is accepted verbatim. SET RHS can reference any source's columns, qualified or not — resolution goes through `Selection.FindSourceColumn` against the multi-source list.
+- **Joined UPDATE / DELETE: each unique target row processed exactly once.** When the same target row matches multiple join tuples (e.g. a customer with two qualifying orders), SQL Server applies the SET / DELETE once per unique target — using the *first* matching tuple's RHS values for SET (heap-scan order, probe-confirmed). The simulator dedupes by `(page, slot)` of the target heap row, recovered via a side-channel byte[]→address map. A wrapper around the target source's `Rows` enumerator records each yielded byte[]'s address into the map as the join driver consumes it; the dedup lookup is reference-equality fast and works whether the target is on the outer or inner side of a join (for inner-side targets, the wrapper repopulates the map on each restart, since the simulator's heap row enumerators allocate fresh byte[] per yield). LEFT JOIN with no right-side match still surfaces the target tuple (probe C); RHS sees NULL for the unmatched-source columns. OUTPUT clause is supported only when the leading identifier resolves to a real table name up-front; OUTPUT alongside an alias-form multi-source UPDATE / DELETE raises `NotSupportedException` (EF Core 10 doesn't combine those, and supporting it would require deferring OUTPUT parsing past the FROM-target binding).
 - **Multi-column SET evaluates RHS against the pre-update row snapshot** — verified: `UPDATE t SET a = 100, b = a + 1` over `(a=10, b=20)` produces `(a=100, b=11)` (b read pre-update a). Scalar subquery RHS sees the pre-update table state.
 - Identity-column update → **Msg 8102** `"Cannot update identity column 'X'."`. Computed-column update → Msg 271 (existing factory). Rowversion update → **Msg 272** `"Cannot update a timestamp column."`.
 - Per-row constraint re-validation: NOT NULL → **Msg 515** with `"UPDATE fails."` verb; CHECK → **Msg 547** with `"UPDATE statement"` verb. PK / UNIQUE → Msg 2627 (same wording as INSERT — verbatim SQL Server quirk: "Cannot insert duplicate key" wording even on UPDATE).
@@ -314,7 +315,6 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121` for date-like → string. Other styles raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date parsing not modeled.
 - `LEN(ntext)` raising Msg 8116 (function-level text/ntext/image restrictions); legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.
 - `OUTPUT INTO @table_var`, `OUTPUT DELETED.*` / `INSERTED.*` star expansion. Per-column `OUTPUT INSERTED.<col>` / `OUTPUT DELETED.<col>` *is* supported (UPDATE / DELETE both); only the star-expansion form is missing. `OUTPUT INTO` (sending the projection to a table variable rather than the result set) isn't.
-- Joined-source UPDATE / DELETE FROM clauses (`UPDATE a SET ... FROM t AS a JOIN u AS b ON ...`). The single-source alias form (`UPDATE a SET ... FROM t AS a [WHERE ...]`, `DELETE FROM a FROM t AS a [WHERE ...]`) IS supported — that's what EF7+ `ExecuteUpdate` / `ExecuteDelete` emit, verified against real SQL Server 2025. Adding sources beyond the single aliased target raises `NotSupportedException` so the gap is visible.
 - MERGE source subqueries; MERGE target column refs in `ON`; `WHEN MATCHED` UPDATE/DELETE branches; `$action`. EF Core's batched-update path emits semicolon-separated `UPDATE … OUTPUT …` statements rather than `MERGE WHEN MATCHED`, so SaveChanges fidelity doesn't require it.
 - Msg 8141 (inline CHECK referencing a peer column — SQL Server rejects at CREATE TABLE; simulator allows).
 - Msg 8133 (CASE where every branch is bare `NULL`; simulator returns NULL of `int`).

SqlServerSimulator.Tests/DeleteTests.cs

@@ -211,12 +211,70 @@ public void Delete_MultiTableSyntax_AliasUnknownAndNoFromClause_RaisesInvalidObj
     }
 
     [TestMethod]
-    public void Delete_MultiTableSyntax_JoinedFromClause_RaisesNotSupported() =>
-        ThrowsExactly<NotSupportedException>(() =>
-        {
-            var simulation = new Simulation();
-            _ = simulation.ExecuteNonQuery("create table t (id int)");
-            _ = simulation.ExecuteNonQuery("create table u (id int)");
-            _ = simulation.ExecuteNonQuery("delete [a] from t as [a] inner join u as [b] on [a].[id] = [b].[id]");
-        });
+    public void Delete_MultiTableSyntax_JoinedFromClause_DeletesEachTargetOnce()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, total decimal(10, 2))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'A'), (2, 'B'), (3, 'C')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 50), (11, 1, 200), (12, 2, 150), (13, 2, 250)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "delete c from customers c inner join orders o on o.customerId = c.id where o.total > 100");
+        AreEqual(2, rows);
+
+        var statuses = new List<string>();
+        using (var reader = simulation.CreateCommand("select status from customers order by id").ExecuteReader())
+            while (reader.Read()) statuses.Add(reader.GetString(0));
+        CollectionAssert.AreEqual(new[] { "C" }, statuses);
+    }
+
+    [TestMethod]
+    public void Delete_JoinedFromClause_DeleteFromAliasSyntax_AlsoWorks()
+    {
+        // DELETE FROM <alias> FROM ... JOIN ... — the form with the extra
+        // FROM keyword. SQL Server accepts both DELETE alias and DELETE FROM
+        // alias; EF Core 10's ExecuteDelete emits the DELETE alias form.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, total decimal(10, 2))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'A'), (2, 'B')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 200)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "delete from c from customers c inner join orders o on o.customerId = c.id where o.total > 100");
+        AreEqual(1, rows);
+    }
+
+    [TestMethod]
+    public void Delete_JoinedFromClause_AliasNotInFrom_RaisesMsg208()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+        _ = simulation.ExecuteNonQuery("create table u (id int)");
+        var ex = Throws<DbException>(() =>
+            _ = simulation.ExecuteNonQuery("delete [x] from t as [a] inner join u as [b] on [a].[id] = [b].[id]"));
+        Contains("Invalid object name", ex.Message);
+    }
+
+    [TestMethod]
+    public void Delete_JoinedFromClause_TargetOnRightSide_DeletesFromTarget()
+    {
+        // Target alias on the right side of the join (delete orders, not
+        // customers). Probe O from the design probe.
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, total decimal(10, 2))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'X')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 50), (11, 1, 200)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "delete o from customers c inner join orders o on o.customerId = c.id where o.total > 100");
+        AreEqual(1, rows);
+
+        var totals = new List<decimal>();
+        using var reader = simulation.CreateCommand("select total from orders order by id").ExecuteReader();
+        while (reader.Read()) totals.Add(reader.GetDecimal(0));
+        CollectionAssert.AreEqual(new[] { 50m }, totals);
+    }
 }

SqlServerSimulator.Tests/UpdateTests.cs

@@ -433,12 +433,72 @@ public void Update_MultiTableSyntax_AliasUnknownAndNoFromClause_RaisesInvalidObj
     }
 
     [TestMethod]
-    public void Update_MultiTableSyntax_JoinedFromClause_RaisesNotSupported() =>
-        ThrowsExactly<NotSupportedException>(() =>
-        {
-            var simulation = new Simulation();
-            _ = simulation.ExecuteNonQuery("create table t (id int)");
-            _ = simulation.ExecuteNonQuery("create table u (id int)");
-            _ = simulation.ExecuteNonQuery("update [a] set [a].[id] = 1 from t as [a] inner join u as [b] on [a].[id] = [b].[id]");
-        });
+    public void Update_MultiTableSyntax_JoinedFromClause_UpdatesEachTargetOnce()
+    {
+        // Joined-source UPDATE: target rows that match the join exactly once
+        // are updated; targets that match multiple join rows are still
+        // updated exactly once (probe-confirmed against SQL Server 2025).
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, total decimal(10, 2))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'New'), (2, 'New'), (3, 'New')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 50), (11, 1, 200), (12, 2, 150), (13, 2, 250)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "update c set c.status = 'Active' from customers c inner join orders o on o.customerId = c.id where o.total > 100");
+        AreEqual(2, rows);
+
+        var statuses = ReadStrings(simulation.CreateCommand("select status from customers order by id"));
+        CollectionAssert.AreEqual(new[] { "Active", "Active", "New" }, statuses);
+    }
+
+    [TestMethod]
+    public void Update_JoinedFromClause_AliasNotInFrom_RaisesMsg208()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+        _ = simulation.ExecuteNonQuery("create table u (id int)");
+        var ex = Throws<DbException>(() =>
+            _ = simulation.ExecuteNonQuery("update [x] set [x].[id] = 1 from t as [a] inner join u as [b] on [a].[id] = [b].[id]"));
+        Contains("Invalid object name", ex.Message);
+    }
+
+    [TestMethod]
+    public void Update_JoinedFromClause_LeftJoinNullRight_StillUpdatesTarget()
+    {
+        // LEFT JOIN with no right match: target rows still update; SET RHS
+        // sees NULL for the right-side columns (probe D from the design probe).
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, total decimal(10, 2))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'New'), (2, 'New')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 50)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "update c set c.status = 'Touched' from customers c left join orders o on o.customerId = c.id and o.total > 1000");
+        AreEqual(2, rows);
+
+        var statuses = ReadStrings(simulation.CreateCommand("select status from customers order by id"));
+        CollectionAssert.AreEqual(new[] { "Touched", "Touched" }, statuses);
+    }
+
+    [TestMethod]
+    public void Update_JoinedFromClause_SetRhsFromOtherSource_UsesFirstMatch()
+    {
+        // Multi-match SET RHS: when a target row matches multiple join rows,
+        // the SET RHS uses the FIRST matching row's value (heap-scan order —
+        // probe B's nondeterminism, deterministic in heap-scan order).
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table customers (id int primary key, status varchar(20))");
+        _ = simulation.ExecuteNonQuery("create table orders (id int primary key, customerId int, code varchar(10))");
+        _ = simulation.ExecuteNonQuery("insert customers values (1, 'New')");
+        _ = simulation.ExecuteNonQuery("insert orders values (10, 1, 'A'), (11, 1, 'B')");
+
+        var rows = simulation.ExecuteNonQuery(
+            "update c set c.status = o.code from customers c inner join orders o on o.customerId = c.id");
+        AreEqual(1, rows);
+
+        var statuses = ReadStrings(simulation.CreateCommand("select status from customers"));
+        CollectionAssert.AreEqual(new[] { "A" }, statuses);
+    }
 }

SqlServerSimulator/Parser/FromSource.cs

@@ -33,7 +33,8 @@ internal sealed class FromSource(
     int[]? storageOrdinals,
     Heap? lobStore,
     IEnumerable<byte[]> rows,
-    Selection? lateralPlan = null)
+    Selection? lateralPlan = null,
+    HeapTable? backingTable = null)
 {
     public readonly string? Qualifier = qualifier;
     public readonly string[] ColumnNames = columnNames;
@@ -43,6 +44,15 @@ internal sealed class FromSource(
     public readonly Heap? LobStore = lobStore;
     public readonly IEnumerable<byte[]> Rows = rows;
 
+    /// <summary>
+    /// Back-reference to the <see cref="HeapTable"/> when this source is a
+    /// table (or system table); null for derived-table sources. Used by the
+    /// UPDATE / DELETE mutation paths to reach the table's
+    /// <see cref="HeapTable.KeyConstraints"/> / <see cref="HeapTable.Name"/>
+    /// after FROM parsing has identified which source is the mutation target.
+    /// </summary>
+    public readonly HeapTable? BackingTable = backingTable;
+
     /// <summary>
     /// When non-null, this source is the right side of a <c>CROSS APPLY</c>
     /// or <c>OUTER APPLY</c>. <see cref="Rows"/> is unused; the join driver

SqlServerSimulator/Parser/Selection.Execution.Joins.cs

@@ -46,7 +46,7 @@ private static SqlValue ResolveAcrossTuple(
     /// finish reading each tuple (typically by projecting / encoding the
     /// row) before advancing the enumerator.
     /// </summary>
-    private static IEnumerable<byte[]?[]> EnumerateJoinedRows(
+    internal static IEnumerable<byte[]?[]> EnumerateJoinedRows(
         FromSource[] sources,
         JoinSpec[] joins,
         Func<MultiPartName, SqlValue>? outerResolver)

SqlServerSimulator/Parser/Selection.Execution.cs

@@ -26,7 +26,7 @@ internal sealed partial class Selection
     /// <c>(-1, -1)</c> when no source resolves the name — the caller then
     /// falls through to the outer scope.
     /// </summary>
-    private static (int SourceIndex, int ColumnIndex) FindSourceColumn(FromSource[] sources, MultiPartName name)
+    internal static (int SourceIndex, int ColumnIndex) FindSourceColumn(FromSource[] sources, MultiPartName name)
     {
         if (name.ImmediateQualifier is { } qualifier)
         {

SqlServerSimulator/Parser/Selection.cs

@@ -422,6 +422,29 @@ private static void ParseFromSourceAndJoins(
         FromClause fromClause,
         Func<MultiPartName, SqlType>? outerTypeResolver,
         bool allowOrderBy)
+    {
+        ParseSourcesAndJoins(context, depth, sources, joins, outerTypeResolver);
+
+        // Now register the multi-source type resolver and parse WHERE / etc.
+        ConsumeWhereOrderByWithOuterScope(context, fromClause, [.. sources], outerTypeResolver, allowOrderBy);
+    }
+
+    /// <summary>
+    /// Pure source-and-joins parser, separable from WHERE / ORDER BY
+    /// consumption. Used by both <see cref="ParseFromSourceAndJoins"/> (which
+    /// adds WHERE consumption on top) and the UPDATE / DELETE mutation paths
+    /// (which handle WHERE separately because the leading-identifier target
+    /// binding has to happen first). Enters with the cursor on the
+    /// <c>FROM</c> keyword (or, in mutation context, on the FROM keyword
+    /// position); leaves the cursor at the lookahead-after-last-source token
+    /// (typically WHERE, end-of-statement, or set-op chain).
+    /// </summary>
+    internal static void ParseSourcesAndJoins(
+        ParserContext context,
+        uint depth,
+        List<FromSource> sources,
+        List<JoinSpec> joins,
+        Func<MultiPartName, SqlType>? outerTypeResolver)
     {
         sources.Add(ParseSingleFromSource(context, depth, outerTypeResolver));
 
@@ -461,9 +484,6 @@ private static void ParseFromSourceAndJoins(
             }
             joins.Add(new JoinSpec(kind, on));
         }
-
-        // Now register the multi-source type resolver and parse WHERE / etc.
-        ConsumeWhereOrderByWithOuterScope(context, fromClause, [.. sources], outerTypeResolver, allowOrderBy);
     }
 
     /// <summary>
@@ -546,7 +566,8 @@ private static FromSource ParseSingleFromSource(ParserContext context, uint dept
                     storedSchema: heapTable.StoredColumns,
                     storageOrdinals: heapTable.StorageOrdinals,
                     lobStore: heapTable.Heap,
-                    rows: heapTable.Rows);
+                    rows: heapTable.Rows,
+                    backingTable: heapTable);
 
             case Operator { Character: '(' }:
                 if (context.GetNextRequired() is not ReservedKeyword { Keyword: Keyword.Select })