Merge pull request #39 from matteobortolazzo/MoreLINQNativeSupport

Composite calls

Author: matteobortolazzo

README.md

@@ -179,10 +179,30 @@ If the Where method is not called in the expression, it will at an empty selecto
 | execution_stats | IncludeExecutionStats()                              |
 | conflicts       | IncludeConflicts()                                   |
 
-### Other IQueryable methods?
+### Composite methods
+
+Some methods that are not directly supported by CouchDB are converted to a composition of supported ones.
+
+| Input                             | Output                                |
+|:----------------------------------|:--------------------------------------|
+| Min(r => r.Age)                   | OrderBy(r => r.Age).Take(1)           |
+| Max(r => r.Age)                   | OrderByDescending(r => r.Age).Take(1) |
+| Single()                          | Take(1)								|
+| SingleOrDefault()                 | Take(1)								|
+| Single(r => r.Age == 19)			| Where(r => r.Age == 19).Take(1)       |
+| SingleOrDefault(r => r.Age == 19) | Where(r => r.Age == 19).Take(1)       |
+
+**WARN**: Do not call a method twice, for example: `Where(func).Single(func)` won't work.
+
+**WARN**: Since Max and Min use **sort**, an *index* must be created.
+
+
+### All other IQueryables
 
 IQueryable methods that are not natively supported by CouchDB are evaluated in-memory using the IEnumerable counterpart, if possible.
-**WARN** Max and Min are not working now because the mapping from IQueryable to IEnumerable is not 1 to 1.
+
+For example: `All` `Any` `Avg` `Count` `DefaultIfEmpty` `ElementAt` `ElementAtOrDefault` `GroupBy` `Last` `Reverse` `SelectMany` `Sum`
+
 
 ## Client operations
 

src/CouchDB.Driver/CouchQueryProvider.cs

@@ -1,5 +1,5 @@
 using CouchDB.Driver.DTOs;
-using CouchDB.Driver.ExpressionVisitors;
+using CouchDB.Driver.CompositeExpressionsEvaluator;
 using CouchDB.Driver.Helpers;
 using CouchDB.Driver.Settings;
 using CouchDB.Driver.Types;
@@ -29,7 +29,7 @@ public CouchQueryProvider(IFlurlClient flurlClient, CouchSettings settings, stri
 
         public override string GetQueryText(Expression expression)
         {
-            return Translate(expression);
+            return Translate(ref expression);
         }
 
         public override object Execute(Expression expression, bool completeResponse)
@@ -38,7 +38,7 @@ public override object Execute(Expression expression, bool completeResponse)
             var unsupportedMethodCallExpressions = new List<MethodCallExpression>();
             expression = RemoveUnsupportedMethodExpressions(expression, out var hasUnsupportedMethods, unsupportedMethodCallExpressions);
 
-            var body = Translate(expression);
+            var body = Translate(ref expression);
             Type elementType = TypeSystem.GetElementType(expression.Type);
 
             // Create generic GetCouchList method and invoke it, sending the request to CouchDB
@@ -60,12 +60,15 @@ public override object Execute(Expression expression, bool completeResponse)
             return result;
         }
 
-        private string Translate(Expression e)
+        private string Translate(ref Expression e)
         {
-            e = Evaluator.PartialEval(e);
-            var whereVisitor = new WhereExpressionVisitor();
+            e = Local.PartialEval(e);
+            var whereVisitor = new BoolMemberToConstantEvaluator();
             e = whereVisitor.Visit(e);
 
+            var pretranslator = new QueryPretranslator();
+            e = pretranslator.Visit(e);
+
             return new QueryTranslator(_settings).Translate(e);
         }
 
@@ -104,6 +107,12 @@ bool IsUnsupportedMethodCallExpression(Expression ex)
                         unsupportedMethodCallExpressions.Add(m);
                         return isUnsupported;
                     }
