In-process batches now share the wire path's continue-on-error semantics, uncaught THROW becomes batch-aborting while severity-16 RAISERROR continues, and draining exposed two stranded-cursor parser bugs now fixed.

Author: RyanLamansky

SqlServerSimulator.Tests.SqlClient/BatchErrorContinuationTests.cs

@@ -87,6 +87,22 @@ public async Task ResultSetBeforeError_FirstResultReadable_NextResultThrows()
         AreEqual(3701, ex.Number);
     }
 
+    [TestMethod]
+    public async Task ExecuteScalar_TrailingError_DrainsBatch_Throws()
+    {
+        var simulation = new Simulation();
+        await using var listener = await simulation.ListenAsync(0, TestContext.CancellationToken);
+        await using var connection = await Wire.OpenAsync(listener, TestContext.CancellationToken);
+
+        // ExecuteScalar drains the whole batch: the value of the first result
+        // set is produced, but a trailing statement-terminating error surfaces
+        // as a throw rather than the value being returned (oracle probe 5).
+        await using var command = new SqlCommand("select 42; select 1/0", connection);
+        var ex = await Assert.ThrowsAsync<SqlException>(async () =>
+            _ = await command.ExecuteScalarAsync(TestContext.CancellationToken));
+        AreEqual(8134, ex.Number);
+    }
+
     [TestMethod]
     public async Task BatchAbortingError_AbortsBatch_LaterStatementDoesNotRun()
     {

SqlServerSimulator.Tests/BatchErrorContinuationInProcTests.cs

@@ -3,39 +3,230 @@
 namespace SqlServerSimulator;
 
 /// <summary>
-/// The in-process ADO surface keeps its long-standing fail-fast contract: the
-/// first error in a batch throws immediately and later statements never run.
-/// This is deliberately the opposite of the TDS wire path, which continues a
-/// batch past a statement-terminating error (see
-/// <c>BatchErrorContinuationTests</c> in <c>SqlServerSimulator.Tests.SqlClient</c>).
-/// The wire opts in via <c>CreateResultSetsForCommand(command, continueOnError: true)</c>;
-/// the in-process path leaves the default <see langword="false"/>, and its
-/// reader filters outcomes on result sets so it never observes the wire-only
-/// error outcome anyway.
+/// The in-process ADO surface shares the TDS wire's continue-on-error engine:
+/// a statement-terminating error (severity 11-16) ends its statement but the
+/// batch runs to completion, and the front door renders the shared outcome
+/// stream as SqlClient-shaped exceptions. The eight cases below mirror the
+/// pinned oracle probed against real SQL Server 2025 + Microsoft.Data.SqlClient
+/// (2026-07-17): ExecuteNonQuery / ExecuteScalar drain the batch and surface
+/// every statement error through one aggregated
+/// <see cref="SimulatedSqlException.Errors"/> collection; the reader surfaces
+/// errors positionally and survives; and a batch-aborting error (a bind miss or
+/// an uncaught THROW) stops the following statements. Message text may differ
+/// from real SQL Server, but Msg numbers, Errors.Count, side-effect counts, and
+/// positional behavior match. The wire counterpart lives in
+/// <c>BatchErrorContinuationTests</c> in <c>SqlServerSimulator.Tests.SqlClient</c>.
 /// </summary>
 [TestClass]
 public sealed class BatchErrorContinuationInProcTests
 {
+    /// <summary>Probe 1: ExecuteNonQuery over a batch with two continue-class errors and three inserts.</summary>
     [TestMethod]
-    public void DropNonexistentTemp_ThenSelect_FailsFast()
-        => _ = new Simulation().AssertSqlError("drop table #nope\nselect 1", 3701);
+    public void ExecuteNonQuery_TwoContinueClassErrors_AggregatesBoth_AllInsertsPersist()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+
+        using var batch = connection.CreateCommand(
+            "insert t values (1); select 1/0; insert t values (2); drop table does_not_exist; insert t values (3)");
+        var ex = Throws<SimulatedSqlException>(() => batch.ExecuteNonQuery());
 
+        // One exception carrying both errors in batch order: Msg 8134 (divide,
+        // class 16) then Msg 3701 (drop missing, class 11).
+        AreEqual(2, ex.Errors.Count);
+        AreEqual(8134, ex.Errors[0].Number);
+        AreEqual(3701, ex.Errors[1].Number);
+        AreEqual(8134, ex.Number);
+
+        // The whole batch ran — all three inserts landed.
+        AreEqual(3, connection.CreateCommand("select count(*) from t").ExecuteScalar());
+    }
+
+    /// <summary>Probe 2: ExecuteReader with an error between result sets — positional at Read, reader survives.</summary>
     [TestMethod]
-    public void StatementErrorMidBatch_LaterInsertNeverRuns()
+    public void ExecuteReader_ErrorBetweenResultSets_ReadThrows_ReaderSurvives()
     {
-        // One shared connection so the session #t survives the failed batch for
-        // the follow-up count (a fresh-connection-per-call helper would drop it).
         using var connection = new Simulation().CreateOpenConnection();
+        using var command = connection.CreateCommand("select 'rs1' as a; select 1/0 as boom; select 'rs3' as c");
+        using var reader = command.ExecuteReader();
+
+        IsTrue(reader.Read());
+        AreEqual("rs1", reader.GetValue(0));
+        IsFalse(reader.Read());
+
+        // Advancing to the failed SELECT succeeds (it is row-returning, so real
+        // SQL Server framed it with COLMETADATA); the first Read throws.
+        IsTrue(reader.NextResult());
+        var ex = Throws<SimulatedSqlException>(() => reader.Read());
+        AreEqual(8134, ex.Number);
+
+        // The reader survives to the trailing result set.
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual("rs3", reader.GetValue(0));
+    }
+
+    /// <summary>Probe 3: ExecuteReader with an error inside a result set — Read throws, tail reads clean.</summary>
+    [TestMethod]
+    public void ExecuteReader_ErrorMidResultSet_ReadThrows_TailReadsClean()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values (2),(1),(0),(5)").ExecuteNonQuery();
+
+        using var command = connection.CreateCommand("select 10/id from t; select 'after' as tail");
+        using var reader = command.ExecuteReader();
+
+        // Divergence (documented, out of scope): the simulator materializes a
+        // SELECT's rows up front, so the divide-by-zero fires before any row is
+        // yielded — real SQL Server streams two rows first. The positional
+        // behavior matches: Read throws, and the reader survives.
+        var ex = Throws<SimulatedSqlException>(() =>
+        {
+            while (reader.Read())
+            {
+            }
+        });
+        AreEqual(8134, ex.Number);
+
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual("after", reader.GetValue(0));
+    }
+
+    /// <summary>Probe 4: ExecuteScalar with the error before the first result set.</summary>
+    [TestMethod]
+    public void ExecuteScalar_ErrorBeforeFirstResult_Throws()
+    {
+        var ex = Throws<SimulatedSqlException>(() => new Simulation().ExecuteScalar("select 1/0; select 42"));
+        AreEqual(8134, ex.Number);
+        AreEqual(1, ex.Errors.Count);
+    }
+
+    /// <summary>Probe 5: ExecuteScalar with the error after the first result set still throws (drains the batch).</summary>
+    [TestMethod]
+    public void ExecuteScalar_ErrorAfterFirstResult_ThrowsRatherThanReturningValue()
+    {
+        var ex = Throws<SimulatedSqlException>(() => new Simulation().ExecuteScalar("select 42; select 1/0"));
+        AreEqual(8134, ex.Number);
+    }
+
+    /// <summary>Probe 6: disposing a reader without draining executes the remaining statements and swallows their errors.</summary>
+    [TestMethod]
+    public void ReaderDispose_WithoutDraining_ExecutesRemainingStatements_SwallowsErrors()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+
+        using (var command = connection.CreateCommand(
+            "select 'rs1' as a; insert t values (1); select 1/0; insert t values (2)"))
+        {
+            using var reader = command.ExecuteReader();
+            IsTrue(reader.Read());
+            // Dispose here (end of using) without draining.
+        }
+
+        // Both inserts ran during the drain-on-dispose; the divide-by-zero was
+        // swallowed (no exception escaped the dispose).
+        AreEqual(2, connection.CreateCommand("select count(*) from t").ExecuteScalar());
+    }
 
