Added multi-table-syntax UPDATE / DELETE (UPDATE alias SET ... FROM table AS alias, DELETE FROM alias FROM table AS alias) — the EF7+ ExecuteUpdate / ExecuteDelete emission shape. Single-source-only; joined-source FROM clauses raise NotSupportedException.

Author: RyanLamansky

CLAUDE.md

@@ -18,7 +18,7 @@ Priority is opportunistic: each bundle picks the lowest-effort path that unlocks
 
 Standing pattern for non-trivial SQL feature work:
 
-1. **Probe.** Behavior questions get answered against a real SQL Server 2025 instance, not from memory or docs. Connection details for the user's reference instance live in user memory under "Real SQL Server reference instance."
+1. **Probe.** Behavior questions get answered against a real SQL Server 2025 instance, not from memory or docs. Connection details for the user's reference instance live in user memory under "Real SQL Server reference instance." Probe scaffolds — both raw SqlClient probes and EF Core emission probes — live in `/tmp/<probe-name>/` console projects and get deleted after the bundle. The git workspace stays free of probe scratch; only graduated regression tests land in `*.Tests` / `*.Tests.EFCore`.
 2. **Surface decisions.** Before writing code, surface 2–3 concrete design choices and recommend one each. The user is decisive at choice points.
 3. **Implement + test.** Tests in `*.Tests` exercise the public API path; `*.Tests.EFCore` validates the oracle. Use `*.Tests.Internal` only for things genuinely unreachable from public SQL.
 4. **Update CLAUDE.md.** Move bullets between "What's modeled" / "Not modeled" / "Quirks" as scope changes.