+                    // If the next call is supported and the current is in the composite list
+                    if (QueryTranslator.CompositeQueryableMethods.Contains(m.Method.Name))
+                    {
+                        unsupportedMethodCallExpressions.Add(m);
+                        return true;
+                    }
                     // If the next call is supported and the current is not in the supported list
                     if (!QueryTranslator.NativeQueryableMethods.Contains(m.Method.Name))
                     {
@@ -123,13 +132,25 @@ private object InvokeUnsupportedMethodCallExpression(object result, MethodCallEx
         {
             MethodInfo queryableMethodInfo = methodCallExpression.Method;
             Expression[] queryableMethodArguments = methodCallExpression.Arguments.ToArray();
-            // Find the equivalent method in Enumerable
-            MethodInfo enumarableMethodInfo = typeof(Enumerable).GetMethods().Single(enumerableMethodInfo =>
+
+            // Since Max and Min are not map 1 to 1 from Queryable to Enumerable 
+            // they need to be handled differently
+            MethodInfo FindEnumerableMethod()
             {
-                return 
-                    queryableMethodInfo.Name ==  enumerableMethodInfo.Name &&
-                    ReflectionComparator.IsCompatible(queryableMethodInfo, enumerableMethodInfo);
-            });
+                if (queryableMethodInfo.Name == nameof(Queryable.Max) || queryableMethodInfo.Name == nameof(Queryable.Min))
+                {
+                    return FindEnumerableMinMax(queryableMethodInfo);
+                }
+                return typeof(Enumerable).GetMethods().Single(enumerableMethodInfo =>
+                {
+                    return
+                        queryableMethodInfo.Name == enumerableMethodInfo.Name &&
+                        ReflectionComparator.IsCompatible(queryableMethodInfo, enumerableMethodInfo);
+                });
+            }
+
+            // Find the equivalent method in Enumerable
+            MethodInfo enumarableMethodInfo = FindEnumerableMethod();
 
             // Add the list as first parameter of the call
             var invokeParameter = new List<object> { result };
@@ -158,5 +179,19 @@ private object GetArgumentValueFromExpression(Expression e)
             }
             throw new NotImplementedException($"Expression of type {e.NodeType} not supported.");
         }
+        
+        private static MethodInfo FindEnumerableMinMax(MethodInfo queryableMethodInfo)
+        {
+            Type[] genericParams = queryableMethodInfo.GetGenericArguments();
+            MethodInfo finalMethodInfo = typeof(Enumerable).GetMethods().Single(enumerableMethodInfo =>
+            {
+                Type[] enumerableArguments = enumerableMethodInfo.GetGenericArguments();
+                return
+                    enumerableMethodInfo.Name == queryableMethodInfo.Name &&
+                    enumerableArguments.Length == genericParams.Length - 1 &&
+                    enumerableMethodInfo.ReturnType == genericParams[1];
+            });
+            return finalMethodInfo;
+        }           
     }
 }

src/CouchDB.Driver/ExpressionVisitors/WhereExpressionVisitor.cs renamed to src/CouchDB.Driver/ExpressionVisitors/BoolMemberToConstantEvaluator.cs

@@ -2,15 +2,15 @@
 using System.Linq.Expressions;
 using System.Reflection;
 