-        using var failing = connection.CreateCommand();
-        failing.CommandText = "create table #t (a int); drop table #nope; insert #t values (1)";
-        var ex = Throws<SimulatedSqlException>(() => failing.ExecuteNonQuery());
+    /// <summary>Probe 7: a batch-aborting bind error (Msg 208) stops the following statements.</summary>
+    [TestMethod]
+    public void BatchAbortingError_Msg208_StopsFollowingStatements()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+
+        using var batch = connection.CreateCommand(
+            "insert t values (1); select * from table_that_does_not_exist; insert t values (2)");
+        var ex = Throws<SimulatedSqlException>(() => batch.ExecuteNonQuery());
+        AreEqual(208, ex.Number);
+        AreEqual(1, ex.Errors.Count);
+
+        // The insert before the miss ran; the one after did not.
+        AreEqual(1, connection.CreateCommand("select count(*) from t").ExecuteScalar());
+    }
+
+    /// <summary>Probe 8: severity-16 RAISERROR continues; an uncaught THROW aborts. Both errors aggregate.</summary>
+    [TestMethod]
+    public void RaiserrorSeverity16Continues_ThrowAborts_AggregatesBothErrors()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+
+        using var batch = connection.CreateCommand(
+            "insert t values (1); raiserror('custom failure', 16, 1); insert t values (2); throw 50001, 'thrown failure', 1; insert t values (3)");
+        var ex = Throws<SimulatedSqlException>(() => batch.ExecuteNonQuery());
+
+        // RAISERROR's Msg 50000 and THROW's Msg 50001, in batch order.
+        AreEqual(2, ex.Errors.Count);
+        AreEqual(50000, ex.Errors[0].Number);
+        AreEqual(50001, ex.Errors[1].Number);
+
+        // The two inserts before the THROW ran; the THROW aborted the batch so
+        // the third insert did not.
+        AreEqual(2, connection.CreateCommand("select count(*) from t").ExecuteScalar());
+    }
+
+    /// <summary>
+    /// A single non-row-returning statement that fails surfaces eagerly at
+    /// ExecuteReader — real SQL Server sent no result-set envelope, so SqlClient
+    /// throws on the advance rather than a later Read. This is what lets EF
+    /// Core's no-OUTPUT modification batches, which never call Read, observe a
+    /// failed INSERT / UPDATE / DELETE.
+    /// </summary>
+    [TestMethod]
+    public void NonRowReturningError_SurfacesEagerlyAtExecuteReader()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        var ex = Throws<SimulatedSqlException>(() =>
+        {
+            using var reader = connection.CreateCommand("drop table #nope").ExecuteReader();
+        });
+        AreEqual(3701, ex.Number);
+    }
+
+    /// <summary>
+    /// A non-row-returning error between two result sets surfaces on the
+    /// NextResult that advances onto it (not a later Read) — matching how real
+    /// SqlClient surfaces an error token that no COLMETADATA precedes.
+    /// </summary>
+    [TestMethod]
+    public void NonRowReturningError_BetweenResultSets_SurfacesAtNextResult()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        using var command = connection.CreateCommand("select 1 as a; drop table #nope; select 2 as b");
+        using var reader = command.ExecuteReader();
+
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetValue(0));
+        IsFalse(reader.Read());
+
+        var ex = Throws<SimulatedSqlException>(() => reader.NextResult());
         AreEqual(3701, ex.Number);
