Implemented many of the standard SQL Server functions with a TODO list for the documented set.

Author: RyanLamansky

CLAUDE.md

@@ -10,7 +10,7 @@ Auto-loaded orientation. `README.md` is for humans.
 
 ## Operating goal
 
-High-fidelity emulation. Authenticity over desirability — when SQL Server's behavior is quirky or lossy (CP1252 `?` replacement, ANSI trailing-space `=` padding, `LEN` excluding trailing spaces), mirror it. Current fidelity bar: EF Core trusts the simulator end-to-end. `*.Tests.EFCore` is the regression oracle. Priority is opportunistic — pick the lowest-effort path that unlocks the most application compatibility next.
+High-fidelity emulation. Authenticity over desirability — when SQL Server's behavior is quirky or lossy (CP1252 `?` replacement, ANSI trailing-space `=` padding, `LEN` excluding trailing spaces), mirror it. EF Core trusts the simulator end-to-end (`*.Tests.EFCore` is the regression oracle and must stay green). Beyond that floor, priority is broad SQL Server coverage weighted by popularity (user wins) and ease (thoroughness wins). The function-coverage backlog at [`docs/claude/function-coverage-todo.md`](docs/claude/function-coverage-todo.md) is sorted by that weighting and tracks category-completion milestones — read it before pitching a new built-in function.
 
 ## Feature-bundle workflow
 

SqlServerSimulator.Tests/AtAtKeywordExpansionTests.cs

@@ -0,0 +1,89 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the expanded <c>@@</c>-keyword surface added alongside the
+/// scalar-function coverage push: constant-returning ones land in
+/// <c>Value</c>'s switch; session/database-state ones get dedicated
+/// expression classes. Probe-confirmed defaults against SQL Server 2025
+/// (2026-05-22) for the configurable knobs (@@DATEFIRST=7, @@TEXTSIZE=-1,
+/// @@OPTIONS=5432, etc.).
+/// </summary>
+[TestClass]
+public sealed class AtAtKeywordExpansionTests
+{
+    [TestMethod]
+    public void AtAt_MaxPrecision_ReturnsByte38()
+        => AreEqual((byte)38, new Simulation().ExecuteScalar("select @@max_precision"));
+
+    [TestMethod]
+    public void AtAt_MaxConnections_Returns32767()
+        => AreEqual(32767, new Simulation().ExecuteScalar("select @@max_connections"));
+
+    [TestMethod]
+    public void AtAt_Langid_ReturnsZero()
+        => AreEqual((short)0, new Simulation().ExecuteScalar("select @@langid"));
+
+    [TestMethod]
+    public void AtAt_Language_ReturnsUsEnglish()
+        => AreEqual("us_english", new Simulation().ExecuteScalar("select @@language"));
+
+    [TestMethod]
+    public void AtAt_ServiceName_ReturnsMssqlServer()
+        => AreEqual("MSSQLSERVER", new Simulation().ExecuteScalar("select @@servicename"));
+
+    [TestMethod]
+    public void AtAt_ServerName_ReturnsSimulated()
+        => AreEqual("SIMULATED", new Simulation().ExecuteScalar("select @@servername"));
+
+    [TestMethod]
+    public void AtAt_RemServer_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select @@remserver"));
+
+    [TestMethod]
+    public void AtAt_DateFirst_ReturnsSeven()
+        => AreEqual((byte)7, new Simulation().ExecuteScalar("select @@datefirst"));
+
+    [TestMethod]
+    public void AtAt_TextSize_ReturnsNegativeOne()
+        => AreEqual(-1, new Simulation().ExecuteScalar("select @@textsize"));
+
+    [TestMethod]
+    public void AtAt_Options_ReturnsDefaultMask()
+        => AreEqual(5432, new Simulation().ExecuteScalar("select @@options"));
+
+    [TestMethod]
+    public void AtAt_NestLevel_ReturnsZeroOutsideProc()
+        => AreEqual(0, new Simulation().ExecuteScalar("select @@nestlevel"));
+
+    [TestMethod]
+    public void AtAt_NestLevel_IncrementsInProc()
+    {
+        var sim = new Simulation();
+        sim.ExecuteBatches(
+            "create procedure dbo.p as select @@nestlevel");
+        AreEqual(1, sim.ExecuteScalar("exec dbo.p"));
+    }
+
+    [TestMethod]
+    public void AtAt_ProcId_ReturnsZeroOutsideProc()
+        => AreEqual(0, new Simulation().ExecuteScalar("select @@procid"));
+
+    [TestMethod]
+    public void AtAt_ProcId_ReturnsProcObjectIdInProc()
+    {
+        var sim = new Simulation();
+        sim.ExecuteBatches(
+            "create procedure dbo.p as select @@procid");
+        var procId = (int?)sim.ExecuteScalar("select object_id('dbo.p')");
+        AreEqual(procId, sim.ExecuteScalar("exec dbo.p"));
+    }
+
+    [TestMethod]
+    public void AtAt_Dbts_ReturnsEightBytes()
+    {
+        var result = new Simulation().ExecuteScalar("select @@dbts");
+        IsTrue(result is byte[] { Length: 8 });
+    }
+}

