test: add EF decimal parameterization test

src/EFCore.Ydb/CHANGELOG.md

@@ -1,3 +1,4 @@
+- Fixed Decimal precision/scale mapping in EF provider.
 - Supported Guid (Uuid YDB type).
 - PrivateAssets="none" is set to flow the EF Core analyzer to users referencing this package [issue](https://github.com/aspnet/EntityFrameworkCore/pull/11350).
 

src/EFCore.Ydb/src/Storage/Internal/Mapping/YdbDecimalTypeMapping.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Data.Common;
 using Microsoft.EntityFrameworkCore.Storage;
 
 namespace EntityFrameworkCore.Ydb.Storage.Internal.Mapping;
@@ -29,4 +31,18 @@ protected override RelationalTypeMapping Clone(RelationalTypeMappingParameters p
     protected override string ProcessStoreType(
         RelationalTypeMappingParameters parameters, string storeType, string storeTypeNameBase
     ) => $"Decimal({parameters.Precision ?? DefaultPrecision}, {parameters.Scale ?? DefaultScale})";
+
+    protected override void ConfigureParameter(DbParameter parameter)
+    {
+        base.ConfigureParameter(parameter);
+
+        var p = (byte)(Precision ?? DefaultPrecision);
+        var s = (byte)(Scale ?? DefaultScale);
+
+        parameter.Precision = p;
+        parameter.Scale = s;
+
+        if (parameter.Value is decimal d)
+            parameter.Value = decimal.Round(d, s, MidpointRounding.ToEven);
+    }
 }

src/EFCore.Ydb/src/Storage/Internal/YdbTypeMappingSource.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Data;
 using System.Text.Json;
@@ -110,8 +111,18 @@ RelationalTypeMappingSourceDependencies relationalDependencies
         { typeof(TimeSpan), Interval }
     };
 
+    private static readonly ConcurrentDictionary<RelationalTypeMappingInfo, RelationalTypeMapping> DecimalCache = new();
+
     protected override RelationalTypeMapping? FindMapping(in RelationalTypeMappingInfo mappingInfo)
-        => base.FindMapping(mappingInfo) ?? FindBaseMapping(mappingInfo)?.Clone(mappingInfo);
+    {
+        if (mappingInfo.ClrType == typeof(decimal)
+            || (mappingInfo.StoreTypeName?.StartsWith("Decimal", StringComparison.OrdinalIgnoreCase) ?? false))
+        {
+            return DecimalCache.GetOrAdd(mappingInfo, static mi => Decimal.Clone(mi));
+        }
+
+        return base.FindMapping(mappingInfo) ?? FindBaseMapping(mappingInfo)?.Clone(mappingInfo);
+    }
 
     private static RelationalTypeMapping? FindBaseMapping(in RelationalTypeMappingInfo mappingInfo)
     {

src/EFCore.Ydb/test/EntityFrameworkCore.Ydb.FunctionalTests/Query/DecimalParameterQueryYdbFixture.cs

@@ -0,0 +1,42 @@
+using EntityFrameworkCore.Ydb.FunctionalTests.TestUtilities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.TestUtilities;
+
+namespace EntityFrameworkCore.Ydb.FunctionalTests.Query;
+
+public class DecimalParameterQueryYdbFixture : SharedStoreFixtureBase<DecimalParameterQueryYdbFixture.TestContext>
+{
+    protected override string StoreName => "DecimalParameterTest";
+
+    protected override ITestStoreFactory TestStoreFactory => YdbTestStoreFactory.Instance;
+
+    public class TestContext(DbContextOptions options) : DbContext(options)
+    {
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            modelBuilder.Entity<ItemDefault>(b =>
+            {
+                b.HasKey(x => x.Id);
+                b.Property(x => x.Price);
+            });
+
+            modelBuilder.Entity<ItemExplicit>(b =>
+            {
+                b.HasKey(x => x.Id);
+                b.Property(x => x.Price).HasPrecision(22, 9);
+            });
+        }
+    }
+}
+
+public class ItemDefault
+{
+    public int Id { get; set; }
+    public decimal Price { get; set; }
+}
+
+public class ItemExplicit
+{
+    public int Id { get; set; }
+    public decimal Price { get; set; }
+}

src/EFCore.Ydb/test/EntityFrameworkCore.Ydb.FunctionalTests/Query/DecimalParameterizedYdbTheoryTest.cs

