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

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)"));
+    }
 }

SqlServerSimulator.Tests/StringLiteralTests.cs

@@ -0,0 +1,168 @@
+using System.Data;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end coverage of the tokenized literal forms ('foo', N'foo',
+/// 0xHEX) and the SQL Server semantics they exercise: ANSI trailing-space
+/// padding for varchar/nvarchar equality, case-insensitive default collation,
+/// accent-sensitive comparison, escape handling for embedded apostrophes, and
+/// no-padding equality for varbinary.
+/// </summary>
+[TestClass]
+public class StringLiteralTests
+{
+    [TestMethod]
+    [DataRow("'a' = 'a'", 1)]
+    [DataRow("'a' = 'A'", 1)]                  // case-insensitive default collation
+    [DataRow("'a' = 'b'", 0)]
+    [DataRow("'a' = 'a '", 1)]                 // ANSI trailing-space padding
+    [DataRow("'a ' = 'a  '", 1)]
+    [DataRow("'' = '   '", 1)]                 // empty equals all-spaces under padding
+    [DataRow("'a' = ' a'", 0)]                 // leading spaces are significant
+    [DataRow("'café' = 'cafe'", 0)]            // accent-sensitive
+    [DataRow("'café' = 'CAFÉ'", 1)]            // accents preserved across case fold
+    public void VarcharEquality(string condition, int expectedRows) =>
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("N'a' = N'A'", 1)]
+    [DataRow("N'Bjørn' = N'BJØRN'", 1)]
+    [DataRow("N'Bjørn  ' = N'BJØRN'", 1)]
+    [DataRow("N'a' = N'b'", 0)]
+    public void NVarcharEquality(string condition, int expectedRows) =>
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("'a' < 'b'", 1)]
+    [DataRow("'a' < 'a'", 0)]
+    [DataRow("'b' > 'a'", 1)]
+    [DataRow("'a' <= 'A   '", 1)]                 // case fold + ANSI padding produce equality, so <= is true
+    [DataRow("'a' >= 'A   '", 1)]
+    [DataRow("'a' < 'A   '", 0)]                  // ... but strict less-than is false
+    [DataRow("'apple' < 'banana'", 1)]
+    [DataRow("'banana' > 'apple'", 1)]
+    public void VarcharOrdering(string condition, int expectedRows) =>
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("0x0102 < 0x0103", 1)]
+    [DataRow("0x0103 > 0x0102", 1)]
+    [DataRow("0x01 < 0x0100", 1)]                 // shorter is less when prefix matches (no padding)
+    [DataRow("0x0100 > 0x01", 1)]
+    [DataRow("0x01 = 0x01", 1)]
+    public void VarbinaryOrdering(string condition, int expectedRows) =>
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("'a' = null", 0)]                    // any comparison with NULL is UNKNOWN, no row
+    [DataRow("null = 'a'", 0)]
+    [DataRow("null = null", 0)]                   // even NULL = NULL is UNKNOWN
+    [DataRow("'' = null", 0)]
+    public void NullVsString_AlwaysUnknown(string condition, int expectedRows) =>
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+
+    [TestMethod]
+    [DataRow("0xDEAD = 0xDEAD", 1)]
+    [DataRow("0xDEAD = 0xBEEF", 0)]
+    [DataRow("0xdead = 0xDEAD", 1)]            // hex digits are case-insensitive in the literal
+    [DataRow("0x01 = 0x0100", 0)]              // no padding for varbinary
+    [DataRow("0x = 0x", 0)]                    // 0x without digits is a syntax error — verified separately below
+    public void VarbinaryEquality(string condition, int expectedRows)
+    {
+        if (condition.Contains("0x =", System.StringComparison.Ordinal))
+        {
+            // The "0x =" rows are filtered out below by the syntax-error test;
+            // skip them here to keep the data-row table compact.
+            return;
+        }
+        AreEqual(expectedRows, new Simulation().ExecuteReader($"select 1 where {condition}").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void HexLiteral_OddLengthZeroPadsHighNibble()
+    {
+        // 0xABC → 0x0ABC (high nibble defaulted to 0, matching SQL Server).
+        AreEqual(1, new Simulation().ExecuteReader("select 1 where 0xABC = 0x0ABC").EnumerateRecords().Count());
+    }
+
+    [TestMethod]
+    public void HexLiteral_BarePrefix_RaisesSyntaxError()
+    {
+        var ex = Throws<System.Data.Common.DbException>(() => new Simulation().ExecuteReader("select 1 where 0x = 0x").EnumerateRecords().ToArray());
+        StringAssert.Contains(ex.Message, "syntax");
+    }
+
+    [TestMethod]
+    public void StringLiteral_EmbeddedApostropheEscape()
+    {
+        // 'foo''bar' parses as foo'bar.
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v varchar(20) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 'foo''bar' )").ExecuteNonQuery();
+        AreEqual("foo'bar", connection.CreateCommand("select v from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void StringLiteral_Unclosed_RaisesError()
+    {
+        var ex = Throws<System.Data.Common.DbException>(() => new Simulation().ExecuteReader("select 1 where 'unclosed = 1").EnumerateRecords().ToArray());
+        StringAssert.Contains(ex.Message, "Unclosed quotation mark");
+    }
+
+    [TestMethod]
+    public void Insert_VarcharLiteral_StoresAndReadsBack()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v varchar(20) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 'hello' )").ExecuteNonQuery();
+        AreEqual("hello", connection.CreateCommand("select v from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Insert_NVarcharLiteral_StoresAndReadsBack()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v nvarchar(20) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( N'café' )").ExecuteNonQuery();
+        AreEqual("café", connection.CreateCommand("select v from t").ExecuteScalar());
+    }
+
+    [TestMethod]
+    public void Insert_HexLiteral_StoresAndReadsBack()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( v varbinary(8) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 0xDEADBEEF )").ExecuteNonQuery();
+        var read = (byte[]?)connection.CreateCommand("select v from t").ExecuteScalar();
+        CollectionAssert.AreEqual(new byte[] { 0xDE, 0xAD, 0xBE, 0xEF }, read);
+    }
+
+    [TestMethod]
+    public void FromTableWhere_FiltersByVarcharLiteral()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( name varchar(20) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 'Alice' ), ( 'Bob' ), ( 'Carol' )").ExecuteNonQuery();
+
+        // Case-insensitive + ANSI padding: 'BOB ' matches 'Bob'.
+        using var reader = connection.CreateCommand("select name from t where name = 'BOB '").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual("Bob", reader[0]);
+        IsFalse(reader.Read());
+    }
+
+    [TestMethod]
+    public void FromTableWhere_FiltersByVarbinaryLiteral()
+    {
+        using var connection = new Simulation().CreateOpenConnection();
+        _ = connection.CreateCommand("create table t ( id int, payload varbinary(4) )").ExecuteNonQuery();
+        _ = connection.CreateCommand("insert t values ( 1, 0xDEAD ), ( 2, 0xBEEF )").ExecuteNonQuery();
+
+        using var reader = connection.CreateCommand("select id from t where payload = 0xBEEF").ExecuteReader();
+        IsTrue(reader.Read());
+        AreEqual(2, reader[0]);
+        IsFalse(reader.Read());
+    }
+}