Filled out varchar/nvarchar/varbinary support: string and binary literals ('foo', N'foo', 0xAB), case-insensitive equality and ordering with ANSI trailing-space padding, twelve common string functions (LEN, LEFT/RIGHT, SUBSTRING, UPPER/LOWER, LTRIM/RTRIM/TRIM, CHARINDEX, REPLACE, REVERSE), and CAST for integer-family targets.

Author: RyanLamansky

CLAUDE.md

@@ -10,6 +10,8 @@ SqlServerSimulator is a .NET library that emulates a SQL Server instance in-proc
 
 High-fidelity SQL Server simulation, eventually including transactions, locks, MVCC, real allocation tracking (IAM/PFS), and overflow pages — the things that make SQL Server *SQL Server*, not just a SQL parser with a hash table behind it. The fidelity bar is set by the EF Core regression oracle in the `*.Tests.EFCore` project: if EF Core trusts the simulator end-to-end, the simulator is earning its keep. That project must stay green.
 
+When SQL Server's actual behavior is quirky or lossy (CP1252's silent `?` replacement for out-of-codepage characters, ANSI trailing-space padding for `=`, `LEN` excluding trailing spaces), mirror it rather than "fixing" it — authenticity over desirability is what makes the simulator a faithful stand-in.
+
 A long arc replacing in-memory boxed-object row storage with page-format-aligned encoding completed before this file was written; the simulator now has a single backend with real 8KB pages. Transactions / locks / MVCC are the next phase.
 
 ## Public API surface
@@ -61,10 +63,13 @@ Single sentence with period. Concrete artifacts named where useful. Squashes cap
 
 The main test project is split topically — one file per feature (SELECT, WHERE, TOP, INSERT, etc.). When adding tests, prefer extending an existing topical file over creating a new one with overlapping scope. Storage internals are tested separately because they require `internal` access.
 
+Prefer public-API tests when the behavior is reachable from SQL — they exercise the full parse/evaluate path and don't pin internal shapes that may refactor. Reserve `Tests.Internal` for things genuinely unreachable from public SQL: raw storage byte layouts, encoder/decoder invariants, and similar contracts that have no observable public surface.
+
 ## Live limitations
 
 Live state is best read from the code itself and recent commit history. Architectural-level gaps as of the page-storage milestone:
 - Transactions / locks / MVCC: not implemented. The page foundation is in place; the next phase hasn't started.
 - Row-overflow / LOB pages: not modeled. Rows whose encoded size exceeds SQL Server's 8060-byte in-row limit throw at insert time; `varchar(MAX)` is parsed but rejected with a clear "not yet supported" error rather than silently fall through.
 - Heap allocation: flat page list. No IAM/PFS allocation tracking.
-- Cross-category type promotion (string ↔ numeric): not implemented.
+- Cross-category and cross-string-type coercion (string ↔ numeric, varchar ↔ nvarchar): not implemented. `CAST` and the binary-expression `Promote` path both error on these pairs.
+- Pattern matching (`LIKE`), `CONVERT`, fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns: not modeled.

SqlServerSimulator.Tests.EFCore/EFCoreStrings.cs

@@ -159,6 +159,91 @@ public void Insert_NullableAvatarAcceptsNull()
         Assert.IsNull(context.People.Select(p => p.Avatar).FirstOrDefault());
     }
 
+    [TestMethod]
+    public void StringFunction_Length()
+    {
+        // EF Core translates string.Length to CAST(LEN(x) AS int) — exercises
+        // LEN's trailing-space exclusion and CAST in one query.
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "Alice   " });
+        _ = context.SaveChanges();
+
+        var len = context.People.Select(p => p.Name.Length).FirstOrDefault();
+        Assert.AreEqual(5, len);
+    }
+
+    [TestMethod]
+    public void StringFunction_ToUpper()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "alice" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("ALICE", context.People.Select(p => p.Name.ToUpper()).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_ToLower()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "ALICE" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("alice", context.People.Select(p => p.Name.ToLower()).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_Trim()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "  bob  " });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("bob", context.People.Select(p => p.Name.Trim()).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_TrimStart()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "  bob" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("bob", context.People.Select(p => p.Name.TrimStart()).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_TrimEnd()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "bob  " });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("bob", context.People.Select(p => p.Name.TrimEnd()).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_Substring()
+    {
+        // C# Substring(start, length) is 0-indexed; EF Core's translation to
+        // T-SQL SUBSTRING (1-indexed) handles the off-by-one.
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "alphabet" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("lpha", context.People.Select(p => p.Name.Substring(1, 4)).FirstOrDefault());
+    }
+
+    [TestMethod]
+    public void StringFunction_Replace()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        _ = context.People.Add(new Person { Id = 1, Name = "hello" });
+        _ = context.SaveChanges();
+
+        Assert.AreEqual("heLLo", context.People.Select(p => p.Name.Replace("l", "L")).FirstOrDefault());
+    }
+
     [TestMethod]
     public void Insert_MultipleRows_RoundTripsBothColumns()
     {

SqlServerSimulator.Tests/BuiltInFunctionTests.cs

@@ -35,4 +35,133 @@ public void BuiltInFunction(string function, string input, object output)
         AreEqual(output, ExecuteScalar($"select {function}({input})"));
         AreEqual(output, ExecuteScalar($"select {function.ToUpperInvariant()}({input})"));
     }