SqlServerSimulator.Tests/BitManipulationTests.cs

@@ -0,0 +1,74 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the SQL Server 2022+ bit-manipulation family: <c>BIT_COUNT</c>,
+/// <c>GET_BIT</c>, <c>SET_BIT</c>, <c>LEFT_SHIFT</c>, <c>RIGHT_SHIFT</c>.
+/// Probe-confirmed against SQL Server 2025 (2026-05-22): RIGHT_SHIFT uses
+/// LOGICAL (unsigned) shift semantics — <c>RIGHT_SHIFT(-16, 2)</c> returns
+/// <c>1073741820</c>, not <c>-4</c>.
+/// </summary>
+[TestClass]
+public sealed class BitManipulationTests
+{
+    [TestMethod]
+    public void BitCount_Seven_ReturnsThree()
+        => AreEqual(3L, new Simulation().ExecuteScalar("select bit_count(cast(7 as int))"));
+
+    [TestMethod]
+    public void BitCount_NegativeOneInt_Returns32()
+        => AreEqual(32L, new Simulation().ExecuteScalar("select bit_count(cast(-1 as int))"));
+
+    [TestMethod]
+    public void BitCount_NegativeOneBigint_Returns64()
+        => AreEqual(64L, new Simulation().ExecuteScalar("select bit_count(cast(-1 as bigint))"));
+
+    [TestMethod]
+    public void BitCount_TinyintMax_Returns8()
+        => AreEqual(8L, new Simulation().ExecuteScalar("select bit_count(cast(255 as tinyint))"));
+
+    [TestMethod]
+    public void BitCount_Null_RaisesMsg8116()
+        => new Simulation().AssertSqlError("select bit_count(null)", 8116);
+
+    [TestMethod]
+    public void GetBit_LowBitSet_ReturnsTrue()
+        => IsTrue((bool)new Simulation().ExecuteScalar("select get_bit(cast(7 as int), 0)")!);
+
+    [TestMethod]
+    public void GetBit_HighBitClear_ReturnsFalse()
+        => IsFalse((bool)new Simulation().ExecuteScalar("select get_bit(cast(7 as int), 3)")!);
+
+    [TestMethod]
+    public void GetBit_OutOfRange_RaisesMsg8120()
+        => new Simulation().AssertSqlError("select get_bit(cast(8 as int), 32)", 8120);
+
+    [TestMethod]
+    public void SetBit_SetsHighBit()
+        => AreEqual(8, new Simulation().ExecuteScalar("select set_bit(cast(0 as int), 3)"));
+
+    [TestMethod]
+    public void SetBit_ClearWithValue_Works()
+        => AreEqual(7, new Simulation().ExecuteScalar("select set_bit(cast(15 as int), 3, 0)"));
+
+    [TestMethod]
+    public void LeftShift_PreservesType_Tinyint()
+        => AreEqual((byte)128, new Simulation().ExecuteScalar("select left_shift(cast(1 as tinyint), 7)"));
+
+    [TestMethod]
+    public void LeftShift_OverflowsTinyint_WrapsToZero()
+        => AreEqual((byte)0, new Simulation().ExecuteScalar("select left_shift(cast(1 as tinyint), 8)"));
+
+    [TestMethod]
+    public void RightShift_PositiveInt_Works()
+        => AreEqual(4, new Simulation().ExecuteScalar("select right_shift(cast(16 as int), 2)"));
+
+    [TestMethod]
+    public void RightShift_NegativeInt_LogicalShift()
+        => AreEqual(1073741820, new Simulation().ExecuteScalar("select right_shift(cast(-16 as int), 2)"));
+
+    [TestMethod]
+    public void LeftShift_Bigint_LargeShift()
+        => AreEqual(1073741824L, new Simulation().ExecuteScalar("select left_shift(cast(1 as bigint), 30)"));
+}

