Add @@error — always returns 0 because TRY/CATCH isn't modeled (every SimulatedSqlException terminates the batch, so only successful statements ever complete). LastErrorExpression mirrors TranCount/RowCount and provides the natural home for live tracking on BatchContext when TRY/CATCH lands.

Author: RyanLamansky

CLAUDE.md

@@ -279,6 +279,8 @@ Variable references resolve at runtime via a captured `VariableSlot` — require
 
 **`@@ROWCOUNT`**: tracks the most-recently-completed statement's row count via `SimulatedDbConnection.LastStatementRowCount`. SELECT row counts populate after the dispatch materializes rows up-front (so the next statement in the batch sees the final count); DML mutations write their affected count; `SET` / `DECLARE @v = init` write 1; bare `DECLARE @v` (no initializer) preserves the prior count; transaction / DDL statements reset to 0.
 
+**`@@ERROR`**: error number of the most-recently-completed statement; `int`. **Always 0 in the simulator** because TRY/CATCH isn't modeled — every `SimulatedSqlException` propagates out of the dispatch loop and terminates the batch, so only successful statements ever complete. Straight-line scripts that read `@@ERROR` after a known-good statement get correct behavior; scripts that wrap a statement-terminating-only error in `TRY ... CATCH` and expect to observe the number won't until TRY/CATCH lands — at which point `LastErrorExpression` becomes the natural home for live tracking on `BatchContext`.
+
 **Compound assignment** (`SET @v += expr` etc.) and **table variables** (`DECLARE @t TABLE (...)`) aren't modeled — rewrite as `SET @v = @v + expr` for the former; the latter is a separate bundle.
 
 ### Common table expressions
@@ -433,7 +435,7 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - **`ALTER 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`, 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`, 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). `@@ERROR` parses + returns 0 (see batch-state section); live tracking lands with TRY/CATCH.
 - **`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`.
 

SqlServerSimulator.Tests/AtAtErrorTests.cs

@@ -0,0 +1,54 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>@@ERROR</c>. The simulator always returns 0 because TRY/CATCH
+/// isn't modeled — any <c>SimulatedSqlException</c> propagates out of the
+/// dispatch loop and terminates the batch, so the only statements that ever
+/// complete are successful ones and the most-recently-completed statement's
+/// error number is always 0. Apps that read <c>@@ERROR</c> in straight-line
+/// scripts (no TRY/CATCH wrapping) get correct behavior; apps that wrap a
+/// statement-terminating-only error in TRY/CATCH and expect to observe the
+/// number won't work until TRY/CATCH lands.
+/// </summary>
+[TestClass]
+public sealed class AtAtErrorTests
+{
+    [TestMethod]
+    public void AtAtError_BareRead_IsZero()
+        => AreEqual(0, new Simulation().ExecuteScalar("select @@error"));
+
+    [TestMethod]
+    public void AtAtError_AfterSuccessfulInsert_IsZero()
+        => AreEqual(0, new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1);
+            select @@error
+            """));
+
+    [TestMethod]
+    public void AtAtError_CaseInsensitive()
+        => AreEqual(0, new Simulation().ExecuteScalar("select @@ERROR"));
+
+    [TestMethod]
+    public void AtAtError_UsableInPredicate()
+        => AreEqual("ok", new Simulation().ExecuteScalar("""
+            create table t (id int);
+            insert t values (1);
+            if @@error = 0 select 'ok'
+            """));
+
+    [TestMethod]
+    public void AtAtError_ReturnsInt()
+    {
+        using var reader = new Simulation().ExecuteReader("select @@error as e");
+        IsTrue(reader.Read());
+        AreEqual(typeof(int), reader.GetFieldType(0));
+        AreEqual(0, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void AtAtError_InArithmetic_IsZero()
+        => AreEqual(7, new Simulation().ExecuteScalar("select @@error + 7"));
+}

SqlServerSimulator/Parser/AtAtKeyword.cs

@@ -4,6 +4,7 @@ enum AtAtKeyword
 {
     _ = 0, // "Default" value for the enum, indicating not a keyword.
     Dbts,
+    Error,
     Identity,
     LangId,
     Language,

SqlServerSimulator/Parser/Expression.cs

@@ -64,6 +64,7 @@ public static Expression Parse(ParserContext context)
             AtPrefixedString atPrefixed => new VariableReference(atPrefixed, context),
             DoubleAtPrefixedString doubleAtPrefixedString => doubleAtPrefixedString.Parse() switch
             {
+                AtAtKeyword.Error => new LastErrorExpression(),
                 AtAtKeyword.Identity => new LastIdentityExpression(),
                 AtAtKeyword.TranCount => new TranCountExpression(context),
                 AtAtKeyword.RowCount => new RowCountExpression(),

SqlServerSimulator/Parser/Expressions/LastErrorExpression.cs

@@ -0,0 +1,21 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Backs <c>@@ERROR</c>: error number of the most recently completed
+/// statement, <see cref="SqlType.Int32"/>. Always returns 0 in the simulator
+/// because TRY/CATCH isn't modeled — any <see cref="SimulatedSqlException"/>
+/// propagates out of the dispatch loop and terminates the batch, so the only
+/// statements that ever complete are successful ones. When TRY/CATCH lands,
+/// this expression becomes the natural home for live error-number tracking
+/// against state on <see cref="BatchContext"/>.
+/// </summary>
+internal sealed class LastErrorExpression : Expression
+{
+    public override SqlValue Run(RuntimeContext runtime) => SqlValue.FromInt32(0);
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => "@@ERROR";
+}