Undo Take < 0 logic; introduce IsSummaryQuery flag (#469)

Author: AlekseyMartynov

net/DevExtreme.AspNet.Data.Tests/DataSourceLoaderTests.cs

@@ -475,37 +475,6 @@ public void Load_Select_NoAnonTypeLimits(bool? remoteSelect) {
             );
         }
 
-        [Theory]
-        [InlineData(false, false)]
-        [InlineData(false, true)]
-        [InlineData(true, false)]
-        [InlineData(true, true)]
-        public void Load_NegativeTake(bool remoteGrouping, bool group) {
-            var loadOptions = new SampleLoadOptions {
-                Filter = new[] { "this", "<", "100" },
-                RemoteGrouping = remoteGrouping,
-                Take = -1,
-                TotalSummary = new[] {
-                    new SummaryInfo { Selector = "this", SummaryType = "sum" }
-                }
-            };
-
-            if(group) {
-                loadOptions.Group = new[] {
-                    new GroupingInfo { Selector = "any", IsExpanded = !remoteGrouping }
-                };
-                loadOptions.GroupSummary = new[] {
-                    new SummaryInfo { Selector = "any", SummaryType = "any" }
-                };
-            }
-
-            var loadResult = DataSourceLoader.Load(new[] { 1, 1, 2, 2, 100 }, loadOptions);
-            Assert.Null(loadResult.data);
-            Assert.Equal(6m, loadResult.summary[0]);
-
-            Assert.Single(loadOptions.ExpressionLog);
-        }
-
         [Theory]
         [InlineData(false, true)]
         [InlineData(false, false)]

net/DevExtreme.AspNet.Data.Tests/IsSummaryQueryTests.cs

@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace DevExtreme.AspNet.Data.Tests {
+
+    public class IsSummaryQueryTests {
+
+        [Theory]
+        [MemberData(nameof(CombinatorialBool), 4)]
+        public void Case(bool remoteGrouping, bool requireTotalCount, bool hasGroups, bool hasSummary) {
+            var loadOptions = new SampleLoadOptions {
+                IsSummaryQuery = true,
+                RemoteGrouping = remoteGrouping,
+                RequireTotalCount = requireTotalCount,
+                Filter = new[] { "this", "<", "100" }
+            };
+            if(hasGroups) {
+                loadOptions.Group = new[] {
+                    new GroupingInfo { Selector = "any", IsExpanded = !remoteGrouping }
+                };
+                loadOptions.GroupSummary = new[] {
+                    new SummaryInfo { Selector = "any", SummaryType = "any" }
+                };
+            }
+            if(hasSummary) {
+                loadOptions.TotalSummary = new[] {
+                    new SummaryInfo { Selector = "this", SummaryType = "sum" }
+                };
+            }
+
+            var loadResult = DataSourceLoader.Load(new[] { 1, 1, 2, 2, 100 }, loadOptions);
+
+            Assert.Null(loadResult.data);
+
+            if(hasSummary)
+                Assert.Equal(6m, loadResult.summary[0]);
+            else
+                Assert.Null(loadResult.summary);
+
+            // Refer to RemoteGroupExpressionCompiler.MakeAggregatingProjection
+            var implicitTotalCount = hasSummary && remoteGrouping;
+
+            if(requireTotalCount || implicitTotalCount)
+                Assert.True(loadResult.totalCount > 0);
+            else
+                Assert.Equal(-1, loadResult.totalCount);
+
+            var expectedExpressionCount = 0;
+
+            if(requireTotalCount && !implicitTotalCount) {
+                expectedExpressionCount++;
+                Assert.Contains(loadOptions.ExpressionLog, line => line.EndsWith(".Where(obj => (obj < 100)).Count()"));
+            }
+
+            if(hasSummary) {
+                expectedExpressionCount++;
+                if(remoteGrouping)
+                    Assert.Contains(loadOptions.ExpressionLog, line => line.Contains(".GroupBy(obj => new AnonType())"));
+                else
+                    Assert.Contains(loadOptions.ExpressionLog, line => line.EndsWith(".Where(obj => (obj < 100))"));
+            }
+
+            Assert.Equal(expectedExpressionCount, loadOptions.ExpressionLog.Count);
+        }
+
+        public static IEnumerable<object[]> CombinatorialBool(int count) {
+            var combinationCount = 1 << count;
+            for(var i = 0; i < combinationCount; i++) {
+                yield return Enumerable.Range(0, count)
+                    .Select(bit => (i & 1 << bit) != 0)
+                    .Cast<object>()
+                    .ToArray();
+            }
+        }
+    }
+
+}

net/DevExtreme.AspNet.Data/DataSourceLoadContext.cs

@@ -88,7 +88,7 @@ partial class DataSourceLoadContext {
 
         public IReadOnlyList<GroupingInfo> Group => _options.Group;
 
-        public bool HasGroups => Take > -1 && !IsEmpty(Group);
+        public bool HasGroups => !IsSummaryQuery && !IsEmpty(Group);
 
         public bool ShouldEmptyGroups {
             get {
@@ -260,6 +260,8 @@ public bool ExpandLinqSumType {
             }
         }
 
+        public bool IsSummaryQuery => _options.IsSummaryQuery;
+
         public bool IsRemoteTotalSummary => UseRemoteGrouping && !SummaryIsTotalCountOnly && HasSummary && !HasGroups;
     }
 

net/DevExtreme.AspNet.Data/DataSourceLoadOptionsBase.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.ComponentModel;
 using System.Linq;
 using System.Linq.Expressions;
 
@@ -29,6 +30,9 @@ public class DataSourceLoadOptionsBase {
         /// </summary>
         public bool IsCountQuery { get; set; }
 
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public bool IsSummaryQuery { get; set; }
+
         /// <summary>
         /// The number of data objects to be skipped from the start of the resulting set.
         /// </summary>

net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs

@@ -44,7 +44,7 @@ public async Task<LoadResult> LoadAsync() {
             if(Context.IsCountQuery)
                 return new LoadResult { totalCount = await ExecTotalCountAsync() };
 
-            if(Context.Take < 0)
+            if(Context.IsSummaryQuery)
                 return await LoadAggregatesOnlyAsync();
 
             var result = new LoadResult();
@@ -122,13 +122,11 @@ await ExecExprAsync<S>(loadExpr),
         async Task<LoadResult> LoadAggregatesOnlyAsync() {
             var result = new LoadResult();
 
-            if(Context.HasTotalSummary) {
-                if(Context.IsRemoteTotalSummary) {
-                    await ContinueWithAggregationAsync<S>(null, null, result, false);
-                } else {
-                    var data = await ExecExprAsync<S>(CreateBuilder().BuildLoadExpr(false));
-                    await ContinueWithAggregationAsync(data, new DefaultAccessor<S>(), result, false);
-                }
+            if(!Context.HasTotalSummary || Context.IsRemoteTotalSummary) {
+                await ContinueWithAggregationAsync<S>(null, null, result, false);
+            } else {
+                var data = await ExecExprAsync<S>(CreateBuilder().BuildLoadExpr(false));
+                await ContinueWithAggregationAsync(data, new DefaultAccessor<S>(), result, false);
             }
 
             return result;