Math scalar functions: ROUND (2- and 3-arg, half-away-from-zero plus truncate mode for Math.Truncate), FLOOR, CEILING, POWER, SQRT, SIGN, LOG (1- and 2-arg), EXP, LOG10 added; ABS extended from integer-only to the full numeric family (decimal/numeric/money/smallmoney/float/real/bit). Shared MathScalars helper centralizes the probe-confirmed widening rule — tinyint/smallint→int, smallmoney→money, real→float, bit→float (sic) — and the AsLong / AsDouble / AsDecimalOrMoney accessors plus matching writers that bridge decimal's boxed storage and money's scaled-int64 storage. Result-type rules: FLOOR/CEILING/ROUND/SIGN/POWER preserve (post-widen) input type; SQRT/LOG/EXP/LOG10 always return float; POWER follows its first arg. Errors: Msg 3623 (invalid float op) for sqrt-neg / log-non-positive / power-neg-fractional / log-base-1; Msg 8134 for POWER(0, neg); Msg 232 for POWER int overflow; Msg 8115 for EXP overflow and ABS(int.MinValue) / ABS(bigint.MinValue). EF Core 10 emits all of these from natural Math.X LINQ; Math.Truncate translates to ROUND(x, 0, 1).

Author: RyanLamansky

CLAUDE.md

@@ -232,6 +232,32 @@ Two shapes are modeled:
 
 EF Core 10 always wraps ROW_NUMBER in a derived-table subquery: `SELECT ... FROM (SELECT cols, ROW_NUMBER() OVER(...) AS row FROM T) AS sub WHERE sub.row <= N` (Take) or `WHERE 1 < sub.row AND sub.row <= K` (Skip+Take). The simulator's plain-derived-table-doesn't-see-outer-scope limitation doesn't bite here because the ROW_NUMBER subquery has no outer correlation — its OVER refers only to the inner FROM.
 
