execution options.

Author: David Lebee

PoweredSoft.DynamicQuery.Core/IInterceptQueryExecutionOptions.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace PoweredSoft.DynamicQuery.Core
+{
+    public interface IQueryExecutionOptionsInterceptor : IQueryInterceptor
+    {
+        IQueryExecutionOptions InterceptQueryExecutionOptions(IQueryable queryable, IQueryExecutionOptions current);
+    }
+}

PoweredSoft.DynamicQuery.Core/IQueryExecutionOptions.cs

@@ -0,0 +1,8 @@
+namespace PoweredSoft.DynamicQuery.Core
+{
+    public interface IQueryExecutionOptions
+    {
+        bool GroupByInMemory { get; set; }
+        bool GroupByInMemoryNullCheck { get; set; }
+    }
+}

PoweredSoft.DynamicQuery.Core/IQueryHandler.cs

@@ -15,11 +15,15 @@ public interface IQueryHandler : IInterceptableQueryHandler
     {
         IQueryExecutionResult<TSource> Execute<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria);
         IQueryExecutionResult<TRecord> Execute<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria);
+        IQueryExecutionResult<TSource> Execute<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, IQueryExecutionOptions options);
+        IQueryExecutionResult<TRecord> Execute<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, IQueryExecutionOptions options);
     }
 
     public interface IQueryHandlerAsync : IInterceptableQueryHandler
     {
-        Task<IQueryExecutionResult<TSource>> ExecuteAsync<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));
-        Task<IQueryExecutionResult<TRecord>> ExecuteAsync<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default(CancellationToken));
+        Task<IQueryExecutionResult<TSource>> ExecuteAsync<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default);
+        Task<IQueryExecutionResult<TRecord>> ExecuteAsync<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, CancellationToken cancellationToken = default);
+        Task<IQueryExecutionResult<TSource>> ExecuteAsync<TSource>(IQueryable<TSource> queryable, IQueryCriteria criteria, IQueryExecutionOptions options, CancellationToken cancellationToken = default);
+        Task<IQueryExecutionResult<TRecord>> ExecuteAsync<TSource, TRecord>(IQueryable<TSource> queryable, IQueryCriteria criteria, IQueryExecutionOptions options, CancellationToken cancellationToken = default);
     }
 }

PoweredSoft.DynamicQuery.Core/QueryExecutionOptions.cs

@@ -0,0 +1,8 @@
+namespace PoweredSoft.DynamicQuery.Core
+{
+    public class QueryExecutionOptions : IQueryExecutionOptions
+    {
+        public bool GroupByInMemory { get; set; } = false;
+        public bool GroupByInMemoryNullCheck { get; set; } = false;
+    }
+}

PoweredSoft.DynamicQuery.Test/AggregateInterceptorTests.cs

@@ -1,4 +1,5 @@
-using PoweredSoft.DynamicQuery.Core;
+using Microsoft.EntityFrameworkCore;
+using PoweredSoft.DynamicQuery.Core;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
 using System.Collections.Generic;
@@ -14,7 +15,7 @@ private class MockAggregateInterceptor : IAggregateInterceptor
         {
             public IAggregate InterceptAggregate(IAggregate aggregate) => new Aggregate
             {
-                Path = "Item.Price",
+                Path = "Price",
                 Type = AggregateType.Avg
             };
         }
@@ -24,10 +25,12 @@ public void Simple()
         {
             MockContextFactory.SeedAndTestContextFor("AggregatorInterceptorTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
             {
-                var expected = ctx.OrderItems.GroupBy(t => true).Select(t => new
-                {
-                    PriceAtTheTime = t.Average(t2 => t2.Item.Price)
-                }).First();
+                var expected = ctx.Items
+                    .GroupBy(t => true)
+                    .Select(t => new
+                    {
+                        PriceAtTheTime = t.Average(t2 => t2.Price)
+                    }).First();
 
                 var criteria = new QueryCriteria();
                 criteria.Aggregates.Add(new Aggregate
@@ -37,7 +40,7 @@ public void Simple()
                 });
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(new MockAggregateInterceptor());
-                var result = queryHandler.Execute(ctx.OrderItems, criteria);
+                var result = queryHandler.Execute(ctx.Items, criteria);
                 Assert.Equal(expected.PriceAtTheTime, result.Aggregates.First().Value);
             });
         }

PoweredSoft.DynamicQuery.Test/AggregateTests.cs

@@ -1,4 +1,5 @@
-using PoweredSoft.DynamicQuery.Core;
+using Microsoft.EntityFrameworkCore;
+using PoweredSoft.DynamicQuery.Core;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
 using System.Collections.Generic;
