Implemented CONVERT and TRY_CONVERT.

Author: RyanLamansky

CLAUDE.md

@@ -12,7 +12,7 @@ High-fidelity SQL Server simulation, eventually including transactions, locks, M
 
 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.
 
-The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, `LIKE` and `CONVERT`, identity columns, the `varchar(MAX)` family, the EF Core adapter — all of these are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
+The overall plan is incremental and non-specific: pick the lowest-effort path that unlocks the most useful application compatibility next. Transactions / locks / MVCC, the `varchar(MAX)` family, the EF Core adapter — all of these are eventual targets, but the order is opportunistic, driven by what's blocking the user's actual application stand-ins. Over time, this accretion gets the simulator to "most apps just work"; near term, work flows to the smallest unlock for the biggest cohort of pain points.
 
 ## Public API surface
 
@@ -73,7 +73,7 @@ Heavy-hitters someone might assume work but don't. Source and `git log` are the
 - Row-overflow / LOB pages and the `varchar(MAX)` / `nvarchar(MAX)` / `varbinary(MAX)` types they enable.
 - `decimal` / `numeric` values are backed by .NET `decimal`, so values requiring more than 28 significant digits aren't modeled (the type declarations up through `decimal(38, *)` are accepted so storage byte-width still matches SQL Server). `float` text formatting uses .NET's `G15`/`G7` conventions rather than SQL Server's exact `1e+015`-style scientific layout. `money` / `smallmoney` are wired in raw SQL but unreachable through EF Core for the same `SqlParameter`-downcast reason as the date-only / time-only mappings — adding a money column to an EF entity breaks that entity's whole save path.
 - `NEWSEQUENTIALID()` (deferred until `DEFAULT`-clause support exists in `CREATE TABLE`; the function is only valid in that context).
-- `CONVERT` (cousin to `CAST`, with a separate style-code surface).
+- `CONVERT` / `TRY_CONVERT` style-code coverage. Only styles `0`, `120`, and `121` are wired up for date-like sources targeting a character string (the EF Core code-generation defaults). Other style numbers raise Msg 281; money / float / binary style codes and `CONVERT(date, str, 103)`-style date-parsing styles aren't modeled.
 - `LIKE` `COLLATE` override. The default collation (case-insensitive, Latin1_General-shaped) is what every `LIKE` runs under; explicit `COLLATE` clauses on the predicate aren't parsed yet.
 - Cross-category `Promote` for integer ↔ string. Only CAST works for that pair.
 - EF Core compatibility: the SqlServer provider downcasts `DbParameter` to `SqlParameter` for some mappings — `DateTime → date`, `DateTime → smalldatetime`, `DateOnly`, `TimeOnly`, `TimeSpan`, and `decimal → money` / `decimal → smallmoney` (via `SqlServerDecimalTypeMapping`) all break at SaveChanges. See `SimulatedDbParameter` for the matrix; a `SqlServerSimulator.EFCore` adapter package is planned to close the gap.

SqlServerSimulator.Tests/ConvertTests.cs

