support select with MemberInitExpression

Author: Ihar Yakimush

SolrNet.Linq.IntegrationTests/SelectTests.cs

@@ -1,21 +1,76 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Runtime.Serialization;
+using SolrNet.Attributes;
+using SolrNet.Commands.Parameters;
 using Xunit;
 
 namespace SolrNet.Linq.IntegrationTests
 {
+    public class Product2
+    {
+        public string Id { get; set; }
+
+        public ICollection<string> Categories { get; set; }
+
+        public decimal Price { get; set; }
+
+        public double Qwe { get; set; }
+    }
     public class SelectTests
     {
         [Fact]
         public void AnonymousClass()
         {
-            var t1 = Product.SolrOperations.Value.AsQueryable().Where(p => p.Id != null)
+            var t1 = Product.SolrOperations.Value.AsQueryable(lo => lo.SetupQueryOptions = qo =>
+                    {
+                        Assert.Equal("Qwe:pow(2,2)", qo.Fields.ElementAt(0));
+                        Assert.Equal("Id:id", qo.Fields.ElementAt(1));
+                        Assert.Equal("Price:price", qo.Fields.ElementAt(2));
+                        Assert.Equal("Categories:cat", qo.Fields.ElementAt(3));
+                    }).Where(p => p.Id != null)
                 .Select(p => new {p.Id, p.Price, p.Categories, Qwe = Math.Pow(2,2) })
                 .Where(arg => arg.Categories.Any(s => s == "electronics"))
                 .OrderBy(arg => arg.Id)
                 .FirstOrDefault();
 
             Assert.NotNull(t1);
         }
+
+        [Fact]
+        public void Product2()
+        {
+            var t1 = Product.SolrOperations.Value.AsQueryable(lo => lo.SetupQueryOptions = qo =>
+                {
+                    Assert.Equal(4, qo.Fields.Count);
+                    Assert.Equal("Qwe:pow(2,2)", qo.Fields.ElementAt(0));
+                    Assert.Equal("Id:id", qo.Fields.ElementAt(1));
+                    Assert.Equal("Price:price", qo.Fields.ElementAt(2));
+                    Assert.Equal("Categories:cat", qo.Fields.ElementAt(3));
+                }).Where(p => p.Id != null)
+                .Select(p => new Product2 {Id = p.Id, Price = p.Price, Categories = p.Categories, Qwe = Math.Pow(2, 2)})
+                .Where(arg => arg.Categories.Any(s => s == "electronics"))
+                .OrderBy(arg => arg.Id)
+                .FirstOrDefault();
+
+            Assert.NotNull(t1);
+
+            var t2 = Product.SolrOperations.Value.AsQueryable().Where(p => p.Id != null)                
+                .Where(arg => arg.Categories.Any(s => s == "electronics"))
+                .OrderBy(arg => arg.Id)
+                .FirstOrDefault();
+
+            Assert.NotNull(t2); 
+            Assert.Equal(t2.Id, t1.Id);
+
+            SolrQueryResults<Product2> t3 = Product.SolrOperations.Value.AsQueryable().Where(p => p.Id != null)
+                .Select(p => new Product2 {Id = p.Id, Price = p.Price, Categories = p.Categories, Qwe = Math.Pow(2, 2)})
+                .Where(arg => arg.Categories.Any(s => s == "electronics"))
+                .OrderBy(arg => arg.Id).Take(1).ToSolrQueryResults();
+
+            Assert.Single(t3);
+            Assert.Equal(t1.Id, t3.Single().Id);
+        }
     }
 }

SolrNet.Linq/Expressions/Context/SelectContext.cs