@@ -27,10 +28,11 @@ public void WithoutGrouping()
                         ItemQuantityAverage = t.Average(t2 => t2.Quantity),
                         ItemQuantitySum = t.Sum(t2 => t2.Quantity),
                         AvgOfPrice = t.Average(t2 => t2.PriceAtTheTime),
+                        /* not supported by ef core 3.0
                         First = t.First(),
                         FirstOrDefault = t.FirstOrDefault(),
                         Last = t.Last(),
-                        LastOrDefault = t.LastOrDefault()
+                        LastOrDefault = t.LastOrDefault()*/
                     })
                     .First();
 
@@ -45,21 +47,28 @@ public void WithoutGrouping()
                         new Aggregate { Type = AggregateType.Avg, Path = "PriceAtTheTime"},
                         new Aggregate { Type = AggregateType.Min, Path = "Quantity"},
                         new Aggregate { Type = AggregateType.Max, Path = "Quantity" },
+                        /*not support by ef core 3.0
                         new Aggregate { Type = AggregateType.First },
                         new Aggregate { Type = AggregateType.FirstOrDefault },
                         new Aggregate { Type = AggregateType.Last },
                         new Aggregate { Type = AggregateType.LastOrDefault },
+                        */
                     }
                 };
 
                 var queryHandler = new QueryHandler();
-                var result = queryHandler.Execute(ctx.OrderItems, criteria);
+                var result = queryHandler.Execute(ctx.OrderItems, criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
 
                 var aggCount = result.Aggregates.First(t => t.Type == AggregateType.Count);
+
+                /*
                 var aggFirst = result.Aggregates.First(t => t.Type == AggregateType.First);
                 var aggFirstOrDefault = result.Aggregates.First(t => t.Type == AggregateType.FirstOrDefault);
                 var aggLast = result.Aggregates.First(t => t.Type == AggregateType.Last);
-                var aggLastOrDefault = result.Aggregates.First(t => t.Type == AggregateType.LastOrDefault);
+                var aggLastOrDefault = result.Aggregates.First(t => t.Type == AggregateType.LastOrDefault);*/
 
                 var aggItemQuantityMin  = result.Aggregates.First(t => t.Type == AggregateType.Min && t.Path == "Quantity");
                 var aggItemQuantityMax = result.Aggregates.First(t => t.Type == AggregateType.Max && t.Path == "Quantity");
@@ -68,10 +77,11 @@ public void WithoutGrouping()
                 var aggAvgOfPrice = result.Aggregates.First(t => t.Type == AggregateType.Avg && t.Path == "PriceAtTheTime");
 
                 Assert.Equal(shouldResult.Count, aggCount.Value);
+                /*
                 Assert.Equal(shouldResult.First?.Id, (aggFirst.Value as OrderItem)?.Id);
                 Assert.Equal(shouldResult.FirstOrDefault?.Id, (aggFirstOrDefault.Value as OrderItem)?.Id);
                 Assert.Equal(shouldResult.Last?.Id, (aggLast.Value as OrderItem)?.Id);
-                Assert.Equal(shouldResult.LastOrDefault?.Id, (aggLastOrDefault.Value as OrderItem)?.Id);
+                Assert.Equal(shouldResult.LastOrDefault?.Id, (aggLastOrDefault.Value as OrderItem)?.Id);*/
 
                 Assert.Equal(shouldResult.ItemQuantityAverage, aggItemQuantityAverage.Value);
                 Assert.Equal(shouldResult.ItemQuantitySum, aggItemQuantitySum.Value);
@@ -113,7 +123,11 @@ public void WithGrouping()
                 };
 
                 var queryHandler = new QueryHandler();
-                var result = queryHandler.Execute(ctx.OrderItems, criteria);
+                var queryable = ctx.OrderItems.Include(t => t.Order);
+                var result = queryHandler.Execute(queryable, criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
 
                 var groupedResult = result as IQueryExecutionGroupResult<OrderItem>;
                 Assert.NotNull(groupedResult);

PoweredSoft.DynamicQuery.Test/AsyncTests.cs

@@ -1,4 +1,5 @@
-using PoweredSoft.Data;
+using Microsoft.EntityFrameworkCore;
+using PoweredSoft.Data;
 using PoweredSoft.Data.EntityFrameworkCore;
 using PoweredSoft.DynamicQuery.Core;
 using PoweredSoft.DynamicQuery.Extensions;
@@ -9,6 +10,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using Xunit;
+using static PoweredSoft.DynamicQuery.Test.GroupInterceptorTests;
 
 namespace PoweredSoft.DynamicQuery.Test
 {
@@ -65,7 +67,11 @@ public void WithGrouping()
                 };
                 var asyncService = new AsyncQueryableService(new[] { new AsyncQueryableHandlerService() });
                 var queryHandler = new QueryHandlerAsync(asyncService);
-                var result = await queryHandler.ExecuteAsync(ctx.OrderItems, criteria);
+                var result = await queryHandler.ExecuteAsync(ctx.OrderItems.Include(t => t.Order.Customer), criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
+
                 var groups = result.GroupedResult().Groups;
 
                 // validate group and aggregates of groups.
@@ -165,6 +171,68 @@ public void TestPaging()
                 Assert.Equal(resultShouldMatch, result.Data);
             });
         }
