EF.Functions string + type-check + rowset bundle: PATINDEX (Msg 8116 on NULL subject, int / bigint result by MAX-ness, ESCAPE rejected via grammar), STUFF (NULL on out-of-range start / negative length, nvarchar promotion via SqlType.Promote), QUOTENAME (7 delimiter pairs incl. quote / paren / angle / brace, closing-char doubling, 128-char input cap → NULL, multi-char delim picks first), REPLICATE (parse-time MAX-form capture via Expression.GetSqlType + outer-type resolver — runtime SqlValue is length-agnostic so this is the only signal; falls back to truncating for unresolvable column refs), SPACE (varchar not nvarchar, 8000-byte cap), FORMAT (.NET IFormattable passthrough, en-US default w/ silent culture-not-found fallback, FormatException → NULL, format string echoed on token miss; Msg 8116 for strings / bit / binary / uniqueidentifier / rowversion), ISNUMERIC (hand-rolled state machine matching probed quirks: bare sign / decimal point / comma / currency all return 1, exponent requires leading + trailing digit, internal whitespace breaks, bit returns 0, NULL → 0), ISDATE (1753-9999 gate atop SqlValue.TryParseLegacyDateTime + empty-string short-circuit; Msg 8116 on modern date / time / datetimeoffset; integer stringified then re-parsed), RAND (per-instance cached for the run-once-per-query rule, XOR-folded 64-bit-double seed mix avoids int-cast collapse on small integer seeds), and STRING_SPLIT as a Selection factory (FromStringSplit) dispatched in ParseSingleFromSource alongside OPENJSON and reachable through CROSS / OUTER APPLY via a chained-resolver entry in ParseLateralFromSource that wires left-side sources for the right-side column reach. New LikePatternBuilder hoists the LIKE wildcard compiler (BuildAnchored for LIKE's ^…[ ]*\z; BuildForPatIndex strips leading / trailing % so the returned position points at non-wildcard content not at .* consumption start); LikeExpression now delegates. SqlValue.TryParseLegacyDateTime promoted to internal for ISDATE reuse. New QueryErrors factories: StringSplitSeparatorMustBeSingleChar (Msg 214) and StringSplitInvalidEnableOrdinal (Msg 4199) with verbatim probed wording. STRING_SPLIT third arg enforced parse-time-constant (column / parameter refs raise NotSupportedException, matching SQL Server's compile-time shape-fix). EF Core LINQ surface (EF.Functions.IsNumeric / IsDate / Random) regression-covered; PATINDEX / STUFF / QUOTENAME / REPLICATE / SPACE / FORMAT / STRING_SPLIT covered by raw-SQL tests since EF.Functions doesn't expose them. CLAUDE.md notes two pre-existing-but-now-observable divergences: REPLICATE of a column-typed varchar(MAX) truncates to 8000 because the parse-time outer-type resolver doesn't reach FROM-source columns; DATALENGTH returns int (not bigint) for MAX inputs.

Author: RyanLamansky

CLAUDE.md

@@ -134,7 +134,7 @@ Full `DbDataReader` contract. Typed accessors read `SqlValue` directly via the c
 
 Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger: read the linked file on demand when working in the matching area.
 
-- **Adding or modifying a built-in scalar** (math, date, current-time, `*FROMPARTS`/EOMONTH, AT TIME ZONE, CONCAT/CONCAT_WS, string `+`) → [`docs/claude/scalars.md`](docs/claude/scalars.md).
+- **Adding or modifying a built-in scalar** (math, date, current-time, `*FROMPARTS`/EOMONTH, AT TIME ZONE, CONCAT/CONCAT_WS, string `+`, PATINDEX/STUFF/QUOTENAME/REPLICATE/SPACE/FORMAT, ISNUMERIC/ISDATE/RAND, STRING_SPLIT) → [`docs/claude/scalars.md`](docs/claude/scalars.md).
 - **Touching `SqlType.Promote` / `PromoteForArithmetic` / decimal precision-scale formulas / int↔string promotion** → [`docs/claude/arithmetic.md`](docs/claude/arithmetic.md).
 - **Touching `Cast` or coercion error paths** (CAST/CONVERT narrow targets, TRY_CAST/TRY_CONVERT swallow set) → [`docs/claude/casting.md`](docs/claude/casting.md).
 - **Changing `Selection`, aggregates, window functions, set ops, CASE, OFFSET/FETCH** → [`docs/claude/query.md`](docs/claude/query.md).
