Improved simulation accuracy.

Author: RyanLamansky

CLAUDE.md

@@ -71,5 +71,5 @@ Live state is best read from the code itself and recent commit history. Architec
 - 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 and cross-string-type coercion (string ↔ numeric, varchar ↔ nvarchar): not implemented. `CAST` and the binary-expression `Promote` path both error on these pairs.
+- Cross-string-type coercion (`varchar` ↔ `nvarchar`): not modeled. The binary-expression `Promote` path's cross-category handling is also not modeled (string ↔ integer in expressions still errors). String → integer-family `CAST` is implemented, with the SQL-Server-matched Msg 244 / 245 / 248 / 8115 error variants.
 - Pattern matching (`LIKE`), `CONVERT`, fixed-length `char(N)` / `nchar(N)` / `binary(N)`, and identity columns: not modeled.

SqlServerSimulator.Tests.Internal/Parser/TokenLineNumberTests.cs

@@ -0,0 +1,87 @@
+using SqlServerSimulator.Parser.Tokens;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+
+namespace SqlServerSimulator.Parser;
+
+/// <summary>
+/// Internal-only tests. If a behavior is reachable through SQL, write it in
+/// SqlServerSimulator.Tests instead — public-API tests survive refactors and
+/// catch regressions the way users will.
+/// </summary>
+/// <remarks>
+/// <see cref="Token.LineNumber"/> backs the <c>"Line N"</c> prefix in
+/// SQL-Server-mimicking error messages (e.g. Msg 1002 invalid scale). Pin
+/// the byte-counting math directly so the line attributed to an error is
+/// not silently miscounted by an off-by-one against newline conventions.
+/// </remarks>
+[TestClass]
+public sealed class TokenLineNumberTests
+{
+    [TestMethod]
+    public void SingleLineCommand_AllTokensReportLine1()
+    {
+        foreach (var token in TokenizeMeaningful("select 1 + 2"))
+            AreEqual(1, token.LineNumber, $"token '{token}' expected line 1");
+    }
+
+    [TestMethod]
+    public void TokenAfterLfNewline_ReportsLine2()
+    {
+        var tokens = TokenizeMeaningful("select 1\n+ 2").ToArray();
+        AreEqual(1, tokens[0].LineNumber);                  // 'select'
+        var plus = tokens.First(t => t.ToString() == "+");
+        AreEqual(2, plus.LineNumber);
+    }
+
+    [TestMethod]
+    public void TokenAfterCrlfNewline_AlsoReportsLine2()
+    {
+        // Only \n increments the line. \r before it is folded into the same
+        // line so CRLF and LF both count once. (SQL Server matches this.)
+        var tokens = TokenizeMeaningful("select 1\r\n+ 2").ToArray();
+        var plus = tokens.First(t => t.ToString() == "+");
+        AreEqual(2, plus.LineNumber);
+    }
+
+    [TestMethod]
+    public void LeadingBlankLines_PushTokenLineDown()
+    {
+        var tokens = TokenizeMeaningful("\n\n\nselect 1").ToArray();
+        AreEqual(4, tokens[0].LineNumber);
+    }
+
+    [TestMethod]
+    public void MultipleLineBreaks_AccumulateInOrder()
+    {
+        var tokens = TokenizeMeaningful("a\nb\nc\nd").ToArray();
+        AreEqual(1, tokens[0].LineNumber);
+        AreEqual(2, tokens[1].LineNumber);
+        AreEqual(3, tokens[2].LineNumber);
+        AreEqual(4, tokens[3].LineNumber);
+    }
+
+    [TestMethod]
+    public void NewlineWithinACommentToken_PushesLaterTokensDown()
+    {
+        // Block comments are skipped at the parser level, but the lines they
+        // contain still count toward what comes after them.
+        var tokens = TokenizeMeaningful("/* a\nb */ select 1").ToArray();
+        var select = tokens.First(t => t.ToString().Equals("select", StringComparison.OrdinalIgnoreCase));
+        AreEqual(2, select.LineNumber);
+    }
+
+    /// <summary>
+    /// Mirrors <see cref="ParserContext.MoveNext"/>: skips whitespace and
+    /// comment tokens so the assertions match what error-reporting code sees.
+    /// </summary>
+    private static IEnumerable<Token> TokenizeMeaningful(string command)
+    {
+        var index = -1;
+        while (Tokenizer.NextToken(command, ref index) is Token t)
+        {
+            if (t is Whitespace or Comment)
+                continue;
+            yield return t;
+        }
+    }
+}