@@ -0,0 +1,207 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class ConvertTests
+{
+    [TestMethod]
+    [DataRow("convert(int, '42')", 42)]
+    [DataRow("convert(int, 1)", 1)]
+    [DataRow("convert(bigint, 1)", 1L)]
+    [DataRow("convert(varchar(10), 42)", "42")]
+    [DataRow("convert(varchar, 12345)", "12345")]
+    public void Convert_Basics(string expression, object expected) =>
+        AreEqual(expected, ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void Convert_DecimalRoundsToTargetScale() =>
+        AreEqual(3.14m, ExecuteScalar("select convert(decimal(10,2), 3.14)"));
+
+    [TestMethod]
+    public void Convert_NullSourcePassesThroughTypedNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select convert(int, null)"));
+
+    /// <summary>
+    /// Any NULL style argument propagates the entire result to NULL, even on non-applicable source types.
+    /// </summary>
+    [TestMethod]
+    public void Convert_NullStyleReturnsNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select convert(int, '42', null)"));
+
+    [TestMethod]
+    [DataRow("'abc'")]
+    [DataRow("'42.5'")]
+    public void Convert_StringParseFailure_StillThrows(string source)
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar($"select convert(int, {source})"));
+        Contains("Conversion failed", ex.Message);
+    }
+
+    [TestMethod]
+    public void Convert_NarrowingOverflow_StillThrows()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select convert(tinyint, 300)"));
+        Contains("Arithmetic overflow", ex.Message);
+    }
+
+    // --- Date/time × style 0/120/121 -----------------------------------
+
+    [TestMethod]
+    [DataRow(0, "Mar 15 2024 10:20AM")]
+    [DataRow(120, "2024-03-15 10:20:30")]
+    [DataRow(121, "2024-03-15 10:20:30.000")]
+    public void Convert_DateTime_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(30), cast('2024-03-15 10:20:30' as datetime), {style})"));
+
+    [TestMethod]
+    [DataRow(0, "Mar 15 2024 10:21AM")]
+    [DataRow(120, "2024-03-15 10:21:00")]
+    [DataRow(121, "2024-03-15 10:21:00.000")]
+    public void Convert_SmallDateTime_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(30), cast('2024-03-15 10:21:00' as smalldatetime), {style})"));
+
+    [TestMethod]
+    [DataRow(0, "2024-03-15")]
+    [DataRow(120, "2024-03-15")]
+    [DataRow(121, "2024-03-15")]
+    public void Convert_Date_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(30), cast('2024-03-15' as date), {style})"));
+
+    [TestMethod]
+    [DataRow(0, "Mar 15 2024 10:20AM")]      // legacy form for explicit style 0
+    [DataRow(120, "2024-03-15 10:20:30")]    // ISO without fractional
+    [DataRow(121, "2024-03-15 10:20:30.1234567")] // precision-respecting
+    public void Convert_DateTime2_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(40), cast('2024-03-15 10:20:30.1234567' as datetime2(7)), {style})"));
+
+    [TestMethod]
+    public void Convert_DateTime2_Precision0_Style121_OmitsFractional() =>
+        AreEqual("2024-03-15 10:20:30", ExecuteScalar(
+            "select convert(varchar(40), cast('2024-03-15 10:20:30' as datetime2(0)), 121)"));
+
+    [TestMethod]
+    [DataRow(0, "10:20AM")]
+    [DataRow(120, "10:20:30")]
+    [DataRow(121, "10:20:30.123")]
+    public void Convert_Time_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(40), cast('10:20:30.123' as time(3)), {style})"));
+
+    [TestMethod]
+    [DataRow(0, "Mar 15 2024 10:20AM -05:00")]
+    [DataRow(120, "2024-03-15 10:20:30 -05:00")]
+    [DataRow(121, "2024-03-15 10:20:30.123 -05:00")]
+    public void Convert_DateTimeOffset_StyleOutputs(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar(
+            $"select convert(varchar(40), cast('2024-03-15 10:20:30.123 -05:00' as datetimeoffset(3)), {style})"));
+
+    [TestMethod]
+    public void Convert_NoStyle_MatchesCastDefault()
+    {
+        // No-style CONVERT mirrors CAST: datetime2 stays in ISO form, even
+        // though explicit style 0 would switch it to legacy.
+        AreEqual("2024-03-15 10:20:30.1234567", ExecuteScalar(
+            "select convert(varchar(40), cast('2024-03-15 10:20:30.1234567' as datetime2(7)))"));
+        AreEqual("Mar 15 2024 10:20AM", ExecuteScalar(
+            "select convert(varchar(40), cast('2024-03-15 10:20:30' as datetime))"));
+    }
+
+    [TestMethod]
+    public void Convert_NVarcharTarget_StyleStillApplies() =>
+        AreEqual("2024-03-15 10:20:30.000", ExecuteScalar(
+            "select convert(nvarchar(30), cast('2024-03-15 10:20:30' as datetime), 121)"));
+
+    // --- Style validation ----------------------------------------------
+
+    [TestMethod]
+    [DataRow("datetime", "'2024-03-15 10:00:00'", "999")]
+    [DataRow("datetime2", "'2024-03-15 10:00:00'", "999")]
+    [DataRow("time", "'10:00:00'", "999")]
+    [DataRow("datetimeoffset", "'2024-03-15 10:00:00 +00:00'", "999")]
+    [DataRow("date", "'2024-03-15'", "999")]
+    [DataRow("smalldatetime", "'2024-03-15 10:00:00'", "999")]
+    public void Convert_BadStyle_RaisesMsg281(string typeName, string sourceLiteral, string style)
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar(
+            $"select convert(varchar(30), cast({sourceLiteral} as {typeName}), {style})"));
+        AreEqual($"{style} is not a valid style number when converting from {typeName} to a character string.", ex.Message);
+    }
+
+    [TestMethod]
+    public void Convert_StyleOnNonDateSource_SilentlyIgnored()
+    {
+        // Probe-confirmed: real SQL Server happily accepts a style argument
+        // on int → varchar conversions and just ignores it.
+        AreEqual("12345", ExecuteScalar("select convert(varchar(30), 12345, 120)"));
+        AreEqual(42, ExecuteScalar("select convert(int, '42', 1)"));
+    }
+
+    [TestMethod]
+    public void Convert_StringStyle_RaisesMsg8116()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar(
+            "select convert(varchar(30), cast('2024-03-15' as datetime), '120')"));
+        AreEqual("Argument data type varchar is invalid for argument 3 of convert function.", ex.Message);
+    }
+
+    // --- TRY_CONVERT ---------------------------------------------------
+
+    [TestMethod]
+    public void TryConvert_GoodValue_ReturnsValue() =>
+        AreEqual(42, ExecuteScalar("select try_convert(int, '42')"));
+
+    [TestMethod]
+    public void TryConvert_NullSource_ReturnsNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select try_convert(int, null)"));
+
+    [TestMethod]
+    [DataRow("try_convert(int, 'abc')")]              // Msg 245
+    [DataRow("try_convert(int, '42.5')")]             // Msg 245
+    [DataRow("try_convert(tinyint, '300')")]          // Msg 244
+    [DataRow("try_convert(int, '99999999999')")]      // Msg 248
+    [DataRow("try_convert(uniqueidentifier, 'bad')")] // Msg 8169
+    [DataRow("try_convert(tinyint, 300)")]            // Msg 8115 (overflow)
+    [DataRow("try_convert(int, 'x', 1)")]             // probe-confirmed: ignored style + failure → NULL
+    public void TryConvert_ConversionFailure_ReturnsNull(string expression) =>
+        IsInstanceOfType<DBNull>(ExecuteScalar($"select {expression}"));
+
+    [TestMethod]
+    public void TryConvert_TruncatesDecimalToInt() =>
+        AreEqual(42, ExecuteScalar("select try_convert(int, 42.7)"));
+
+    [TestMethod]
+    public void TryConvert_ExplicitConversionNotAllowed_StillThrows()
+    {
+        // Msg 529: SQL Server still raises for type pairs where coercion
+        // is fundamentally disallowed, even under TRY_CONVERT.
+        var ex = Throws<DbException>(() => ExecuteScalar("select try_convert(date, 0)"));
+        Contains("Explicit conversion", ex.Message);
+    }
+
+    [TestMethod]
+    public void TryConvert_NullStyle_ReturnsNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select try_convert(int, '42', null)"));
+
+    // --- Syntax errors -------------------------------------------------
+
+    [TestMethod]
+    public void Convert_MissingArgs_RaisesSyntaxError()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select convert(int)"));
+        Contains("syntax", ex.Message);
+    }
+
+    [TestMethod]
+    public void Convert_BadTargetType_RaisesMsg243()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select convert(notatype, 1)"));
+        Contains("notatype", ex.Message);
+    }
+}