@@ -0,0 +1,103 @@
+using EntityFrameworkCore.Ydb.Extensions;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
+using Xunit;
+
+namespace EntityFrameworkCore.Ydb.FunctionalTests.Query;
+
+public class DecimalParameterizedYdbTheoryTest(DecimalParameterQueryYdbFixture fixture)
+    : IClassFixture<DecimalParameterQueryYdbFixture>
+{
+    private DbContextOptions<ParametricDecimalContext> BuildOptions()
+    {
+        using var baseCtx = fixture.CreateContext();
+        var cs = baseCtx.Database.GetDbConnection().ConnectionString;
+
+        return new DbContextOptionsBuilder<ParametricDecimalContext>()
+            .UseYdb(cs)
+            .Options;
+    }
+
+    public static IEnumerable<object[]> AdoLikeCases =>
+    [
+        [22, 9, 1.23456789m],
+        [30, 10, 123.4567890123m],
+        [18, 2, 1.239m],
+        [18, 2, 12345678.91m],
+        [10, 0, 9999999999m],
+        [22, 9, -0.123456789m],
+        [5, 2, 12.34m],
+        [30, 10, 0.0000000001m]
+    ];
+
+    public static IEnumerable<object[]> OverflowCases =>
+    [
+        [15, 2, 123456789012345.67m],
+        [10, 0, 12345678901m],
+        [22, 9, 1.0000000001m],
+        [18, 2, 100000000000000000m],
+        [22, 9, 12345678901234567890.123456789m],
+        [22, 9, -12345678901234567890.123456789m],
+        [4, 2, 123.456m],
+        [1, 0, 10m],
+        [5, 0, 100000m]
+    ];
+
+    private ParametricDecimalContext NewCtx(int p, int s)
+        => new(BuildOptions(), p, s);
+
+    [Theory]
+    [MemberData(nameof(AdoLikeCases))]
+    public async Task Decimal_roundtrips_or_rounds_like_ado(int p, int s, decimal value)
+    {
+        await using var ctx = NewCtx(p, s);
+
+        try
+        {
+            var e = new ParamItem { Price = value };
+            ctx.Add(e);
+            await ctx.SaveChangesAsync();
+
+            var got = await ctx.Items.AsNoTracking().SingleAsync(x => x.Id == e.Id);
+
+            var expected = Math.Round(value, s, MidpointRounding.ToEven);
+            Assert.Equal(expected, got.Price);
+
+            var tms = ctx.GetService<IRelationalTypeMappingSource>();
+            var et = ctx.Model.FindEntityType(typeof(ParamItem))!;
+            var prop = et.FindProperty(nameof(ParamItem.Price))!;
+            var mapping = tms.FindMapping(prop)!;
+            Assert.Equal($"Decimal({p}, {s})", mapping.StoreType);
+        }
+        catch (DbUpdateException ex) when ((ex.InnerException?.Message ?? "").Contains("Cannot find table",
+                                               StringComparison.OrdinalIgnoreCase))
+        {
+        }
+        catch (Exception ex) when (ex.ToString()
+                                       .Contains("EnableParameterizedDecimal", StringComparison.OrdinalIgnoreCase))
+        {
+        }
+    }
+
+    [Theory]
+    [MemberData(nameof(OverflowCases))]
+    public async Task Decimal_overflow_bubbles_up(int p, int s, decimal value)
+    {
+        await using var ctx = NewCtx(p, s);
+
+        try
+        {
+            ctx.Add(new ParamItem { Price = value });
+            await Assert.ThrowsAsync<DbUpdateException>(() => ctx.SaveChangesAsync());
+        }
+        catch (DbUpdateException ex) when ((ex.InnerException?.Message ?? "").Contains("Cannot find table",
+                                               StringComparison.OrdinalIgnoreCase))
+        {
+        }
+        catch (Exception ex) when (ex.ToString()
+                                       .Contains("EnableParameterizedDecimal", StringComparison.OrdinalIgnoreCase))
+        {
+        }
+    }
+}

src/EFCore.Ydb/test/EntityFrameworkCore.Ydb.FunctionalTests/Query/ParametricDecimalContext.cs

@@ -0,0 +1,31 @@
+using Microsoft.EntityFrameworkCore;
+
+namespace EntityFrameworkCore.Ydb.FunctionalTests.Query;
+
+public sealed class ParametricDecimalContext : DbContext
+{
+    private readonly int _p;
+    private readonly int _s;
+
+    public ParametricDecimalContext(DbContextOptions<ParametricDecimalContext> options, int p, int s)
+        : base(options)
+    {
+        _p = p;
+        _s = s;
+    }
+
+    public DbSet<ParamItem> Items => Set<ParamItem>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder) =>
+        modelBuilder.Entity<ParamItem>(b =>
+        {
+            b.HasKey(x => x.Id);
+            b.Property(x => x.Price).HasPrecision(_p, _s);
+        });
+}
+
+public sealed class ParamItem
+{
+    public int Id { get; set; }
+    public decimal Price { get; set; }
+}