@@ -188,7 +188,8 @@ Per-type keyword compatibility mirrors SQL Server (verified against Kardax7 2026
 - `PRIMARY KEY` / `UNIQUE`: linear scan (O(N) per insert); no B-tree backing.
 
 ### UPDATE / DELETE
-- `UPDATE table SET col = expr [, col = expr]* [WHERE pred]` and `DELETE [FROM] table [WHERE pred]`. Single-table only.
+- `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-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).
@@ -250,7 +251,7 @@ Type-metadata accessors (`GetDataTypeName` / `GetFieldType`) read from `Simulate
 - Cross-category `Promote` for integer ↔ string. Only CAST works that pair.
 - `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.
-- Multi-table UPDATE / DELETE (`UPDATE alias SET ... FROM table AS alias`, `DELETE alias FROM ...`). EF7+ `ExecuteUpdate` / `ExecuteDelete` emit these and won't work without the bundle.
+- 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 9 emits N semicolon-separated `UPDATE … OUTPUT INSERTED.[RowVersion] WHERE [Id] = @p AND [RowVersion] = @p` statements for batched updates (verified 2026-05-07, real SQL Server 2025) — *not* MERGE WHEN MATCHED — so EF SaveChanges fidelity already works without WHEN MATCHED. WHEN MATCHED is still legitimate SQL Server surface (hand-written MERGE, future trigger model) but isn't the EF unlock the older roadmap framed it as. Triggers, when added, will reuse the same INSERTED/DELETED projection model already wired here.
 - 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.EFCore/EFCoreAggregates.cs

@@ -112,4 +112,41 @@ public void Aggregate_OnEmptyFilteredSet()
         using var context = SeededContext();
         Assert.AreEqual(0, context.Filters.Where(f => f.A > 999).Sum(f => f.A));
     }
+
+    [TestMethod]
+    public void GroupBy_MultipleAggregatesPerGroup()
+    {
+        // GroupBy producing multiple aggregates per key in one projection.
+        // Verifies the simulator emits all three aggregates from a single
+        // grouped scan rather than re-issuing per-aggregate.
+        var simulation = TestDbContext.CreateCustomersSimulation();
+        using (var seed = new TestDbContext(simulation))
+        {
+            seed.CustomerOrders.AddRange(
+                new CustomerOrder { CustomerId = 1, Amount = 10 },
+                new CustomerOrder { CustomerId = 1, Amount = 20 },
+                new CustomerOrder { CustomerId = 2, Amount = 30 },
+                new CustomerOrder { CustomerId = 2, Amount = 40 });
+            _ = seed.SaveChanges();
+        }
+
+        using var context = new TestDbContext(simulation);
+        var summary = context.CustomerOrders
+            .GroupBy(o => o.CustomerId)
+            .Select(g => new
+            {
+                CustomerId = g.Key,
+                Total = g.Sum(o => o.Amount),
+                Count = g.Count(),
+                Max = g.Max(o => o.Amount),
+            })
+            .OrderBy(x => x.CustomerId)
+            .ToList();
+
+        Assert.HasCount(2, summary);
+        Assert.AreEqual(30m, summary[0].Total);
+        Assert.AreEqual(2, summary[0].Count);
+        Assert.AreEqual(20m, summary[0].Max);
+        Assert.AreEqual(70m, summary[1].Total);
+    }
 }

SqlServerSimulator.Tests.EFCore/EFCoreDecimal.cs

@@ -86,4 +86,17 @@ public void OrderBy_DecimalAscending()
         var ordered = context.Products.OrderBy(p => p.Price).Select(p => p.Price).ToArray();
         CollectionAssert.AreEqual(new[] { 9.99m, 19.99m, 29.99m }, ordered);
     }
+
+    [TestMethod]
+    public void Cast_DecimalToDouble_ProjectsAsFloat()
+    {
+        // (double)decimalCol — EF Core emits CAST(... AS float). Common when
+        // Math functions or aggregations need a wider numeric type.
+        using var context = new TestDbContext(TestDbContext.CreateProductsSimulation());
+        _ = context.Products.Add(new Product { Id = 1, Price = 19.99m });
+        _ = context.SaveChanges();
+
+        var asDouble = context.Products.Select(p => (double)p.Price).Single();
+        Assert.AreEqual(19.99, asDouble, 0.001);
+    }
 }

SqlServerSimulator.Tests.EFCore/EFCoreStrings.cs

@@ -298,4 +298,18 @@ public void Insert_MultipleRows_RoundTripsBothColumns()
         CollectionAssert.AreEquivalent(new[] { "Alice", "Bob", "Carol" }, names);
         CollectionAssert.AreEquivalent(new[] { "A", "B", null }, codes);
     }
+
+    [TestMethod]
+    public void StringFunction_IndexOf()
+    {
+        // EF Core translates .IndexOf to CHARINDEX-1 (CHARINDEX is 1-based,
+        // .NET's IndexOf is 0-based; -1 conversion happens server-side).
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "hello world" });
+        _ = context.SaveChanges();
+
+        using var fresh = new TestDbContext(context.Simulation);
+        var index = fresh.People.Select(p => p.Name.IndexOf("world", StringComparison.Ordinal)).Single();
+        Assert.AreEqual(6, index);
+    }
 }

SqlServerSimulator.Tests.EFCore/EFCoreUpdateDelete.cs

@@ -4,12 +4,12 @@ namespace SqlServerSimulator;
 
 /// <summary>
 /// End-to-end tests for the UPDATE / DELETE shapes EF Core's SqlServer
-/// provider emits during <c>SaveChanges</c> on modified or removed
-/// entities. Without this bundle the simulator couldn't faithfully stand
-/// in for any real EF Core app — the canonical "load, modify, save"
-/// flow ended at SaveChanges. Concurrency tokens (rowversion + UPDATE
-/// OUTPUT) and the EF7+ bulk operations (ExecuteUpdate / ExecuteDelete)
-/// are both deferred to follow-up bundles; see CLAUDE.md.
+/// provider emits — both the change-tracker-driven <c>SaveChanges</c>
+/// path (single-row UPDATE / DELETE per modified entity, batched as
+/// semicolon-separated statements) and the EF7+ bulk
+/// <c>ExecuteUpdate</c> / <c>ExecuteDelete</c> path (multi-table-syntax
+/// <c>UPDATE [a] SET ... FROM [t] AS [a]</c> / <c>DELETE [a] FROM [t] AS [a]</c>).
+/// Optimistic concurrency via <c>[Timestamp]</c> rides through both paths.
 /// </summary>
 [TestClass]
 public class EFCoreUpdateDelete
@@ -163,6 +163,51 @@ public void SaveChanges_ModifyMultipleTimestampedEntities_BatchedUpdatesWithRowV
         CollectionAssert.AreEqual(new[] { "a!", "b!", "c!" }, names);
     }
 
+    [TestMethod]
+    public void ExecuteUpdate_BulkUpdate_EmitsMultiTableSyntax()
+    {
+        // EF7+ ExecuteUpdate emits a multi-table-syntax UPDATE
+        //   UPDATE [a] SET [a].[col] = ... FROM [t] AS [a] WHERE ...
+        // (probed against real SQL Server 2025, 2026-05-07). The simulator's
+        // parser accepts the alias-form leading identifier and the trailing
+        // `FROM <table> AS <alias>` clause; runtime column-resolvers use
+        // name.Leaf so alias-qualified column refs resolve to the target.
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        context.People.AddRange(
+            new Person { Id = 1, Name = "alice", Code = "A" },
+            new Person { Id = 2, Name = "bob", Code = "B" },
+            new Person { Id = 3, Name = "carol", Code = "C" });
+        _ = context.SaveChanges();
+
+        var rows = context.People.Where(p => p.Code == "A" || p.Code == "B")
+            .ExecuteUpdate(setters => setters.SetProperty(p => p.Name, p => p.Name.ToUpper()));
+
+        Assert.AreEqual(2, rows);
+        using var fresh = new TestDbContext(context.Simulation);
+        var names = fresh.People.OrderBy(p => p.Id).Select(p => p.Name).ToArray();
+        CollectionAssert.AreEqual(new[] { "ALICE", "BOB", "carol" }, names);
+    }
+
+    [TestMethod]
+    public void ExecuteDelete_BulkDelete_EmitsMultiTableSyntax()
+    {
+        // EF7+ ExecuteDelete emits
+        //   DELETE FROM [a] FROM [t] AS [a] WHERE ...
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        context.People.AddRange(
+            new Person { Id = 1, Name = "alice", Code = "A" },
+            new Person { Id = 2, Name = "bob", Code = "B" },
+            new Person { Id = 3, Name = "carol", Code = "C" });
+        _ = context.SaveChanges();
+
+        var rows = context.People.Where(p => p.Code == "B").ExecuteDelete();
+
+        Assert.AreEqual(1, rows);
+        using var fresh = new TestDbContext(context.Simulation);
+        var names = fresh.People.OrderBy(p => p.Id).Select(p => p.Name).ToArray();
+        CollectionAssert.AreEqual(new[] { "alice", "carol" }, names);
+    }
+
     [TestMethod]
     public void SaveChanges_TimestampEntity_ReadsBackAutoBumpedRowVersion()
     {

SqlServerSimulator.Tests/DeleteTests.cs

@@ -171,4 +171,52 @@ public void Delete_PrimaryKeyTable_AllowsReinsertAfterDelete()
         var values = ReadInts(simulation.CreateCommand("select v from t"));
         CollectionAssert.AreEqual(new[] { 20 }, values);
     }
+
+    // === Multi-table-syntax DELETE (EF7+ ExecuteDelete emission) ===
+
+    [TestMethod]
+    public void Delete_MultiTableSyntax_AcceptsAliasFormWithFromClause()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (1), (2), (3)");
+
+        var rows = simulation.ExecuteNonQuery(
+            "delete from [a] from t as [a] where [a].[id] = 2");
+        AreEqual(1, rows);
+
+        var ids = ReadInts(simulation.CreateCommand("select id from t order by id"));
+        CollectionAssert.AreEqual(new[] { 1, 3 }, ids);
+    }
+
+    [TestMethod]
+    public void Delete_MultiTableSyntax_NoWhereClause_DeletesAllRows()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+        _ = simulation.ExecuteNonQuery("insert into t values (1), (2), (3)");
+
+        var rows = simulation.ExecuteNonQuery("delete from [a] from t as [a]");
+        AreEqual(3, rows);
+    }
+
+    [TestMethod]
+    public void Delete_MultiTableSyntax_AliasUnknownAndNoFromClause_RaisesInvalidObject()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("delete from [unknown]"));
+        Contains("Invalid object name", ex.Message);
+    }
+
+    [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]");
+        });
 }

SqlServerSimulator.Tests/UpdateTests.cs

@@ -390,4 +390,55 @@ public void Update_ThenSelect_SeesNewState()
         names = ReadStrings(simulation.CreateCommand("select name from t"));
         CollectionAssert.AreEqual(new[] { "newer" }, names);
     }
+
+    // === Multi-table-syntax UPDATE (EF7+ ExecuteUpdate emission) ===
+
+    [TestMethod]
+    public void Update_MultiTableSyntax_AcceptsAliasFormWithFromClause()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int, name varchar(30))");
+        _ = simulation.ExecuteNonQuery("insert into t values (1, 'a'), (2, 'b'), (3, 'c')");
+
+        var rows = simulation.ExecuteNonQuery(
+            "update [a] set [a].[name] = upper([a].[name]) from t as [a] where [a].[id] = 2");
+        AreEqual(1, rows);
+
+        var names = ReadStrings(simulation.CreateCommand("select name from t order by id"));
+        CollectionAssert.AreEqual(new[] { "a", "B", "c" }, names);
+    }
+
+    [TestMethod]
+    public void Update_MultiTableSyntax_NoWhereClause_UpdatesAllRows()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int, name varchar(30))");
+        _ = simulation.ExecuteNonQuery("insert into t values (1, 'a'), (2, 'b')");
+
+        var rows = simulation.ExecuteNonQuery("update [a] set [a].[name] = 'X' from t as [a]");
+        AreEqual(2, rows);
+
+        var names = ReadStrings(simulation.CreateCommand("select name from t order by id"));
+        CollectionAssert.AreEqual(new[] { "X", "X" }, names);
+    }
+
+    [TestMethod]
+    public void Update_MultiTableSyntax_AliasUnknownAndNoFromClause_RaisesInvalidObject()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("create table t (id int)");
+
+        var ex = Throws<DbException>(() => simulation.ExecuteNonQuery("update [unknown] set [unknown].[id] = 1"));
+        Contains("Invalid object name", ex.Message);
+    }
+
+    [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]");
+        });
 }

SqlServerSimulator/Parser/ParserContext.cs

@@ -200,6 +200,24 @@ public void MoveNextRequired()
             throw SimulatedSqlException.SyntaxErrorNear(previous);
     }
 
+    /// <summary>
+    /// Advances <see cref="Token"/> to the next token, throwing an exception
+    /// if the end was reached or if the new token isn't of type
+    /// <typeparamref name="T"/>. Use when the caller needs the type assertion
+    /// but not the token value — pairs with <see cref="GetNextRequired{T}"/>
+    /// the same way <see cref="MoveNextRequired"/> pairs with
+    /// <see cref="GetNextRequired"/>.
+    /// </summary>
+    /// <typeparam name="T">The expected type of the new token.</typeparam>
+    /// <exception cref="SimulatedSqlException">Incorrect syntax near '{token}'.</exception>
+    public void MoveNextRequired<T>()
+        where T : Token
+    {
+        var previous = this.Token;
+        if (!MoveNext() || this.Token is not T)
+            throw SimulatedSqlException.SyntaxErrorNear(previous);
+    }
+
     /// <summary>
     /// Updates <see cref="Token"/> with the next usable token in <see cref="commandText"/>.
     /// </summary>