SqlServerSimulator/Parser/Expression.cs

@@ -64,9 +64,10 @@ public static Expression Parse(ParserContext context)
                 ? new LastIdentityExpression(context.Simulation)
                 : new Value(doubleAtPrefixedString),
             ReservedKeyword { Keyword: Keyword.Null } => new Value(),
-            // LEFT and RIGHT are reserved (for future JOIN support) but
-            // dispatch as function calls when followed by '('.
-            ReservedKeyword { Keyword: Keyword.Left or Keyword.Right } reserved => new Reference(reserved.ToString()),
+            // LEFT, RIGHT, CONVERT, and TRY_CONVERT are reserved keywords
+            // but dispatch as function calls when followed by '(' — the
+            // surrounding loop hands the call shape off to ResolveBuiltIn.
+            ReservedKeyword { Keyword: Keyword.Left or Keyword.Right or Keyword.Convert or Keyword.Try_Convert } reserved => new Reference(reserved.ToString()),
             Name name => new Reference(name),
             Operator { Character: '(' } => new Parenthesized(context),
             _ => throw SimulatedSqlException.SyntaxErrorNear(context)
@@ -186,6 +187,7 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
             },
             7 => uppercaseName switch
             {
+                "CONVERT" => new ConvertExpression(context, tryMode: false),
                 "REPLACE" => new Replace(context),
                 "REVERSE" => new Reverse(context),
                 _ => null
@@ -201,6 +203,11 @@ private static Expression ResolveBuiltIn(string name, ParserContext context)
                 "DATALENGTH" => new DataLength(context),
                 _ => null
             },
