LibRed: ACE-parity SQL semantics, standard SQL extensions and file-format write fixes; Jet Math translation fixes (11.0.0-alpha.3)

AGENTS.md

@@ -7,7 +7,7 @@ It is kept in sync with `CLAUDE.md`; if you change guidance in one, check whethe
 
 EntityFrameworkCore.Jet is an EF Core provider for Microsoft Jet/ACE databases (Microsoft Access `.mdb`/`.accdb` files). The **Jet** provider runs **Windows only** and bridges EF Core to the Access database engine via either ODBC or OLE DB. Alongside it, **LibRed** (also in this repo, on `master`) is a from-scratch managed engine that reads/writes the file format directly and is **cross-platform** — see the LibRed section below.
 
-Current version: `11.0.0-alpha.1` (`Version.props`) targeting EF Core 11 and `net11.0`; `global.json` pins the 11.0.100 RC1 SDK with `rollForward: latestFeature`. The test projects use **xunit v3**.
+Current version: `11.0.0-alpha.3` (`Version.props`) targeting EF Core 11 and `net11.0`; `global.json` pins the 11.0.100 RC1 SDK with `rollForward: latestFeature`. The test projects use **xunit v3**.
 
 ### Which layer am I touching?
 
@@ -211,7 +211,9 @@ contract.
 > underneath us. It did: dotnet/runtime#130566 (.NET 11 preview 7) dropped `Convert.ToDecimal`'s 15-significant-digit
 > rounding, which came from OA's own `VarDecFromR8` and had been stable since the 1990s. That turned
 > `SUM(ROUND(UnitPrice, 2))` into `58.600000000000001421085471520`. The fix was to own it:
-> `src/EFCore.Jet.Data/JetDecimalConverter.cs`. **When a long-stable conversion suddenly misbehaves with no code
+> `src/Shared/Data/JetDecimalConverter.cs` (compiled into both EFCore.Jet.Data and LibRed.Core; every LibRed
+> assembly uses the Core copy, and any double/float that can reach a decimal goes through its `ToDecimal`, never
+> `Convert.ToDecimal` or a cast). **When a long-stable conversion suddenly misbehaves with no code
 > change on our side, suspect the runtime's OA-era compatibility behaviour before suspecting the provider.**
 
 ## LibRed — Native Managed Engine

CLAUDE.md

@@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 EntityFrameworkCore.Jet is an EF Core provider for Microsoft Jet/ACE databases (Microsoft Access `.mdb`/`.accdb` files). The **Jet** provider runs **Windows only** and bridges EF Core to the Access database engine via either ODBC or OLE DB. Alongside it, **LibRed** (also in this repo, on `master`) is a from-scratch managed engine that reads/writes the file format directly and is **cross-platform** — see the LibRed section below.
 
-Current version: `11.0.0-alpha.1` (`Version.props`) targeting EF Core 11 and `net11.0`; `global.json` pins the 11.0.100 RC1 SDK with `rollForward: latestFeature`. The test projects use **xunit v3**.
+Current version: `11.0.0-alpha.3` (`Version.props`) targeting EF Core 11 and `net11.0`; `global.json` pins the 11.0.100 RC1 SDK with `rollForward: latestFeature`. The test projects use **xunit v3**.
 
 ### Which layer am I touching?
 
@@ -223,7 +223,9 @@ contract.
 > underneath us. It did: dotnet/runtime#130566 (.NET 11 preview 7) dropped `Convert.ToDecimal`'s 15-significant-digit
 > rounding, which came from OA's own `VarDecFromR8` and had been stable since the 1990s. That turned
 > `SUM(ROUND(UnitPrice, 2))` into `58.600000000000001421085471520`. The fix was to own it:
-> `src/EFCore.Jet.Data/JetDecimalConverter.cs`. **When a long-stable conversion suddenly misbehaves with no code
+> `src/Shared/Data/JetDecimalConverter.cs` (compiled into both EFCore.Jet.Data and LibRed.Core; every LibRed
+> assembly uses the Core copy, and any double/float that can reach a decimal goes through its `ToDecimal`, never
+> `Convert.ToDecimal` or a cast). **When a long-stable conversion suddenly misbehaves with no code
 > change on our side, suspect the runtime's OA-era compatibility behaviour before suspecting the provider.**
 
 ## LibRed — Native Managed Engine

Version.props

@@ -17,7 +17,7 @@
         -->
 		<VersionPrefix>11.0.0</VersionPrefix>
 		<PreReleaseVersionLabel>alpha</PreReleaseVersionLabel>
