PRINT message capture via internal SimulatedDbConnection.InfoMessage event — mirrors SqlClient's batch-coalescing semantic (multiple PRINTs in one command join with \n into one event firing), opt-in observability for the existing PRINT statement that previously discarded the operand. Surface kept internal pending the public-API shape decision; SqlServerSimulator.Tests.Internal/PrintInfoMessageTests.cs exercises the wire-up. New SimulatedInfoMessageEventArgs class (internal-sealed-with-public-fields, SSS001-compliant) carries Message + LineNumber + Source — the SqlInfoMessageEventArgs subset that matters without Errors collection or the other catalog fields. BatchContext gains a pendingPrintMessages: List<string>? buffer + firstPrintLine: int slot, populated by AppendPrintMessage(text) lazily (null until the first PRINT — avoids the per-batch allocation for the typical PRINT-less batch); on the dispatch loop's exit from CreateResultSetsForCommand (alongside the existing WriteBackOutputParameters call), FlushPrintMessages() joins the buffer with \n and raises Connection.InfoMessage once with the first contributing PRINT's StatementContext.StartLine as the event's LineNumber. The probe-confirmed NULL-operand surprise (PRINT NULL → message string " ", single space, not empty) is preserved in FormatPrintValue's null branch; string-typed values pass through AsString verbatim (preserving embedded CR/LF for the 'line1\nline2' case); other types coerce to varchar(8000) via SqlValue.CoerceTo — the same path CAST(value AS VARCHAR(8000)) takes, which differs from SQL Server's PRINT-specific style 0 conventions (datetime / money formatting divergence documented as known fidelity gap; string-based PRINT is the dominant pattern so the gap is rarely hit in practice). Skip-mode IF correctly suppresses the buffer append because the existing if (batch.IsSkipping) return; guard in ParsePrintStatement runs before AppendPrintMessage. PRINT inside BEGIN TRAN / ROLLBACK still delivers (info messages aren't transactional — matches SqlClient probe). 16 new internal tests cover: simple string, NULL → single space, 'a' + null → single space (ANSI string-concat-NULL → NULL), integer formatting, embedded-newline preservation, no-PRINT-no-event, skip-mode IF suppression, ELSE-branch firing, WHILE-loop coalescing across iterations, transaction-rollback delivery, TRY/CATCH cross-block coalescing, multi-command separation (one event per ExecuteNonQuery), line-number = first PRINT's line, Source = "SqlServerSimulator", and null-subscriber no-throw. CLAUDE.md "Not modeled" entry rewritten — InfoMessage surface is internal-shipped; the *public* event remains deferred pending shape design (mirror SqlClient exactly? trim further? add DbConnection-compatible extension method?). Documented fidelity gaps preserved: Msg 1046 subquery-in-operand rejection still silently evaluates; datetime / money formatting routes through CoerceTo rather than PRINT style 0; 8000-byte / 4000-char output truncation not enforced.

Author: RyanLamansky

CLAUDE.md

@@ -176,7 +176,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **`CREATE SCHEMA sys` / `INFORMATION_SCHEMA`** — raises Msg 2760 (matching real SQL Server). The schemas themselves exist as catalog-view hosts (`select * from sys.tables` / `select * from INFORMATION_SCHEMA.COLUMNS` work); legacy bare 1-part system-table access (`select * from systypes`) also still works.
 - T-SQL `GOTO` / labels — `IF` / `BEGIN…END` / `WHILE` / `BREAK` / `CONTINUE` / `RETURN` (bare + UDF-body and stored-procedure-body value form) ship; unconditional jumps don't.
 - CLR functions, INSTEAD OF UPDATE / DELETE on *non-updatable* views (INSTEAD OF INSERT on any view ships; INSTEAD OF UPDATE / DELETE on updatable single-base views ships). DDL / logon triggers also unmodeled. Scalar UDFs, inline TVFs, multi-statement TVFs (`RETURNS @r TABLE (cols) AS BEGIN ... END` — EF Core `HasDbFunction` end-to-end), views, DML-through-views (single-source updatable shape), stored procedures (including CREATE / ALTER / DROP, EXEC with input/output/default params, `@rc = EXEC` return-code capture, `CommandType.StoredProcedure`, `EXEC (@sql)` and `sp_executesql` dynamic SQL), user-defined table types + table-valued parameters (CREATE TYPE … AS TABLE / DROP TYPE / DECLARE @t MyType / READONLY proc params / EXEC with TVP arg / ADO.NET Structured parameter via the `DbParameter.TypeName` C# 14 extension property + DataTable/IDataReader sources), sequence objects (CREATE / ALTER / DROP SEQUENCE / NEXT VALUE FOR / sys.sequences — supports EF Core HiLo identity strategy end-to-end), and DML triggers (CREATE / ALTER / CREATE OR ALTER / DROP TRIGGER, FOR-as-AFTER synonym, AFTER on heap tables + INSTEAD OF on heap tables / views, multi-action INSERT,UPDATE,DELETE, INSERTED/DELETED pseudo-tables, multiple AFTER triggers per parent / one INSTEAD OF per action per target (Msg 2111), DISABLE/ENABLE TRIGGER, TRIGGER_NESTLEVEL(), direct-recursion suppression matching RECURSIVE_TRIGGERS OFF, sys.triggers + sys.objects integration, trigger-error rolls back firing DML, MERGE per-action routing through INSTEAD OF, DROP TABLE / DROP VIEW cascade-drops attached triggers) ship (see `docs/claude/programmable.md`, `docs/claude/table-valued-parameters.md`, `docs/claude/sequences.md`, and `docs/claude/triggers.md`). JOIN-view single-base-table UPDATE/DELETE, OUTPUT through views, and multi-source alias-form UPDATE/DELETE through views are deferred (Msg 4405 or `NotSupportedException` at the DML site). `BEGIN ATOMIC` / `BEGIN DISTRIBUTED TRANSACTION` raise `NotSupportedException` at dispatch. Value-form `RETURN N` is legal inside a scalar-UDF body and a stored-procedure body; bare batch / dynamic-SQL scope raises Msg 178. TRY/CATCH + THROW + RAISERROR (printf-style `%s %d/%i %u %o %x %X %% %ld %I64d` with width / precision / left-align / zero-pad; severity routing 0-10 informational vs 11-18 catchable; `WITH SETERROR`/`NOWAIT` ship, `WITH LOG` uniformly raises Msg 2778; numeric `msg_id` raises Msg 2732 for 50000 / `< 13000` and Msg 18054 otherwise — `sys.messages` registry / `sp_addmessage` not modeled) + live `@@ERROR` + `ERROR_*()` functions ship (see `docs/claude/control-flow.md`).
-- **`PRINT` message capture** — the statement parses + evaluates the operand (so operand-side errors like Msg 245 surface), but the message is discarded. `DbConnection` has no `InfoMessage` event (that's a `SqlConnection` extension), so adding a public observability surface would mean a new event on `SimulatedDbConnection`. Defer until an application needs it.
+- **Public `InfoMessage` event** — `SimulatedDbConnection.InfoMessage` ships as an `internal` event (with `internal SimulatedInfoMessageEventArgs` carrying `Message`, `LineNumber`, `Source`) and a `BatchContext`-side buffer that coalesces multiple `PRINT`s per command into one firing (joined with `\n`, line number = first contributing `PRINT`'s line). The internal surface is exercised through `SqlServerSimulator.Tests.Internal/PrintInfoMessageTests.cs`. Going *public* — exposing the event on the `SimulatedDbConnection` consumer surface for application use — is deferred pending the public-API shape decision (mirror SqlClient's `SqlInfoMessageEventArgs` exactly? trim to a minimal shape? add a `DbConnection`-compatible extension method instead of a typed event?). Subquery-in-operand still silently evaluates instead of raising Msg 1046 ("Subqueries are not allowed in this context"); non-string-value formatting routes through `SqlValue.CoerceTo(varchar(8000))` rather than SQL Server's PRINT-specific style 0 conventions (datetime → ISO instead of `"May 14 2026 12:00AM"`; money → `F4` instead of 2-decimal). The 8000-byte ANSI / 4000-character Unicode PRINT truncation isn't enforced — long strings pass through verbatim.
 - **`ALTER TABLE` grammar beyond SET / ADD / DROP / ALTER COLUMN / CHECK / NOCHECK CONSTRAINT** — `SET (SYSTEM_VERSIONING = OFF)` (see [`docs/claude/temporal-tables.md`](docs/claude/temporal-tables.md)), `[WITH CHECK | WITH NOCHECK] ADD [CONSTRAINT name] (PRIMARY KEY | UNIQUE | FOREIGN KEY | CHECK | DEFAULT) …`, `DROP CONSTRAINT [IF EXISTS] name [, …]`, `[WITH CHECK | WITH NOCHECK] (CHECK | NOCHECK) CONSTRAINT (ALL | name [, …])` (trust toggling for bulk imports — sets / clears `is_disabled` + `is_not_trusted`), `ADD [COLUMN] col TYPE [, …]` (multi-column add — inline DEFAULT / IDENTITY / CHECK / FK / computed all supported; Msg 4901 on NOT NULL without DEFAULT on non-empty table; eager row rewrite with NULL backfill for nullable adds and constant-snapshot DEFAULT for NOT NULL), `DROP COLUMN [IF EXISTS] col [, …]` (Msg 4924 missing column, Msg 5074 dependency rejection with multi-blocker enumeration across PK/UQ/FK/CHECK/DEFAULT/index, atomic multi-drop), and `ALTER COLUMN col TYPE[(prec[,scale])] [COLLATE coll] [NULL|NOT NULL]` (single-column shape — type widening / narrowing routed through `SqlValue.CoerceTo` so Msg 220 / 245 / 241 / 8115 / 2628 surface verbatim; nullability flip raises Msg 515 on existing NULL; Msg 4928 for COMPUTED / rowversion; Msg 5074 multi-blocker enumeration across PK / UQ / FK both directions / computed-column dependencies / type-changing index references — length widening within the same `SqlType` family allowed under an index; COLLATE clause parse-accepted then ignored; identity / DEFAULT / inline CHECK preserve through the column instance swap) all ship (see [`docs/claude/alter-table.md`](docs/claude/alter-table.md)). DROP PERIOD FOR SYSTEM_TIME, REBUILD, SWITCH PARTITION, the SET-versioning-on direction, the `ALTER COLUMN col ADD/DROP {PERSISTED|MASKED|ROWGUIDCOL|SPARSE}` sub-clause forms, ALTER COLUMN on an identity column targeting a non-integer type, and every other shape raise `NotSupportedException`. Multi-constraint ADD (`ADD CONSTRAINT pk1 PK (a), CONSTRAINT fk1 FK …`) also raises.
 - `hierarchyid`, `geography`, `geometry`.
 

SqlServerSimulator.Tests.Internal/PrintInfoMessageTests.cs

@@ -0,0 +1,223 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Internal-only tests for the <see cref="SimulatedDbConnection.InfoMessage"/>
+/// event surface that delivers buffered <c>PRINT</c> output. The event itself
+/// is internal pending a public-API decision (DbConnection has no equivalent
+/// in the base class); these tests pin the wire-up so that consumer-shape
+/// changes catch a failure rather than silent behavior shift.
+/// </summary>
+/// <remarks>
+/// Probed against SQL Server 2025 (2026-05-14):
+/// <list type="bullet">
+/// <item>Multiple <c>PRINT</c>s in one batch coalesce into one event with
+/// messages joined by <c>\n</c>.</item>
+/// <item>NULL operand emits a single space, not empty.</item>
+/// <item>Skip-mode IF suppresses the PRINT.</item>
+/// <item>Event fires once per <c>ExecuteNonQuery</c> command, after all
+/// statements complete (even when later statements roll back).</item>
+/// </list>
+/// </remarks>
+[TestClass]
+public sealed class PrintInfoMessageTests
+{
+    private static (Simulation Sim, System.Data.Common.DbConnection Conn, List<SimulatedInfoMessageEventArgs> Captured) NewWithCapture()
+    {
+        var sim = new Simulation();
+        var conn = sim.CreateDbConnection();
+        conn.Open();
+        var captured = new List<SimulatedInfoMessageEventArgs>();
+        ((SimulatedDbConnection)conn).InfoMessage += (_, e) => captured.Add(e);
+        return (sim, conn, captured);
+    }
+
+    private static int RunNonQuery(System.Data.Common.DbConnection conn, string commandText)
+    {
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = commandText;
+        return cmd.ExecuteNonQuery();
+    }
+
+    [TestMethod]
+    public void Print_StringLiteral_FiresOneMessage()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'hello'");
+        HasCount(1, captured);
+        AreEqual("hello", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_TwoStatements_CoalesceWithLineFeed()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'first'; print 'second'");
+        HasCount(1, captured);
+        AreEqual("first\nsecond", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_NullOperand_EmitsSingleSpace()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print null");
+        HasCount(1, captured);
+        AreEqual(" ", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_StringPlusNull_EmitsSingleSpace()
+    {
+        // 'a' + NULL collapses to NULL under ANSI string-concat NULL semantics,
+        // and the NULL-operand-formats-as-single-space rule kicks in.
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'a' + null");
+        HasCount(1, captured);
+        AreEqual(" ", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_Integer_FormatsAsInvariantString()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 42");
+        HasCount(1, captured);
+        AreEqual("42", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_StringLiteral_PreservesEmbeddedNewlines()
+    {
+        // T-SQL string literals can carry raw newlines; the captured message
+        // should preserve them verbatim. (The `CHAR(13) + CHAR(10)` form used
+        // by some SQL idioms isn't reachable here — CHAR() isn't modeled —
+        // but the literal-newline form covers the same observation.)
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'line1\nline2'");
+        HasCount(1, captured);
+        AreEqual("line1\nline2", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_NoStatements_NoEventFires()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "select 1");
+        IsEmpty(captured);
+    }
+
+    [TestMethod]
+    public void Print_SkipModeIf_SuppressesEvent()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "if 1 = 0 print 'unreachable'");
+        IsEmpty(captured);
+    }
+
+    [TestMethod]
+    public void Print_ElseBranchTaken_FiresMessage()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "if 1 = 0 print 'no' else print 'yes'");
+        HasCount(1, captured);
+        AreEqual("yes", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_InsideWhile_CoalescesAllIterations()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, """
+            declare @i int = 0;
+            while @i < 3
+            begin
+                print 'iter ' + cast(@i as varchar(5));
+                set @i = @i + 1;
+            end
+            """);
+        HasCount(1, captured);
+        AreEqual("iter 0\niter 1\niter 2", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_InTransactionRollback_StillDelivers()
+    {
+        // Info messages aren't transactional — probe-confirmed PRINT inside
+        // BEGIN TRAN / ROLLBACK still fires.
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, """
+            begin tran;
+            print 'inside';
+            rollback
+            """);
+        HasCount(1, captured);
+        AreEqual("inside", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_BeforeAndAfterTryCatch_BothCoalesced()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, """
+            begin try
+                print 'before';
+                throw 50000, 'oops', 1;
+            end try
+            begin catch
+                print 'caught';
+            end catch
+            """);
+        HasCount(1, captured);
+        AreEqual("before\ncaught", captured[0].Message);
+    }
+
+    [TestMethod]
+    public void Print_TwoSeparateCommands_FireTwoEvents()
+    {
+        // Each ExecuteNonQuery is its own batch; events are per-batch, not
+        // per-connection-lifetime.
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'first command'");
+        _ = RunNonQuery(conn, "print 'second command'");
+        HasCount(2, captured);
+        AreEqual("first command", captured[0].Message);
+        AreEqual("second command", captured[1].Message);
+    }
+
+    [TestMethod]
+    public void Print_LineNumber_PointsToFirstPrint()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        // Three lines, first PRINT on line 2 (after the comment + select).
+        _ = RunNonQuery(conn, """
+            select 1;
+            print 'first';
+            print 'second'
+            """);
+        HasCount(1, captured);
+        AreEqual(2, captured[0].LineNumber);
+    }
+
+    [TestMethod]
+    public void Print_Source_IsSimulatorIdentifier()
+    {
+        var (_, conn, captured) = NewWithCapture();
+        _ = RunNonQuery(conn, "print 'hi'");
+        AreEqual("SqlServerSimulator", captured[0].Source);
+    }
+
+    [TestMethod]
+    public void Print_NoSubscriber_DoesNotThrow()
+    {
+        // Event delivery is null-safe — running PRINT without a subscriber
+        // is the common ad-hoc case.
+        var sim = new Simulation();
+        using var conn = sim.CreateDbConnection();
+        conn.Open();
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = "print 'no listener'";
+        _ = cmd.ExecuteNonQuery();
+    }
+}

SqlServerSimulator/Parser/BatchContext.cs

@@ -55,6 +55,63 @@ internal sealed class BatchContext
     /// </summary>
     public readonly StatementContext CurrentStatement = new();
 
+    /// <summary>
+    /// Buffer of <c>PRINT</c>-emitted strings collected across this batch.
+    /// Probe-confirmed coalescing semantic: multiple <c>PRINT</c> statements
+    /// in one command join with <c>\n</c> separators into a single
+    /// <see cref="SimulatedDbConnection.InfoMessage"/> firing at end of
+    /// dispatch. Null when no PRINT has fired yet (avoids the per-batch
+    /// allocation for the typical PRINT-less batch).
+    /// </summary>
+    private List<string>? pendingPrintMessages;
+
+    /// <summary>
+    /// 1-based line of the first <c>PRINT</c> statement in this batch —
+    /// captured at the moment the first message is buffered. SqlClient
+    /// probe-confirmed: the coalesced <c>InfoMessage</c> event carries
+    /// the first contributing statement's line, even when later <c>PRINT</c>s
+    /// in the same batch live on different lines.
+    /// </summary>
+    private int firstPrintLine;
+
+    /// <summary>
+    /// Buffers a <c>PRINT</c>-emitted string against this batch's pending
+    /// output list. Caller has already formatted the operand value into its
+    /// display string (NULL → single space per probe). Skipped-IF / loop-
+    /// control suppression is decided by the caller (<see cref="IsSkipping"/>),
+    /// not here.
+    /// </summary>
+    internal void AppendPrintMessage(string text)
+    {
+        if (this.pendingPrintMessages is null)
+        {
+            this.pendingPrintMessages = [];
+            this.firstPrintLine = this.CurrentStatement.StartLine;
+        }
+        this.pendingPrintMessages.Add(text);
+    }
+
+    /// <summary>
+    /// If any <c>PRINT</c> statements buffered output during this batch,
+    /// delivers them to <see cref="SimulatedDbConnection.InfoMessage"/>
+    /// subscribers as a single event (messages joined with <c>\n</c>,
+    /// <see cref="SimulatedInfoMessageEventArgs.LineNumber"/> set to the
+    /// first contributing PRINT's line). No-op when the buffer is empty.
+    /// Called by <see cref="Simulation.CreateResultSetsForCommand"/> after
+    /// dispatch completes.
+    /// </summary>
+    internal void FlushPrintMessages()
+    {
+        if (this.pendingPrintMessages is not { Count: > 0 } list)
+            return;
+        var joined = string.Join('\n', list);
+        this.Connection.RaiseInfoMessage(new SimulatedInfoMessageEventArgs(
+            joined,
+            this.firstPrintLine,
+            source: "SqlServerSimulator"));
+        list.Clear();
+    }
+
     /// <summary>
     /// Raw IF-skip flag: true while the dispatch loop is walking through an
     /// un-taken IF branch. The <see cref="IsSkipping"/> property OR's this

SqlServerSimulator/SimulatedDbConnection.cs

@@ -154,6 +154,25 @@ internal bool IsVerboseTruncationActive() =>
         ?? (this.TraceFlags.Contains(460)
             || this.CurrentDatabase.CompatibilityLevel >= CompatibilityLevel.Sql160);
 
+    /// <summary>
+    /// Fires once per batch when the batch contained at least one
+    /// <c>PRINT</c> statement that produced output (the un-taken-IF /
+    /// skip-mode path doesn't fire). Multiple <c>PRINT</c> calls in the
+    /// batch coalesce into a single event with the messages joined by
+    /// <c>\n</c> — matches SqlClient's <c>InfoMessage</c> probe behavior.
+    /// Internal-only until the consumer-facing event shape is settled
+    /// (<c>DbConnection</c> has no equivalent event in the base
+    /// class — going public means adding a new public-API surface).
+    /// </summary>
+    internal event EventHandler<SimulatedInfoMessageEventArgs>? InfoMessage;
+
+    /// <summary>
+    /// Delivers a buffered <c>PRINT</c> batch to <see cref="InfoMessage"/>
+    /// subscribers. Called from <see cref="Parser.BatchContext.FlushPrintMessages"/>
+    /// at the end of each command's dispatch.
+    /// </summary>
+    internal void RaiseInfoMessage(SimulatedInfoMessageEventArgs args) => this.InfoMessage?.Invoke(this, args);
+
     [AllowNull]
     public override string ConnectionString { get => ""; set => throw new NotImplementedException(); }