Per-batch scalar variables: DECLARE @v TYPE [= expr] [, @w ...] (multi-decl + inline init + optional AS), SET @v = expr, and SELECT @v = expr [, @w = expr2 ...] [FROM ...] (multi-assign, last-row-wins post-ORDER-BY, empty-result-keeps-prior, mixed-with-projection → Msg 141, yields SimulatedNonQuery so no result-set envelope). SqlClient parameters seed the same per-batch Variables dictionary as if pre-DECLAREd, sharing a namespace (collision → Msg 134); InputOutput/Output parameters write their final slot value back to DbParameter.Value at end of batch. VariableReference captures a live VariableSlot at parse time and reads slot.Value at runtime so SET/SELECT-assign mutations are observable; assignment coercion routes through Cast.ApplyCoercion so slot type fidelity is honored (SET @v(varchar(3)) = 'hello' truncates to 'hel'; SET @v(int) = 'abc' → Msg 245). @@rowcount tracks the last-completed statement via Simulation.LastStatementRowCount — SELECT materializes rows up-front so the next statement sees the final count, DML writes RecordsAffected, SET/DECLARE-with-init write 1, bare DECLARE preserves prior, transaction/DDL reset to 0. Compound assignment (+= etc.), table variables, control flow, TRY/CATCH, and implicit statement separation deferred.

Author: RyanLamansky

CLAUDE.md

