CONVERT style codes — common subset, bidirectional, plus money formatting. Datetime → string surface gains 11 new styles (1/101 US, 10/110 USA, 12/112 ISO compact, 102 ANSI, 103 UK, 23 date-only ISO, 126/127 ISO 8601) on top of the existing 0/120/121; the 9 date-only-emit styles share a new FormatDateOnlyStyle helper that every date/datetime/smalldatetime/datetime2/datetimeoffset routes through (so CONVERT(varchar, dt, 112) returns '20260513' regardless of source precision, matching probe). Styles 126/127 emit T-separated ISO 8601 with source-precision fractional seconds; 127 on datetimeoffset projects to UTC and emits a trailing Z via FormatDateTimeOffsetIso + a +00:00→Z rewrite. String → datetime surface gains a new CoerceStringToDateLikeWithStyle path: per-style DateTime.TryParseExact format-string lists (each with optional trailing-time variants so CONVERT(date, '20260513 14:25:36', 112) works), success re-encodes through datetime2(7) then narrows to target. Parse-failure dispositions are probe-faithful: input that's not a date at all → Msg 241 (general parse fail), input that's a valid date but wrong format for the style → new Msg 9807 ("The input character string does not follow style N…") via new InputCharacterStringStyleMismatch factory. Msg 9807 added to Cast.IsConversionFailure so TRY_CONVERT swallows it. Money → string surface adds CoerceMoneyToStringWithStyle with styles 0 (no commas, 2 decimals — F2), 1 (comma thousands, 2 decimals — N2), 2 (no commas, 4 decimals — F4); smallmoney shares the formatter. ConvertExpression.Run routes by (source category × target category × style present) into the three new paths (date→string, string→date, money→string); all other source-target combinations keep silently ignoring style, matching real SQL Server. Unknown styles within each path raise Msg 281 with the source-family wording (e.g. 99 is not a valid style number when converting from datetime to a character string.). 36 new ConvertTests (datarow-parametrized) cover the new datetime/date/datetime2/datetimeoffset → string styles, the string → date round-trips for 101/112/102/103/23/126/127, the Msg 9807 vs Msg 241 distinction, TRY_CONVERT swallow, money 0/1/2 + smallmoney + negative + Msg 281. CLAUDE.md "Not modeled" entry shrunk to list the residual unsupported style numbers; docs/claude/casting.md gains a full CONVERT style-code section with per-direction tables.

Author: RyanLamansky

CLAUDE.md