+    }
+
+    /// <summary>
+    /// A severity ≤ 10 RAISERROR is informational, not a statement error: it
+    /// raises the <see cref="SimulatedDbConnection.InfoMessage"/> event and the
+    /// batch continues without an exception.
+    /// </summary>
+    [TestMethod]
+    public void InformationalRaiserror_DoesNotThrow_FiresInfoMessage_BatchContinues()
+    {
+        using var connection = (SimulatedDbConnection)new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t (id int)").ExecuteNonQuery();
+
+        var messages = new List<string>();
+        connection.InfoMessage += (_, e) => messages.Add(e.Message);
+
+        using var batch = connection.CreateCommand(
+            "insert t values (1); raiserror('just a note', 5, 1); insert t values (2)");
+        var affected = batch.ExecuteNonQuery();
 
-        // The insert after the failed drop never executed — fail-fast aborts
-        // the whole batch in-process (the wire would have continued and run it).
-        using var count = connection.CreateCommand();
-        count.CommandText = "select count(*) from #t";
-        AreEqual(0, count.ExecuteScalar());
+        AreEqual(2, affected);
+        Contains("just a note", string.Join("\n", messages));
+        AreEqual(2, connection.CreateCommand("select count(*) from t").ExecuteScalar());
     }
 }

SqlServerSimulator.Tests/BatchErrorRecoveryTests.cs