-		<PreReleaseVersionIteration>2</PreReleaseVersionIteration>
+		<PreReleaseVersionIteration>3</PreReleaseVersionIteration>
 
 		<!--
             The following properties will automatically be set by CI builds when appropriate:

src/EFCore.Jet.Common/Query/ExpressionTranslators/Internal/JetMathTranslator.cs

@@ -122,15 +122,15 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
             {
                 return method.Name switch
                 {
-                    // Arccos(X) = Atn(-X / Sqr(-X * X + 1)) + 2 * Atn(1)
+                    // Arccos(X) = 2 * Atn(-X / (Sqr(-X * X + 1) + 1)) + 2 * Atn(1)
                     nameof(Math.Acos) => _sqlExpressionFactory.Add(
                         _sqlExpressionFactory.Constant(Math.Atan(1) * 2),
-                        _sqlExpressionFactory.Function(
+                        _sqlExpressionFactory.Multiply(_sqlExpressionFactory.Function(
                             "ATN",
                             [
                                 _sqlExpressionFactory.Divide(
                                     _sqlExpressionFactory.Negate(arguments[0]),
-                                    Translate(
+                                    _sqlExpressionFactory.Add(Translate(
                                         null,
                                         method.DeclaringType == typeof(MathF)
                                             ? typeof(MathF).GetRuntimeMethod(nameof(MathF.Sqrt), [typeof(float)])!
@@ -147,20 +147,20 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
                                             )
                                         ],
                                         logger
-                                    )!
+                                    )!, _sqlExpressionFactory.Constant(1d))
                                 )
                             ],
                             true,
                             [true],
-                            method.ReturnType)),
+                            method.ReturnType), _sqlExpressionFactory.Constant(2d))),
 
-                    // Arcsin(X) = Atn(X / Sqr(-X * X + 1))
-                    nameof(Math.Asin) => _sqlExpressionFactory.Function(
+                    // Arcsin(X) = 2 * Atn(X / (Sqr(-X * X + 1) + 1))
+                    nameof(Math.Asin) => _sqlExpressionFactory.Multiply(_sqlExpressionFactory.Function(
                         "ATN",
                         [
                             _sqlExpressionFactory.Divide(
                                 arguments[0],
-                                Translate(
+                                _sqlExpressionFactory.Add(Translate(
                                     null,
                                     method.DeclaringType == typeof(MathF)
                                         ? typeof(MathF).GetRuntimeMethod(nameof(MathF.Sqrt), [typeof(float)])!
@@ -177,12 +177,12 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
                                         )
                                     ],
                                     logger
-                                )!
+                                )!, _sqlExpressionFactory.Constant(1d))
                             )
                         ],
                         true,
                         [true],
-                        method.ReturnType),
+                        method.ReturnType), _sqlExpressionFactory.Constant(2d)),
 
                     // Logn(x) = Log(x) / Log(n)
                     nameof(Math.Log10) => _sqlExpressionFactory.Divide(
@@ -196,10 +196,12 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
                         _sqlExpressionFactory.Function("LOG", [arguments[1]], true, [true], method.ReturnType)
                     ),
 
-                    nameof(Math.Floor) => CreateFix(arguments, method.ReturnType),
-                    nameof(Math.Ceiling) => CreateCeiling(arguments, method.ReturnType),
+                    nameof(Math.Floor) => CreateFloor(arguments[0], method.ReturnType),
+                    nameof(Math.Ceiling) => CreateCeiling(arguments[0], method.ReturnType),
 
-                    nameof(Math.Atan2) => _sqlExpressionFactory.Function(
+                    // Atan2(Y, X) = IIf(X = 0, Sgn(Y) * Pi / 2, Atn(Y / X) + IIf(X < 0, IIf(Y < 0, -Pi, Pi), 0))
+                    nameof(Math.Atan2) => _sqlExpressionFactory.Case([new CaseWhenClause(_sqlExpressionFactory.Equal(arguments[1], _sqlExpressionFactory.Constant(0d)), _sqlExpressionFactory.Multiply(_sqlExpressionFactory.Function("SGN", [arguments[0]], true, [true], method.ReturnType), _sqlExpressionFactory.Constant(Math.PI / 2)))],
+                        _sqlExpressionFactory.Add(_sqlExpressionFactory.Function(
                         "ATN",
                         [
                             _sqlExpressionFactory.Divide(
@@ -209,7 +211,7 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
                         ],
                         true,
                         [true],
-                        method.ReturnType),
+                        method.ReturnType), _sqlExpressionFactory.Case([new CaseWhenClause(_sqlExpressionFactory.LessThan(arguments[1], _sqlExpressionFactory.Constant(0d)), _sqlExpressionFactory.Case([new CaseWhenClause(_sqlExpressionFactory.LessThan(arguments[0], _sqlExpressionFactory.Constant(0d)), _sqlExpressionFactory.Constant(-Math.PI))], _sqlExpressionFactory.Constant(Math.PI)))], _sqlExpressionFactory.Constant(0d)))),
 
                     nameof(double.DegreesToRadians) => _sqlExpressionFactory.Multiply(arguments[0], _sqlExpressionFactory.Divide(_sqlExpressionFactory.Constant(Math.PI), _sqlExpressionFactory.Constant(180))),
 
@@ -274,40 +276,25 @@ public class JetMathTranslator(ISqlExpressionFactory sqlExpressionFactory) : IMe
             return null;
         }
 