SqlServerSimulator.Tests/ChecksumAndRowVersionTests.cs

@@ -0,0 +1,61 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>CHECKSUM</c>, <c>BINARY_CHECKSUM</c>, and
+/// <c>MIN_ACTIVE_ROWVERSION</c>. The simulator's CHECKSUM uses a
+/// 32-bit FNV-1a fold over the value representation rather than
+/// SQL Server's unpublished CRC; only the semantic guarantee
+/// ("equal inputs → equal outputs") matches, not the exact bit
+/// pattern — documented quirk.
+/// </summary>
+[TestClass]
+public sealed class ChecksumAndRowVersionTests
+{
+    [TestMethod]
+    public void Checksum_SameInput_SameOutput()
+    {
+        var a = (int)new Simulation().ExecuteScalar("select checksum('foo')")!;
+        var b = (int)new Simulation().ExecuteScalar("select checksum('foo')")!;
+        AreEqual(a, b);
+    }
+
+    [TestMethod]
+    public void Checksum_DifferentInput_DifferentOutput()
+    {
+        var a = (int)new Simulation().ExecuteScalar("select checksum('foo')")!;
+        var b = (int)new Simulation().ExecuteScalar("select checksum('bar')")!;
+        AreNotEqual(a, b);
+    }
+
+    [TestMethod]
+    public void Checksum_MultipleArgs_Works()
+    {
+        var result = new Simulation().ExecuteScalar("select checksum(1, 'foo', cast('2024-01-15' as date))");
+        IsTrue(result is int);
+    }
+
+    [TestMethod]
+    public void Checksum_CaseInsensitive_SameAsLower()
+    {
+        var a = (int)new Simulation().ExecuteScalar("select checksum('FOO')")!;
+        var b = (int)new Simulation().ExecuteScalar("select checksum('foo')")!;
+        AreEqual(a, b);
+    }
+
+    [TestMethod]
+    public void BinaryChecksum_CaseSensitive_DiffersFromCaseChange()
+    {
+        var a = (int)new Simulation().ExecuteScalar("select binary_checksum('FOO')")!;
+        var b = (int)new Simulation().ExecuteScalar("select binary_checksum('foo')")!;
+        AreNotEqual(a, b);
+    }
+
+    [TestMethod]
+    public void MinActiveRowVersion_Returns8Bytes()
+    {
+        var result = new Simulation().ExecuteScalar("select min_active_rowversion()");
+        IsTrue(result is byte[] { Length: 8 });
+    }
+}

SqlServerSimulator.Tests/ChooseTests.cs