+
+        [Fact]
+        public void WithGroupingInterceptorOptions()
+        {
+            MockContextFactory.SeedAndTestContextFor("AsyncTests_WithGroupingInterceptorOptions", TestSeeders.SimpleSeedScenario, async ctx =>
+            {
+                var shouldResults = ctx.OrderItems
+                    .GroupBy(t => t.Order.CustomerId)
+                    .Select(t => new
+                    {
+                        GroupValue = t.Key,
+                        Count = t.Count(),
+                        ItemQuantityAverage = t.Average(t2 => t2.Quantity),
+                        ItemQuantitySum = t.Sum(t2 => t2.Quantity),
+                        AvgOfPrice = t.Average(t2 => t2.PriceAtTheTime)
+                    })
+                    .ToList();
+
+                // query handler that is empty should be the same as running to list.
+                var criteria = new QueryCriteria()
+                {
+                    Groups = new List<IGroup>
+                    {
+                        new Group { Path = "Order.CustomerId" }
+                    },
+                    Aggregates = new List<Core.IAggregate>
+                    {
+                        new Aggregate { Type = AggregateType.Count },
+                        new Aggregate { Type = AggregateType.Avg, Path = "Quantity" },
+                        new Aggregate { Type = AggregateType.Sum, Path = "Quantity" },
+                        new Aggregate { Type = AggregateType.Avg, Path = "PriceAtTheTime"}
+                    }
+                };
+                var asyncService = new AsyncQueryableService(new[] { new AsyncQueryableHandlerService() });
+                var queryHandler = new QueryHandlerAsync(asyncService);
+                queryHandler.AddInterceptor(new MockQueryExecutionOptionsInterceptor());
+                var result = await queryHandler.ExecuteAsync(ctx.OrderItems.Include(t => t.Order.Customer), criteria);
+
+                var groups = result.GroupedResult().Groups;
+
+                // validate group and aggregates of groups.
+                Assert.Equal(groups.Count, shouldResults.Count);
+                Assert.All(groups, g =>
+                {
+                    var index = groups.IndexOf(g);
+                    var shouldResult = shouldResults[index];
+
+                    // validate the group value.
+                    Assert.Equal(g.GroupValue, shouldResult.GroupValue);
+
+                    // validate the group aggregates.
+                    var aggCount = g.Aggregates.First(t => t.Type == AggregateType.Count);
+                    var aggItemQuantityAverage = g.Aggregates.First(t => t.Type == AggregateType.Avg && t.Path == "Quantity");
+                    var aggItemQuantitySum = g.Aggregates.First(t => t.Type == AggregateType.Sum && t.Path == "Quantity");
+                    var aggAvgOfPrice = g.Aggregates.First(t => t.Type == AggregateType.Avg && t.Path == "PriceAtTheTime");
+                    Assert.Equal(shouldResult.Count, aggCount.Value);
+                    Assert.Equal(shouldResult.ItemQuantityAverage, aggItemQuantityAverage.Value);
+                    Assert.Equal(shouldResult.ItemQuantitySum, aggItemQuantitySum.Value);
+                    Assert.Equal(shouldResult.AvgOfPrice, aggAvgOfPrice.Value);
+                });
+            });
+        }
     }
 
 }

PoweredSoft.DynamicQuery.Test/GroupInterceptorTests.cs

@@ -1,4 +1,5 @@
-using PoweredSoft.DynamicQuery.Core;
+using Microsoft.EntityFrameworkCore;
+using PoweredSoft.DynamicQuery.Core;
 using PoweredSoft.DynamicQuery.Extensions;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
