Don't calculate the 'LoadResult.data' field value if Take < 0 (#468)

Author: AlekseyMartynov

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

@@ -475,6 +475,37 @@ 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/DataSourceLoadContext.cs

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

net/DevExtreme.AspNet.Data/DataSourceLoaderImpl.cs

@@ -44,6 +44,9 @@ public async Task<LoadResult> LoadAsync() {
             if(Context.IsCountQuery)
                 return new LoadResult { totalCount = await ExecTotalCountAsync() };
 
+            if(Context.Take < 0)
+                return await LoadAggregatesOnlyAsync();
+
             var result = new LoadResult();
 
             if(Context.UseRemoteGrouping && Context.ShouldEmptyGroups) {
@@ -116,6 +119,21 @@ await ExecExprAsync<S>(loadExpr),
             return result;
         }
 
+        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);
+                }
+            }
+
+            return result;
+        }
+
         async Task<IEnumerable<ExpandoObject>> ExecWithSelectAsync(Expression loadExpr) {
             if(Context.UseRemoteSelect)
                 return SelectHelper.ConvertRemoteResult(await ExecExprAnonAsync(loadExpr), Context.FullSelect);
@@ -129,14 +147,14 @@ async Task ContinueWithGroupingAsync<R>(IEnumerable<R> loadResult, LoadResult re
                 var groups = new GroupHelper<R>(accessor).Group(loadResult, Context.Group);
                 if(Context.RequireGroupCount)
                     result.groupCount = groups.Count;
-                await ContinueWithAggregationAsync(groups, accessor, result);
+                await ContinueWithAggregationAsync(groups, accessor, result, true);
             } else {
-                await ContinueWithAggregationAsync(loadResult, accessor, result);
+                await ContinueWithAggregationAsync(loadResult, accessor, result, true);
             }
         }
 
-        async Task ContinueWithAggregationAsync<R>(IEnumerable data, IAccessor<R> accessor, LoadResult result) {
-            if(Context.UseRemoteGrouping && !Context.SummaryIsTotalCountOnly && Context.HasSummary && !Context.HasGroups) {
+        async Task ContinueWithAggregationAsync<R>(IEnumerable data, IAccessor<R> accessor, LoadResult result, bool includeData) {
+            if(Context.IsRemoteTotalSummary) {
                 var totalsResult = await ExecRemoteTotalsAsync();
                 result.totalCount = totalsResult.TotalCount;
                 result.summary = totalsResult.Totals;
@@ -152,12 +170,14 @@ async Task ContinueWithAggregationAsync<R>(IEnumerable data, IAccessor<R> access
                 if(Context.SummaryIsTotalCountOnly) {
                     result.summary = Enumerable.Repeat((object)totalCount, Context.TotalSummary.Count).ToArray();
                 } else if(Context.HasSummary) {
-                    data = Buffer<R>(data);
+                    if(includeData)
+                        data = Buffer<R>(data);
                     result.summary = new AggregateCalculator<R>(data, accessor, Context.TotalSummary, Context.GroupSummary).Run();
                 }
             }
 
-            result.data = data;
+            if(includeData)
+                result.data = data;
         }
 
         Task<int> ExecCountAsync(Expression expr) {