INSERT … SELECT source: Selection.Parse + Execute, full-buffer materialization via RowDecoder, parse-time projection-count check via selection.Schema.Length (Msg 120 / Msg 121). Source-kind dispatch (Values vs Select) lives at the post-OUTPUT-clause cursor; both branches funnel into one shared per-row encode loop that operates on SqlValue[] directly. Self-insert is safe — source materializes before any destination write. WHERE / JOIN / GROUP BY / aggregates / ORDER BY / TOP / OFFSET-FETCH / UNION all work on the source side. Statement-level atomicity carries over: a CHECK / NOT NULL / PK / UNIQUE violation mid-source rolls back every row from the SELECT.

Author: RyanLamansky

CLAUDE.md

@@ -339,6 +339,17 @@ 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`.
 
+### 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.
+
+Source-kind dispatch happens after the OUTPUT-clause parse: a `Values`-keyword token routes to the existing tuple-parsing path; a `Select`-keyword token routes to `Selection.Parse(…).Execute()`. Both paths funnel into one shared per-row encode loop that handles defaults / identity / rowversion / computed / constraints / OUTPUT — VALUES eagerly evaluates each cell expression to a `SqlValue` upstream, SELECT-source rows arrive pre-decoded via `RowDecoder` from the executed `SimulatedSqlResultSet`'s row bytes.
+
+Buffering is full: `ExecuteSelectSource` materializes the entire source result-set into `List<SqlValue[]>` before any destination write. This makes self-insert (`INSERT t SELECT … FROM t`) safe — without it, scanning the source's heap while inserting into it would yield undefined behavior.
+
+Projection-count vs insert-list mismatch fires at parse time via `selection.Schema.Length`: too few SELECT columns → **Msg 120 St 1 Cls 15** (`"The select list for the INSERT statement contains fewer items than the insert list. The number of SELECT values must match the number of INSERT columns."`); too many → **Msg 121 St 1 Cls 15** with `"more items"` wording. Empty source → silent success with rows-affected 0. CHECK / NOT NULL / PK / UNIQUE violations mid-source still trigger statement-level rollback (every row from the SELECT is unwound, matching the VALUES path's atomicity).
+
+EF Core 10 doesn't emit `INSERT … SELECT` from SaveChanges (which uses INSERT…OUTPUT VALUES for single-row and MERGE for batched-multi-row); this is reachable from raw SQL (`FromSqlInterpolated` / direct command text) and from application-side bulk-copy patterns. CTE-prefix INSERTs (`WITH … INSERT t SELECT …`) aren't modeled — orthogonal to this bundle since the simulator has no CTE support.
+
 ### MERGE / OUTPUT (EF Core SaveChanges shape only)
 - `INSERT ... OUTPUT INSERTED.<col>` (single-row).
 - `MERGE INTO target USING (VALUES ...) AS alias (cols) ON predicate WHEN NOT MATCHED THEN INSERT ... [OUTPUT ...]` (multi-row batch).

SqlServerSimulator.Tests/InsertTests.cs

@@ -472,6 +472,237 @@ public void Insert_PersistedComputedNotNull_ResultNullRaisesMsg515()
             insert t (a) values (null)
             """, 515);
 
+    [TestMethod]
+    public void InsertSelect_VanillaWithColumnList_CopiesAllRows()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (id int, name varchar(50));
+            create table dst (id int, name varchar(50));
+            insert src (id, name) values (1, 'alpha'), (2, 'beta'), (3, 'gamma')
+            """);
+        AreEqual(3, simulation.ExecuteNonQuery("insert dst (id, name) select id, name from src"));
+        AreEqual(3, simulation.ExecuteScalar("select count(*) from dst"));
+        AreEqual("beta", simulation.ExecuteScalar("select name from dst where id = 2"));
+    }
+
+    // No column list — INSERT skips IDENTITY and computed columns from the destination,
+    // and the SELECT projection must match the remaining writable columns.
+    [TestMethod]
+    public void InsertSelect_NoColumnList_TargetsWritableColumns()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (v varchar(20));
+            create table dst (id int identity, v varchar(20));
+            insert src (v) values ('alpha')
+            """);
+        AreEqual(1, simulation.ExecuteNonQuery("insert dst select v from src"));
+        AreEqual("alpha", simulation.ExecuteScalar("select v from dst where id = 1"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_TooManyColumns_RaisesMsg121()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int, b int, c int);
+            create table dst (a int, b int);
+            insert src (a, b, c) values (1, 2, 3)
+            """);
+        simulation.AssertSqlError("insert dst (a, b) select a, b, c from src", 121,
+            "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.");
+    }
+
+    [TestMethod]
+    public void InsertSelect_TooFewColumns_RaisesMsg120()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int);
+            create table dst (a int, b int);
+            insert src (a) values (1)
+            """);
+        simulation.AssertSqlError("insert dst (a, b) select a from src", 120,
+            "The select list for the INSERT statement contains fewer items than the insert list. The number of SELECT values must match the number of INSERT columns.");
+    }
+
+    [TestMethod]
+    public void InsertSelect_EmptySource_SilentSuccess()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int);
+            create table dst (a int)
+            """);
+        AreEqual(0, simulation.ExecuteNonQuery("insert dst (a) select a from src where a > 0"));
+        AreEqual(0, simulation.ExecuteScalar("select count(*) from dst"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_WhereJoinAggregateOffset_AllSelectionFeaturesWorkInSource()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (id int, score int);
+            create table aux (id int, label varchar(20));
+            create table dst (a int, b varchar(20));
+            insert src (id, score) values (1, 10), (2, 20), (3, 30);
+            insert aux (id, label) values (1, 'one'), (2, 'two'), (3, 'three')
+            """);
+        AreEqual(2, simulation.ExecuteNonQuery("""
+            insert dst (a, b)
+                select s.id, a.label
+                from src s inner join aux a on a.id = s.id
+                where s.score >= 20
+                order by s.id
+                offset 0 rows fetch next 5 rows only
+            """));
+        AreEqual("two", simulation.ExecuteScalar("select b from dst where a = 2"));
+        AreEqual("three", simulation.ExecuteScalar("select b from dst where a = 3"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_UnionAllSource_BothBranchesInserted()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (id int, score int);
+            create table dst (v int);
+            insert src (id, score) values (1, 10), (2, 20), (3, 30)
+            """);
+        AreEqual(6, simulation.ExecuteNonQuery("insert dst (v) select id from src union all select score from src"));
+        AreEqual(6, simulation.ExecuteScalar("select count(*) from dst"));
+        AreEqual(66, simulation.ExecuteScalar("select sum(v) from dst"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_SelfInsertBuffersSourceBeforeWrite()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table t (a int);
+            insert t (a) values (1), (2)
+            """);
+        AreEqual(2, simulation.ExecuteNonQuery("insert t (a) select a + 100 from t"));
+        AreEqual(4, simulation.ExecuteScalar("select count(*) from t"));
+        AreEqual(206, simulation.ExecuteScalar("select sum(a) from t"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_IdentityColumnSkippedFromAutoColumnList()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (v varchar(20));
+            create table dst (id int identity primary key, v varchar(20));
+            insert src (v) values ('alpha'), ('beta'), ('gamma')
+            """);
+        AreEqual(3, simulation.ExecuteNonQuery("insert dst select v from src"));
+        AreEqual(1, simulation.ExecuteScalar("select id from dst where v = 'alpha'"));
+        AreEqual(3, simulation.ExecuteScalar("select id from dst where v = 'gamma'"));
+    }
+
+    // Explicit IDENTITY column without SET IDENTITY_INSERT ON — same Msg 544 path
+    // as the VALUES-side; SELECT-source uses the existing pre-source identity check.
+    [TestMethod]
+    public void InsertSelect_ExplicitIdentityWithoutInsertOn_RaisesMsg544()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (id int, v varchar(20));
+            create table dst (id int identity, v varchar(20));
+            insert src (id, v) values (5, 'x')
+            """);
+        _ = simulation.AssertSqlError("insert dst (id, v) select id, v from src", 544);
+    }
+
+    [TestMethod]
+    public void InsertSelect_DefaultAppliesForOmittedColumn()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int);
+            create table dst (a int, b int default 99);
+            insert src (a) values (1), (2)
+            """);
+        AreEqual(2, simulation.ExecuteNonQuery("insert dst (a) select a from src"));
+        AreEqual(99, simulation.ExecuteScalar("select b from dst where a = 1"));
+        AreEqual(99, simulation.ExecuteScalar("select b from dst where a = 2"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_TypeCoercion_IntToBigInt()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int);
+            create table dst (a bigint);
+            insert src (a) values (12345)
+            """);
+        AreEqual(1, simulation.ExecuteNonQuery("insert dst (a) select a from src"));
+        AreEqual(12345L, simulation.ExecuteScalar("select a from dst"));
+    }
+
+    // CHECK violation in mid-SELECT-source rolls back the whole statement
+    // — same statement-level atomicity the VALUES path enjoys. The earlier
+    // rows from the same INSERT must not survive.
+    [TestMethod]
+    public void InsertSelect_CheckViolation_RollsBackEntireStatement()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int);
+            create table dst (a int check (a > 0));
+            insert src (a) values (10), (20), (-1)
+            """);
+        _ = simulation.AssertSqlError("insert dst (a) select a from src", 547);
+        AreEqual(0, simulation.ExecuteScalar("select count(*) from dst"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_OutputClause_ProjectsInsertedRows()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (v varchar(20));
+            create table dst (id int identity, v varchar(20));
+            insert src (v) values ('alpha'), ('beta')
+            """);
+
+        using var connection = simulation.CreateOpenConnection();
+        using var reader = connection.CreateCommand("insert dst (v) output inserted.id, inserted.v select v from src order by v").ExecuteReader();
+        var rows = new List<(int id, string v)>();
+        while (reader.Read())
+            rows.Add((reader.GetInt32(0), reader.GetString(1)));
+        CollectionAssert.AreEqual(new[] { (1, "alpha"), (2, "beta") }, rows);
+    }
+
+    [TestMethod]
+    public void InsertSelect_BareWithoutInto_Works()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (a int, b varchar(20));
+            create table dst (a int, b varchar(20));
+            insert src (a, b) values (1, 'x'), (2, 'y')
+            """);
+        AreEqual(2, simulation.ExecuteNonQuery("insert dst select a, b from src"));
+    }
+
+    [TestMethod]
+    public void InsertSelect_AggregateSource_SingleRow()
+    {
+        var simulation = new Simulation();
+        _ = simulation.ExecuteNonQuery("""
+            create table src (score int);
+            create table dst (total int);
+            insert src (score) values (10), (20), (30)
+            """);
+        AreEqual(1, simulation.ExecuteNonQuery("insert dst (total) select sum(score) from src"));
+        AreEqual(60, simulation.ExecuteScalar("select total from dst"));
+    }
+
     private static void AddTypedParameter(DbCommand command, string name, DbType dbType, object value)
     {
         var parameter = command.CreateParameter();

SqlServerSimulator/Errors/SimulatedSqlException.QueryErrors.cs

@@ -175,6 +175,22 @@ internal static SimulatedSqlException OrderByItemNotInSelectListWithDistinct() =
     internal static SimulatedSqlException LobTypesCannotBeComparedOrSorted() =>
         new("The text, ntext, and image data types cannot be compared or sorted, except when using IS NULL or LIKE operator.", 306, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 120: <c>INSERT … SELECT</c> whose source
+    /// projects fewer columns than the destination's column list (explicit
+    /// or implied). Distinct from Msg 121 (the "more items" variant).
+    /// </summary>
+    internal static SimulatedSqlException InsertSelectListFewerThanInsertList() =>
+        new("The select list for the INSERT statement contains fewer items than the insert list. The number of SELECT values must match the number of INSERT columns.", 120, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server error 121: <c>INSERT … SELECT</c> whose source
+    /// projects more columns than the destination's column list (explicit
+    /// or implied). Distinct from Msg 120 (the "fewer items" variant).
+    /// </summary>
+    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 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/Simulation/Simulation.Insert.cs

@@ -94,37 +94,12 @@ private static SimulatedStatementOutcome ProcessHeapInsert(HeapTable destination
 
         var output = TryParseOutputClause(context, destinationTable, sourceColumnNames: null);
 
-        if (context.Token is not ReservedKeyword { Keyword: Keyword.Values })
-            throw SimulatedSqlException.SyntaxErrorNear(context);
-
-        var sourceRows = new List<Expression[]>();
-
-        do
+        var sourceRows = context.Token switch
         {
-            if (context.GetNextRequired<Operator>() is not { Character: '(' })
-                throw SimulatedSqlException.SyntaxErrorNear(context);
-
-            var sourceValues = new List<Expression>();
-            while (true)
-            {
-                // Position context.Token at the start of the value expression
-                // (just past the '(' or the previous ','), then let
-                // Expression.Parse consume it. Parse leaves context.Token at
-                // the first un-consumed token, which must be ',' or ')' here.
-                context.MoveNextRequired();
-                if (context.Token is Operator { Character: ',' or ')' })
-                    throw SimulatedSqlException.SyntaxErrorNear(context);
-                sourceValues.Add(Expression.Parse(context));
-
-                if (context.Token is Operator { Character: ')' })
-                    break;
-                if (context.Token is not Operator { Character: ',' })
-                    throw SimulatedSqlException.SyntaxErrorNear(context);
-            }
-
-            sourceRows.Add([.. sourceValues]);
-
-        } while (context.GetNextOptional() is Operator { Character: ',' });
+            ReservedKeyword { Keyword: Keyword.Values } => EvaluateValuesTuples(context),
+            ReservedKeyword { Keyword: Keyword.Select } => ExecuteSelectSource(context, destinationColumns.Length),
+            _ => throw SimulatedSqlException.SyntaxErrorNear(context),
+        };
 
         decimal? lastIdentityValue = null;
         var outputRows = output is null ? null : new List<byte[]>(sourceRows.Count);
@@ -170,7 +145,7 @@ private static SimulatedStatementOutcome ProcessHeapInsert(HeapTable destination
                     }
                 }
 
-                var source = sourceRow[i].Run(name => throw SimulatedSqlException.InvalidColumnName(name));
+                var source = sourceRow[i];
                 EnforceMaxLength(source, targetColumn, destinationTable.Name, context.Simulation);
                 var coerced = CoerceForInsert(source, targetColumn.Type);
                 rowValues[ordinal] = coerced;
@@ -232,4 +207,50 @@ private static SimulatedStatementOutcome ProcessHeapInsert(HeapTable destination
             ? new SimulatedSqlResultSet(o2.Schema, o2.ColumnNames, outputRows!)
             : new SimulatedNonQuery(sourceRows.Count);
     }
+
+    /// <summary>
+    /// Parses INSERT's <c>VALUES (…), (…)</c> source via the shared
+    /// <c>ParseValuesTuples</c> helper, then eagerly evaluates each cell
+    /// expression to a <see cref="SqlValue"/>. VALUES expressions can't
+    /// reference columns; the column-resolver hook always raises
+    /// <see cref="SimulatedSqlException.InvalidColumnName(string)"/>.
+    /// </summary>
+    private static List<SqlValue[]> EvaluateValuesTuples(ParserContext context)
+    {
+        var tuples = ParseValuesTuples(context);
+        var rows = new List<SqlValue[]>(tuples.Count);
+        foreach (var tuple in tuples)
+        {
+            var values = new SqlValue[tuple.Length];
+            for (var i = 0; i < tuple.Length; i++)
+                values[i] = tuple[i].Run(name => throw SimulatedSqlException.InvalidColumnName(name));
+            rows.Add(values);
+        }
+        return rows;
+    }
+
+    /// <summary>
+    /// Parses and executes the <c>SELECT</c>-source side of <c>INSERT … SELECT</c>.
+    /// Validates the projection-count vs insert-list count at parse time
+    /// (Msg 120 / Msg 121, matching SQL Server's pre-execution diagnostic),
+    /// then buffers the result into a list of rows so the existing per-row
+    /// encode loop can run unchanged. Buffering also makes self-insert
+    /// (<c>INSERT t SELECT … FROM t</c>) safe — the source materializes
+    /// before any destination write.
+    /// </summary>
+    private static List<SqlValue[]> ExecuteSelectSource(ParserContext context, int expectedColumnCount)
+    {
+        var selection = Selection.Parse(context, depth: 0);
+
+        if (selection.Schema.Length < expectedColumnCount)
+            throw SimulatedSqlException.InsertSelectListFewerThanInsertList();
+        if (selection.Schema.Length > expectedColumnCount)
+            throw SimulatedSqlException.InsertSelectListMoreThanInsertList();
+
+        var resultSet = selection.Execute();
+        var rows = new List<SqlValue[]>();
+        foreach (var rowBytes in resultSet.RowBytes)
+            rows.Add(RowDecoder.DecodeRow(resultSet.Schema, rowBytes));
+        return rows;
+    }
 }