-namespace CouchDB.Driver.ExpressionVisitors
+namespace CouchDB.Driver.CompositeExpressionsEvaluator
 {
-    internal  class WhereExpressionVisitor : ExpressionVisitor
+    internal  class BoolMemberToConstantEvaluator : ExpressionVisitor
     {
         private bool _visitingWhereMethod;
 
         protected override Expression VisitMethodCall(MethodCallExpression m)
         {
-            _visitingWhereMethod = m.Method.Name == "Where" && m.Method.DeclaringType == typeof(Queryable);
+            _visitingWhereMethod = m.Method.Name == nameof(Queryable.Where) && m.Method.DeclaringType == typeof(Queryable);
             if (_visitingWhereMethod)
             {
                 Expression result = base.VisitMethodCall(m);
@@ -22,7 +22,7 @@ protected override Expression VisitMethodCall(MethodCallExpression m)
 
         protected override Expression VisitBinary(BinaryExpression expression)
         {
-            if (expression.Right is ConstantExpression c && c.Type == typeof(bool) && 
+            if (_visitingWhereMethod && expression.Right is ConstantExpression c && c.Type == typeof(bool) && 
                 (expression.NodeType == ExpressionType.Equal || expression.NodeType == ExpressionType.NotEqual))
             {
                 return expression;

src/CouchDB.Driver/ExpressionVisitors/CompositeExpressionsEvaluator.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace CouchDB.Driver.CompositeExpressionsEvaluator
+{
+    public class QueryPretranslator : ExpressionVisitor
+    {
+        protected override Expression VisitMethodCall(MethodCallExpression node)
+        {
+            Type[] genericArgs = node.Method.GetGenericArguments();
+            var numberOfParameters = node.Method.GetParameters().Length;
+
+            // Return an expression representing Queryable<T>.Take(1)
+            MethodCallExpression GetTakeOneExpression(Expression previousExpression)
+            {
+                return Expression.Call(typeof(Queryable), nameof(Queryable.Take), genericArgs.Take(1).ToArray(), previousExpression, Expression.Constant(1));
+            }
+
+            // Min(e => e.P) == OrderBy(e => e.P).Take(1) + Min
+            if (node.Method.Name == nameof(Queryable.Min) && numberOfParameters == 2)
+            {
+                MethodCallExpression orderByDesc = Expression.Call(typeof(Queryable), nameof(Queryable.OrderBy), genericArgs, node.Arguments[0], node.Arguments[1]);
+                return GetTakeOneExpression(orderByDesc);
+            }
+            // Max(e => e.P) == OrderByDescending(e => e.P).Take(1) + Max
+            if (node.Method.Name == nameof(Queryable.Max) && numberOfParameters == 2)
+            {
+                MethodCallExpression orderBy = Expression.Call(typeof(Queryable), nameof(Queryable.OrderByDescending), genericArgs, node.Arguments[0], node.Arguments[1]);
+                return GetTakeOneExpression(orderBy);
+            }
+            // Single and SingleOrDefault have the same behaviour
+            if (node.Method.Name == nameof(Queryable.First) || node.Method.Name == nameof(Queryable.FirstOrDefault))
+            {
+                // First() == Take(1) + First
+                if (numberOfParameters == 1)
+                {
+                    return GetTakeOneExpression(node.Arguments[0]);
+                }
+                // First(e => e.P) == Where(e => e.P).Take(1) + First
+                else if (numberOfParameters == 2)
+                {
+                    MethodCallExpression whereExpression = Expression.Call(typeof(Queryable), nameof(Queryable.Where), genericArgs, node.Arguments[0], node.Arguments[1]);
+                    return GetTakeOneExpression(whereExpression);
+                }
+            }
+            return base.VisitMethodCall(node);
+        }
+    }
+}

src/CouchDB.Driver/Helpers/Evaluator.cs renamed to src/CouchDB.Driver/ExpressionVisitors/LocalExpressionEvaluator.cs

@@ -5,9 +5,9 @@
 using System.Linq.Expressions;
 
 #pragma warning disable IDE0058 // Expression value is never used
-namespace CouchDB.Driver.Helpers
+namespace CouchDB.Driver.CompositeExpressionsEvaluator
 {
-    internal static class Evaluator
+    internal static class Local
     {
         /// <summary>
         /// Performs evaluation & replacement of independent sub-trees
@@ -27,17 +27,15 @@ public static Expression PartialEval(Expression expression, Func<Expression, boo
         /// /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
         public static Expression PartialEval(Expression expression)
         {
-            return PartialEval(expression, Evaluator.CanBeEvaluatedLocally);
+            return PartialEval(expression, Local.CanBeEvaluatedLocally);
         }
 
         private static bool CanBeEvaluatedLocally(Expression expression)
         {
             if (expression is MethodCallExpression c)
             {
-                return
-                    c.Method.Name != nameof(Queryable.Where) &&
-                    c.Method.Name != nameof(Queryable.Skip) &&
-                    c.Method.Name != nameof(Queryable.Take) &&
+                return !QueryTranslator.CompositeQueryableMethods.Contains(c.Method.Name) &&
+                    !QueryTranslator.NativeQueryableMethods.Contains(c.Method.Name) &&
                     c.Method.Name != nameof(QueryableExtensions.WithReadQuorum) &&
                     c.Method.Name != nameof(QueryableExtensions.WithoutIndexUpdate) &&
                     c.Method.Name != nameof(QueryableExtensions.UseBookmark) &&

src/CouchDB.Driver/Translators/MethodCallExpressionTranslator.cs

@@ -12,12 +12,22 @@ internal partial class QueryTranslator
     {
         internal static List<string> NativeQueryableMethods { get; } = new List<string>
         {
-            "Where",
-            "OrderBy", "ThenByWhere",
-            "OrderByDescending", "ThenByDescending",
-            "Skip",
-            "Take",
-            "Select"
+            nameof(Queryable.Where),
+            nameof(Queryable.OrderBy),
+            nameof(Queryable.ThenBy),
+            nameof(Queryable.OrderByDescending),
+            nameof(Queryable.ThenByDescending),
+            nameof(Queryable.Skip),
+            nameof(Queryable.Take),
+            nameof(Queryable.Select)
+        };
+
+        internal static List<string> CompositeQueryableMethods { get; } = new List<string>
+        {
+            nameof(Queryable.Max),
+            nameof(Queryable.Min),
+            nameof(Queryable.First),
+            nameof(Queryable.FirstOrDefault)
         };
 
         private static Expression StripQuotes(Expression e)

tests/CouchDB.Driver.UnitTests/SupportByCombination_Tests.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using CouchDB.Driver.UnitTests.Models;
+using Flurl.Http.Testing;
+using Xunit;
+
+namespace CouchDB.Driver.UnitTests
+{
+    public class SupportByCombination_Tests
+    {
+        private readonly CouchDatabase<Rebel> _rebels;
+        private readonly Rebel _mainRebel;
+        private readonly List<Rebel> _rebelsList;
+        private object _response;
+
+        public SupportByCombination_Tests()
+        {
+            var client = new CouchClient("http://localhost");
+            _rebels = client.GetDatabase<Rebel>();
+            _mainRebel = new Rebel
+            {
+                Id = Guid.NewGuid().ToString(),
+                Name = "Luke",
+                Age = 19,
+                Skills = new List<string> { "Force" }
+            };
+            _rebelsList = new List<Rebel>
+                {
+                    _mainRebel
+                };
+            _response = new
+            {
+                Docs = _rebelsList
+            };
+        }
+
+        [Fact]
+        public async Task Max()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(_response);
+                var result = _rebels.AsQueryable().Max(r => r.Age);
+                Assert.Equal(_mainRebel.Age, result);
+            }
+        }
+
+        [Fact]
+        public async Task Min()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(_response);
+                var result = _rebels.AsQueryable().Min(r => r.Age);
+                Assert.Equal(_mainRebel.Age, result);
+            }
+        }
+
+        [Fact]
+        public async Task First()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(_response);
+                var result = _rebels.AsQueryable().First();
+                Assert.Equal(_mainRebel.Age, result.Age);
+            }
+        }
+
+        [Fact]
+        public async Task First_Expr()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(_response);
+                var result = _rebels.AsQueryable().First(r => r.Age == 19);
+                Assert.Equal(_mainRebel.Age, result.Age);
+            }
+        }
+
+        [Fact]
+        public async Task FirstOrDefault()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(new { Docs = Array.Empty<Rebel>() });
+                var result = _rebels.AsQueryable().FirstOrDefault();
+                Assert.Null(result);
+            }
+        }
+
+        [Fact]
+        public async Task FirstOrDefault_Expr()
+        {
+            using (var httpTest = new HttpTest())
+            {
+                httpTest.RespondWithJson(new { Docs = Array.Empty<Rebel>() });
+                var result = _rebels.AsQueryable().FirstOrDefault(r => r.Age == 20);
+                Assert.Null(result);
+            }
+        }
+    }
+}