@@ -9,7 +10,7 @@
 
 namespace PoweredSoft.DynamicQuery.Test
 {
-    public class GroupInterceptorTests
+    public partial class GroupInterceptorTests
     {
         private class MockGroupInterceptor : IGroupInterceptor
         {
@@ -37,7 +38,34 @@ public void Simple()
                 criteria.Groups.Add(new Group { Path = "CustomerFirstName" });
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(new MockGroupInterceptor());
-                var result = queryHandler.Execute(ctx.Orders, criteria);
+                var result = queryHandler.Execute(ctx.Orders.Include(t => t.Customer), criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
+
+                var groupedResult = result.GroupedResult();
+                var actual = groupedResult.Groups.Select(t => t.GroupValue).ToList();
+                Assert.Equal(expected, actual);
+            });
+        }
+
+        [Fact]
+        public void WithInterptorSimple()
+        {
+            MockContextFactory.SeedAndTestContextFor("GroupInterceptorTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
+            {
+                var expected = ctx.Orders
+                    .OrderBy(t => t.Customer.FirstName)
+                    .GroupBy(t => t.Customer.FirstName)
+                    .Select(t => t.Key)
+                    .ToList();
+
+                var criteria = new QueryCriteria();
+                criteria.Groups.Add(new Group { Path = "CustomerFirstName" });
+                var queryHandler = new QueryHandler();
+                queryHandler.AddInterceptor(new MockGroupInterceptor());
+                queryHandler.AddInterceptor(new MockQueryExecutionOptionsInterceptor());
+                var result = queryHandler.Execute(ctx.Orders.Include(t => t.Customer), criteria);
 
                 var groupedResult = result.GroupedResult();
                 var actual = groupedResult.Groups.Select(t => t.GroupValue).ToList();

PoweredSoft.DynamicQuery.Test/GroupTests.cs

@@ -1,4 +1,5 @@
-using PoweredSoft.DynamicQuery.Core;
+using Microsoft.EntityFrameworkCore;
+using PoweredSoft.DynamicQuery.Core;
 using PoweredSoft.DynamicQuery.Extensions;
 using PoweredSoft.DynamicQuery.Test.Mock;
 using System;
@@ -18,23 +19,32 @@ public void Simple()
         {
             MockContextFactory.SeedAndTestContextFor("GroupTests_Simple", TestSeeders.SimpleSeedScenario, ctx =>
             {
-                var shouldResult = ctx.Orders.OrderBy(t => t.Customer).GroupBy(t => t.Customer).Select(t => new
-                {
-                    Customer = t.Key,
-                    Orders = t.ToList()
-                }).ToList();
+                var shouldResult = ctx.Orders
+                    .OrderBy(t => t.CustomerId)
+                    .ToList()
+                    .GroupBy(t => t.CustomerId)
+                    .Select(t => new
+                    {
+                        CustomerId = t.Key,
+                        Orders = t.ToList()
+                    })
+                    .ToList();
 
                 // query handler that is empty should be the same as running to list.
                 var criteria = new QueryCriteria()
                 {
                     Groups = new List<IGroup>
                     {
-                        new Group { Path = "Customer" }
+                        new Group { Path = "CustomerId" }
                     }
                 };
 
                 var queryHandler = new QueryHandler();
-                var result = queryHandler.Execute(ctx.Orders, criteria);
+                var result = queryHandler.Execute(ctx.Orders, criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true,
+                    GroupByInMemoryNullCheck = false
+                });
                 var groupedResult = result.GroupedResult();
 
                 // top level should have same amount of group levels.
@@ -43,7 +53,7 @@ public void Simple()
                 {
                     var expected = shouldResult[0];
                     var actual = groupedResult.Groups[0];
-                    Assert.Equal(expected.Customer.Id, (actual.GroupValue as Customer).Id);
+                    Assert.Equal(expected.CustomerId, actual.GroupValue);
 
                     var expectedOrderIds = expected.Orders.Select(t => t.Id).ToList();
                     var actualOrderIds = actual.Data.Cast<Order>().Select(t => t.Id).ToList();
@@ -71,7 +81,10 @@ public void GroupComplex()
                 };
 
                 var queryHandler = new QueryHandler();
-                var result = queryHandler.Execute(ctx.Tickets, criteria);
+                var result = queryHandler.Execute(ctx.Tickets, criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
 
                 var groupedResult = result.GroupedResult();
 
@@ -106,7 +119,11 @@ public void InterceptorsWithGrouping()
                 var interceptor = new InterceptorsWithGrouping();
                 var queryHandler = new QueryHandler();
                 queryHandler.AddInterceptor(interceptor);
-                var result = queryHandler.Execute<Ticket, InterceptorWithGroupingFakeModel>(ctx.Tickets, criteria);
+                var result = queryHandler.Execute<Ticket, InterceptorWithGroupingFakeModel>(ctx.Tickets, criteria, new QueryExecutionOptions
+                {
+                    GroupByInMemory = true
+                });
+
                 Assert.Equal(4, interceptor.Count);
                 Assert.True(interceptor.Test);
                 Assert.True(interceptor.Test2);