SqlServerSimulator.Tests.Internal/Storage/SqlValueTests.cs

@@ -171,8 +171,12 @@ public void CoerceTo_BigIntToInt32_OutOfRangeOverflows() =>
         Throws<OverflowException>(() => SqlValue.FromInt64(int.MaxValue + 1L).CoerceTo(SqlType.Int32));
 
     [TestMethod]
-    public void CoerceTo_BetweenStringAndInt_NotSupported() =>
-        Throws<NotSupportedException>(() => SqlValue.FromVarchar("42").CoerceTo(SqlType.Int32));
+    public void CoerceTo_VarcharToInt32_Parses()
+    {
+        var coerced = SqlValue.FromVarchar("42").CoerceTo(SqlType.Int32);
+        AreSame(SqlType.Int32, coerced.Type);
+        AreEqual(42, coerced.AsInt32);
+    }
 
     [TestMethod]
     public void Date_AsDate_OnNull_Throws() =>

SqlServerSimulator.Tests/CastTests.cs

@@ -14,6 +14,8 @@ public sealed class CastTests
     [DataRow("cast(255 as tinyint)", (byte)255)]
     [DataRow("cast(1 as bit)", true)]
     [DataRow("cast(0 as bit)", false)]
+    [DataRow("cast(-1 as int)", -1)]              // regression: unary minus inside CAST
+    [DataRow("cast(-(2 + 3) as int)", -5)]        // unary minus + parenthesized
     public void Cast(string expression, object expected) =>
         AreEqual(expected, ExecuteScalar($"select {expression}"));
 
@@ -25,15 +27,118 @@ public void Cast_NullPassesThroughWithRetargetedType() =>
     public void Cast_NarrowingOverflow_RaisesArithmeticOverflow()
     {
         var ex = Throws<DbException>(() => ExecuteScalar("select cast(300 as tinyint)"));
-        StringAssert.Contains(ex.Message, "Arithmetic overflow");
+        Contains("Arithmetic overflow", ex.Message);
     }
 
     [TestMethod]