@@ -197,3 +197,5 @@ Per-feature deep-dives live under `docs/claude/`. Each entry below is a trigger:
 - **Un-taken IF branches resolve names eagerly**: real SQL Server defers name resolution for un-taken branches, so `IF 1=0 SELECT bad_col FROM bad_table` runs silently. The simulator's parsers do name resolution inline with parsing, so un-taken branches that reference non-existent tables/columns still raise `Msg 208` / `Msg 207`. The common idioms (`IF NOT EXISTS (…) CREATE TABLE foo (…)`, `IF OBJECT_ID('foo','U') IS NOT NULL DROP TABLE foo`, `IF cond INSERT t VALUES (…)` against pre-existing `t`) work end-to-end because referenced names exist when the branch is skipped. State mutations inside the un-taken branch are correctly suppressed (skip-mode gate); the gap is name resolution only.
 - **`IF` cond divide-by-zero**: real SQL Server surfaces `IF 1/0 = 0 …` as Msg 8134; the simulator surfaces the raw `DivideByZeroException` from .NET decimal arithmetic. Same pre-existing gap as documented for `TRY_CAST(1/0 AS INT)`.
 - **`IF (1) select` paren-wrapped non-boolean cond — slight positional gap**: simulator raises Msg 4145 near `')'`; real SQL Server reports `'select'` (the post-paren token). Wording is correct (Msg 4145, non-boolean type), only the "near 'X'" suffix differs. Same gap applies to any `IF (value-expr) …` shape.
+- **`REPLICATE` of a column-typed `varchar(MAX)` / `nvarchar(MAX)` truncates to 8000 bytes**: the simulator's runtime `SqlValue` doesn't carry the varchar / nvarchar declared length — both bounded `varchar(N)` and `varchar(MAX)` collapse to the length-agnostic singleton at the value level. `Replicate` captures the MAX-vs-bounded distinction at parse time via `Expression.GetSqlType`, which works for literal-only or CAST-target inputs (the common shape) but falls back to "treat as bounded" for column references because the parse-time outer-type resolver doesn't reach FROM-source column types. Threading the projection-time resolver through would lift this; EF's REPLICATE emissions don't hit the affected path.
+- **`DATALENGTH` returns `int` for MAX-typed inputs**: real SQL Server returns `bigint` for `varchar(MAX)` / `nvarchar(MAX)` and the legacy LOB family. Pre-existing simulator divergence; the result still fits in int for any value the simulator can produce, but the declared column type doesn't widen.

SqlServerSimulator.Tests.EFCore/EFCoreFunctionsBundle.cs

