fix: migration of checks to extension, correct scale, new overflow tests

Author: LiamHamsters

src/Ydb.Sdk/src/Ado/YdbParameter.cs

@@ -2,8 +2,6 @@
 using System.Data;
 using System.Data.Common;
 using System.Diagnostics.CodeAnalysis;
-using System.Globalization;
-using System.Numerics;
 using Ydb.Sdk.Ado.YdbType;
 using Ydb.Sdk.Value;
 
@@ -274,54 +272,12 @@ internal TypedValue TypedValue
 
     private TypedValue Decimal(decimal value)
     {
-        var p = (Precision == 0 && Scale == 0) ? 22 : Precision;
-        var s = (Precision == 0 && Scale == 0) ? 9  : Scale;
-
-        EnsureDecimalFits(value, p, s);
+        var p = Precision == 0 && Scale == 0 ? 22 : Precision;
+        var s = Precision == 0 && Scale == 0 ? 9  : Scale;
 
         return value.Decimal((byte)p, (byte)s);
     }
 
-    private static void EnsureDecimalFits(decimal value, int precision, int scale)
-    {
-        if (precision <= 0 || scale < 0 || scale > precision)
-            throw new ArgumentOutOfRangeException(
-                $"Invalid DECIMAL({precision},{scale}) — must have precision>0 and 0<=scale<=precision.");
-
-        GetTrimmedMantissaAndScale(value, out BigInteger mantissa, out int fracDigits /* = scale' */);
-
-        var totalDigits = mantissa.IsZero ? 1 : mantissa.ToString(CultureInfo.InvariantCulture).Length;
-
-        var intDigits = Math.Max(1, totalDigits - fracDigits);
-
-        if (fracDigits > scale)
-            throw new OverflowException(
-                $"Decimal scale overflow: fractional digits {fracDigits} exceed allowed {scale} for DECIMAL({precision},{scale}). Value={value}");
-
-        if (intDigits > (precision - scale))
-            throw new OverflowException(
-                $"Decimal precision overflow: integer digits {intDigits} exceed allowed {precision - scale} for DECIMAL({precision},{scale}). Value={value}");
-    }
-
-    private static void GetTrimmedMantissaAndScale(decimal value, out BigInteger mantissa, out int scale)
-    {
-        var bits = decimal.GetBits(value);
-        scale = (bits[3] >> 16) & 0xFF;
-
-        var lo = (uint)bits[0];
-        var mid = (uint)bits[1];
-        var hi = (uint)bits[2];
-
-        mantissa = ((BigInteger)hi << 64) | ((BigInteger)mid << 32) | lo;
-        mantissa = BigInteger.Abs(mantissa);
-
-        while (scale > 0 && !mantissa.IsZero && mantissa % 10 == 0)
-        {
-            mantissa /= 10;
-            scale--;
-        }
-    }
-
     private TypedValue NullTypedValue()
     {
         if (YdbNullByDbType.TryGetValue(YdbDbType, out var value))

src/Ydb.Sdk/src/Ado/YdbType/YdbTypedValueExtensions.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using Google.Protobuf;
 using Google.Protobuf.WellKnownTypes;
 
@@ -73,16 +74,49 @@ internal static TypedValue Double(this double value) =>
 
     internal static TypedValue Decimal(this decimal value, byte precision, byte scale)
     {
-        value *= 1.00000000000000000000000000000m; // 29 zeros, max supported by c# decimal
-        value = Math.Round(value, scale);
+        var bits0 = decimal.GetBits(value);
+        var fracDigits0 = (bits0[3] >> 16) & 0xFF;
 
-        var bits = decimal.GetBits(value);
-        var low = ((ulong)bits[1] << 32) + (uint)bits[0];
-        var high = (ulong)bits[2];
+        var absInt0 = decimal.Truncate(Math.Abs(value));
+        var integerDigits0 = absInt0 == 0m
+            ? 1
+            : absInt0.ToString(CultureInfo.InvariantCulture).Length;
+
+        if (fracDigits0 > scale)
+            throw new OverflowException(
+                $"Decimal scale overflow: fractional digits {fracDigits0} exceed allowed {scale} for DECIMAL({precision},{scale}). Value={value}");
+
+        if (integerDigits0 > precision - scale)
+            throw new OverflowException(
+                $"Decimal precision overflow: integer digits {integerDigits0} exceed allowed {precision - scale} for DECIMAL({precision},{scale}). Value={value}");
+
+        var rounded = Math.Round(value, scale, MidpointRounding.ToEven);
+
+        var rb = decimal.GetBits(rounded);
+        var roundedScale = (rb[3] >> 16) & 0xFF;
+        var negative = (rb[3] & unchecked((int)0x80000000)) != 0;
+
+        var unscaled = new decimal(rb[0], rb[1], rb[2], false, 0);
+
+        int delta = scale - roundedScale;
+        if (delta > 0)
+        {
+            for (int i = 0; i < delta; i++)
+                unscaled *= 10m;
+        }
+        else if (delta < 0)
+        {
+            for (int i = 0; i < -delta; i++)
+                unscaled /= 10m;
+        }
+
+        var ub = decimal.GetBits(unscaled);
+        var low = ((ulong)ub[1] << 32) + (uint)ub[0];
+        var high = (ulong)ub[2];
 
         unchecked
         {
-            if (value < 0)
+            if (negative)
             {
                 low = ~low;
                 high = ~high;

src/Ydb.Sdk/test/Ydb.Sdk.Ado.Tests/YdbParameterTests.cs

@@ -258,6 +258,39 @@ public async Task Decimal_WhenIntegerDigitsExceedPrecisionMinusScale_Throws()
 
         await Assert.ThrowsAsync<OverflowException>(() => cmd.ExecuteNonQueryAsync());
     }
+    
+    [Fact]
+    public async Task Decimal_WhenScaleGreaterThanPrecision_ThrowsByMathNotByIf()
+    {
+        await using var ydb = await CreateOpenConnectionAsync();
+        var t = $"T_{Random.Shared.Next()}";
+        await new YdbCommand(ydb){ CommandText = $"CREATE TABLE {t}(d Decimal(5,4), PRIMARY KEY(d))" }.ExecuteNonQueryAsync();
+
+        var cmd = new YdbCommand(ydb)
+        {
+            CommandText = $"INSERT INTO {t}(d) VALUES (@d);",
+            Parameters = { new YdbParameter("d", DbType.Decimal, 0.0m){ Precision = 1, Scale = 2 } }
+        };
+
+        await Assert.ThrowsAnyAsync<Exception>(() => cmd.ExecuteNonQueryAsync());
+    }
+
+    [Fact]
+    public async Task Decimal_WhenYdbReturnsDecimal35_0_OverflowsDotNetDecimal()
+    {
+        await using var ydb = await CreateOpenConnectionAsync();
+        var t = $"T_{Random.Shared.Next()}";
+        await new YdbCommand(ydb){ CommandText = $"CREATE TABLE {t}(d Decimal(35,0), PRIMARY KEY(d))" }.ExecuteNonQueryAsync();
+
+        await new YdbCommand(ydb)
+        {
+            CommandText = $@"INSERT INTO {t}(d) VALUES (CAST('10000000000000000000000000000000000' AS Decimal(35,0)));"
+        }.ExecuteNonQueryAsync();
+
+        var select = new YdbCommand(ydb){ CommandText = $"SELECT d FROM {t};" };
+
+        await Assert.ThrowsAsync<OverflowException>(() => select.ExecuteScalarAsync());
+    }
 
     [Fact]
     public async Task YdbParameter_WhenYdbDbTypeSetAndValueIsNull_ReturnsNullValue()