@@ -1,40 +1,59 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 
 namespace SolrNet.Linq.Expressions.Context
 {
     public class SelectContext : MemberContext
     {
-        public NewExpression Expression { get; }
+        public NewExpression NewExpression { get; }
         public MemberContext ParentContext { get; }
 
         public Dictionary<MemberInfo, string> Members { get; } = new Dictionary<MemberInfo, string>();
         public Dictionary<MemberInfo, string> Aliases { get; } = new Dictionary<MemberInfo, string>();
 
         public SelectContext(NewExpression expression, MemberContext parentContext)
         {
-            Expression = expression ?? throw new ArgumentNullException(nameof(expression));
+            NewExpression = expression ?? throw new ArgumentNullException(nameof(expression));
             ParentContext = parentContext ?? throw new ArgumentNullException(nameof(parentContext));
 
             for (int i = 0; i < expression.Arguments.Count; i++)
             {
                 Expression argument = expression.Arguments[i];
                 if (argument.NodeType != ExpressionType.MemberAccess)
                 {
-                    string value = $"v{i}:{parentContext.GetSolrMemberProduct(argument)}";
-                    Aliases.Add(expression.Members[i], value);
+                    Aliases.Add(expression.Members[i], parentContext.GetSolrMemberProduct(argument));
                 }
                 else
                 {
                     Members.Add(expression.Members[i], parentContext.GetSolrMemberProduct(argument, true));
                 }
             }            
         }
+
+        public SelectContext(MemberInitExpression expression, MemberContext parentContext)
+        {
+            NewExpression = expression?.NewExpression ?? throw new ArgumentNullException(nameof(expression));
+            ParentContext = parentContext ?? throw new ArgumentNullException(nameof(parentContext));
+
+            foreach (MemberAssignment binding in expression.Bindings.OfType<MemberAssignment>())
+            {
+                if (binding.Expression.NodeType != ExpressionType.MemberAccess)
+                {
+                    Aliases.Add(binding.Member, parentContext.GetSolrMemberProduct(binding.Expression));
+                }
+                else
+                {
+                    Members.Add(binding.Member, parentContext.GetSolrMemberProduct(binding.Expression, true));
+                }
+            }
+        }
+
         public override bool HasMemberAccess(Expression expression)
         {
-            bool hasMemberAccess = expression.HasMemberAccess(this.Expression.Type);
+            bool hasMemberAccess = expression.HasMemberAccess(this.NewExpression.Type);
             return hasMemberAccess;
         }
 

SolrNet.Linq/Expressions/NodeTypeHelpers/SelectMethod.cs

@@ -25,11 +25,19 @@ public static bool TryVisitSelect(this MethodCallExpression node, QueryOptions o
 
                     if (lambda.Body is NewExpression selectMember)
                     {
-                        newContext = new SelectContext(selectMember, context);
+                        newContext = new SelectContext(selectMember, context);                        
+                    }
 
-                        foreach (var pairValue in newContext.Aliases.Values.Concat(newContext.Members.Values))
+                    if (lambda.Body is MemberInitExpression memberInit)
+                    {
+                        newContext = new SelectContext(memberInit, context);
+                    }
+
+                    if (newContext != null)
+                    {
+                        foreach (var pairValue in newContext.Aliases.Concat(newContext.Members))
                         {
-                            options.Fields.Add(pairValue);
+                            options.Fields.Add($"{pairValue.Key.Name}:{pairValue.Value}");
                         }
 
                         return result;

SolrNet.Linq/Impl/ExecuterExtensions.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using SolrNet.Impl;
+using SolrNet.Impl.DocumentPropertyVisitors;
+using SolrNet.Impl.FieldParsers;
+using SolrNet.Impl.ResponseParsers;
+using SolrNet.Mapping;
+
+namespace SolrNet.Linq.Impl
+{
+    public static class ExecuterExtensions
+    {
+        public static IExecuter<TNew> ChangeType<TNew, TOld>(this IExecuter<TOld> executer)
+        {
+            try
+            {
+                SolrQueryExecuter<TOld> oldExecuter = executer.Executer;
+
+                ISolrConnection connection = oldExecuter.GetSingleField<ISolrConnection>();
+                ISolrQuerySerializer serializer = oldExecuter.GetSingleField<ISolrQuerySerializer>();
+                ISolrFacetQuerySerializer facetQuerySerializer = oldExecuter.GetSingleField<ISolrFacetQuerySerializer>();
+
+                //TODO: 
+                IReadOnlyMappingManager mapper = new AllPropertiesMappingManager();
+
+                ISolrFieldParser sfp = new DefaultFieldParser();
+                ISolrDocumentPropertyVisitor sdpv = new DefaultDocumentVisitor(mapper, sfp);
+
+                ISolrAbstractResponseParser<TNew> parser =
+                    new DefaultResponseParser<TNew>(
+                        new SolrDocumentResponseParser<TNew>(mapper, sdpv, new SolrDocumentActivator<TNew>()));
+
+                SolrQueryExecuter<TNew> newExecuter = new SolrQueryExecuter<TNew>(parser, connection, serializer,
+                    facetQuerySerializer,
+                    new SolrMoreLikeThisHandlerQueryResultsParser<TNew>(Enumerable.Repeat(parser, 1)));
+
+                newExecuter.DefaultHandler = oldExecuter.DefaultHandler;
+                newExecuter.DefaultRows = oldExecuter.DefaultRows;
+                newExecuter.MoreLikeThisHandler = oldExecuter.MoreLikeThisHandler;
+
+                return new SelectQueryExecutor<TNew>(newExecuter);
+            }
+            catch (Exception e)
+            {
+                throw new InvalidOperationException(
+                    $"Unable to change solr query executer from {typeof(TOld)} to {typeof(TNew)}.", e);
+            }                       
+        }
+
+        internal static T GetSingleField<T>(this object instance)
+        {
+            if (instance == null) throw new ArgumentNullException(nameof(instance));
+
+            BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic
+                                     | BindingFlags.Static;
+
+            Type type = instance.GetType();
+
+            FieldInfo field = type.GetFields(bindFlags).Single(info => info.FieldType == typeof(T));
+            
+            return (T)field.GetValue(instance);
+        }
+    }
+}

SolrNet.Linq/Impl/IExecuter.cs

@@ -0,0 +1,15 @@
+using System.Threading.Tasks;
+using SolrNet.Commands.Parameters;
+using SolrNet.Impl;
+
+namespace SolrNet.Linq.Impl
+{
+    public interface IExecuter<T>
+    {
+        SolrQueryResults<T> Execute(ISolrQuery q, QueryOptions options);
+
+        Task<SolrQueryResults<T>> ExecuteAsync(ISolrQuery q, QueryOptions options);
+
+        SolrQueryExecuter<T> Executer { get; }
+    }
+}

SolrNet.Linq/Impl/SelectQueryExecutor.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Threading.Tasks;
+using SolrNet.Commands.Parameters;
+using SolrNet.Impl;
+
+namespace SolrNet.Linq.Impl
+{
+    public class SelectQueryExecutor<T> : IExecuter<T>
+    {
+        private readonly SolrQueryExecuter<T> _executer;
+
+        public SelectQueryExecutor(SolrQueryExecuter<T> executer)
+        {
+            _executer = executer ?? throw new ArgumentNullException(nameof(executer));
+        }
+        public SolrQueryResults<T> Execute(ISolrQuery q, QueryOptions options)
+        {
+            return this._executer.Execute(q, options);
+        }
+
+        public Task<SolrQueryResults<T>> ExecuteAsync(ISolrQuery q, QueryOptions options)
+        {
+            return this._executer.ExecuteAsync(q, options);
+        }
+
+        public SolrQueryExecuter<T> Executer => this._executer;
+    }
+}

SolrNet.Linq/Impl/SolrQueryExecuterWrapperBasicOperations.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading.Tasks;
+using SolrNet.Commands.Parameters;
+using SolrNet.Impl;
+
+namespace SolrNet.Linq.Impl
+{
+    public class SolrQueryExecuterWrapperBasicOperations<T> : IExecuter<T>
+    {
+        private readonly ISolrBasicReadOnlyOperations<T> _basicOperations;
+
+        public SolrQueryExecuterWrapperBasicOperations(ISolrBasicReadOnlyOperations<T> basicOperations)
+        {
+            _basicOperations = basicOperations ?? throw new ArgumentNullException(nameof(basicOperations));
+        }
+        public SolrQueryResults<T> Execute(ISolrQuery q, QueryOptions options)
+        {
+            return this._basicOperations.Query(q, options);
+        }       
+
+        public Task<SolrQueryResults<T>> ExecuteAsync(ISolrQuery q, QueryOptions options)
+        {
+            return this._basicOperations.QueryAsync(q, options);
+        }
+
+        public SolrQueryExecuter<T> Executer
+        {
+            get
+            {
+                if (this._basicOperations is SolrBasicServer<T> sbs)
+                {
+                    return sbs.GetSingleField<ISolrQueryExecuter<T>>() as SolrQueryExecuter<T>;
+                }
+
+                if (this._basicOperations is SolrServer<T> srv)
+                {
+                    if (srv.GetSingleField<ISolrBasicOperations<T>>() is SolrBasicServer<T> sbs2)
+                    {
+                        return sbs2.GetSingleField<ISolrQueryExecuter<T>>() as SolrQueryExecuter<T>;
+                    }
+                }
+
+                throw new InvalidOperationException(
+                    $"Unable to get executer from current instance of type {_basicOperations.GetType()}");
+            }
+        }
+    }
+}

SolrNet.Linq/SolrOperationsExtensions.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using SolrNet.Commands.Parameters;
+using SolrNet.Linq.Impl;
 
 namespace SolrNet.Linq
 {
@@ -12,22 +13,33 @@ public static IQueryable<T> AsQueryable<T>(this ISolrBasicReadOnlyOperations<T>
         {
             SolrNetLinqOptions o = new SolrNetLinqOptions();
             setupOptions?.Invoke(o);
-            return new SolrQuery<T>(new SolrQueryProvider<T>(operations, o, null));
+            return new SolrQuery<T>(new SolrQueryProvider<T>(
+                new SolrQueryExecuterWrapperBasicOperations<T>(operations),
+                o, null));
         }
 
+        //public static IQueryable<T> AsQueryable<T>(this ISolrQueryExecuter<T> operations, Action<SolrNetLinqOptions> setupOptions = null)
+        //{
+        //    SolrNetLinqOptions o = new SolrNetLinqOptions();
+        //    setupOptions?.Invoke(o);
+        //    return new SolrQuery<T>(new SolrQueryProvider<T>(
+        //        operations,
+        //        o, null));
+        //}
+
         public static SolrQueryResults<T> ToSolrQueryResults<T>(this IQueryable<T> queryable)
         {
             return (SolrQueryResults<T>)queryable.Provider.Execute(queryable.Expression);
         }
 
         public static Task<SolrQueryResults<T>> ToSolrQueryResultsAsync<T>(this IQueryable<T> queryable)
-        {
+        {            
             if (queryable.Provider is IAsyncProvider<T> solrProvider)
             {
                 return solrProvider.ExecuteAsync<SolrQueryResults<T>>(queryable.Expression);
             }
 
             return Task.FromResult(ToSolrQueryResults(queryable));
-        }
+        }        
     }
 }