@@ -0,0 +1,77 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Coverage for the <see cref="EF.Functions"/> members added in the EF.Functions
+/// scalar bundle: <c>IsNumeric</c>, <c>IsDate</c>, and <c>Random</c>. Each
+/// emits the corresponding SQL Server built-in via the SqlServer provider,
+/// so the LINQ→SQL pipeline is the actual coverage target — raw SQL paths
+/// are validated in the *.Tests project.
+/// </summary>
+[TestClass]
+public sealed class EFCoreFunctionsBundle
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        context.People.AddRange(
+            new Person { Id = 1, Name = "Alice", Code = "100" },
+            new Person { Id = 2, Name = "Bob", Code = "abc" },
+            new Person { Id = 3, Name = "Charlie", Code = "-7.5" },
+            new Person { Id = 4, Name = "Dave", Code = null });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void EFFunctions_IsNumeric_FiltersNumericCodes()
+    {
+        using var context = SeededContext();
+        var ids = context.People
+            .Where(p => EF.Functions.IsNumeric(p.Code!))
+            .OrderBy(p => p.Id)
+            .Select(p => p.Id)
+            .ToArray();
+        // '100' and '-7.5' are numeric per SQL Server's loose rules; 'abc'
+        // and NULL are not. NULL through IsNumeric returns 0 (probe-confirmed
+        // in the *.Tests suite). EF.Functions.IsNumeric surfaces this as
+        // bool via comparison-to-1.
+        CollectionAssert.AreEqual(new[] { 1, 3 }, ids);
+    }
+
+    [TestMethod]
+    public void EFFunctions_IsDate_FiltersDateStrings()
+    {
+        using var context = new TestDbContext(TestDbContext.CreatePeopleSimulation());
+        context.People.AddRange(
+            new Person { Id = 1, Name = "X", Code = "2026-05-12" },
+            new Person { Id = 2, Name = "Y", Code = "not-a-date" },
+            new Person { Id = 3, Name = "Z", Code = "20260512" });
+        _ = context.SaveChanges();
+        var ids = context.People
+            .Where(p => EF.Functions.IsDate(p.Code!))
+            .OrderBy(p => p.Id)
+            .Select(p => p.Id)
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 1, 3 }, ids);
+    }
+
+    /// <summary>
+    /// <see cref="DbFunctionsExtensions.Random"/> emits <c>RAND()</c> (no
+    /// seed). The defining behavior is that the value is unique per query
+    /// invocation but reused across rows — assertion here just verifies
+    /// the function executes and returns a value in [0, 1).
+    /// </summary>
+    [TestMethod]
+    public void EFFunctions_Random_EvaluatesInRange()
+    {
+        using var context = SeededContext();
+        var values = context.People.Select(p => new { p.Id, Roll = EF.Functions.Random() }).ToArray();
+        Assert.HasCount(4, values);
+        foreach (var v in values)
+            Assert.IsTrue(v.Roll is >= 0.0 and < 1.0, $"Random produced {v.Roll}");
+    }
+}

SqlServerSimulator.Tests/FormatTests.cs

@@ -0,0 +1,76 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for <c>FORMAT(value, format [, culture])</c>. The
+/// implementation routes through .NET's <see cref="IFormattable"/> on the
+/// underlying CLR value — so .NET's format-token rules (and quirks)
+/// determine whether the result is the format string echoed, a properly
+/// formatted value, or NULL via <see cref="FormatException"/>.
+/// </summary>
+[TestClass]
+public sealed class FormatTests
+{
+    [TestMethod]
+    public void IntN0_ThousandsSeparated()
+        => AreEqual("1,234,567", ExecuteScalar("select FORMAT(1234567, 'N0')"));
+
+    [TestMethod]
+    public void IntN2_TwoDecimalPlaces()
+        => AreEqual("1,234,567.00", ExecuteScalar("select FORMAT(1234567, 'N2')"));
+
+    [TestMethod]
+    public void DecimalCurrency_EnUS()
+        => AreEqual("$1,234.56", ExecuteScalar("select FORMAT(cast(1234.56 as decimal(10,2)), 'C', 'en-US')"));
+
+    [TestMethod]
+    public void DateCustomFormat()
+        => AreEqual("2026-05-12", ExecuteScalar("select FORMAT(cast('2026-05-12' as date), 'yyyy-MM-dd')"));
+
+    [TestMethod]
+    public void NumberDeDE_DecimalCommaThousandsDot()
+        => AreEqual("1.234,50", ExecuteScalar("select FORMAT(cast(1234.5 as decimal(10,2)), 'N2', 'de-DE')"));
+
+    [TestMethod]
+    public void NullValue_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select FORMAT(cast(NULL as int), 'N0')"));
+
+    /// <summary>Probe-confirmed: NULL format raises Msg 8116 even with a NULL value side.</summary>
+    [TestMethod]
+    public void NullFormat_RaisesMsg8116()
+        => AssertSqlError("select FORMAT(1234, NULL)", 8116);
+
+    [TestMethod]
+    public void StringInput_RaisesMsg8116()
+        => AssertSqlError("select FORMAT('abc', 'N0')", 8116);
+
+    [TestMethod]
+    public void BitInput_RaisesMsg8116()
+        => AssertSqlError("select FORMAT(cast(1 as bit), 'N0')", 8116);
+
+    /// <summary>
+    /// .NET's int.ToString accepts unrecognized custom-format strings by
+    /// echoing them — matching SQL Server's documented passthrough.
+    /// </summary>
+    [TestMethod]
+    public void UnrecognizedFormat_OnInt_Passthrough()
+        => AreEqual("qq qq", ExecuteScalar("select FORMAT(1234, 'qq qq')"));
+
+    /// <summary>
+    /// .NET's decimal.ToString throws FormatException for the D specifier
+    /// (decimals don't support D). SQL Server catches and returns NULL.
+    /// </summary>
+    [TestMethod]
+    public void IncompatibleFormat_OnDecimal_ReturnsNull()
+        => IsInstanceOfType<DBNull>(ExecuteScalar("select FORMAT(cast(42 as decimal(10,0)), 'D5')"));
+
+    [TestMethod]
+    public void InvalidCulture_FallsBackToEnUS()
+        => AreEqual("1,234", ExecuteScalar("select FORMAT(1234, 'N0', 'qq-QQ')"));
+
+    [TestMethod]
+    public void DateTimeCustomFormat()
+        => AreEqual("12/05/2026 13:45", ExecuteScalar("select FORMAT(cast('2026-05-12T13:45:00' as datetime2), 'dd/MM/yyyy HH:mm')"));
+}