@@ -160,7 +160,7 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - `RANGE BETWEEN <N> PRECEDING` / `<N> FOLLOWING` — real SQL Server gates the numeric-offset RANGE form behind a separately-licensed feature surface and the simulator matches that rejection (Msg 4194). `ROWS` numeric-offset frames ship; both modes support the canonical `UNBOUNDED` / `CURRENT ROW` bounds and the single-bound shorthand (`ROWS UNBOUNDED PRECEDING` ≡ `ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW`). The default frame when ORDER BY is present in OVER is `RANGE UNBOUNDED PRECEDING TO CURRENT ROW` (running-total semantic with peer-tie grouping); without ORDER BY, default frame is whole partition. LAST_VALUE ships with the same semantics as real SQL Server (its default frame returns the current row's value or the peer-tie last under RANGE — the intuitive "partition last" form needs explicit `ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING`).
 - Recursive-part feature restrictions (Msg 460 DISTINCT / 461 TOP / 462 OUTER JOIN / 467 aggregate-or-GROUP-BY / 465 ref-in-subquery) — silently accepted with possibly-incorrect semantics rather than raising. Apps that exercise these in real SQL Server hit rejection there too.
 - `LIKE` with `COLLATE` override (default collation only).
-- `CONVERT` / `TRY_CONVERT` style codes other than `0` / `120` / `121`.
+- `CONVERT` / `TRY_CONVERT` style codes other than `0` / `1` / `10` / `12` / `23` / `101` / `102` / `103` / `110` / `112` / `120` / `121` / `126` / `127` (datetime ⇄ string, both directions; ISO 8601 + regional formats) and `0` / `1` / `2` (money → string). See [`docs/claude/casting.md`](docs/claude/casting.md).
 - `LEN(ntext)` raising Msg 8116; legacy `READTEXT` / `WRITETEXT` / `UPDATETEXT`.
 - MERGE source as a CTE-headed SELECT (`USING (WITH cte AS … SELECT …)`) — Selection.Parse's CTE entry doesn't reach the USING-clause grammar; wrap the CTE inside a regular SELECT instead. MERGE inside a CTE body, multi-statement MERGE WHEN-clause bodies, and `MERGE INTO <view>` (real SQL Server's updatable-view MERGE) are also deferred.
 - `PRIMARY KEY` / `UNIQUE` on a computed column (`NotSupportedException`).

SqlServerSimulator.Tests/ConvertTests.cs

@@ -172,4 +172,110 @@ public void Convert_BadTargetType_RaisesMsg243()
         var ex = Throws<DbException>(() => ExecuteScalar("select convert(notatype, 1)"));
         Contains("notatype", ex.Message);
     }
+
+    [TestMethod]
+    [DataRow(1, "05/13/26")]
+    [DataRow(101, "05/13/2026")]
+    [DataRow(10, "05-13-26")]
+    [DataRow(110, "05-13-2026")]
+    [DataRow(12, "260513")]
+    [DataRow(112, "20260513")]
+    [DataRow(102, "2026.05.13")]
+    [DataRow(103, "13/05/2026")]
+    [DataRow(23, "2026-05-13")]
+    [DataRow(126, "2026-05-13T14:25:36.790")]
+    [DataRow(127, "2026-05-13T14:25:36.790")]
+    public void Convert_DateTimeStyle(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar($"declare @d datetime = '2026-05-13T14:25:36.789'; select convert(varchar(40), @d, {style})"));
+
+    [TestMethod]
+    [DataRow(1, "05/13/26")]
+    [DataRow(101, "05/13/2026")]
+    [DataRow(112, "20260513")]
+    [DataRow(23, "2026-05-13")]
+    [DataRow(126, "2026-05-13")]
+    public void Convert_DateStyle(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select convert(varchar(40), cast('2026-05-13' as date), {style})"));
+
+    [TestMethod]
+    public void Convert_DateTime2Style126_FullPrecision() =>
+        AreEqual("2026-05-13T14:25:36.1234567", ExecuteScalar(
+            "select convert(varchar(40), cast('2026-05-13T14:25:36.1234567' as datetime2(7)), 126)"));
+
+    [TestMethod]
+    public void Convert_DateTimeOffsetStyle126_PreservesOffset() =>
+        AreEqual("2026-05-13T14:25:36.1234567+05:30", ExecuteScalar(
+            "select convert(varchar(40), cast('2026-05-13T14:25:36.1234567+05:30' as datetimeoffset(7)), 126)"));
+
+    [TestMethod]
+    public void Convert_DateTimeOffsetStyle127_ProjectsToUtcWithZ() =>
+        AreEqual("2026-05-13T08:55:36.1234567Z", ExecuteScalar(
+            "select convert(varchar(40), cast('2026-05-13T14:25:36.1234567+05:30' as datetimeoffset(7)), 127)"));
+
+    [TestMethod]
+    [DataRow(101, "05/13/2026")]
+    [DataRow(112, "20260513")]
+    [DataRow(102, "2026.05.13")]
+    [DataRow(103, "13/05/2026")]
+    [DataRow(23, "2026-05-13")]
+    public void Convert_StringToDateWithStyle(int style, string input) =>
+        AreEqual(new DateTime(2026, 5, 13), ExecuteScalar($"select convert(date, '{input}', {style})"));
+
+    [TestMethod]
+    public void Convert_StringToDateTime2_Style126() =>
+        AreEqual(new DateTime(2026, 5, 13, 14, 25, 36, 789), ExecuteScalar(
+            "select convert(datetime2(3), '2026-05-13T14:25:36.789', 126)"));
+
+    [TestMethod]
+    public void Convert_StringToDateTime2_Style127WithZ() =>
+        AreEqual(new DateTime(2026, 5, 13, 14, 25, 36, 789), ExecuteScalar(
+            "select convert(datetime2(3), '2026-05-13T14:25:36.789Z', 127)"));
+
+    [TestMethod]
+    public void Convert_StringToDate_StyleMismatchRaisesMsg9807()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar(
+            "select convert(date, '05/13/2026', 112)"));
+        AreEqual("9807", ex.Data["HelpLink.EvtID"]);
+        Contains("style 112", ex.Message);
+    }
+
+    [TestMethod]
+    public void Convert_StringToDate_NotADate_RaisesMsg241()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar(
+            "select convert(date, 'nope', 112)"));
+        AreEqual("241", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void TryConvert_StringToDate_StyleMismatchReturnsNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select try_convert(date, '05/13/2026', 112)"));
+
+    [TestMethod]
+    public void TryConvert_StringToDate_NotADateReturnsNull() =>
+        IsInstanceOfType<DBNull>(ExecuteScalar("select try_convert(date, 'nope', 112)"));
+
+    [TestMethod]
+    [DataRow(0, "1234567.89")]
+    [DataRow(1, "1,234,567.89")]
+    [DataRow(2, "1234567.8910")]
+    public void Convert_MoneyStyle(int style, string expected) =>
+        AreEqual(expected, ExecuteScalar($"select convert(varchar(40), cast(1234567.891 as money), {style})"));
+
+    [TestMethod]
+    public void Convert_MoneyStyle_Negative()
+        => AreEqual("-12.50", ExecuteScalar("select convert(varchar(40), cast(-12.5 as money), 0)"));
+
+    [TestMethod]
+    public void Convert_SmallMoneyStyle1()
+        => AreEqual("1,234.56", ExecuteScalar("select convert(varchar(40), cast(1234.56 as smallmoney), 1)"));
+
+    [TestMethod]
+    public void Convert_MoneyStyle_UnknownStyle_RaisesMsg281()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select convert(varchar(40), cast(1.5 as money), 99)"));
+        AreEqual("281", ex.Data["HelpLink.EvtID"]);
+        Contains("money", ex.Message);
+    }
 }

