Apply given decimal parameters hint to cast of aggregate expression

Author: alex-kulakov

Orm/Xtensive.Orm.PostgreSql/Orm.Providers.PostgreSql/SqlCompiler.cs

@@ -19,8 +19,6 @@ namespace Xtensive.Orm.Providers.PostgreSql
 {
   internal class SqlCompiler : Providers.SqlCompiler
   {
-    private static readonly Type DecimalType = typeof(decimal);
-
     protected override SqlProvider VisitFreeText(FreeTextProvider provider)
     {
       var rankColumnName = provider.Header.Columns[provider.Header.Columns.Count - 1].Name;
@@ -60,15 +58,73 @@ protected override SqlExpression ProcessAggregate(SqlProvider source, List<SqlEx
       var result = base.ProcessAggregate(source, sourceColumns, aggregateColumn);
       var aggregateType = aggregateColumn.AggregateType;
       var originCalculateColumn = source.Origin.Header.Columns[aggregateColumn.SourceIndex];
-      if (aggregateType == AggregateType.Sum || aggregateType == AggregateType.Avg) {
-        if (!IsCalculatedColumn(originCalculateColumn) && aggregateColumn.Type == DecimalType) {
-            return result;
+      if (AggregateRequiresDecimalAdjustments(aggregateColumn)) {
+        if (!IsCalculatedColumn(originCalculateColumn)) {
+          // this is aggregate by one column, result will be defined by the precision and scale of the column
+          return result;
         }
+
+        // For expressions we had to try to guess result type parameters to avoid overflow exception
+        // on reading something like 12.000000000000000000000000000000 (30 zeros) which in practice can be reduced
+        // to 12.0 on reading but Npgsql does not allow us neither to turn on such conversion inside Npgsql (as it was in v3.x.x) nor
+        // to get raw data and make conversion by ourselves (because nothing similar to SqlDecimal has provided by the library).
+
+        // Official answer of the Npgsql team is to either cast to DECIMAL with proper parameters or read all parameters as
+        // strings and then convert :-)
+        // Reading strings is not an option so we try to tell fortunes in a teacup :-(
+        var resultType = (!TryAdjustPrecisionScale(aggregateColumn.Descriptor.DecimalParametersHint, aggregateType, out var newPrecision, out var newScale))
+          ? Driver.MapValueType(aggregateColumn.Type)
+          : Driver.MapValueType(aggregateColumn.Type, null, newPrecision, newScale);
+        return SqlDml.Cast(result, resultType);
+      }
+      else if (aggregateType != AggregateType.Count) {
         result = SqlDml.Cast(result, Driver.MapValueType(aggregateColumn.Type));
       }
       return result;
     }
 
+    private bool AggregateRequiresDecimalAdjustments(AggregateColumn aggregateColumn)
+    {
+      var aggregateType = aggregateColumn.AggregateType;
+      return (aggregateType is AggregateType.Sum or AggregateType.Avg
+        or AggregateType.Min or AggregateType.Min) && aggregateColumn.Type == WellKnownTypes.DecimalType;
+    }
+
+    private bool TryAdjustPrecisionScale(
+      in (int precision, int scale)? typeHint,
+      in AggregateType aggregateType,
+      out int precision, out int scale)
+    {
+      if (!typeHint.HasValue) {
+        precision = -1;
+        scale = -1;
+        return false;
+      }
+      var typeHintValue = typeHint.Value;
+
+      if (typeHintValue.precision == 28) {
+        // No room for adjust, otherwise we'll lose floor part data
+        precision = typeHintValue.precision;
+        scale = typeHintValue.scale;
+        return true;
+      }
+
+      // choose max available precision for .net or let it be the one user declared
+      precision = (typeHintValue.precision < 28) ? 28 : typeHintValue.precision;
+
+      // It is benefitial to increase scale but for how much? It is open question,
+      // sometimes we need bigger floor part, and sometimes bigger fractional part.
+      // This algorithm is a trade-off.
+      scale = aggregateType switch {
+        AggregateType.Avg => (typeHintValue.precision < 28) ? typeHintValue.scale + Math.Max((precision - typeHintValue.precision) / 2, 1) : typeHintValue.scale + 1,
+        AggregateType.Sum => (typeHintValue.precision < 27) ? typeHintValue.scale + 2 : typeHintValue.scale + 1,
+        AggregateType.Min => (typeHintValue.precision < 27) ? typeHintValue.scale + 2 : typeHintValue.scale + 1,
+        AggregateType.Max => (typeHintValue.precision < 27) ? typeHintValue.scale + 2 : typeHintValue.scale + 1,
+        _ => typeHintValue.scale,
+      };
+      return true;
+    }
+
     private bool IsCalculatedColumn(Column column) => column is CalculatedColumn;
 
     public SqlCompiler(HandlerAccessor handlers, CompilerConfiguration configuration)

Orm/Xtensive.Orm.PostgreSql/WellKnownTypes.cs

@@ -16,6 +16,7 @@ internal static class WellKnownTypes
     public static readonly Type GuidType = typeof(Guid);
     public static readonly Type ByteArrayType = typeof(byte[]);
     public static readonly Type StringType = typeof(string);
+    public static readonly Type DecimalType = typeof(decimal);
 
     public static readonly Type NpgsqlPointType = typeof(NpgsqlPoint);
     public static readonly Type NpgsqlLSegType = typeof(NpgsqlLSeg);