+### Math scalar functions
+`ABS`, `ROUND` (2- and 3-arg), `FLOOR`, `CEILING`, `POWER`, `SQRT`, `SIGN`, `LOG` (1- and 2-arg), `EXP`, `LOG10`. EF Core 10 emits all from natural `Math.X` LINQ — `Math.Round(x, n)` → `ROUND(x, n)`, `Math.Truncate(x)` → `ROUND(x, 0, 1)` (the truncate-mode third-arg form), `Math.Pow(a, b)` → `POWER(a, b)`, `Math.Log10(x)` → `LOG10(x)`, `Math.Abs(x)` → `ABS(x)`, etc. Probe-confirmed against SQL Server 2025 (2026-05-09).
+
+**Type-widening rule** (shared across `ABS` / `FLOOR` / `CEILING` / `ROUND` / `SIGN` / `POWER`'s first-arg type — probe-confirmed via `SELECT INTO #t` + `tempdb.information_schema.columns`):
+- `tinyint` / `smallint` → `int`
+- `smallmoney` → `money`
+- `real` / `bit` → `float` (sic — `bit` widens to float, not int, despite being in the integer category)
+- `int` / `bigint` / `decimal(p,s)` / `money` / `float` → preserve input type
+
+**Other type rules**:
+- `POWER` returns the (post-widen) type of the *first* argument regardless of exponent type — `POWER(int, float) → int` with truncation toward zero.
+- `SQRT` / `LOG` / `EXP` / `LOG10` always return `float` regardless of input.
+- The narrow-integer asymmetric range gets absorbed by the widening: `ABS(smallint.MinValue) = 32768` succeeds because the int result type holds it; `ABS(int.MinValue)` and `ABS(bigint.MinValue)` raise Msg 8115.
+
+**Error semantics** (probe-confirmed 2026-05-09):
+- `SQRT(negative)`, `LOG(<= 0)`, `LOG10(<= 0)`, `LOG(x, base = 1)`, `POWER(negative, fractional)` → **Msg 3623** `"An invalid floating point operation occurred."`.
+- `POWER(0, negative)` → **Msg 8134** `"Divide by zero error encountered."`.
+- `EXP(huge)` (overflow to inf) → **Msg 8115** `"Arithmetic overflow error converting expression to data type float."`.
+- `ABS(int.MinValue)` / `ABS(bigint.MinValue)` → **Msg 8115** with the result type's family name in the data-type slot.
+- `POWER` int-result overflow → **Msg 232** `"Arithmetic overflow error for type int, value = X.XXXXXX."` (six-digit fractional in the value slot).
+- `ROUND` non-integer length / function argument → **Msg 8116** (existing factory) `"Argument data type X is invalid for argument N of round function."`.
+
+NULL on any operand → typed NULL of the (post-widen) result type. `MathScalars` (sibling helper in `Parser/Expressions/`) centralizes the widening rule and the `AsLong` / `AsDouble` / `AsDecimalOrMoney` accessors plus the matching `PromoteInteger` / `FromDecimalOrMoney` writers — each function file stays small and dispatches on `resultType.Category`. The `AsDecimal` / `FromDecimal` pair is decimal-only (rejects money); `AsDecimalOrMoney` / `FromDecimalOrMoney` bridge the two storage shapes (decimal stores boxed `decimal`, money stores scaled `int64`).
+
+**`Math.Sign(decimal)` through EF Core 10 doesn't work end-to-end against either real SQL Server or the simulator** (probe-confirmed 2026-05-09): the LINQ method's CLR signature returns `int` but EF emits `SELECT SIGN([col])` and SQL Server's `SIGN(decimal)` returns decimal, so the reader-side cast throws — real SqlClient surfaces `InvalidCastException("Unable to cast object of type 'System.Decimal' to type 'System.Int32'.")`, the simulator surfaces `InvalidOperationException("Value is decimal(p,s), not int.")` from its stricter `GetInt32`. Same failure mode, different exception subtype; not a fidelity bug. Apps using `Math.Sign` over an int column work fine.
+
 ### Date scalar functions: `DATEPART` / `DATEADD` / `DATEDIFF` / `DATEDIFF_BIG`
 All four take a bare datepart keyword as the first argument (parse-time `Name` token, not an expression). Canonical keywords + common aliases: `year`/`yy`/`yyyy`, `quarter`/`qq`/`q`, `month`/`mm`/`m`, `dayofyear`/`dy`/`y`, `day`/`dd`/`d`, `week`/`wk`/`ww`, `iso_week`/`isowk`/`isoww`, `weekday`/`dw`, `hour`/`hh`, `minute`/`mi`/`n`, `second`/`ss`/`s`, `millisecond`/`ms`, `microsecond`/`mcs`, `nanosecond`/`ns`, `tzoffset`/`tz`. Result types: `DATEPART` → `int`; `DATEADD` preserves the input's SQL type (`date` stays `date`, `time(N)` stays `time(N)`, etc.); `DATEDIFF` → `int`; `DATEDIFF_BIG` → `bigint`.
 

SqlServerSimulator.Tests.EFCore/EFCoreMath.cs

@@ -0,0 +1,160 @@
+namespace SqlServerSimulator;
+
+/// <summary>
+/// End-to-end coverage for EF Core 10's translation of <c>Math.X</c> LINQ
+/// methods. Probe-confirmed (2026-05-09): EF emits the SQL function
+/// directly for <c>Math.Round</c> / <c>Floor</c> / <c>Ceiling</c> /
+/// <c>Pow</c> / <c>Sqrt</c> / <c>Sign</c> / <c>Log</c> / <c>Exp</c> /
+/// <c>Log10</c>, and emits <c>ROUND(x, 0, 1)</c> for <c>Math.Truncate</c>
+/// (the truncate-mode third-arg form). <c>Math.Abs</c> already routes
+/// through the existing <c>AbsoluteValue</c> path.
+/// </summary>
+[TestClass]
+public class EFCoreMath
+{
+    public TestContext TestContext { get; set; } = null!;
+
+    private static TestDbContext SeededProductsContext()
+    {
+        var context = new TestDbContext(TestDbContext.CreateProductsSimulation());
+        context.Products.AddRange(
+            new Product { Id = 1, Price = 12.345m },
+            new Product { Id = 2, Price = 0.5m },
+            new Product { Id = 3, Price = -5.5m });
+        _ = context.SaveChanges();
+        return context;
+    }
+
+    [TestMethod]
+    public void Round_DecimalProperty()
+    {
+        // Math.Round(p.Price, 2) → ROUND([p].[Price], 2) — half-away-from-zero.
+        using var context = SeededProductsContext();
+        var rounded = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Round(p.Price, 2))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 12.35m, 0.50m, -5.50m }, rounded);
+    }
+
+    [TestMethod]
+    public void RoundToInteger()
+    {
+        // Math.Round(p.Price) → ROUND([p].[Price], 0) — half-away-from-zero.
+        using var context = SeededProductsContext();
+        var rounded = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Round(p.Price))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 12m, 1m, -6m }, rounded);
+    }
+
+    [TestMethod]
+    public void Floor_DecimalProperty()
+    {
+        // Math.Floor(p.Price) → FLOOR([p].[Price]).
+        using var context = SeededProductsContext();
+        var floors = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Floor(p.Price))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 12m, 0m, -6m }, floors);
+    }
+
+    [TestMethod]
+    public void Ceiling_DecimalProperty()
+    {
+        using var context = SeededProductsContext();
+        var ceilings = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Ceiling(p.Price))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 13m, 1m, -5m }, ceilings);
+    }
+
+    [TestMethod]
+    public void Sign_IntFromOrderBy()
+    {
+        // EF Core emits SIGN([t].[Id]) for Math.Sign(int); the result is
+        // an int column. Math.Sign(decimal) → int has a server-side type
+        // mismatch (SQL Server's SIGN(decimal) returns decimal, but EF
+        // reads the column as int) — that route isn't exercised here.
+        using var context = SeededProductsContext();
+        var signs = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Sign(p.Id))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 1, 1, 1 }, signs);
+    }
+
+    [TestMethod]
+    public void Abs_DecimalProperty()
+    {
+        // Math.Abs(p.Price) → ABS([p].[Price]) — preserves decimal(p,s).
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Abs(p.Price))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 12.35m, 0.50m, 5.50m }, values);
+    }
+
+    [TestMethod]
+    public void Truncate_DecimalProperty_EmitsRoundWithTruncateFlag()
+    {
+        // Math.Truncate(p.Price) → ROUND([p].[Price], 0, 1) — truncate mode.
+        using var context = SeededProductsContext();
+        var truncated = context.Products
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Truncate(p.Price))
+            .ToArray();
+        CollectionAssert.AreEqual(new[] { 12m, 0m, -5m }, truncated);
+    }
+
+    [TestMethod]
+    public void Power_AndSqrt_OverFloatProjection()
+    {
+        // Math.Pow / Math.Sqrt require float operands at the LINQ side
+        // (EF Core's translator doesn't widen decimal to double
+        // automatically), so route through a CAST to double.
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .Where(p => p.Price > 0)
+            .OrderBy(p => p.Id)
+            .Select(p => new { Pow = Math.Pow((double)p.Price, 2), Root = Math.Sqrt((double)p.Price) })
+            .ToArray();
+        // Price is decimal(10,2) so 12.345 stores as 12.35 → 12.35^2 = 152.5225.
+        AreClose(152.5225m, (decimal)values[0].Pow, 0.001m);
+        AreClose(3.5142m, (decimal)values[0].Root, 0.001m);
+        AreClose(0.25m, (decimal)values[1].Pow, 0.001m);
+    }
+
+    [TestMethod]
+    public void LogAndExp_FloatProjection()
+    {
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .Where(p => p.Price > 0)
+            .OrderBy(p => p.Id)
+            .Select(p => new { Log = Math.Log((double)p.Price), Exp = Math.Exp(1.0) })
+            .ToArray();
+        Assert.HasCount(2, values);
+        AreClose(2.5133m, (decimal)values[0].Log, 0.001m); // log(12.345)
+        AreClose(2.7183m, (decimal)values[0].Exp, 0.001m); // e
+    }
+
+    [TestMethod]
+    public void Log10_FloatProjection()
+    {
+        using var context = SeededProductsContext();
+        var values = context.Products
+            .Where(p => p.Price > 0)
+            .OrderBy(p => p.Id)
+            .Select(p => Math.Log10((double)p.Price))
+            .ToArray();
+        AreClose(1.0915m, (decimal)values[0], 0.001m); // log10(12.345)
+    }
+
+    private static void AreClose(decimal expected, decimal actual, decimal tolerance)
+        => Assert.IsLessThanOrEqualTo(tolerance, Math.Abs(expected - actual), $"Expected {expected} ± {tolerance}, got {actual}");
+}

