Add T-SQL PRINT (parses + evaluates operand so type errors like Msg 245 still surface; discards the message — DbConnection has no InfoMessage event and no app has needed observation yet; @@rowcount resets to 0 per probe; skip-mode gates evaluation; Msg 1046 scalar-subquery rejection and 8000/4000-char truncation are documented fidelity gaps).

RyanLamansky · RyanLamansky · commit 9865049f094f · 2026-05-11T09:24:42.000-05:00
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -370,6 +370,19 @@ Each statement parser still runs its full parse — the cursor advances normally
 
 **Fidelity gap** (Q15): real SQL Server defers name resolution for un-taken branches — `IF 1=0 SELECT bad_col FROM bad_table` runs silently. The simulator's parsers do name resolution inline with parsing, so un-taken branches with non-existent table/column refs still raise Msg 208 / Msg 207. Common idioms (safe-CREATE / safe-DROP / safe-INSERT against pre-existing tables) work end-to-end because referenced names exist when the branch is skipped.
 
+### `PRINT`
+`PRINT <expression>` parses + evaluates the operand and **discards the result** — no `InfoMessage` event on `SimulatedDbConnection` (DbConnection doesn't define one, and no application has needed PRINT output observation yet). The evaluation isn't a no-op: operand-side errors still surface — `PRINT 'val=' + 5` raises Msg 245 because the `+` operator's int-side promotion tries to parse `'val='` as int (probe-confirmed against SQL Server 2025).
+
+Probe-confirmed semantics (2026-05-11) the simulator handles correctly because evaluation runs unchanged:
+- `PRINT NULL` and `PRINT ''` are silent no-ops (no message body, no error).
+- `PRINT` resets `@@ROWCOUNT` to 0 — applied by the dispatcher after the parser returns.
+- Skip-mode (un-taken IF, after BREAK / CONTINUE / RETURN) suppresses operand evaluation entirely, so an error-bearing operand in a skipped branch doesn't fire. Standard pattern: parse the expression unconditionally to advance the cursor, then gate `expression.Run` on `!batch.IsSkipping`.
+- Rollback doesn't undo a PRINT (real SQL Server's InfoMessage stream is non-transactional too); orthogonal to the simulator's discard-everything design.
+
+**Fidelity gaps** (modeled deviations from probed behavior):
+- Real SQL Server's PRINT truncates messages at 8000 chars (varchar) / 4000 chars (nvarchar). Simulator: no truncation modeled (output is discarded).
+- Real SQL Server raises **Msg 1046** ("Subqueries are not allowed in this context. Only scalar expressions are allowed.") for `PRINT (SELECT 'inner')`. The simulator silently evaluates the scalar subquery — Msg 1046 isn't modeled.
+
 ### Local temp tables (`#foo`)
 Per-connection `Dictionary<string, HeapTable> TempTables` on `SimulatedDbConnection`; routed by `BatchContext.TryResolveTable` (`#`-prefix → connection dict, else current DB + system tables). Auto-cleared on `Dispose`, matching real SQL Server's session-close drop. Lifecycle, cross-conn isolation, and Msg 208 from other sessions all probe-confirmed against SQL Server 2025.
 
@@ -414,7 +427,8 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - **`ALTER TABLE #foo`**, **`TRUNCATE TABLE #foo`**, **`OBJECT_ID('tempdb..#foo')`** — none modeled (none of those exist for regular tables either yet). The common `IF OBJECT_ID(...) IS NOT NULL DROP TABLE` cleanup pattern works via `DROP TABLE IF EXISTS #foo` instead.
 - **Three-part name resolution outside DROP TABLE**: `tempdb..#foo` in FROM / INSERT / UPDATE / DELETE / MERGE / SET IDENTITY_INSERT raises `InvalidObjectName` (Msg 208) on the qualifier; use bare `#foo`. DROP TABLE alone tolerates the qualifier (probe pattern).
 - T-SQL `GOTO` / labels — `IF` / `BEGIN…END` / `WHILE` / `BREAK` / `CONTINUE` / `RETURN` (bare) ship; unconditional jumps don't.