SqlServerSimulator/Errors/SimulatedSqlException.TypeErrors.cs

@@ -167,6 +167,17 @@ internal static SimulatedSqlException InvalidTimeZoneParameter(string name) =>
     internal static SimulatedSqlException ConversionFailedDateTimeFromString() =>
         new("Conversion failed when converting date and/or time from character string.", 241, 16, 1);
 
+    /// <summary>
+    /// Mimics SQL Server error 9807: <c>CONVERT(date-like, '...', N)</c>
+    /// received a string that parses as a valid date but doesn't follow the
+    /// specific style number's format. Distinct from Msg 241 (general bad
+    /// format) — apps that explicitly check for style-specific input shape
+    /// can distinguish "wrong format" from "not a date at all". Probe-
+    /// confirmed verbatim against SQL Server 2025 (2026-05-13).
+    /// </summary>
+    internal static SimulatedSqlException InputCharacterStringStyleMismatch(int style) =>
+        new($"The input character string does not follow style {style}, either change the input character string or use a different style.", 9807, 16, 1);
+
     /// <summary>
     /// Mimics SQL Server error 295: the <c>smalldatetime</c>-specific
     /// counterpart of <see cref="ConversionFailedDateTimeFromString"/>. SQL

SqlServerSimulator/Parser/Expressions/Cast.cs

@@ -248,5 +248,6 @@ or 295 // ConversionFailedSmallDateTimeFromString
         or 8114 // ConvertingDataTypeError
         or 8115 // ArithmeticOverflow
         or 8169 // ConversionFailedFromStringToUniqueIdentifier
-        or 8170; // InsufficientResultSpaceForUniqueIdentifier
+        or 8170 // InsufficientResultSpaceForUniqueIdentifier
+        or 9807; // InputCharacterStringStyleMismatch
 }

SqlServerSimulator/Parser/Expressions/Convert.cs

@@ -83,14 +83,29 @@ public override SqlValue Run(RuntimeContext runtime)
 
         try
         {
-            // Style is meaningful only for date-like sources targeting a
-            // character string; everywhere else SQL Server silently
-            // ignores it.
-            return styleCode is int sc
-                && sourceValue.Type.Category == SqlTypeCategory.DateTime
-                && this.targetType.Category == SqlTypeCategory.String
-                    ? sourceValue.CoerceDateTimeToStringWithStyle(this.targetType, sc)
-                    : Cast.ApplyCoercion(sourceValue, this.targetType, this.targetMaxLength);
+            // Style is meaningful for: date-like → string (formatted output),
+            // string → date-like (style-aware input parser), and money →
+            // string (currency formatting). Everywhere else SQL Server
+            // silently ignores it.
+            if (styleCode is int sc)
+            {
+                if (sourceValue.Type.Category == SqlTypeCategory.DateTime
+                    && this.targetType.Category == SqlTypeCategory.String)
+                {
+                    return sourceValue.CoerceDateTimeToStringWithStyle(this.targetType, sc);
+                }
+                if (sourceValue.Type.Category == SqlTypeCategory.String
+                    && this.targetType.Category == SqlTypeCategory.DateTime)
+                {
+                    return sourceValue.CoerceStringToDateLikeWithStyle(this.targetType, sc);
+                }
+                if (sourceValue.Type.Category == SqlTypeCategory.Money
+                    && this.targetType.Category == SqlTypeCategory.String)
+                {
+                    return sourceValue.CoerceMoneyToStringWithStyle(this.targetType, sc);
+                }
+            }
+            return Cast.ApplyCoercion(sourceValue, this.targetType, this.targetMaxLength);
         }
         catch (SimulatedSqlException ex) when (this.tryMode && Cast.IsConversionFailure(ex.Number))
         {