ExpandLinqSumType option (#398)

AlekseyMartynov · web-flow · commit 0fbeb5f4f16f · 2019-12-09T16:14:33.000+03:00
diff --git a/net/DevExtreme.AspNet.Data.Tests.Common/ExpandLinqSumTypeTestHelper.cs b/net/DevExtreme.AspNet.Data.Tests.Common/ExpandLinqSumTypeTestHelper.cs
@@ -0,0 +1,40 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests {
+
+    public static class ExpandLinqSumTypeTestHelper {
+
+        public interface IEntity {
+            Int32? Int32Prop { get; set; }
+            Single? SingleProp { get; set; }
+        }
+
+        public static IEnumerable<T> GenerateTestData<T>(Func<T> itemFactory) where T : IEntity {
+            for(var i = 0; i < 2; i++) {
+                var item = itemFactory();
+                item.Int32Prop = Int32.MaxValue;
+                item.SingleProp = Single.MaxValue;
+                yield return item;
+            }
+        }
+
+        public static void Run<T>(IQueryable<T> data) {
+            var loadResult = DataSourceLoader.Load(data, new SampleLoadOptions {
+                RemoteGrouping = true,
+                TotalSummary = new[] {
+                    new SummaryInfo { SummaryType = "sum", Selector = nameof(IEntity.Int32Prop) },
+                    new SummaryInfo { SummaryType = "sum", Selector = nameof(IEntity.SingleProp) }
+                }
+            });
+
+            var summary = loadResult.summary;
+
+            Assert.Equal(2m * Int32.MaxValue, summary[0]);
+            Assert.Equal(2d * Single.MaxValue, summary[1]);
+        }
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/DevExtreme.AspNet.Data.Tests.EF6.csproj b/net/DevExtreme.AspNet.Data.Tests.EF6/DevExtreme.AspNet.Data.Tests.EF6.csproj
@@ -86,6 +86,7 @@
     <Compile Include="Bug235.cs" />
     <Compile Include="Bug239.cs" />
     <Compile Include="Bug240.cs" />
+    <Compile Include="ExpandLinqSumType.cs" />
     <Compile Include="PaginateViaPrimaryKey.cs" />
     <Compile Include="RemoteGroupingStress.cs" />
     <Compile Include="Summary.cs" />
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/ExpandLinqSumType.cs b/net/DevExtreme.AspNet.Data.Tests.EF6/ExpandLinqSumType.cs
@@ -0,0 +1,30 @@
+﻿using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.EF6 {
+    using DataItem = ExpandLinqSumType_DataItem;
+
+    class ExpandLinqSumType_DataItem : ExpandLinqSumTypeTestHelper.IEntity {
+        public int ID { get; set; }
+        public int? Int32Prop { get; set; }
+        public float? SingleProp { get; set; }
+    }
+
+    public class ExpandLinqSumType {
+
+        [Fact]
+        public async Task Scenario() {
+            await TestDbContext.ExecAsync(context => {
+                var dbSet = context.Set<DataItem>();
+
+                dbSet.AddRange(ExpandLinqSumTypeTestHelper.GenerateTestData(() => new DataItem()));
+                context.SaveChanges();
+
+                ExpandLinqSumTypeTestHelper.Run(dbSet);
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.EF6/TestDbContext.cs b/net/DevExtreme.AspNet.Data.Tests.EF6/TestDbContext.cs
@@ -33,6 +33,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) {
             modelBuilder.Entity<Summary_DataItem>();
             modelBuilder.Entity<PaginateViaPrimaryKey_DataItem>().HasKey(i => new { i.K1, i.K2 });
             modelBuilder.Entity<Async_DataItem>();
+            modelBuilder.Entity<ExpandLinqSumType_DataItem>();
         }
 
         public static async Task ExecAsync(Func<TestDbContext, Task> action) {
diff --git a/net/DevExtreme.AspNet.Data.Tests.EFCore/ExpandLinqSumType.cs b/net/DevExtreme.AspNet.Data.Tests.EFCore/ExpandLinqSumType.cs
@@ -0,0 +1,32 @@
+#if !EFCORE1 && !EFCORE2
+using System;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.EFCore {
+
+    public class ExpandLinqSumType {
+
+        [Table(nameof(ExpandLinqSumType) + "_" + nameof(DataItem))]
+        public class DataItem : ExpandLinqSumTypeTestHelper.IEntity {
+            public int ID { get; set; }
+            public int? Int32Prop { get; set; }
+            public float? SingleProp { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await TestDbContext.ExecAsync(context => {
+                var dbSet = context.Set<DataItem>();
+
+                dbSet.AddRange(ExpandLinqSumTypeTestHelper.GenerateTestData(() => new DataItem()));
+                context.SaveChanges();
+
+                ExpandLinqSumTypeTestHelper.Run(dbSet);
+            });
+        }
+
+    }
+}
+#endif
diff --git a/net/DevExtreme.AspNet.Data.Tests.EFCore/TestDbContext.cs b/net/DevExtreme.AspNet.Data.Tests.EFCore/TestDbContext.cs
@@ -22,6 +22,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) {
             modelBuilder.Entity<Bug326.Entity>();
             modelBuilder.Entity<PaginateViaPrimaryKey.DataItem>().HasKey("K1", "K2");
             modelBuilder.Entity<Async.DataItem>();
+#if !EFCORE1 && !EFCORE2
+            modelBuilder.Entity<ExpandLinqSumType.DataItem>();
+#endif
         }
 
         public static async Task ExecAsync(Func<TestDbContext, Task> action) {
diff --git a/net/DevExtreme.AspNet.Data.Tests.Xpo/ExpandLinqSumType.cs b/net/DevExtreme.AspNet.Data.Tests.Xpo/ExpandLinqSumType.cs
@@ -0,0 +1,31 @@
+﻿using DevExpress.Xpo;
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests.Xpo {
+
+    public class ExpandLinqSumType {
+
+        [Persistent(nameof(ExpandLinqSumType) + "_" + nameof(DataItem))]
+        public class DataItem : ExpandLinqSumTypeTestHelper.IEntity {
+            [Key(AutoGenerate = true)]
+            public int ID { get; set; }
+            public int? Int32Prop { get; set; }
+            public float? SingleProp { get; set; }
+        }
+
+        [Fact]
+        public async Task Scenario() {
+            await UnitOfWorkHelper.ExecAsync(uow => {
+                foreach(var i in ExpandLinqSumTypeTestHelper.GenerateTestData(() => new DataItem()))
+                    uow.Save(i);
+                uow.CommitChanges();
+
+                ExpandLinqSumTypeTestHelper.Run(uow.Query<DataItem>());
+            });
+        }
+
+    }
+
+}
diff --git a/net/DevExtreme.AspNet.Data.Tests.Xpo/UnitOfWorkHelper.cs b/net/DevExtreme.AspNet.Data.Tests.Xpo/UnitOfWorkHelper.cs
@@ -23,7 +23,8 @@ public static async Task ExecAsync(Func<UnitOfWork, Task> action) {
                     typeof(Summary.DataItem),
                     typeof(Bug339.DataItem),
                     typeof(PaginateViaPrimaryKey.DataItem),
-                    typeof(Async.DataItem)
+                    typeof(Async.DataItem),
+                    typeof(ExpandLinqSumType.DataItem)
                 );
 
                 var provider = XpoDefault.GetConnectionProvider(
diff --git a/net/DevExtreme.AspNet.Data.Tests/Extensions.cs b/net/DevExtreme.AspNet.Data.Tests/Extensions.cs
@@ -17,7 +17,7 @@ public static Expression BuildCountExpr<T>(this DataSourceExpressionBuilder<T> b
         }
 
         public static Expression BuildLoadGroupsExpr<T>(this DataSourceExpressionBuilder<T> builder) {
-            return builder.BuildLoadGroupsExpr(CreateSourceExpr<T>());
+            return builder.BuildLoadGroupsExpr(CreateSourceExpr<T>(), false);
         }
 
         static Expression CreateSourceExpr<T>() {
diff --git a/net/DevExtreme.AspNet.Data.Tests/RemoteGroupExpressionCompilerTests.cs b/net/DevExtreme.AspNet.Data.Tests/RemoteGroupExpressionCompilerTests.cs
@@ -106,7 +106,7 @@ public void GroupInterval_Numeric() {
 
             string Compile<T>(string selector, bool guardNulls) {
                 var compiler = new RemoteGroupExpressionCompiler<T>(
-                    guardNulls, null,
+                    guardNulls, false, null,
                     new[] {
                         new GroupingInfo { Selector = selector, GroupInterval = "123" }
                     },
@@ -130,7 +130,7 @@ public void GroupInterval_Date() {
 
             string Compile<T>(string selector, bool guardNulls) {
                 var compiler = new RemoteGroupExpressionCompiler<T>(
-                    guardNulls, null,
+                    guardNulls, false, null,
                     new[] {
                         new GroupingInfo { Selector = selector, GroupInterval = "year" },
                         new GroupingInfo { Selector = selector, GroupInterval = "quarter" },
@@ -216,6 +216,52 @@ void Bug100Core<T>(params string[] memberNames) {
             );
         }
 
+        [Fact]
+        public void GetSumType_ExpandFalse() {
+            Type GetSumType<T>() => RemoteGroupExpressionCompiler<object>.GetSumType(typeof(T), false);
+
+            // Validation: check lambda type in new T[0].Sum(i => i)
+
+            Assert.Equal(typeof(int), GetSumType<sbyte>());
+            Assert.Equal(typeof(int), GetSumType<byte>());
+
+            Assert.Equal(typeof(int), GetSumType<short>());
+            Assert.Equal(typeof(int), GetSumType<ushort>());
+
+            Assert.Equal(typeof(int), GetSumType<int>());
+            Assert.Equal(typeof(long), GetSumType<uint>());
+
+            Assert.Equal(typeof(long), GetSumType<long>());
+            Assert.Equal(typeof(decimal), GetSumType<ulong>());
+
+            Assert.Equal(typeof(float), GetSumType<float>());
+            Assert.Equal(typeof(double), GetSumType<double>());
+            Assert.Equal(typeof(decimal), GetSumType<decimal>());
+        }
+
+        [Fact]
+        public void GetSumType_ExpandTrue() {
+            Type GetSumType<T>() => RemoteGroupExpressionCompiler<object>.GetSumType(typeof(T), true);
+
+            // Don't convert integer types to decimal because SQL decimals have variable precision
+            // Except for UInt64 for which there is no better choice
+
+            Assert.Equal(typeof(long), GetSumType<sbyte>());
+            Assert.Equal(typeof(long), GetSumType<byte>());
+
+            Assert.Equal(typeof(long), GetSumType<short>());
+            Assert.Equal(typeof(long), GetSumType<ushort>());
+
+            Assert.Equal(typeof(long), GetSumType<int>());
+            Assert.Equal(typeof(long), GetSumType<uint>());
+
+            Assert.Equal(typeof(long), GetSumType<long>());
+            Assert.Equal(typeof(decimal), GetSumType<ulong>());
+
+            Assert.Equal(typeof(double), GetSumType<float>());
+            Assert.Equal(typeof(double), GetSumType<double>());
+            Assert.Equal(typeof(decimal), GetSumType<decimal>());
+        }
     }
 
 }
diff --git a/net/DevExtreme.AspNet.Data.Tests/RemoteGroupingTests.cs b/net/DevExtreme.AspNet.Data.Tests/RemoteGroupingTests.cs
@@ -385,6 +385,115 @@ public void AggregateTranslationError() {
             Assert.Contains("No coercion operator", exception.InnerException.Message);
         }
 
+        [Fact]
+        public void ExpandLinqSumType() {
+            var sourceItem = new {
+                SByte = SByte.MaxValue,
+                Byte = Byte.MaxValue,
+
+                Int16 = Int16.MaxValue,
+                UInt16 = UInt16.MaxValue,
+
+                Int32 = Int32.MaxValue,
+                UInt32 = UInt32.MaxValue,
+
+                Int64 = Int64.MaxValue / 2,
+                UInt64 = UInt64.MaxValue,
+
+                Single = Single.MaxValue,
+                Double = Double.MaxValue / 2,
+                Decimal = (Decimal.MaxValue - 1) / 2,
+
+                SByteN = (SByte?)SByte.MaxValue,
+                ByteN = (Byte?)Byte.MaxValue,
+
+                Int16N = (Int16?)Int16.MaxValue,
+                UInt16N = (UInt16?)UInt16.MaxValue,
+
+                Int32N = (Int32?)Int32.MaxValue,
+                UInt32N = (UInt32?)UInt32.MaxValue,
+
+                Int64N = (Int64?)Int64.MaxValue / 2,
+                UInt64N = (UInt64?)UInt64.MaxValue,
+
+                SingleN = (Single?)Single.MaxValue,
+                DoubleN = (Double?)Double.MaxValue / 2,
+                DecimalN = ((Decimal?)Decimal.MaxValue - 1) / 2
+            };
+
+            var loadOptions = new SampleLoadOptions {
+                SuppressGuardNulls = true,
+                TotalSummary = new[] {
+                    nameof(sourceItem.SByte),
+                    nameof(sourceItem.Byte),
+                    nameof(sourceItem.Int16),
+                    nameof(sourceItem.UInt16),
+                    nameof(sourceItem.Int32),
+                    nameof(sourceItem.UInt32),
+                    nameof(sourceItem.Int64),
+                    nameof(sourceItem.UInt64),
+                    nameof(sourceItem.Single),
+                    nameof(sourceItem.Double),
+                    nameof(sourceItem.Decimal),
+
+                    nameof(sourceItem.SByteN),
+                    nameof(sourceItem.ByteN),
+                    nameof(sourceItem.Int16N),
+                    nameof(sourceItem.UInt16N),
+                    nameof(sourceItem.Int32N),
+                    nameof(sourceItem.UInt32N),
+                    nameof(sourceItem.Int64N),
+                    nameof(sourceItem.UInt64N),
+                    nameof(sourceItem.SingleN),
+                    nameof(sourceItem.DoubleN),
+                    nameof(sourceItem.DecimalN),
+                }
+                .Select(i => new SummaryInfo { Selector = i, SummaryType = "sum" })
+                .ToArray(),
+                RemoteGrouping = true,
+                ExpandLinqSumType = true
+            };
+
+            var summary = DataSourceLoader.Load(new[] { sourceItem, sourceItem }, loadOptions).summary;
+
+            var exprText = loadOptions.ExpressionLog.First(line => line.Contains("GroupBy"));
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.SByte", "Int64"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Byte", "Int64"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Int16", "Int64"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt16", "Int64"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Int32", "Int64"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt32", "Int64"), exprText);
+            Assert.Contains("Sum(obj => obj.Int64", exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.UInt64", "Decimal"), exprText);
+            Assert.Contains("Sum(obj => " + Compat.ExpectedConvert("obj.Single", "Double"), exprText);
+            Assert.Contains("Sum(obj => obj.Double", exprText);
+            Assert.Contains("Sum(obj => obj.Decimal", exprText);
+
+            Assert.Equal(2m * sourceItem.SByte, summary[0]);
+            Assert.Equal(2m * sourceItem.Byte, summary[1]);
+            Assert.Equal(2m * sourceItem.Int16, summary[2]);
+            Assert.Equal(2m * sourceItem.UInt16, summary[3]);
+            Assert.Equal(2m * sourceItem.Int32, summary[4]);
+            Assert.Equal(2m * sourceItem.UInt32, summary[5]);
+            Assert.Equal(2m * sourceItem.Int64, summary[6]);
+            Assert.Equal(2m * sourceItem.UInt64, summary[7]);
+            Assert.Equal(2d * sourceItem.Single, summary[8]);
+            Assert.Equal(2d * sourceItem.Double, summary[9]);
+            Assert.Equal(2m * sourceItem.Decimal, summary[10]);
+
+            Assert.Equal(2m * sourceItem.SByteN, summary[11]);
+            Assert.Equal(2m * sourceItem.ByteN, summary[12]);
+            Assert.Equal(2m * sourceItem.Int16N, summary[13]);
+            Assert.Equal(2m * sourceItem.UInt16N, summary[14]);
+            Assert.Equal(2m * sourceItem.Int32N, summary[15]);
+            Assert.Equal(2m * sourceItem.UInt32N, summary[16]);
+            Assert.Equal(2m * sourceItem.Int64N, summary[17]);
+            Assert.Equal(2m * sourceItem.UInt64N, summary[18]);
+            Assert.Equal(2d * sourceItem.SingleN, summary[19]);
+            Assert.Equal(2d * sourceItem.DoubleN, summary[20]);
+            Assert.Equal(2m * sourceItem.DecimalN, summary[21]);
+        }
+
     }
 
 }
diff --git a/net/DevExtreme.AspNet.Data/DataSourceExpressionBuilder.cs b/net/DevExtreme.AspNet.Data/DataSourceExpressionBuilder.cs
@@ -27,11 +27,11 @@ public Expression BuildCountExpr(Expression source) {
             return BuildCore(source, isCountQuery: true);
         }
 
-        public Expression BuildLoadGroupsExpr(Expression source) {
-            return BuildCore(source, remoteGrouping: true);
+        public Expression BuildLoadGroupsExpr(Expression source, bool expandSumType) {
+            return BuildCore(source, remoteGrouping: true, expandSumType: expandSumType);
         }
 
-        Expression BuildCore(Expression expr, bool paginate = false, bool isCountQuery = false, bool remoteGrouping = false, IList filterOverride = null, IReadOnlyList<string> selectOverride = null) {
+        Expression BuildCore(Expression expr, bool paginate = false, bool isCountQuery = false, bool remoteGrouping = false, bool expandSumType = false, IList filterOverride = null, IReadOnlyList<string> selectOverride = null) {
             var queryableType = typeof(Queryable);
             var genericTypeArguments = new[] { typeof(T) };
 
@@ -52,7 +52,7 @@ Expression BuildCore(Expression expr, bool paginate = false, bool isCountQuery =
                         genericTypeArguments = expr.Type.GetGenericArguments();
                     }
                 } else {
-                    expr = new RemoteGroupExpressionCompiler<T>(_guardNulls, _anonTypeNewTweaks, _context.Group, _context.TotalSummary, _context.GroupSummary).Compile(expr);
+                    expr = new RemoteGroupExpressionCompiler<T>(_guardNulls, expandSumType, _anonTypeNewTweaks, _context.Group, _context.TotalSummary, _context.GroupSummary).Compile(expr);
                 }
 
                 if(paginate) {
diff --git a/net/DevExtreme.AspNet.Data/DataSourceLoadContext.cs b/net/DevExtreme.AspNet.Data/DataSourceLoadContext.cs
diff --git a/net/DevExtreme.AspNet.Data/DataSourceLoadOptionsBase.cs b/net/DevExtreme.AspNet.Data/DataSourceLoadOptionsBase.cs
diff --git a/net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs b/net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs
diff --git a/net/DevExtreme.AspNet.Data/RemoteGrouping/RemoteGroupExpressionCompiler.cs b/net/DevExtreme.AspNet.Data/RemoteGrouping/RemoteGroupExpressionCompiler.cs

Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ protected override void OnModelCreating(DbModelBuilder modelBuilder) {`
`33`	`33`	`modelBuilder.Entity<Summary_DataItem>();`
`34`	`34`	`modelBuilder.Entity<PaginateViaPrimaryKey_DataItem>().HasKey(i => new { i.K1, i.K2 });`
`35`	`35`	`modelBuilder.Entity<Async_DataItem>();`
	`36`	`+ modelBuilder.Entity<ExpandLinqSumType_DataItem>();`
`36`	`37`	`}`
`37`	`38`
`38`	`39`	`public static async Task ExecAsync(Func<TestDbContext, Task> action) {`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,9 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) {`
`22`	`22`	`modelBuilder.Entity<Bug326.Entity>();`
`23`	`23`	`modelBuilder.Entity<PaginateViaPrimaryKey.DataItem>().HasKey("K1", "K2");`
`24`	`24`	`modelBuilder.Entity<Async.DataItem>();`
	`25`	`+#if !EFCORE1 && !EFCORE2`
	`26`	`+ modelBuilder.Entity<ExpandLinqSumType.DataItem>();`
	`27`	`+#endif`
`25`	`28`	`}`
`26`	`29`
`27`	`30`	`public static async Task ExecAsync(Func<TestDbContext, Task> action) {`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ public static Expression BuildCountExpr<T>(this DataSourceExpressionBuilder<T> b`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`public static Expression BuildLoadGroupsExpr<T>(this DataSourceExpressionBuilder<T> builder) {`
`20`		`- return builder.BuildLoadGroupsExpr(CreateSourceExpr<T>());`
	`20`	`+ return builder.BuildLoadGroupsExpr(CreateSourceExpr<T>(), false);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`static Expression CreateSourceExpr<T>() {`