SqlServerSimulator.Tests/IsDateTests.cs

@@ -0,0 +1,56 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for <c>ISDATE(expression)</c>. Validates against the
+/// legacy <c>datetime</c> range (1753-9999); modern <c>date</c> / <c>time</c>
+/// / <c>datetimeoffset</c> raise Msg 8116; integer input gets implicitly
+/// stringified before parse.
+/// </summary>
+[TestClass]
+public sealed class IsDateTests
+{
+    [TestMethod] public void IsoDate_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('2026-05-12')"));
+    [TestMethod] public void YyyyMmDd_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('20260512')"));
+    [TestMethod] public void DateAndTime_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('2026-05-12 13:45')"));
+    [TestMethod] public void TimeOnly_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('12:34:56')"));
+
+    [TestMethod] public void InvalidMonth_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE('2026-13-01')"));
+    [TestMethod] public void InvalidDay_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE('2026-02-30')"));
+    [TestMethod] public void NonDate_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE('not a date')"));
+    [TestMethod] public void Empty_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE('')"));
+
+    /// <summary>Pre-1753 dates are outside the legacy datetime range; ISDATE rejects.</summary>
+    [TestMethod] public void PreLegacyMinYear_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE('1700-01-01')"));
+    [TestMethod] public void LegacyMinYear_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('1753-01-01')"));
+    [TestMethod] public void LegacyMaxYear_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE('9999-12-31')"));
+
+    [TestMethod] public void Null_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISDATE(NULL)"));
+
+    [TestMethod] public void IntegerYyyyMmDd_AcceptedViaStringCoercion() => AreEqual(1, ExecuteScalar<int>("select ISDATE(20260512)"));
+    [TestMethod] public void IntegerOutOfBounds_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE(99999999)"));
+    [TestMethod] public void IntegerZero_Rejected() => AreEqual(0, ExecuteScalar<int>("select ISDATE(0)"));
+    [TestMethod] public void IntegerOne_RejectedBelowYearFloor() => AreEqual(0, ExecuteScalar<int>("select ISDATE(1)"));
+
+    [TestMethod] public void DateTimeInput_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISDATE(getdate())"));
+
+    /// <summary>
+    /// Probe-confirmed: modern date/time/datetimeoffset are explicitly rejected
+    /// with Msg 8116 — ISDATE intentionally lives in the legacy datetime domain.
+    /// </summary>
+    [TestMethod]
+    public void DateInput_RaisesMsg8116()
+        => AssertSqlError("select ISDATE(cast('2026-05-12' as date))", 8116);
+
+    [TestMethod]
+    public void TimeInput_RaisesMsg8116()
+        => AssertSqlError("select ISDATE(cast('12:34:56' as time))", 8116);
+
+    [TestMethod]
+    public void DateTimeOffsetInput_RaisesMsg8116()
+        => AssertSqlError("select ISDATE(SYSDATETIMEOFFSET())", 8116);
+
+    [TestMethod] public void FloatInput_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISDATE(cast(1.5 as float))"));
+}