@@ -0,0 +1,69 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for the <c>CHOOSE(index, val1, val2, ...)</c> scalar function — the
+/// 1-based variadic picker. Result type is the joint promotion of the value
+/// arms (CASE-style branch-type unification); out-of-range and NULL index
+/// both return typed NULL.
+/// </summary>
+[TestClass]
+public sealed class ChooseTests
+{
+    [TestMethod]
+    public void Choose_FirstValue_ReturnsFirst()
+        => AreEqual("a", new Simulation().ExecuteScalar("select choose(1, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_MiddleValue_ReturnsThat()
+        => AreEqual("b", new Simulation().ExecuteScalar("select choose(2, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_LastValue_ReturnsLast()
+        => AreEqual("c", new Simulation().ExecuteScalar("select choose(3, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_IndexZero_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select choose(0, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_IndexNegative_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select choose(-1, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_IndexBeyondList_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select choose(4, 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_NullIndex_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select choose(cast(null as int), 'a', 'b', 'c')"));
+
+    [TestMethod]
+    public void Choose_PickedValueIsNull_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select choose(2, 'a', cast(null as varchar(10)), 'c')"));
+
+    [TestMethod]
+    public void Choose_IntegerValues_ReturnsInt()
+        => AreEqual(20, new Simulation().ExecuteScalar("select choose(2, 10, 20, 30)"));
+
+    [TestMethod]
+    public void Choose_MixedTypes_PromotesToHigher()
+        => AreEqual(20m, new Simulation().ExecuteScalar("select choose(2, cast(10 as decimal(10, 2)), 20, 30)"));
+
+    [TestMethod]
+    public void Choose_OnlyIndexNoValues_RaisesMsg174()
+        => new Simulation().AssertSqlError("select choose(1)", 174);
+
+    [TestMethod]
+    public void Choose_FromTableValues_RoundTrips()
+        => AreEqual("medium", new Simulation().ExecuteScalar("""
+            create table sizes (id int);
+            insert sizes values (2);
+            select choose(id, 'small', 'medium', 'large') from sizes
+            """));
+
+    [TestMethod]
+    public void Choose_StringIndexCoerced_Works()
+        => AreEqual("b", new Simulation().ExecuteScalar("select choose('2', 'a', 'b', 'c')"));
+}

SqlServerSimulator.Tests/ColNameLengthTests.cs

@@ -0,0 +1,57 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Tests for <c>COL_NAME(table_id, col_id)</c> and
+/// <c>COL_LENGTH(table_name, col_name)</c>: column-level metadata
+/// lookups used by introspection queries and EF Core's schema
+/// migration scaffolding.
+/// </summary>
+[TestClass]
+public sealed class ColNameLengthTests
+{
+    [TestMethod]
+    public void ColName_FirstColumn_ReturnsName()
+        => AreEqual("id", new Simulation().ExecuteScalar("create table t (id int, name varchar(50)); select col_name(object_id('t'), 1)"));
+
+    [TestMethod]
+    public void ColName_SecondColumn_ReturnsName()
+        => AreEqual("name", new Simulation().ExecuteScalar("create table t (id int, name varchar(50)); select col_name(object_id('t'), 2)"));
+
+    [TestMethod]
+    public void ColName_OutOfRange_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("create table t (id int); select col_name(object_id('t'), 99)"));
+
+    [TestMethod]
+    public void ColName_UnknownTable_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select col_name(99999, 1)"));
+
+    [TestMethod]
+    public void ColName_NullTableId_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select col_name(null, 1)"));
+
+    [TestMethod]
+    public void ColLength_Int_Returns4()
+        => AreEqual((short)4, new Simulation().ExecuteScalar("create table t (id int); select col_length('t', 'id')"));
+
+    [TestMethod]
+    public void ColLength_Bigint_Returns8()
+        => AreEqual((short)8, new Simulation().ExecuteScalar("create table t (id bigint); select col_length('t', 'id')"));
+
+    [TestMethod]
+    public void ColLength_Varchar50_Returns50()
+        => AreEqual((short)50, new Simulation().ExecuteScalar("create table t (name varchar(50)); select col_length('t', 'name')"));
+
+    [TestMethod]
+    public void ColLength_Nvarchar50_Returns100Bytes()
+        => AreEqual((short)100, new Simulation().ExecuteScalar("create table t (name nvarchar(50)); select col_length('t', 'name')"));
+
+    [TestMethod]
+    public void ColLength_UnknownColumn_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("create table t (id int); select col_length('t', 'missing')"));
+
+    [TestMethod]
+    public void ColLength_NullArg_ReturnsNull()
+        => AreEqual(DBNull.Value, new Simulation().ExecuteScalar("select col_length(null, 'col')"));
+}