+
+    [TestMethod]
+    [DataRow("len('abc')", 3)]
+    [DataRow("len('abc   ')", 3)]                   // trailing spaces excluded
+    [DataRow("len('   ')", 0)]                      // all-trailing-space → 0
+    [DataRow("len('')", 0)]
+    [DataRow("len('  abc')", 5)]                    // leading spaces preserved
+    [DataRow("datalength('abc')", 3)]               // for varchar: 1 byte/char in CP1252
+    [DataRow("datalength('café')", 4)]              // 'café' is 4 CP1252 bytes
+    [DataRow("datalength(N'café')", 8)]             // nvarchar: 2 bytes/char
+    [DataRow("upper('AbC')", "ABC")]
+    [DataRow("upper('café')", "CAFÉ")]
+    [DataRow("lower('AbC')", "abc")]
+    [DataRow("lower('CAFÉ')", "café")]
+    [DataRow("ltrim('   abc')", "abc")]
+    [DataRow("ltrim('   abc   ')", "abc   ")]       // only leading
+    [DataRow("rtrim('abc   ')", "abc")]
+    [DataRow("rtrim('   abc   ')", "   abc")]       // only trailing
+    [DataRow("trim('   abc   ')", "abc")]
+    [DataRow("trim('abc')", "abc")]
+    [DataRow("reverse('abc')", "cba")]
+    [DataRow("reverse('')", "")]
+    [DataRow("left('hello', 3)", "hel")]
+    [DataRow("left('hi', 10)", "hi")]                // count past length clamps
+    [DataRow("left('abc', 0)", "")]
+    [DataRow("right('hello', 3)", "llo")]
+    [DataRow("right('hi', 10)", "hi")]
+    [DataRow("right('abc', 0)", "")]
+    [DataRow("substring('hello', 2, 3)", "ell")]    // 1-indexed
+    [DataRow("substring('hello', 1, 5)", "hello")]
+    [DataRow("substring('hello', 6, 5)", "")]       // start past end → empty
+    [DataRow("substring('hello', 0, 3)", "he")]     // start <= 0 truncates window
+    [DataRow("charindex('lo', 'hello')", 4)]
+    [DataRow("charindex('xx', 'hello')", 0)]        // not found
+    [DataRow("charindex('LO', 'hello')", 4)]        // case-insensitive
+    [DataRow("charindex('l', 'hello', 4)", 4)]      // start at l-position
+    [DataRow("charindex('l', 'hello', 5)", 0)]      // start past last l
+    [DataRow("replace('hello', 'l', 'L')", "heLLo")]
+    [DataRow("replace('hello', 'L', 'X')", "heXXo")] // case-insensitive match
+    [DataRow("replace('hello', 'xyz', '!')", "hello")]
+    public void StringFunction(string expression, object expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("len")]
+    [DataRow("upper")]
+    [DataRow("lower")]
+    [DataRow("ltrim")]
+    [DataRow("rtrim")]
+    [DataRow("trim")]
+    [DataRow("reverse")]
+    public void StringFunction_NullPassThrough(string function) =>
+        IsInstanceOfType<DBNull>(ExecuteScalar($"select {function}(null)"));
+
+    [TestMethod]
+    [DataRow("left(null, 3)")]
+    [DataRow("left('abc', null)")]
+    [DataRow("right(null, 3)")]
+    [DataRow("substring(null, 1, 3)")]
+    [DataRow("substring('abc', null, 3)")]
+    [DataRow("substring('abc', 1, null)")]
+    [DataRow("charindex(null, 'abc')")]
+    [DataRow("charindex('a', null)")]
+    [DataRow("replace(null, 'a', 'b')")]
+    [DataRow("replace('abc', null, 'b')")]
+    [DataRow("replace('abc', 'a', null)")]
+    public void MultiArgStringFunction_NullPropagates(string expression) =>
+        IsInstanceOfType<DBNull>(ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("left('abc', -1)")]
+    [DataRow("right('abc', -1)")]
+    [DataRow("substring('abc', 1, -1)")]
+    public void NegativeLength_RaisesMsg537(string expression)
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar($"select {expression}"));
+        StringAssert.Contains(ex.Message, "Invalid length parameter");
+    }
+
+    [TestMethod]
+    public void FunctionOfColumn_FromTable()
+    {
+        // Regression: Expression.Parse used to advance past the function's
+        // closing ')' AND let the surrounding while loop advance again,
+        // skipping a trailing FROM. The `select abs(n) from t` shape never had
+        // a test before this arc, so the bug surfaced only via EF Core.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v int )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 5 )").ExecuteNonQuery();
+        AreEqual(5, connection.CreateCommand("select abs(v) from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void StringFunctionOfColumn_FromTable()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( name varchar(20) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 'alice' )").ExecuteNonQuery();
+        AreEqual("ALICE", connection.CreateCommand("select upper(name) from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    [DataRow("cast(1 as int)", 1)]
+    [DataRow("cast(1 as bigint)", 1L)]
+    [DataRow("cast(1 as smallint)", (short)1)]
+    [DataRow("cast(255 as tinyint)", (byte)255)]
+    [DataRow("cast(1 as bit)", true)]
+    [DataRow("cast(0 as bit)", false)]
+    public void Cast(string expression, object expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void Cast_NullPassesThroughWithRetargetedType() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select cast(null as int)"));
+
+    [TestMethod]
+    public void Cast_NarrowingOverflow_RaisesArithmeticOverflow()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(300 as tinyint)"));
+        StringAssert.Contains(ex.Message, "Arithmetic overflow");
+    }
+
+    [TestMethod]
+    public void Cast_CrossCategory_NotSupported()
+    {
+        // String ↔ numeric coercion isn't modeled yet; CAST surfaces the same
+        // NotSupportedException SqlValue.CoerceTo throws.
+        _ = Throws<NotSupportedException>(() => ExecuteScalar("select cast('42' as int)"));
+    }
 }