+            11 => uppercaseName switch
+            {
+                "TRY_CONVERT" => new ConvertExpression(context, tryMode: true),
+                _ => null
+            },
             13 => uppercaseName switch
             {
                 "IDENT_CURRENT" => new IdentCurrent(context),

SqlServerSimulator/Parser/Expressions/Cast.cs

@@ -33,10 +33,31 @@ public Cast(ParserContext context)
             throw SimulatedSqlException.SyntaxErrorNear(context);
 
         var typeName = context.GetNextRequired<Name>();
+        (this.targetType, this.targetMaxLength) = ParseTargetTypeSpec(context, typeName);
 
-        // Optional (N) or (P, S) length/precision specifier — accepted for
-        // parity with SQL Server syntax. Length is generally not enforced as
-        // a value-level cap; precision/scale are interpreted by the type.
+        if (context.Token is not Operator { Character: ')' })
+            throw SimulatedSqlException.SyntaxErrorNear(context);
+    }
+
+    public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue) =>
+        ApplyCoercion(source.Run(getColumnValue), this.targetType, this.targetMaxLength);
+
+    public override SqlType GetSqlType(Func<List<string>, SqlType> resolveColumnType) => targetType;
+
+#if DEBUG
+    public override string ToString() => $"CAST({source} AS {targetType})";
+#endif
+
+    /// <summary>
+    /// Parses the optional <c>(length)</c> or <c>(precision, scale)</c> spec
+    /// after a CAST/CONVERT target type name and resolves the type. The caller
+    /// supplies the already-consumed type-name token; the helper advances past
+    /// the spec (if any) and leaves <see cref="ParserContext.Token"/> on the
+    /// first un-consumed token, ready for the wrapping function's closing
+    /// paren. Errors use Msg 243 / 291 with the CAST-context wording.
+    /// </summary>
+    internal static (SqlType targetType, int? targetMaxLength) ParseTargetTypeSpec(ParserContext context, Name typeName)
+    {
         int? declaredMaxLength = null;
         int? declaredScale = null;
         context.MoveNextRequired();
@@ -45,8 +66,7 @@ public Cast(ParserContext context)
             if (context.GetNextRequired() is not Numeric { Value: { IsNull: false } numericValue })
                 throw SimulatedSqlException.SyntaxErrorNear(context);
             declaredMaxLength = numericValue.AsInt32;
-            var next = context.GetNextRequired();
-            switch (next)
+            switch (context.GetNextRequired())
             {
                 case Operator { Character: ',' }:
                     if (context.GetNextRequired() is not Numeric { Value: { IsNull: false } scaleValue })
@@ -63,21 +83,20 @@ public Cast(ParserContext context)
             context.MoveNextRequired();
         }
 
-        if (context.Token is not Operator { Character: ')' })
-            throw SimulatedSqlException.SyntaxErrorNear(context);
-
-        // Null columnName signals CAST context: errors use Msg 243 (unknown
-        // type), 291 (length on fixed type), and the "type"/"convert
-        // specification" wording for Msg 131 size errors.
-        var (resolved, max) = SqlType.GetByName(typeName, declaredMaxLength, declaredScale, 1, columnName: null);
-        this.targetType = resolved;
-        this.targetMaxLength = max;
+        // Null columnName signals CAST/CONVERT context: errors use Msg 243
+        // (unknown type), 291 (length on fixed type), and the
+        // "type"/"convert specification" wording for Msg 131 size errors.
+        return SqlType.GetByName(typeName, declaredMaxLength, declaredScale, 1, columnName: null);
     }
 
-    public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue)
+    /// <summary>
+    /// Runs the value-level coercion shared by CAST and CONVERT: rejects
+    /// uniqueidentifier-to-too-narrow-string with the target-specific Msg
+    /// 8170 / 8115, then delegates to <see cref="SqlValue.CoerceTo"/> and
+    /// rewraps <see cref="OverflowException"/> as the generic Msg 8115.
+    /// </summary>
+    internal static SqlValue ApplyCoercion(SqlValue value, SqlType targetType, int? targetMaxLength)
     {
-        var value = source.Run(getColumnValue);
-
         // uniqueidentifier → too-narrow string: SQL Server raises a target-
         // specific error rather than silently truncating. char/varchar use
         // Msg 8170 with its dedicated text; nchar/nvarchar use the generic
@@ -86,12 +105,12 @@ public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue)
         // NULLs pass through silently.
         if (!value.IsNull
             && value.Type == SqlType.UniqueIdentifier
-            && this.targetMaxLength is int max
+            && targetMaxLength is int max
             && max < 36)
         {
-            if (this.targetType == SqlType.Varchar || this.targetType is CharSqlType)
+            if (targetType == SqlType.Varchar || targetType is CharSqlType)
                 throw SimulatedSqlException.InsufficientResultSpaceForUniqueIdentifier();
-            if (this.targetType == SqlType.NVarchar || this.targetType is NCharSqlType)
+            if (targetType == SqlType.NVarchar || targetType is NCharSqlType)
                 throw SimulatedSqlException.ArithmeticOverflow("nvarchar");
         }
 
@@ -104,10 +123,4 @@ public override SqlValue Run(Func<List<string>, SqlValue> getColumnValue)
             throw SimulatedSqlException.ArithmeticOverflow(targetType.ToString()!);
         }
     }
-
-    public override SqlType GetSqlType(Func<List<string>, SqlType> resolveColumnType) => targetType;
-
-#if DEBUG
-    public override string ToString() => $"CAST({source} AS {targetType})";
-#endif
 }