-        private SqlExpression CreateCeiling(IReadOnlyList<SqlExpression> arguments, Type methodReturnType)
-        {
-            SqlFunctionExpression fixExpression = (SqlFunctionExpression)CreateFix(arguments, methodReturnType);
-            var addoneexp = _sqlExpressionFactory.Add(fixExpression, _sqlExpressionFactory.Constant(1));
-            return _sqlExpressionFactory.Case(
-                [
-                    new CaseWhenClause(
-                        _sqlExpressionFactory.Equal(
-                            fixExpression,
-                            arguments[0]),
-                        fixExpression)
-                ],
-                addoneexp);
-        }
-
-        private SqlExpression CreateFix(IReadOnlyList<SqlExpression> arguments, Type methodReturnType)
-        {
-            var typeMapping = arguments.Count == 1
-                ? ExpressionExtensions.InferTypeMapping(arguments[0])
-                : ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
+        // Math.Floor rounds towards negative infinity, which is Access's INT - not FIX, which rounds towards zero
+        // (that is Math.Truncate) and so gave Floor(-1.5) as -1. Math.Ceiling is the mirror image, -INT(-x): the old
+        // IIF(FIX(x) = x, FIX(x), FIX(x) + 1) was one too high for any negative non-integer, and +1 for anything
+        // between -1 and 0. Verified against ACE and LibRed over -2.7, -1.5, -1, -0.5, 0, 1.5 and 2, Double and
+        // Currency; both keep the argument's type, and -INT(-x) keeps .NET's -0 for Math.Ceiling(-0.5).
+        private SqlExpression CreateFloor(SqlExpression argument, Type methodReturnType)
+            => CreateInt(argument, methodReturnType);
 
-            var newArguments = new SqlExpression[arguments.Count];
-            newArguments[0] = _sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping);
-
-            if (arguments.Count == 2)
-            {
-                newArguments[1] = _sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping);
-            }
+        private SqlExpression CreateCeiling(SqlExpression argument, Type methodReturnType)
+            => _sqlExpressionFactory.Negate(CreateInt(_sqlExpressionFactory.Negate(argument), methodReturnType));
 
+        private SqlExpression CreateInt(SqlExpression argument, Type methodReturnType)
+        {
+            var typeMapping = ExpressionExtensions.InferTypeMapping(argument);
             return _sqlExpressionFactory.Function(
-                "FIX",
-                newArguments,
+                "INT",
+                [_sqlExpressionFactory.ApplyTypeMapping(argument, typeMapping)],
                 nullable: true,
-                argumentsPropagateNullability: newArguments.Select(_ => true).ToArray(),
+                argumentsPropagateNullability: [true],
                 methodReturnType,
                 typeMapping);
         }

src/EFCore.Jet.Common/Query/Internal/JetDateTimeRangeConverter.cs

@@ -21,8 +21,8 @@ namespace EntityFrameworkCore.Jet.Query.Internal;
 ///         alone: <c>d == default</c> must keep matching the epoch a default was stored as.
 ///     </para>
 ///     <para>
-///         This has to run in <c>JetParameterBasedSqlProcessor</c> rather than in the compile-time
-///         <c>JetDateTimeExpressionVisitor</c>, because the value normally arrives as a parameter and query
+///         This has to run in <c>JetParameterBasedSqlProcessor</c> rather than at query compilation, because
+///         the value normally arrives as a parameter and query
 ///         compilation is cached across invocations, so no value is available there. Nor can it be deferred to
 ///         a value-independent clamp in the emitted SQL: by then the DateTime type mapping has already replaced
 ///         0001-01-01 with the epoch, so the clamp would test the substituted value and never fire.