@@ -11,11 +11,13 @@ namespace SqlServerSimulator;
 /// statement-terminating one (unlike Msg 3701 / 8134 / a severity-16 RAISERROR,
 /// which let the batch continue). Missing column (Msg 207), ambiguous column
 /// (Msg 209), and unbindable multi-part identifiers (Msg 4104) abort the same
-/// way. The in-process ADO surface reaches the same end state through its
-/// fail-fast contract (first error throws, later statements never run — see
-/// <see cref="BatchErrorContinuationInProcTests"/>); the wire-path contrast
-/// (results before the error still arrive, exactly one error token, no
-/// abandoned-mid-parse Msg 319 / 102 cascade) lives in
+/// way. The in-process ADO surface now shares the wire's continue-on-error
+/// engine: it drains the batch and surfaces the aggregated error(s) at
+/// completion, so a batch-aborting miss still stops the following statements
+/// (the dispatch loop breaks) while a statement-terminating error lets them
+/// run — see <see cref="BatchErrorContinuationInProcTests"/>. The wire-path
+/// contrast (results before the error still arrive, exactly one error token,
+/// no abandoned-mid-parse Msg 319 / 102 cascade) lives in
 /// <c>BatchErrorRecoveryTests</c> in <c>SqlServerSimulator.Tests.SqlClient</c>.
 /// </summary>
 [TestClass]
@@ -64,18 +66,22 @@ public void MissingColumnMidBatch_AbortsBatch()
     }
 
     [TestMethod]
-    public void SyntaxErrorMidBatch_AbortsBatch_FollowingDoesNotRun()
+    public void SyntaxErrorMidBatch_Continues_FollowingRuns()
     {
-        // A true syntax error aborts the batch on real SQL Server (probe:
-        // `SELECT 1; SELECT FROM; SELECT 2` returns only Msg 156, no SELECT 2).
-        // The in-process path reaches the same end state fail-fast.
+        // Accepted divergence: a true syntax error aborts the batch on real SQL
+        // Server (it fails at compile), but the simulator interleaves parse and
+        // execution and can't tell a parse-origin error (Msg 156, class 15)
+        // from a runtime one — so a mid-batch syntax error is statement-
+        // terminating and the batch continues. This is the same parse-vs-runtime
+        // divergence documented for the wire path; unifying the engine extends
+        // it to the in-process surface. The insert after the syntax error runs.
         using var connection = new Simulation().CreateOpenConnection();
         _ = connection.CreateCommand("create table marker (n int)").ExecuteNonQuery();
 
         using var failing = connection.CreateCommand(
             "insert marker values (1); select from; insert marker values (2)");
         _ = Throws<SimulatedSqlException>(() => failing.ExecuteNonQuery());
-        AreEqual(1, connection.CreateCommand("select count(*) from marker").ExecuteScalar());
+        AreEqual(2, connection.CreateCommand("select count(*) from marker").ExecuteScalar());
     }
 
     /// <summary>