SqlServerSimulator.Tests/MathScalarAbsTests.cs

@@ -0,0 +1,156 @@
+using System.Data.Common;
+using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
+using static SqlServerSimulator.TestHelpers;
+
+namespace SqlServerSimulator;
+
+[TestClass]
+public sealed class MathScalarAbsTests
+{
+    [TestMethod]
+    public void Abs_Int()
+    {
+        AreEqual(5, ExecuteScalar<int>("select abs(-5)"));
+        AreEqual(5, ExecuteScalar<int>("select abs(5)"));
+        AreEqual(0, ExecuteScalar<int>("select abs(0)"));
+    }
+
+    [TestMethod]
+    public void Abs_BigInt_PreservesType()
+    {
+        AreEqual(5L, ExecuteScalar("select abs(cast(-5 as bigint))"));
+    }
+
+    [TestMethod]
+    public void Abs_SmallInt_WidensToInt()
+    {
+        // Server-side type: SELECT INTO #t reports `int`. SqlClient's
+        // ExecuteScalar surfaces the value as int regardless.
+        AreEqual(5, ExecuteScalar<int>("select abs(cast(-5 as smallint))"));
+        // smallint.MinValue widens through int and survives.
+        AreEqual(32768, ExecuteScalar<int>("select abs(cast(-32768 as smallint))"));
+    }
+
+    [TestMethod]
+    public void Abs_TinyInt_WidensToInt()
+    {
+        AreEqual(5, ExecuteScalar<int>("select abs(cast(5 as tinyint))"));
+    }
+
+    [TestMethod]
+    public void Abs_Decimal_PreservesPrecisionScale()
+    {
+        AreEqual(5.50m, ExecuteScalar("select abs(cast(-5.5 as decimal(10,2)))"));
+    }
+
+    [TestMethod]
+    public void Abs_Money_PreservesType()
+    {
+        AreEqual(5.5000m, ExecuteScalar("select abs(cast(-5.5 as money))"));
+    }
+
+    [TestMethod]
+    public void Abs_SmallMoney_WidensToMoney()
+    {
+        // Server-side type: smallmoney input → money result.
+        AreEqual(5.5000m, ExecuteScalar("select abs(cast(-5.5 as smallmoney))"));
+    }
+
+    [TestMethod]
+    public void Abs_Float()
+    {
+        AreEqual(5.5, ExecuteScalar("select abs(cast(-5.5 as float))"));
+    }
+
+    [TestMethod]
+    public void Abs_Real_WidensToFloat()
+    {
+        // Server-side type: real input → float result.
+        AreEqual(5.5, ExecuteScalar("select abs(cast(-5.5 as real))"));
+    }
+
+    [TestMethod]
+    public void Abs_Bit_WidensToFloat()
+    {
+        // SQL Server's quirky widening: ABS(bit) → float (probe-confirmed).
+        AreEqual(0.0, ExecuteScalar("select abs(cast(0 as bit))"));
+        AreEqual(1.0, ExecuteScalar("select abs(cast(1 as bit))"));
+    }
+
+    [TestMethod]
+    public void Abs_IntMinValue_RaisesMsg8115()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select abs(cast(-2147483648 as int))"));
+        StartsWith("Arithmetic overflow error converting expression to data type int", ex.Message);
+        AreEqual("8115", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Abs_BigIntMinValue_RaisesMsg8115()
+    {
+        var ex = Throws<DbException>(() => ExecuteScalar("select abs(cast(-9223372036854775808 as bigint))"));
+        StartsWith("Arithmetic overflow error converting expression to data type bigint", ex.Message);
+        AreEqual("8115", ex.Data["HelpLink.EvtID"]);
+    }
+
+    [TestMethod]
+    public void Abs_Null_TypedNullOfWidenedType()
+    {
+        AreEqual(DBNull.Value, ExecuteScalar("select abs(cast(null as int))"));
+        AreEqual(DBNull.Value, ExecuteScalar("select abs(cast(null as decimal(10,2)))"));
+        AreEqual(DBNull.Value, ExecuteScalar("select abs(cast(null as smallmoney))"));
+    }
+
+    // The widening rule is shared across ABS / FLOOR / CEILING / ROUND /
+    // SIGN; verify the previously-shipped functions also widen smallmoney
+    // / real / bit per the probe.
+
+    [TestMethod]
+    public void Floor_SmallMoney_WidensToMoney()
+    {
+        AreEqual(1.0000m, ExecuteScalar("select floor(cast(1.7 as smallmoney))"));
+    }
+
+    [TestMethod]
+    public void Floor_Real_WidensToFloat()
+    {
+        AreEqual(1.0, ExecuteScalar("select floor(cast(1.7 as real))"));
+    }
+
+    [TestMethod]
+    public void Floor_Bit_WidensToFloat()
+    {
+        AreEqual(1.0, ExecuteScalar("select floor(cast(1 as bit))"));
+        AreEqual(0.0, ExecuteScalar("select floor(cast(0 as bit))"));
+    }
+
+    [TestMethod]
+    public void Ceiling_SmallMoney_WidensToMoney()
+    {
+        AreEqual(2.0000m, ExecuteScalar("select ceiling(cast(1.3 as smallmoney))"));
+    }
+
+    [TestMethod]
+    public void Sign_SmallMoney_WidensToMoney()
+    {
+        AreEqual(-1.0000m, ExecuteScalar("select sign(cast(-1.5 as smallmoney))"));
+    }
+
+    [TestMethod]
+    public void Sign_Real_WidensToFloat()
+    {
+        AreEqual(-1.0, ExecuteScalar("select sign(cast(-1.5 as real))"));
+    }
+
+    [TestMethod]
+    public void Round_SmallMoney_WidensToMoney()
+    {
+        AreEqual(2.0000m, ExecuteScalar("select round(cast(1.5 as smallmoney), 0)"));
+    }
+
+    [TestMethod]
+    public void Round_Real_WidensToFloat()
+    {
+        AreEqual(2.0, ExecuteScalar("select round(cast(1.5 as real), 0)"));
+    }
+}