@@ -250,6 +250,25 @@ Three entry points share one per-connection undo log: implicit (statement-level
 ### `rowversion` (legacy synonym `timestamp`)
 8-byte big-endian database-scoped monotonic counter; advances on every INSERT into a rowversion-bearing table and every UPDATE affecting one. Storage type name surfaces as `timestamp` in `information_schema` regardless of declaration. Explicit insert → Msg 273; explicit update → Msg 272; second column on a table → Msg 2738. Outbound CAST: `varbinary(N)`/`binary(N)` copy 8 bytes; `bigint` reads big-endian. `Promote(RowVersion, Varbinary) → Varbinary` so EF's `WHERE [rv] = @originalRv` parameter works directly. EF `[Timestamp]` SaveChanges round-trips end-to-end.
 
+### Variables: `DECLARE` / `SET` / `SELECT @v = expr`
+Per-batch scalar variables. `DECLARE @v TYPE [= expr] [, @w TYPE [= expr] ...]` registers slots; `SET @v = expr` and `SELECT @v = expr [, @w = expr2 ...]` mutate them. SqlClient parameters seed the same store as if pre-DECLAREd, so a parameter and a DECLARE can't share a name (Msg 134).
+
+Variable references resolve at runtime via a captured `VariableSlot` — required because mutations between statements have to be visible to subsequent reads. Assignment coercion routes through `Cast.ApplyCoercion` so the slot's declared type is honored: `SET @v(varchar(3)) = 'hello'` truncates to `'hel'`; `SET @v(int) = 'abc'` raises Msg 245.
+
+**SELECT-assign quirks**:
+- All-or-nothing: `SELECT @v = 1, 2` (mixing assign and projection) → Msg 141.
+- Empty result-set keeps prior value (no rows iterate, slot unchanged); `SET @v = (SELECT no rows)` differs — assigns NULL.
+- Multi-row last-row-wins post-ORDER-BY (per-row evaluation, last write wins).
+- The dispatch drains rows for side-effects and yields a `SimulatedNonQuery` rather than a result set (matches SQL Server's no-result-set-envelope behavior for SELECT-assign).
+
+**Errors**: Msg 137 use-before-declare (existing factory); Msg 134 duplicate DECLARE (also fires for parameter+DECLARE collision); Msg 141 mixed assignment + retrieval; standard CAST errors propagate from coercion (Msg 245, Msg 8115, etc.). `DECLARE @v INT NOT NULL` and `DECLARE @v INT = DEFAULT` raise Msg 102 / 156 respectively (DECLARE doesn't accept column-style constraints — falls out of grammar mismatch).
+
+**Output-parameter write-back**: at end of batch, the dispatch walks the parameter list and copies each `InputOutput` / `Output` direction parameter's final slot value back to `DbParameter.Value`. Mirrors SqlClient's round-trip behavior for hand-rolled scripts that mutate parameters.
+
+**`@@ROWCOUNT`**: tracks the most-recently-completed statement's row count via `Simulation.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.
+
+**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. Statements within a batch require `;` separators (existing simulator-wide convention; real SQL Server accepts implicit separation in many cases).
+
 ### Common table expressions
 `WITH name [(col, …)] AS (SELECT …) [, …] {SELECT|INSERT|UPDATE|DELETE|MERGE} …`. WITH prefix scopes to exactly one immediately-following statement. Both non-recursive and recursive forms modeled.
 
@@ -329,6 +348,11 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 - `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).
 - Heap allocation tracking (flat page list, no IAM/PFS).
 - Per-connection session state for `SCOPE_IDENTITY()` / `@@IDENTITY`, `SET IDENTITY_INSERT`'s active table, `DBCC TRACEON(N)` flags — all live on `Simulation` rather than connection. (Tx state is already per-connection.)
+- Compound assignment (`SET @v += expr` / `-=` / `*=` etc.) — rewrite as `SET @v = @v + expr`. The arithmetic-operator runtime is locked behind `protected` instance methods on `TwoSidedExpression`; exposing them as static helpers is the prerequisite refactor.
+- Table variables (`DECLARE @t TABLE (...)`) — separate feature with its own storage / scope / lifecycle.
+- T-SQL control flow (`IF` / `WHILE` / `BEGIN ... END` / `BREAK` / `CONTINUE`) — Bundle 2 of scripting.
+- `TRY ... CATCH`, `THROW`, `RAISERROR`, `@@ERROR`, `RETURN`, `PRINT`, stored procs / UDFs.
+- Implicit statement separation: real SQL Server accepts `declare @v int = 7 select @v` without `;`; simulator requires explicit semicolons between statements when one ends with an expression.
 - `hierarchyid`, `geography`, `geometry`.
 
 ## Quirks (modeled, not byte-identical to SQL Server)

SqlServerSimulator.Tests.EFCore/EFCoreFromSql.cs

@@ -44,4 +44,5 @@ public void FromSqlInterpolated_StringParameterAgainstIntColumn_PromotesAndMatch
         Assert.AreEqual(2, customer.Id);
         Assert.AreEqual("beta", customer.Name);
     }
+
 }

SqlServerSimulator.Tests/VariableTests.cs

@@ -0,0 +1,223 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class VariableTests
+{
+    [TestMethod]
+    public void Declare_NoInit_VariableIsNull()
+        => AreEqual(DBNull.Value, ExecuteScalar("declare @v int; select @v"));
+
+    [TestMethod]
+    public void Declare_WithInit_HoldsValue()
+        => AreEqual(7, ExecuteScalar<int>("declare @v int = 7; select @v"));
+
+    [TestMethod]
+    public void Declare_AsKeywordOptional()
+        => AreEqual(1, ExecuteScalar<int>("declare @v as int = 1; select @v"));
+
+    [TestMethod]
+    public void Declare_MultiVariable_AllReadable()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("declare @v int = 7, @w varchar(5) = 'abc'; select @v, @w");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(7, reader.GetInt32(0));
+        AreEqual("abc", reader.GetString(1));
+    }
+
+    [TestMethod]
+    public void Set_Assigns()
+        => AreEqual(42, ExecuteScalar<int>("declare @v int; set @v = 42; select @v"));
+
+    [TestMethod]
+    public void Set_StringToInt_Coerces()
+        => AreEqual(42, ExecuteScalar<int>("declare @v int; set @v = '42'; select @v"));
+
+    [TestMethod]
+    public void Set_BadStringToInt_RaisesMsg245()
+        => AssertSqlError("declare @v int; set @v = 'abc'; select @v", 245,
+            "Conversion failed when converting the varchar value 'abc' to data type int.");
+
+    [TestMethod]
+    public void Set_StringTruncatesToVarcharLength()
+        => AreEqual("hel", ExecuteScalar("declare @v varchar(3); set @v = 'hello'; select @v"));
+
+    [TestMethod]
+    public void Set_DecimalToInt_Truncates()
+        => AreEqual(3, ExecuteScalar<int>("declare @v int; set @v = 3.7; select @v"));
+
+    [TestMethod]
+    public void Set_ScalarSubquery_Assigns()
+        => AreEqual(42, ExecuteScalar<int>("declare @v int; set @v = (select 42); select @v"));
+
+    [TestMethod]
+    public void Set_MultiRowSubquery_RaisesMsg512()
+    {
+        var sim = new Simulation();
+        _ = sim.ExecuteNonQuery("create table t (id int); insert t values (1),(2)");
+        _ = sim.AssertSqlError("declare @v int; set @v = (select id from t); select @v", 512);
+    }
+
+    [TestMethod]
+    public void Set_EmptySubquery_AssignsNull()
+        => AreEqual(DBNull.Value, ExecuteScalar(
+            "declare @v int = 99; set @v = (select 1 where 1 = 0); select @v"));
+
+    [TestMethod]
+    public void SelectAssign_Single()
+        => AreEqual(42, ExecuteScalar<int>("declare @v int; select @v = 42; select @v"));
+
+    [TestMethod]
+    public void SelectAssign_LastRowWins()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (id int); insert t values (1),(2),(3)").ExecuteNonQuery();
+        AreEqual(3, conn.CreateCommand(
+            "declare @v int; select @v = id from t order by id; select @v").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void SelectAssign_EmptyResult_KeepsPriorValue()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (id int); insert t values (1)").ExecuteNonQuery();
+        AreEqual(99, conn.CreateCommand(
+            "declare @v int = 99; select @v = id from t where id = 0; select @v").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void SelectAssign_NullResult_AssignsNull()
+        => AreEqual(DBNull.Value, ExecuteScalar(
+            "declare @v int = 99; select @v = case when 1=0 then 1 else null end; select @v"));
+
+    [TestMethod]
+    public void SelectAssign_MultiVariable()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand(
+            "declare @v int, @w varchar(10); select @v = 1, @w = 'x'; select @v, @w");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(1, reader.GetInt32(0));
+        AreEqual("x", reader.GetString(1));
+    }
+
+    [TestMethod]
+    public void SelectAssign_MultiVariableLastRowWins()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (a int, b int); insert t values (1, 2), (3, 4)").ExecuteNonQuery();
+        using var cmd = conn.CreateCommand(
+            "declare @v int, @w int; select @v = a, @w = b from t order by a; select @v, @w");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(3, reader.GetInt32(0));
+        AreEqual(4, reader.GetInt32(1));
+    }
+
+    [TestMethod]
+    public void SelectAssign_MixedWithProjection_RaisesMsg141()
+        => AssertSqlError("declare @v int; select @v = 1, 2", 141,
+            "A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations.");
+
+    [TestMethod]
+    public void Reference_BeforeDeclare_RaisesMsg137()
+        => AssertSqlError("select @x", 137, "Must declare the scalar variable \"@x\".");
+
+    [TestMethod]
+    public void Declare_Duplicate_RaisesMsg134()
+        => AssertSqlError("declare @v int; declare @v int; select @v", 134,
+            "The variable name '@v' has already been declared. Variable names must be unique within a query batch or stored procedure.");
+
+    [TestMethod]
+    public void Declare_NameCollidesWithParameter_RaisesMsg134()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("declare @x int = 99; select @x", ("@x", 1));
+        var ex = Throws<DbException>(cmd.ExecuteScalar);
+        AreEqual("134", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void ReservedKeywordAsVariableName_Works()
+        => AreEqual(1, ExecuteScalar<int>("declare @select int = 1; select @select"));
+
+    [TestMethod]
+    public void Declare_SelfReference_RaisesMsg137()
+        => AssertSqlError("declare @v int = @v + 1; select @v", 137);
+
+    [TestMethod]
+    public void Declare_MultipleStatementsViaSemicolon()
+        => AreEqual(3, ExecuteScalar<int>("declare @x int = 1; declare @y int = 2; select @x + @y"));
+
+    [TestMethod]
+    public void Variable_InWhereClause_FiltersRows()
+        => IsNull(ExecuteScalar("declare @x int = 5; select 1 where 1 = @x"));
+
+    [TestMethod]
+    public void RowCount_AfterSelect()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand(
+            "select 1 union select 2 union select 3; select @@rowcount as rc");
+        using var reader = cmd.ExecuteReader();
+        IsTrue(reader.NextResult());
+        IsTrue(reader.Read());
+        AreEqual(3, reader.GetInt32(0));
+    }
+
+    [TestMethod]
+    public void RowCount_AfterDeclareWithInit_IsOne()
+        => AreEqual(1, ExecuteScalar<int>(
+            "declare @v int = 99; select @@rowcount"));
+
+    [TestMethod]
+    public void RowCount_AfterBareDeclare_PreservedFromPriorStatement()
+    {
+        // INSERT sets @@ROWCOUNT to 3; bare DECLARE without init does NOT reset.
+        using var conn = new Simulation().CreateOpenConnection();
+        _ = conn.CreateCommand("create table t (id int)").ExecuteNonQuery();
+        using var cmd = conn.CreateCommand(
+            "insert t values (1),(2),(3); declare @v int; select @@rowcount");
+        AreEqual(3, cmd.ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void RowCount_AfterSet_IsOne()
+        => AreEqual(1, ExecuteScalar<int>("declare @v int; set @v = 42; select @@rowcount"));
+
+    [TestMethod]
+    public void OutputParameter_WrittenBackAfterBatch()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("set @x = 999");
+        var p = cmd.CreateParameter();
+        p.ParameterName = "@x";
+        p.DbType = System.Data.DbType.Int32;
+        p.Direction = System.Data.ParameterDirection.InputOutput;
+        p.Value = 5;
+        _ = cmd.Parameters.Add(p);
+        _ = cmd.ExecuteNonQuery();
+        AreEqual(999, p.Value);
+    }
+
+    [TestMethod]
+    public void InputParameter_NotWrittenBack()
+    {
+        using var conn = new Simulation().CreateOpenConnection();
+        using var cmd = conn.CreateCommand("set @x = 999");
+        var p = cmd.CreateParameter();
+        p.ParameterName = "@x";
+        p.DbType = System.Data.DbType.Int32;
+        p.Direction = System.Data.ParameterDirection.Input;
+        p.Value = 5;
+        _ = cmd.Parameters.Add(p);
+        _ = cmd.ExecuteNonQuery();
+        AreEqual(5, p.Value);
+    }
+}

SqlServerSimulator/Errors/SimulatedSqlException.ResolutionErrors.cs

@@ -25,6 +25,24 @@ internal static SimulatedSqlException AmbiguousColumnName(string name) =>
 
     internal static SimulatedSqlException MustDeclareScalarVariable(string name) => new($"Must declare the scalar variable \"@{name}\".", 137, 15, 2);
 
+    /// <summary>
+    /// Mimics SQL Server's Msg 134 — fired when a <c>DECLARE</c> names a
+    /// variable that already exists in the batch (either a previous
+    /// <c>DECLARE</c> or a SqlClient parameter of the same name —
+    /// probe-confirmed parameters and declared variables share a
+    /// namespace).
+    /// </summary>
+    internal static SimulatedSqlException VariableAlreadyDeclared(string name) =>
+        new($"The variable name '@{name}' has already been declared. Variable names must be unique within a query batch or stored procedure.", 134, 15, 1);
+
+    /// <summary>
+    /// Mimics SQL Server's Msg 141 — fired when a <c>SELECT</c> mixes
+    /// variable assignment (<c>@v = expr</c>) with non-assignment
+    /// projection elements in the same projection list.
+    /// </summary>
+    internal static SimulatedSqlException SelectAssignmentMixedWithRetrieval() =>
+        new("A SELECT statement that assigns a value to a variable must not be combined with data-retrieval operations.", 141, 15, 1);
+
     /// <summary>
     /// Mimics SQL Server error 4104: the OUTPUT clause references an
     /// identifier that doesn't exist in either the INSERTED/DELETED virtual

SqlServerSimulator/Parser/AtAtKeyword.cs

@@ -13,6 +13,7 @@ enum AtAtKeyword
     NestLevel,
     Options,
     RemServer,
+    RowCount,
     ServerName,
     ServiceName,
     SpId,

SqlServerSimulator/Parser/Expression.cs

@@ -61,11 +61,12 @@ public static Expression Parse(ParserContext context)
         {
             Numeric number => new Value(number.Value),
             Literal literal => new Value(literal.Value),
-            AtPrefixedString atPrefixed => new Value(atPrefixed, context),
+            AtPrefixedString atPrefixed => new VariableReference(atPrefixed, context),
             DoubleAtPrefixedString doubleAtPrefixedString => doubleAtPrefixedString.Parse() switch
             {
                 AtAtKeyword.Identity => new LastIdentityExpression(context.Simulation),
                 AtAtKeyword.TranCount => new TranCountExpression(context),
+                AtAtKeyword.RowCount => new RowCountExpression(context.Simulation),
                 _ => new Value(doubleAtPrefixedString),
             },
             ReservedKeyword { Keyword: Keyword.Null } => new Value(),

SqlServerSimulator/Parser/Expressions/AssignmentExpression.cs

@@ -0,0 +1,39 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Represents a <c>@v = expr</c> projection element in a SELECT-assign:
+/// holds the live <see cref="VariableSlot"/> reference (mutated as the
+/// projection runs row-by-row) and the RHS source expression. <c>Run</c>
+/// has the side effect of writing to the slot via the standard CAST
+/// coercion path; the returned <see cref="SqlValue"/> is the post-coerce
+/// value but is never surfaced because SELECT-assign produces no result
+/// rows.
+/// </summary>
+/// <remarks>
+/// Empty-result-keeps-prior-value (probe-confirmed) falls out naturally:
+/// when the FROM clause yields zero rows, this expression's <c>Run</c>
+/// is never called, so the slot retains its prior value. Non-empty
+/// last-row-wins (also probe-confirmed) follows from per-row evaluation
+/// — each row's <c>Run</c> overwrites the slot, so the final value is the
+/// last iterated row's RHS.
+/// </remarks>
+internal sealed class AssignmentExpression(VariableSlot slot, Expression source) : Expression
+{
+    public readonly VariableSlot Slot = slot;
+
+    public readonly Expression Source = source;
+
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue)
+    {
+        var value = this.Source.Run(getColumnValue);
+        var coerced = Cast.ApplyCoercion(value, this.Slot.DeclaredType, this.Slot.DeclaredMaxLength);
+        this.Slot.Value = coerced;
+        return coerced;
+    }
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => this.Slot.DeclaredType;
+
+    internal override string DebugDisplay() => $"@{this.Slot.DeclaredType} = {this.Source.DebugDisplay()}";
+}

SqlServerSimulator/Parser/Expressions/AtTimeZone.cs

@@ -178,7 +178,7 @@ public static AtTimeZone ParsePostfix(Expression source, ParserContext context)
         Literal lit => new Value(lit.Value),
         Numeric num => new Value(num.Value),
         ReservedKeyword { Keyword: Keyword.Null } => new Value(),
-        AtPrefixedString atVar => new Value(atVar, context),
+        AtPrefixedString atVar => new VariableReference(atVar, context),
         Name name => new Reference(name),
         Operator { Character: '(' } => ParseParenthesizedZone(context),
         _ => throw SimulatedSqlException.SyntaxErrorNear(context),

SqlServerSimulator/Parser/Expressions/RowCountExpression.cs

@@ -0,0 +1,27 @@
+using SqlServerSimulator.Storage;
+
+namespace SqlServerSimulator.Parser.Expressions;
+
+/// <summary>
+/// Backs <c>@@ROWCOUNT</c>: returns the row count of the most recently
+/// completed statement in the current batch as <see cref="SqlType.Int32"/>.
+/// Probe-confirmed semantics (against SQL Server 2025, 2026-05-12):
+/// <list type="bullet">
+/// <item>SELECT result count (rows produced).</item>
+/// <item>INSERT / UPDATE / DELETE / MERGE rows-affected.</item>
+/// <item><c>SET @v = expr</c> and <c>DECLARE @v T = init</c> set it to 1.</item>
+/// <item><c>DECLARE @v T</c> (no initializer) does NOT reset it.</item>
+/// <item>SELECT-assign with FROM sets it to rows scanned (regardless of
+/// whether assignments fired); empty FROM result sets it to 0.</item>
+/// <item>Most other statements (PRINT, BEGIN, COMMIT, etc.) reset to 0.</item>
+/// </list>
+/// </summary>
+internal sealed class RowCountExpression(Simulation simulation) : Expression
+{
+    public override SqlValue Run(Func<MultiPartName, SqlValue> getColumnValue) =>
+        SqlValue.FromInt32(simulation.LastStatementRowCount);
+
+    public override SqlType GetSqlType(Func<MultiPartName, SqlType> resolveColumnType) => SqlType.Int32;
+
+    internal override string DebugDisplay() => "@@ROWCOUNT";
+}