@@ -99,18 +105,19 @@ select 7
             """));
 
     [TestMethod]
-    public void ContinuableError_DoesNotAbort_InProcStillFailsFast()
+    public void ContinuableError_DoesNotAbort_FollowingRuns()
     {
         // Msg 3701 (drop missing) is statement-terminating, not batch-aborting:
-        // the wire continues past it. The in-process path still fails fast — this
-        // pins that the batch-abort carve-out didn't change the in-process
-        // first-error-throws contract for a continuable error.
+        // the batch continues past it on both front doors. In-process,
+        // ExecuteNonQuery drains the whole batch — both inserts land — and
+        // surfaces the 3701 at completion. Contrast the batch-aborting bind
+        // errors above, where the following insert never runs.
         using var connection = new Simulation().CreateOpenConnection();
         _ = connection.CreateCommand("create table marker (n int)").ExecuteNonQuery();
         using var failing = connection.CreateCommand(
             "insert marker values (1); drop table #nope; insert marker values (2)");
         var ex = Throws<SimulatedSqlException>(() => failing.ExecuteNonQuery());
         AreEqual(3701, ex.Number);
-        AreEqual(1, connection.CreateCommand("select count(*) from marker").ExecuteScalar());
+        AreEqual(2, connection.CreateCommand("select count(*) from marker").ExecuteScalar());
     }
 }

SqlServerSimulator.Tests/CastTests.cs

@@ -339,17 +339,19 @@ public void Cast_InvalidScale_OnLaterLine_PrefixesActualLine()
     [TestMethod]
     public void Cast_InvalidScale_InLaterStatementOfBatch_FiresWhenReaderReachesIt()
     {
-        // Multi-statement batches parse lazily one statement at a time; statement 3's error doesn't fire until NextResult reaches it.
+        // Multi-statement batches parse lazily one statement at a time and
+        // continue past a statement error. Statement 3 is a (row-returning)
+        // SELECT, so the reader advances onto it — NextResult returns true —
+        // and its error surfaces positionally on the first Read, matching how
+        // real SQL Server frames a failed SELECT (COLMETADATA precedes the
+        // error over the wire).
         using var connection = new Simulation().CreateOpenConnection();
         using var command = connection.CreateCommand("select 1;\nselect 2;\nselect cast('x' as datetime2(8))");
         using var reader = command.ExecuteReader();
 
         IsTrue(reader.NextResult());
-        var ex = Throws<System.Data.Common.DbException>(() =>
-        {
-            _ = reader.NextResult();
-            _ = reader.NextResult();
-        });
+        IsTrue(reader.NextResult());
+        var ex = Throws<System.Data.Common.DbException>(() => reader.Read());
         AreEqual("Line 3: Specified scale 8 is invalid.", ex.Message);
     }
 

SqlServerSimulator.Tests/DistinctTests.cs

@@ -179,7 +179,7 @@ public void TopBeforeDistinct_IsSyntaxError()
         // SQL Server requires DISTINCT before TOP. Reversed order is a parse
         // failure (Msg 156 with "near 'distinct'").
         var ex = Throws<DbException>(() =>
-            connection.CreateCommand("select top 2 distinct v from t").ExecuteReader());
+            connection.CreateCommand("select top 2 distinct v from t").ExecuteReader().Read());
         AreEqual("Incorrect syntax near the keyword 'distinct'.", ex.Message);
     }