Non-recursive CTE prefix: WITH name [(cols)] AS (SELECT …) [, …] {SELECT|INSERT|UPDATE|DELETE|MERGE} …. ParseCteBindings runs at the statement-loop top, populating ParserContext.CteBindings (cleared on the next iteration); body parses at depth 1 because of the surrounding parens. ParseSingleFromSource consults the bindings before HeapTables — CTE name shadows a real table for the prefixed statement; each FROM-side reference re-runs the inner Selection via the existing LateralPlan slot. Multiple comma-separated CTEs cascade. Recursive CTE detection via a null-Plan sentinel registered before body parse — self-reference raises NotSupportedException. Errors: Msg 239 duplicate name, Msg 8158/8159 rename-list count mismatch, Msg 1033 ORDER BY without TOP/OFFSET (gated via a new Selection.HasTopOrOffsetOrFetch field threaded through all four ctor sites).

Author: RyanLamansky

CLAUDE.md

@@ -339,6 +339,21 @@ Three entry points share one per-connection undo log: implicit (statement-level
 ### `rowversion` (legacy synonym `timestamp`)
 8-byte big-endian database-scoped monotonic counter; `Simulation.AllocateRowVersion` advances on every INSERT into a rowversion-bearing table and every UPDATE that affects a row in one. Storage type name surfaces as `timestamp` in `information_schema` regardless of declaration keyword. Explicit insert → Msg 273; explicit update → Msg 272; second column on a table → Msg 2738. Outbound CAST: `varbinary(N)` / `binary(N)` copy the 8 bytes; `bigint` reads big-endian. `Promote(RowVersion, Varbinary)` → `Varbinary` so EF Core's `WHERE [rv] = @originalRv` optimistic-concurrency parameter works directly. `EF Core [Timestamp]` SaveChanges round-trips end-to-end via `UPDATE ... OUTPUT INSERTED.[RowVersion] WHERE [Id] = @p AND [RowVersion] = @originalRv`.
 
+### Common table expressions (non-recursive)
+`WITH name [(col, …)] AS (SELECT …) [, …] {SELECT|INSERT|UPDATE|DELETE|MERGE} …`. The WITH prefix scopes to exactly one immediately-following statement; the binding is gone after that statement runs. Probe-confirmed against SQL Server 2025 on 2026-05-10.
+
+`Simulation.ParseCteBindings` runs at the statement-loop top before dispatch, populating `ParserContext.CteBindings` (a `Dictionary<string, CteBinding>`). Each binding's body parses at `depth: 1` because the `(SELECT …)` brackets it; cleared at the top of the next iteration. `ParseSingleFromSource` consults the bindings before falling through to `Simulation.HeapTables` — a CTE name shadows a real table for the prefixed statement (probe-confirmed). Resolution builds a `FromSource` with `lateralPlan: cteBinding.Plan`, so each FROM-side reference re-runs the inner Selection (parallel to derived tables in FROM). Multiple comma-separated CTEs cascade: later ones see earlier ones because the prior bindings are already in the dictionary when the later body is parsed.
+
+**Recursive CTEs aren't modeled.** Self-reference is detected via a sentinel: `ParseCteBindings` registers a `CteBinding` with `Plan = null` *before* parsing the body, so a body's `FROM cte_name` resolves to the sentinel and `ParseSingleFromSource` raises `NotSupportedException("Recursive common table expressions are not modeled.")`. The non-recursive sibling replaces the sentinel with the resolved plan once the body finishes parsing.
+
+**Errors modeled:** **Msg 239** duplicate CTE name (`"Duplicate common table expression name 'a' was specified."`); **Msg 8158** rename list has fewer columns than body projection (`"'name' has more columns than were specified in the column list."`); **Msg 8159** rename list has more columns than body projection (`"'name' has fewer columns than were specified in the column list."`); **Msg 1033** ORDER BY in CTE body without TOP / OFFSET / FETCH (`"The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified."`).
+
+The Msg 1033 enforcement requires knowing whether the body's plan has a TOP / OFFSET / FETCH at any layer — added a new `Selection.HasTopOrOffsetOrFetch` field threaded through all four `new Selection(...)` call sites (`BuildSynthesizedSqlRow` / `BuildSqlProjection` / `CombineSetOps` / `ApplyTopLevelOrderBy`). The set-op combiner inherits from its branches; the top-level ORDER-BY wrapper inherits from the inner plan plus its own OFFSET / FETCH counts. Derived tables face the same SQL Server rule but the simulator currently allows ORDER BY without TOP / OFFSET there — pre-existing divergence orthogonal to this bundle.
+
+**Msg 319** (WITH after a non-terminated previous statement) isn't enforced. The simulator's statement loop consumes one statement per iteration and naturally treats WITH at iteration top as a fresh prefix regardless of prior `;` — more permissive than real SQL Server. Apps that idiomatically terminate statements (or use a single statement) won't notice.
+
+EF Core 10 emits non-recursive CTEs in some shapes (TPC inheritance, certain `Distinct/OrderBy/Skip` patterns); also reachable from raw SQL (`FromSqlInterpolated` / direct command text) including the `WITH … INSERT … SELECT` shape.
+
 ### INSERT … SELECT
 `INSERT [INTO] target [(cols)] SELECT …` accepts the same Selection grammar as a top-level SELECT — WHERE / JOIN / GROUP BY / aggregates / ORDER BY / TOP / OFFSET-FETCH / UNION / INTERSECT / EXCEPT all work on the source side. Probe-confirmed against SQL Server 2025 on 2026-05-10.
 
@@ -375,6 +390,7 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - `UNION` / `UNION ALL` inside a subquery body.
 - Row-constructor `IN ((1,2), (3,4))`.
 - Window functions other than `ROW_NUMBER` and the aggregate-OVER family (see "Window functions" above).
+- Recursive CTEs (`WITH name AS (… UNION ALL … FROM name …)`); self-reference detected and raises `NotSupportedException`. Non-recursive CTEs are modeled.
 - `LIKE` with `COLLATE` override (default collation only — case-insensitive Latin1_General-shaped).
 - `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121` for date-like → string.
 - `LEN(ntext)` raising Msg 8116 (function-level text/ntext/image restrictions); legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.

SqlServerSimulator.Tests/CommonTableExpressionTests.cs

@@ -0,0 +1,209 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for the <c>WITH name [(col, …)] AS (SELECT …)</c>
+/// non-recursive CTE prefix that scopes to one following SELECT / INSERT
+/// / UPDATE / DELETE / MERGE statement. Recursive CTEs are not modeled.
+/// </summary>
+[TestClass]
+public sealed class CommonTableExpressionTests
+{
+    private static Simulation WithSourceTable()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (id int, score int);
+            insert src (id, score) values (1, 10), (2, 20), (3, 30)
+            """);
+        return simulation;
+    }
+
+    [TestMethod]
+    public void Cte_Vanilla_ProjectsBodyRows()
+    {
+        var simulation = WithSourceTable();
+        using var reader = simulation.ExecuteReader("with c as (select id, score from src) select id, score from c order by id");
+        var rows = new List<(int id, int score)>();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 10), (2, 20), (3, 30) }, rows);
+    }
+
+    [TestMethod]
+    public void Cte_RenameList_RenamesProjection()
+    {
+        var simulation = WithSourceTable();
+        using var reader = simulation.ExecuteReader("with c (a, b) as (select id, score from src) select a, b from c order by a");
+        IsTrue(reader.Read());
+        AreEqual("a", reader.GetName(0));
+        AreEqual("b", reader.GetName(1));
+        AreEqual(1, reader.GetInt32(0));
+        AreEqual(10, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void Cte_MultipleBindings_LaterReferencesEarlier()
+        => AreEqual(2, WithSourceTable().ExecuteScalar("""
+            with a as (select id, score from src),
+                 b as (select id from a where score > 10)
+            select count(*) from b
+            """));
+
+    [TestMethod]
+    public void Cte_MultipleReferences_EachReExecutesPlan()
+    {
+        var simulation = WithSourceTable();
+        using var reader = simulation.ExecuteReader("""
+            with c as (select id from src)
+            select x.id, y.id
+            from c x cross join c y
+            where x.id < y.id
+            order by x.id, y.id
+            """);
+        var rows = new List<(int x, int y)>();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 2), (1, 3), (2, 3) }, rows);
+    }
+
+    [TestMethod]
+    public void Cte_AliasOnCteReference_QualifiesColumns()
+        => AreEqual(20, WithSourceTable().ExecuteScalar("with c as (select id, score from src) select alias.score from c as alias where alias.id = 2"));
+
+    [TestMethod]
+    public void Cte_WhereReferencesCteColumns()
+        => AreEqual(2, WithSourceTable().ExecuteScalar("with c as (select id, score from src) select count(*) from c where score >= 20"));
+
+    [TestMethod]
+    public void Cte_StarProjectionInBody_ExpandsBeforeRename()
+    {
+        var simulation = WithSourceTable();
+        using var reader = simulation.ExecuteReader("with c as (select * from src) select id, score from c order by id");
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        AreEqual(10, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void Cte_UnionInBody_Works()
+        => AreEqual(6, new Simulation().ExecuteScalar("""
+            with c as (select 1 as v union all select 2 union all select 3)
+            select sum(v) from c
+            """));
+
+    // CTE shadows a real table of the same name for the prefixed statement.
+    [TestMethod]
+    public void Cte_ShadowsRealTable()
+    {
+        var simulation = WithSourceTable();
+        AreEqual(42, simulation.ExecuteScalar("with src as (select 42 as score) select score from src"));
+    }
+
+    [TestMethod]
+    public void Cte_PrefixesInsertSelect_RowsLandInDestination()
+    {
+        var simulation = WithSourceTable();
+        _ = simulation.ExecuteNonQuery("create table dst (a int)");
+        AreEqual(2, simulation.ExecuteNonQuery("with c as (select score from src where score >= 20) insert dst (a) select score from c"));
+        AreEqual(2, simulation.ExecuteScalar("select count(*) from dst"));
+        AreEqual(50, simulation.ExecuteScalar("select sum(a) from dst"));
+    }
+
+    [TestMethod]
+    public void Cte_PrefixesUpdate_FromJoin()
+    {
+        var simulation = WithSourceTable();
+        _ = simulation.ExecuteNonQuery("create table u (id int, score int); insert u select id, score from src");
+        AreEqual(2, simulation.ExecuteNonQuery("with c as (select id from src where score >= 20) update u set score = score * 10 from u inner join c on c.id = u.id"));
+        AreEqual(10, simulation.ExecuteScalar("select score from u where id = 1"));
+        AreEqual(200, simulation.ExecuteScalar("select score from u where id = 2"));
+        AreEqual(300, simulation.ExecuteScalar("select score from u where id = 3"));
+    }
+
+    [TestMethod]
+    public void Cte_PrefixesDelete_FromJoin()
+    {
+        var simulation = WithSourceTable();
+        _ = simulation.ExecuteNonQuery("create table d (id int, score int); insert d select id, score from src");
+        AreEqual(2, simulation.ExecuteNonQuery("with c as (select id from src where score >= 20) delete d from d inner join c on c.id = d.id"));
+        AreEqual(1, simulation.ExecuteScalar("select count(*) from d"));
+    }
+
+    [TestMethod]
+    public void Cte_DuplicateName_RaisesMsg239()
+        => new Simulation().AssertSqlError("with a as (select 1 as v), a as (select 2 as v) select * from a", 239,
+            "Duplicate common table expression name 'a' was specified.");
+
+    [TestMethod]
+    public void Cte_RenameTooFew_RaisesMsg8158()
+        => WithSourceTable().AssertSqlError("with c (x) as (select id, score from src) select * from c", 8158,
+            "'c' has more columns than were specified in the column list.");
+
+    [TestMethod]
+    public void Cte_RenameTooMany_RaisesMsg8159()
+        => WithSourceTable().AssertSqlError("with c (x, y, z) as (select id, score from src) select * from c", 8159,
+            "'c' has fewer columns than were specified in the column list.");
+
+    [TestMethod]
+    public void Cte_OrderByWithoutTopOrOffset_RaisesMsg1033()
+        => WithSourceTable().AssertSqlError("with c as (select id from src order by id) select * from c", 1033,
+            "The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified.");
+
+    [TestMethod]
+    public void Cte_OrderByWithTop_Allowed()
+        => AreEqual(3, WithSourceTable().ExecuteScalar("with c as (select top 1 id from src order by id desc) select id from c"));
+
+    [TestMethod]
+    public void Cte_OrderByWithOffsetFetch_Allowed()
+        => AreEqual(2, WithSourceTable().ExecuteScalar("with c as (select id from src order by id desc offset 1 rows fetch next 1 rows only) select id from c"));
+
+    [TestMethod]
+    public void Cte_RecursiveSelfReference_RaisesNotSupported()
+        => Throws<NotSupportedException>(() => WithSourceTable().ExecuteNonQuery("""
+            with a as (
+                select 1 as n
+                union all
+                select n + 1 from a where n < 5
+            ) select * from a
+            """));
+
+    [TestMethod]
+    public void Cte_BindingClearsBetweenStatements()
+    {
+        var simulation = WithSourceTable();
+        // First statement uses a CTE binding named 'c'; the second statement
+        // should NOT see 'c' anymore — it must fail with a missing-table error.
+        _ = simulation.ExecuteNonQuery("with c as (select id from src) select count(*) from c");
+        _ = Throws<DbException>(() => simulation.ExecuteNonQuery("select count(*) from c"));
+    }
+
+    [TestMethod]
+    public void Cte_WithParameter()
+    {
+        var simulation = WithSourceTable();
+        using var connection = simulation.CreateOpenConnection();
+        var command = connection.CreateCommand("with c as (select id, score from src where id >= @minId) select count(*) from c", ("minId", 2));
+        AreEqual(2, command.ExecuteScalar());
+    }
+
+    // CTE is reachable from a scalar subquery inside the prefixed statement
+    // (the binding lives in ParserContext.CteBindings for the whole statement).
+    [TestMethod]
+    public void Cte_ReachableFromScalarSubqueryInProjection()
+    {
+        var simulation = WithSourceTable();
+        using var reader = simulation.ExecuteReader("""
+            with c as (select id, score from src)
+            select id, (select max(score) from c) as max_score
+            from c
+            order by id
+            """);
+        var rows = new List<(int id, int max)>();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetInt32(1)));
+        CollectionAssert.AreEqual(new[] { (1, 30), (2, 30), (3, 30) }, rows);
+    }
+}

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -191,6 +191,37 @@ internal static SimulatedSqlException InsertSelectListFewerThanInsertList() =>
     internal static SimulatedSqlException InsertSelectListMoreThanInsertList() =>
         new("The select list for the INSERT statement contains more items than the insert list. The number of SELECT values must match the number of INSERT columns.", 121, 15, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 239: a <c>WITH</c> prefix declares two or more
+    /// CTEs with the same name in one statement.
+    /// </summary>
+    internal static SimulatedSqlException DuplicateCteName(string name) =>
+        new($"Duplicate common table expression name '{name}' was specified.", 239, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 8158: a CTE's column-rename list has fewer
+    /// names than the body's projection produces. Counterpart to Msg 8159.
+    /// </summary>
+    internal static SimulatedSqlException CteHasMoreColumnsThanList(string name) =>
+        new($"'{name}' has more columns than were specified in the column list.", 8158, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 8159: a CTE's column-rename list has more
+    /// names than the body's projection produces. Counterpart to Msg 8158.
+    /// </summary>
+    internal static SimulatedSqlException CteHasFewerColumnsThanList(string name) =>
+        new($"'{name}' has fewer columns than were specified in the column list.", 8159, 16, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 1033: <c>ORDER BY</c> appears inside a CTE
+    /// body without an accompanying <c>TOP</c> / <c>OFFSET</c> / <c>FOR XML</c>.
+    /// Real SQL Server's wording lists the broader set of contexts (views,
+    /// inline functions, derived tables, subqueries, common table expressions);
+    /// the simulator enforces the rule for CTE bodies only.
+    /// </summary>
+    internal static SimulatedSqlException OrderByInvalidInCte() =>
+        new("The ORDER BY clause is invalid in views, inline functions, derived tables, subqueries, and common table expressions, unless TOP, OFFSET or FOR XML is also specified.", 1033, 15, 1);
+
     /// <summary>
     /// Mimics SQL Server error 108: a positional <c>ORDER BY</c> ordinal
     /// (e.g. <c>order by 0</c>, <c>order by 5</c> with only 3 columns) is

SqlServerSimulator/Parser/CteBinding.cs

@@ -0,0 +1,28 @@
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// One named binding from a <c>WITH</c> prefix. Lifetime is exactly one
+/// following statement: <see cref="Simulation.CreateResultSetsForCommand"/>
+/// populates <see cref="ParserContext.CteBindings"/> via <c>ParseCteBindings</c>
+/// before dispatching to SELECT / INSERT / UPDATE / DELETE / MERGE, and
+/// clears the slot at the start of the next iteration.
+/// </summary>
+/// <remarks>
+/// <see cref="Plan"/> is null while the body is mid-parse — a sentinel so
+/// <c>ParseSingleFromSource</c> can detect self-references (recursive CTEs)
+/// and raise <see cref="NotSupportedException"/>. Once the body's
+/// <see cref="Selection"/> resolves, the sentinel is replaced by the real
+/// plan and the binding becomes resolvable from the FROM side.
+/// </remarks>
+internal sealed class CteBinding(string name, string[] columnNames)
+{
+    public readonly string Name = name;
+    public readonly string[] ColumnNames = columnNames;
+
+    /// <summary>
+    /// The body's parsed plan, or <see langword="null"/> while parsing is
+    /// in flight. <see cref="Plan"/> is the only mutable field — set once
+    /// when the body's <c>Selection</c> resolves.
+    /// </summary>
+    public Selection? Plan;
+}

SqlServerSimulator/Parser/ParserContext.cs

@@ -117,6 +117,19 @@ internal sealed class ParserContext(SimulatedDbCommand command)
     /// </summary>
     public Func<MultiPartName, SqlType>? OuterTypeResolver;
 
+    /// <summary>
+    /// Common-table-expression bindings registered by a <c>WITH</c> prefix
+    /// that scope to the immediately-following statement. Populated by
+    /// <c>Simulation.ParseCteBindings</c> before the SELECT / INSERT /
+    /// UPDATE / DELETE / MERGE dispatch and cleared at the top of the next
+    /// statement iteration. Consulted by <c>Selection.ParseSingleFromSource</c>
+    /// before falling through to <see cref="Simulation.HeapTables"/>; matching
+    /// names build a deferred-plan <see cref="FromSource"/> (re-runs per
+    /// reference, parallel to derived tables in FROM). Null when no WITH
+    /// prefix is in scope.
+    /// </summary>
+    public Dictionary<string, CteBinding>? CteBindings;
+
     private readonly FrozenDictionary<string, SqlValue> variables = command
         .Parameters
         .Cast<DbParameter>()