support score pseudo field

Author: Ihar Yakimush

README.md

@@ -102,6 +102,33 @@ IQueryable<Product> solrLinq = solr.AsQueryable(setup =>
   // cat:(qwe)
   Product[] result = solrLinq.Where(p => p.Categories.Any(s => s == "qwe")).ToArray();
   ```
+  ### Select
+  - Anonymous type with fields, pseudo field, functions and transformers
+  ```
+  var result = solrLinq.Select(p => 
+      new {
+              p.Id, 
+	          p.Categories, 
+	          Qwe = Math.Pow(2,2), // function
+	          ValStr = SolrExpr.Transformers.Value("qwe"), // value transformer
+	          Score= SolrExpr.Fields.Score() // score pseudo field 
+	      }).OrderBy(arg => arg.Score).ToSolrQueryResults();
+  ```
+  ### Select
+  - Existing type by member initialization
+  ```
+  var result = solrLinq.Select(p => new Product2 {Id = p.Id, Price = p.Price, Categories = p.Categories, Qwe = Math.Pow(2, 2)}).ToArray();
+  ```
+  - Combine Select with other methods
+  ```
+  var result = solrLinq
+	.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).ThenBy(arg=>arg.Qwe)
+    .Select(arg => new {arg.Id})
+    .FirstOrDefault(arg2 => arg2.Id != null);
+  ```
   ### Paging
   - Top
   - Skip

SolrNet.Linq.IntegrationTests/SelectTests.cs

@@ -40,6 +40,45 @@ public void AnonymousClass()
             Assert.True(t1.Price > 0);
         }
 
+        [Fact]
+        public void AnonymousIdAndScore()
+        {
+            var t1 = Product.SolrOperations.Value.AsQueryable(lo => lo.SetupQueryOptions = qo =>
+                {
+                    Assert.Equal("Score:score", qo.Fields.ElementAt(0));
+                    Assert.Equal("Id:id", qo.Fields.ElementAt(1));
+                })
+                .Select(p => new { p.Id, Score= SolrExpr.Fields.Score()})                
+                .OrderBy(arg => arg.Score)
+                .FirstOrDefault();
+
+            Assert.NotNull(t1);
+            Assert.NotNull(t1.Id);
+            Assert.Equal(1, t1.Score);
+        }
+
+        [Fact]
+        public void AnonymousOrderByProduct()
+        {
+            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).ThenBy(arg=>arg.Qwe)
+                .FirstOrDefault();
+
+            Assert.NotNull(t1);
+            Assert.NotNull(t1.Id);
+            Assert.Equal(4, t1.Qwe);
+            Assert.True(t1.Categories.Count > 0);
+            Assert.True(t1.Price > 0);
+        }
+
         [Fact]
         public void AnonymousClassSolrResult()
         {
@@ -67,7 +106,7 @@ public void MultipleSelects()
                 }).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)
+                .OrderBy(arg => arg.Id).ThenBy(arg=>arg.Qwe)
                 .Select(arg => new {arg.Id})
                 .FirstOrDefault(arg2 => arg2.Id != null);
 
@@ -87,14 +126,24 @@ public void Transformers()
                     ValFloat = SolrExpr.Transformers.Value((float) 2),
                     ValDouble = SolrExpr.Transformers.Value((double) 3),
                     ValDate = SolrExpr.Transformers.Value(dateTime),
-                })
+                    ExplNl = SolrExpr.Transformers.ExplainNl(),
+                    ExplText = SolrExpr.Transformers.ExplainText(),
+                    ExplHtml = SolrExpr.Transformers.ExplainHtml(),
+                    DocId = SolrExpr.Transformers.DocId()
+                }).Skip(1)
                 .First();
 
             Assert.Equal("qwe", t1.ValStr);
             Assert.Equal(1, t1.ValInt);
             Assert.Equal(2f, t1.ValFloat);
             Assert.Equal(3d, t1.ValDouble);
             Assert.Equal(dateTime, t1.ValDate);
+
+            Assert.NotNull(t1.ExplText);
+            Assert.NotNull(t1.ExplNl);
+            Assert.NotNull(t1.ExplHtml);
+
+            Assert.Equal(1, t1.DocId);
         }
 
         [Fact]

SolrNet.Linq/Expressions/MemberExpressionExtensions.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Xml.Linq;
 using SolrNet.Impl;
 using SolrNet.Linq.Expressions.Context;
 
@@ -34,7 +35,19 @@ public static class MemberExpressionExtensions
             { nameof(SolrExpr.Transformers.Value) + typeof(float).Name ,(c,t) => $"[value v={c.Arguments[0].GetSolrMemberProduct(t)} t=float]" },
             { nameof(SolrExpr.Transformers.Value) + typeof(double).Name ,(c,t) => $"[value v={c.Arguments[0].GetSolrMemberProduct(t)} t=double]" },
             { nameof(SolrExpr.Transformers.Value) + typeof(DateTime).Name ,(c,t) => $"[value v={c.Arguments[0].GetSolrMemberProduct(t)} t=date]" },
+
+            { nameof(SolrExpr.Transformers.ExplainHtml) + typeof(string).Name ,(c,t) => "[explain style=html]" },
+            { nameof(SolrExpr.Transformers.ExplainNl) + typeof(XElement).Name ,(c,t) => "[explain style=nl]" },
+            { nameof(SolrExpr.Transformers.ExplainText) + typeof(string).Name ,(c,t) => "[explain style=text]" },
+
+            { nameof(SolrExpr.Transformers.DocId) + typeof(int).Name ,(c,t) => "[docid]" },
+
         };
+        private static readonly Dictionary<string, Func<MethodCallExpression, MemberContext, string>> FieldsHelper = new Dictionary<string, Func<MethodCallExpression, MemberContext, string>> {
+            { nameof(SolrExpr.Fields.Score) ,(c,t) => "score" },
+
+        };
+
 
         internal static string GetSolrMemberProduct(this Expression exp, MemberContext context, bool disableFunctions = false)
         {
@@ -86,6 +99,14 @@ internal static string GetSolrMemberProduct(this Expression exp, MemberContext c
                                 return TransformersHelper[tkey].Invoke(call, context);
                             }
                         }
+
+                        if (call.Method.DeclaringType == typeof(SolrExpr.Fields))
+                        {
+                            if (FieldsHelper.ContainsKey(call.Method.Name))
+                            {
+                                return FieldsHelper[call.Method.Name].Invoke(call, context);
+                            }
+                        }
                     }                    
                 }
 

SolrNet.Linq/Expressions/NodeTypeHelpers/SelectMethod.cs renamed to SolrNet.Linq/Expressions/SelectMethod.cs

@@ -38,7 +38,21 @@ public T ParseDocument(XElement node)
                 object obj = p.ParameterType.IsValueType ? Activator.CreateInstance(p.ParameterType) : null;
                 if (fields.ContainsKey(p.Name))
                 {
-                    if (this.parser.CanHandleSolrType(fields[p.Name].Name.LocalName) &&
+                    if (p.ParameterType == typeof(XElement))
+                    {
+                        string text = fields[p.Name].ToString();
+                        try
+                        {
+                            
+                            obj = XElement.Parse(text);
+                        }
+                        catch (Exception e)
+                        {
+                            throw new InvalidOperationException(
+                                $"Unable to set value for {p.Name}. Value {text} can't be parsed to XElement",e);
+                        }                        
+                    }
+                    else if (this.parser.CanHandleSolrType(fields[p.Name].Name.LocalName) &&
                         this.parser.CanHandleType(p.ParameterType))
                     {
                         obj = this.parser.Parse(fields[p.Name], p.ParameterType);

SolrNet.Linq/Impl/SelectResponseParser.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Xml.Linq;
 using SolrNet.Linq.Expressions;
 using SolrNet.Linq.Expressions.Context;
 
@@ -11,6 +12,14 @@ private static T Throw<T>(T value)
             throw new InvalidOperationException("This method not intended to be invoked. Use it to build expressions only");
 
         }
+
+        public static class Fields
+        {
+            public static double Score()
+            {
+                return Throw(0);
+            }
+        }
         public static class Transformers
         {
             public static string Value(string value)
@@ -37,6 +46,26 @@ public static DateTime Value(DateTime value)
             {
                 return Throw(value);
             }
+
+            public static XElement ExplainNl()
+            {
+                return Throw<XElement>(null);
+            }
+
+            public static string ExplainText()
+            {
+                return Throw(string.Empty);
+            }
+
+            public static string ExplainHtml()
+            {
+                return Throw(string.Empty);
+            }
+
+            public static int DocId()
+            {
+                return Throw(0);
+            }
         }
     }
 }