SqlServerSimulator.Tests/IsNumericTests.cs

@@ -0,0 +1,57 @@
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+/// <summary>
+/// Behavioral tests for <c>ISNUMERIC(expression)</c>. Famously lossy on real
+/// SQL Server — bare <c>-</c> / <c>.</c> / <c>,</c> / <c>$</c> all return 1,
+/// hex strings return 0, and internal whitespace breaks the match. These
+/// cases are all probe-confirmed against SQL Server 2025.
+/// </summary>
+[TestClass]
+public sealed class IsNumericTests
+{
+    [TestMethod] public void Integer() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('123')"));
+    [TestMethod] public void NegativeInteger() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('-123')"));
+    [TestMethod] public void PositiveInteger() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('+123')"));
+    [TestMethod] public void Decimal() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1.5')"));
+    [TestMethod] public void ScientificNotation_e() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1e10')"));
+    [TestMethod] public void ScientificNotation_e_LargeExp() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1e308')"));
+    [TestMethod] public void ScientificNotation_d() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1d10')"));
+    [TestMethod] public void ScientificNotation_SignedExponent() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1e+10')"));
+    [TestMethod] public void Currency() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('$1')"));
+    [TestMethod] public void CurrencyDecimal() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('$1.50')"));
+    [TestMethod] public void NonDollarCurrency() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC(N'£1')"));
+    [TestMethod] public void SignThenCurrency() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('-$1')"));
+    [TestMethod] public void CurrencyThenSign() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('$-1')"));
+
+    /// <summary>Quirky probe-confirmed acceptance: a bare sign returns 1.</summary>
+    [TestMethod] public void SignAlone() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('-')"));
+
+    /// <summary>Quirky probe-confirmed acceptance: a bare decimal point returns 1.</summary>
+    [TestMethod] public void DecimalPointAlone() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('.')"));
+
+    [TestMethod] public void CommaAlone() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC(',')"));
+    [TestMethod] public void CurrencyAlone() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('$')"));
+
+    [TestMethod] public void SpaceAlone_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC(' ')"));
+    [TestMethod] public void EmptyString_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('')"));
+    [TestMethod] public void Null_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC(NULL)"));
+
+    [TestMethod] public void ExponentWithoutLeadingDigit_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('e10')"));
+    [TestMethod] public void ExponentWithoutTrailingDigit_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('1e')"));
+    [TestMethod] public void HexPrefix_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('0x10')"));
+    [TestMethod] public void InternalWhitespace_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC(' 1 2 ')"));
+    [TestMethod] public void TrailingNonDigit_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('1L')"));
+    [TestMethod] public void FExponentRejected() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC('1f10')"));
+
+    [TestMethod] public void IntegerInput_ReturnsOne() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC(123)"));
+    [TestMethod] public void FloatInput_ReturnsOne() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC(cast(1.5 as float))"));
+
+    /// <summary>Probe-confirmed: bit is the one numeric-category type that returns 0.</summary>
+    [TestMethod] public void BitInput_ReturnsZero() => AreEqual(0, ExecuteScalar<int>("select ISNUMERIC(cast(1 as bit))"));
+
+    [TestMethod] public void LeadingAndTrailingWhitespace_TrimmedAccepted() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('   123   ')"));
+    [TestMethod] public void ThousandsSeparated_Accepted() => AreEqual(1, ExecuteScalar<int>("select ISNUMERIC('1,000')"));
+}