-- `TRY ... CATCH`, `THROW`, `RAISERROR`, `@@ERROR`, `PRINT`, stored procs / UDFs. `BEGIN TRY` / `BEGIN ATOMIC` / `BEGIN DISTRIBUTED TRANSACTION` raise `NotSupportedException` at dispatch (peeked after `BEGIN`). Value-form `RETURN N` raises Msg 178 (reserved for the stored-proc / function scope, neither modeled yet).
+- `TRY ... CATCH`, `THROW`, `RAISERROR`, `@@ERROR`, stored procs / UDFs. `BEGIN TRY` / `BEGIN ATOMIC` / `BEGIN DISTRIBUTED TRANSACTION` raise `NotSupportedException` at dispatch (peeked after `BEGIN`). Value-form `RETURN N` raises Msg 178 (reserved for the stored-proc / function scope, neither modeled yet).
+- **`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.
 - `hierarchyid`, `geography`, `geometry`.
 
 ## Quirks (modeled, not byte-identical to SQL Server)
diff --git a/SqlServerSimulator.Tests/PrintStatementTests.cs b/SqlServerSimulator.Tests/PrintStatementTests.cs
@@ -0,0 +1,176 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the <c>PRINT</c> statement. The simulator parses + evaluates
+/// the operand (so type / coercion errors surface naturally) and discards
+/// the result — <see cref="SimulatedDbConnection"/> doesn't expose an
+/// <c>InfoMessage</c> event because <c>DbConnection</c> doesn't define one
+/// and there's no demonstrated need for the public surface yet. The tests
+/// verify side-effect-free behavior (<c>@@ROWCOUNT</c> reset, skip-mode
+/// suppression, runtime errors from the operand path) rather than message
+/// capture. Behavior probed against SQL Server 2025 (2026-05-11).
+/// </summary>
+[TestClass]
+public sealed class PrintStatementTests
+{
+    [TestMethod]
+    public void Print_StringLiteral_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print 'hello'");
+
+    [TestMethod]
+    public void Print_Null_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print null");
+
+    [TestMethod]
+    public void Print_Integer_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print 42");
+
+    [TestMethod]
+    public void Print_Decimal_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print 1.5");
+
+    [TestMethod]
+    public void Print_Float_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print cast(1.5 as float)");
+
+    [TestMethod]
+    public void Print_Variable_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("declare @v varchar(10) = 'hi'; print @v");
+
+    [TestMethod]
+    public void Print_Expression_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print 5 + 3");
+
+    [TestMethod]
+    public void Print_StringConcat_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print 'a' + 'b'");
+
+    [TestMethod]
+    public void Print_Case_DoesNotThrow()
+        => _ = new Simulation().ExecuteNonQuery("print case when 1=1 then 'y' else 'n' end");
+
+    /// <summary>
+    /// PRINT evaluates the operand normally, so the <c>+</c> operator's
+    /// int-side promotion still kicks in — <c>'val=' + 5</c> tries to parse
+    /// <c>'val='</c> as int and raises Msg 245. Probe-confirmed: real SQL
+    /// Server raises the same Msg 245.
+    /// </summary>
+    [TestMethod]
+    public void Print_StringPlusInt_Msg245()
+        => new Simulation().AssertSqlError("print 'val=' + 5", 245);
+
+    /// <summary>
+    /// Probe-confirmed: PRINT resets <c>@@ROWCOUNT</c> to 0 — the next
+    /// statement reads 0 regardless of whatever the prior statement set.
+    /// </summary>
+    [TestMethod]
+    public void Print_Resets_RowCount_To_Zero()
+    {
+        using var reader = new Simulation().ExecuteReader("""
+            select 1 union all select 2 union all select 3;
+            print 'between';
+            select @@rowcount as rc
+            """);
+        // Drain the first result set (the SELECT … UNION ALL).
+        while (reader.Read()) { }
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual(0, reader.GetInt32(0));
+    }
+
+    // ---- Skip-mode interaction ----
+
+    /// <summary>
+    /// In an un-taken IF branch, PRINT's operand isn't evaluated — so an
+    /// otherwise-error-raising expression inside the un-taken branch is
+    /// silently skipped (matches every other statement parser's skip-mode
+    /// gate).
+    /// </summary>
+    [TestMethod]
+    public void Print_InUntakenIf_OperandNotEvaluated()
+        => _ = new Simulation().ExecuteNonQuery("if 1=0 print 'val=' + 5");
+
+    [TestMethod]
+    public void Print_InTakenIf_StillEvaluates()
+        => new Simulation().AssertSqlError("if 1=1 print 'val=' + 5", 245);
+
+    [TestMethod]
+    public void Print_InUntakenElse_OperandNotEvaluated()
+        => _ = new Simulation().ExecuteNonQuery("if 1=1 select 'taken' else print 'val=' + 5");
+
+    [TestMethod]
+    public void Print_AfterReturn_NotEvaluated()
+        => _ = new Simulation().ExecuteNonQuery("return; print 'val=' + 5");
+
+    [TestMethod]
+    public void Print_InBlock_BeforeReturn_Evaluates()
+        => new Simulation().AssertSqlError(
+            "begin print 'val=' + 5; return; end",
+            245);
+
+    /// <summary>
+    /// PRINT inside a WHILE evaluates each iteration. Verify by including
+    /// an operand that would always error if reached past the BREAK gate.
+    /// </summary>
+    [TestMethod]
+    public void Print_InWhile_RunsEachIteration()
+    {
+        // Loop runs twice, then BREAKs; PRINT inside fires on both runs.
+        _ = new Simulation().ExecuteNonQuery("""
+            declare @i int = 0;
+            while @i < 2
+            begin
+                set @i = @i + 1;
+                print @i;
+            end
+            """);
+    }
+
+    // ---- Statement composition / dispatch ----
+
+    [TestMethod]
+    public void Multiple_Prints_AllRun()
+        => _ = new Simulation().ExecuteNonQuery("print 'a'; print 'b'; print 'c'");
+
+    [TestMethod]
+    public void Print_Then_Select_SelectReturnsRow()
+    {
+        using var reader = new Simulation().ExecuteReader("print 'x'; select 1 as v");
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Select_Then_Print_SelectReturnsRow()
+    {
+        using var reader = new Simulation().ExecuteReader("select 1 as v print 'x'");
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void Print_BareReturnsAfter_BatchContinues()
+    {
+        using var reader = new Simulation().ExecuteReader("print 'before'; select 'after'");
+        IsTrue(reader.Read());
+        AreEqual("after", reader.GetString(0));
+    }
+
+    /// <summary>
+    /// PRINT inside a rolled-back transaction is a no-op for the simulator
+    /// (output is discarded anyway). The point of this test is to verify
+    /// PRINT doesn't interact badly with the undo log or transaction state.
+    /// </summary>
+    [TestMethod]
+    public void Print_InRolledBackTransaction_NoStateLeak()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("begin tran; print 'inside'; rollback");
+        // Subsequent statement on a fresh connection should work normally.
+        AreEqual(1, sim.ExecuteScalar<int>("select 1"));
+    }
+}
diff --git a/SqlServerSimulator/Parser/Selection.cs b/SqlServerSimulator/Parser/Selection.cs
@@ -423,6 +423,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                         or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                         or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
                         or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
+                        or Keyword.Print
                 } when depth == 0:
                     goto ExitWhileTokenLoop;
 
@@ -566,6 +567,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                         or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                         or Keyword.Set or Keyword.Declare or Keyword.If or Keyword.Else or Keyword.End
                         or Keyword.While or Keyword.Break or Keyword.Continue or Keyword.Return
+                        or Keyword.Print
                 } when depth == 0:
                     goto ExitWhileTokenLoop;
 
diff --git a/SqlServerSimulator/Simulation/Simulation.Print.cs b/SqlServerSimulator/Simulation/Simulation.Print.cs
@@ -0,0 +1,39 @@
+using SqlServerSimulator.Parser;
+
+namespace SqlServerSimulator;
+
+partial class Simulation
+{
+    /// <summary>
+    /// Parses and runs a <c>PRINT &lt;expression&gt;</c> statement. The
+    /// expression is parsed unconditionally (advancing the cursor) and
+    /// evaluated only when not in skip mode so an un-taken <c>IF</c> branch
+    /// doesn't surface runtime errors from the value computation. Whatever
+    /// value the expression produces is discarded — the simulator doesn't
+    /// expose an <c>InfoMessage</c> event on <see cref="SimulatedDbConnection"/>
+    /// (<c>DbConnection</c> doesn't define one, and a public surface for
+    /// observing PRINT output isn't justified yet). Probed against SQL Server
+    /// 2025 (2026-05-11): PRINT resets <c>@@ROWCOUNT</c> to 0 (the dispatcher
+    /// applies the reset on return); NULL operand emits an empty message;
+    /// long strings truncate at 8000 / 4000 chars depending on collation —
+    /// none of which the simulator needs to model when output is discarded.
+    /// </summary>
+    /// <remarks>
+    /// Type validity follows from normal expression evaluation: <c>PRINT 'val=' + 5</c>
+    /// raises Msg 245 from the <c>+</c> operator (matches probe). One known
+    /// fidelity gap: real SQL Server raises Msg 1046 ("Subqueries are not
+    /// allowed in this context") when a scalar subquery appears in the PRINT
+    /// operand; the simulator silently evaluates it.
+    /// </remarks>
+    private static void ParsePrintStatement(BatchContext batch)
+    {
+        var context = batch.Parser;
+        context.MoveNextRequired(); // consume PRINT
+        var expression = Expression.Parse(context);
+        if (batch.IsSkipping)
+            return;
+        // Evaluate for side effects (surfacing any runtime errors from the
+        // operand's type / coercion path) and discard the result.
+        _ = expression.Run(new RuntimeContext(NoColumnResolver, batch));
+    }
+}
diff --git a/SqlServerSimulator/Simulation/Simulation.cs b/SqlServerSimulator/Simulation/Simulation.cs
@@ -322,6 +322,12 @@ private IEnumerable<SimulatedStatementOutcome> DispatchOneStatement(BatchContext
                 ParseReturnStatement(batch);
                 break;
 
+            case ReservedKeyword { Keyword: Keyword.Print }:
+                ParsePrintStatement(batch);
+                if (!batch.IsSkipping)
+                    connection.LastStatementRowCount = 0;
+                break;
+
             case ReservedKeyword { Keyword: Keyword.Begin }:
                 // Peek the token after BEGIN to disambiguate transaction-start
                 // (BEGIN TRAN / BEGIN TRANSACTION / BEGIN DISTRIBUTED TRAN) from
@@ -413,7 +419,7 @@ or Keyword.Merge or Keyword.Begin or Keyword.Commit or Keyword.Rollback
                 or Keyword.Save or Keyword.Create or Keyword.Drop or Keyword.Alter or Keyword.Dbcc
                 or Keyword.Set or Keyword.Declare or Keyword.With or Keyword.If or Keyword.Else
                 or Keyword.End or Keyword.While or Keyword.Break or Keyword.Continue
-                or Keyword.Return
+                or Keyword.Return or Keyword.Print
         };
 
     /// <summary>