-    public void Cast_CrossCategory_NotSupported()
+    [DataRow("cast('42' as int)", 42)]
+    [DataRow("cast('-42' as int)", -42)]
+    [DataRow("cast('+42' as int)", 42)]
+    [DataRow("cast('  42  ' as int)", 42)]      // whitespace tolerated
+    [DataRow("cast('007' as int)", 7)]          // leading zeros fine
+    [DataRow("cast('' as int)", 0)]             // SQL Server quirk: empty → 0
+    [DataRow("cast('   ' as int)", 0)]          // whitespace-only → 0
+    public void Cast_StringToInt32(string expression, int expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    [DataRow("'abc'", "Conversion failed when converting the varchar value 'abc' to data type int.")]
+    [DataRow("'42.5'", "Conversion failed when converting the varchar value '42.5' to data type int.")]
+    [DataRow("'0x42'", "Conversion failed when converting the varchar value '0x42' to data type int.")]
+    public void Cast_BadStringToInt32_RaisesMsg245(string source, string expected)
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar($"select cast({source} as int)"));
+        AreEqual(expected, ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_NVarcharToInt32_UsesNVarcharInErrorMessage()
+    {
+        // Source-type wording in Msg 245 reflects the actual source type.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(N'abc' as int)"));
+        AreEqual("Conversion failed when converting the nvarchar value 'abc' to data type int.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_StringOverflow_TinyInt_RaisesMsg244WithINT1()
+    {
+        // Tinyint/smallint use Msg 244 with internal SQL names INT1/INT2.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('300' as tinyint)"));
+        AreEqual("The conversion of the varchar value '300' overflowed an INT1 column. Use a larger integer column.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_StringOverflow_SmallInt_RaisesMsg244WithINT2()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('99999' as smallint)"));
+        AreEqual("The conversion of the varchar value '99999' overflowed an INT2 column. Use a larger integer column.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_StringOverflow_Int_RaisesMsg248()
+    {
+        // Int has its own overflow message (Msg 248) — distinct text and no
+        // "Use a larger integer column" suffix.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('99999999999' as int)"));
+        AreEqual("The conversion of the varchar value '99999999999' overflowed an int column.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_StringOverflow_BigInt_RaisesMsg8115()
+    {
+        // Bigint overflow falls through to the generic arithmetic-overflow
+        // message; no source-value detail.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('99999999999999999999' as bigint)"));
+        Contains("Arithmetic overflow", ex.Message);
+        Contains("bigint", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("'1'", true)]
+    [DataRow("'0'", false)]
+    [DataRow("'true'", true)]
+    [DataRow("'TRUE'", true)]
+    [DataRow("'false'", false)]
+    [DataRow("'FALSE'", false)]
+    [DataRow("'  true  '", true)]       // surrounding whitespace tolerated
+    [DataRow("'2'", true)]              // any non-zero numeric → true
+    [DataRow("'-1'", true)]
+    [DataRow("'000'", false)]           // all-zero digit string → false
+    [DataRow("''", false)]              // empty → false
+    [DataRow("'   '", false)]           // whitespace-only → false
+    [DataRow("'99999999999999999999'", true)]   // exceeds long but bit ignores magnitude
+    public void Cast_StringToBit(string source, bool expected) =>
+        AreEqual(expected, ExecuteScalar($"select cast({source} as bit)"));
+
+    [TestMethod]
+    [DataRow("'yes'")]
+    [DataRow("'no'")]
+    [DataRow("'t'")]
+    [DataRow("'truex'")]
+    [DataRow("'1.0'")]              // decimal point not accepted even for bit
+    public void Cast_BadStringToBit_RaisesMsg245(string source)
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar($"select cast({source} as bit)"));
+        Contains("Conversion failed", ex.Message);
+        Contains("to data type bit", ex.Message);
+    }
+
+    [TestMethod]
+    [DataRow("cast(42 as varchar(10))", "42")]
+    [DataRow("cast(-42 as varchar(10))", "-42")]
+    [DataRow("cast(0 as varchar(10))", "0")]
+    [DataRow("cast(cast(255 as tinyint) as varchar(5))", "255")]
+    [DataRow("cast(cast(1 as bit) as varchar(5))", "1")]
+    [DataRow("cast(cast(0 as bit) as varchar(5))", "0")]
+    public void Cast_IntegerToString(string expression, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void Cast_BigIntToVarchar_PreservesFullRange()
     {
-        // String ↔ numeric coercion isn't modeled yet; CAST surfaces the same
-        // NotSupportedException SqlValue.CoerceTo throws.
-        _ = Throws<NotSupportedException>(() => ExecuteScalar("select cast('42' as int)"));
+        // Numeric literal tokens are int-bounded; the source bigint here is
+        // constructed by parsing a string instead.
+        AreEqual("9223372036854775807", ExecuteScalar("select cast(cast('9223372036854775807' as bigint) as varchar(30))"));
     }
 
     [TestMethod]
@@ -261,4 +366,93 @@ public void Cast_DateTimeOffsetToTime_DropsDateAndOffset()
     [TestMethod]
     public void Cast_DateTimeOffsetNullPassesThrough() =>
         IsInstanceOfType<DBNull>(ExecuteScalar("select cast(cast(null as datetimeoffset(7)) as varchar(40))"));
+
+    [TestMethod]
+    public void Cast_UnknownTypeName_RaisesMsg243()
+    {
+        // CAST takes a different error path than CREATE TABLE: Msg 243
+        // ("Type X is not a defined system type.") instead of Msg 2715.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('x' as intz)"));
+        AreEqual("Type intz is not a defined system type.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_LengthSpecifierOnFixedType_RaisesMsg291()
+    {
+        // CAST equivalent of CREATE TABLE's Msg 2716. Note the absence of a
+        // trailing period — SQL Server's Msg 291 message lacks one.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('x' as int(4))"));
+        AreEqual("CAST or CONVERT: invalid attributes specified for type 'int'", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_VarcharSizeExceedsMaximum_UsesTypeWording()
+    {
+        // CAST form of Msg 131 says "given to the type 'T'" rather than the
+        // column-context "given to the column 'V'".
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('x' as varchar(8001))"));
+        AreEqual("The size (8001) given to the type 'varchar' exceeds the maximum allowed for any data type (8000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_VarbinarySizeExceedsMaximum_UsesTypeWording()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(0xAB as varbinary(8001))"));
+        AreEqual("The size (8001) given to the type 'varbinary' exceeds the maximum allowed for any data type (8000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_NVarcharSizeExceedsMaximum_UsesConvertSpecificationWording()
+    {
+        // nvarchar in CAST has its own phrasing distinct from varchar.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast(N'x' as nvarchar(4001))"));
+        AreEqual("The size (4001) given to the convert specification 'nvarchar' exceeds the maximum allowed for any data type (4000).", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_InvalidScale_OnLine1_PrefixesLine1()
+    {
+        // Msg 1002 is one of the few SQL Server errors that puts the line
+        // number into the message text itself.
+        var ex = Throws<DbException>(() => ExecuteScalar("select cast('x' as datetime2(8))"));
+        AreEqual("Line 1: Specified scale 8 is invalid.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_InvalidScale_OnLaterLine_PrefixesActualLine()
+    {
+        // The "Line N" tracks the line of the offending type token, not a
+        // fixed line 1 — verified against real SQL Server. Single statement
+        // with leading blank lines so ExecuteScalar surfaces the parse error
+        // immediately (multi-statement batches parse lazily; see the
+        // semicolon-batch variant below).
+        var ex = Throws<DbException>(() => ExecuteScalar(
+            "\n" +
+            "\n" +
+            "select cast('x' as datetime2(8))"));
+        AreEqual("Line 3: Specified scale 8 is invalid.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Cast_InvalidScale_InLaterStatementOfBatch_FiresWhenReaderReachesIt()
+    {
+        // Multi-statement batches are parsed lazily one statement at a time
+        // (CreateResultSetsForCommand is an iterator). The third statement's
+        // parse error doesn't fire until the consumer asks for its result
+        // set via NextResult.
+        using var connection = new Simulation().CreateOpenConnection();
+        using var command = connection.CreateCommand(
+            "select 1;\n" +
+            "select 2;\n" +
+            "select cast('x' as datetime2(8))");
+        using var reader = command.ExecuteReader();
+
+        IsTrue(reader.NextResult());                            // advance past statement 1
+        var ex = Throws<DbException>(() =>
+        {
+            _ = reader.NextResult();                            // forces parse of statement 3
+            _ = reader.NextResult();
+        });
+        AreEqual("Line 3: Specified scale 8 is invalid.", ex.Message);
+    }
 }

SqlServerSimulator.Tests/CompatibilityLevelTests.cs

@@ -108,11 +108,12 @@ public void ExplicitVerboseSetting_WinsOverTraceFlag()
     [TestMethod]
     public void InvalidCompatibilityLevel_RaisesMsg15048()
     {
+        // SQL Server's Msg 15048 lists valid values but doesn't echo the
+        // rejected value back — verified against real SQL Server 2025.
         using var connection = new Simulation().CreateOpenConnection();
         using var alter = connection.CreateCommand("alter database master set compatibility_level = 145");
         var ex = Assert.Throws<DbException>(() => alter.ExecuteNonQuery());
-        StringAssert.Contains(ex.Message, "145");
-        StringAssert.Contains(ex.Message, "compatibility level");
+        Assert.AreEqual("Valid values of the database compatibility level are 100, 110, 120, 130, 140, 150, 160 or 170.", ex.Message);
     }
 
     [TestMethod]