select transformers

Author: Ihar Yakimush

SolrNet.Linq.IntegrationTests/SelectTests.cs

@@ -37,6 +37,7 @@ public void AnonymousClass()
                 .FirstOrDefault();
 
             Assert.NotNull(t1);
+            Assert.NotNull(t1.Id);
         }
 
         [Fact]
@@ -55,8 +56,30 @@ public void MultipleSelects()
                 .FirstOrDefault(arg2 => arg2.Id != null);
 
             Assert.NotNull(t1);
+            Assert.NotNull(t1.Id);
         }
 
+        [Fact]
+        public void Transformers()
+        {
+            var dateTime = new DateTime(2011, 1, 2, 3, 4, 5, DateTimeKind.Utc);
+            var t1 = Product.SolrOperations.Value.AsQueryable()
+                .Select(arg => new
+                {
+                    ValStr = SolrExpr.Transformers.Value("qwe"),
+                    ValInt = SolrExpr.Transformers.Value((int) 1),
+                    ValFloat = SolrExpr.Transformers.Value((float) 2),
+                    ValDouble = SolrExpr.Transformers.Value((double) 3),
+                    ValDate = SolrExpr.Transformers.Value(dateTime),
+                })
+                .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);
+        }
 
         [Fact]
         public void Product2()
@@ -83,6 +106,7 @@ public void Product2()
                 .FirstOrDefault();
 
             Assert.NotNull(t1);
+            Assert.NotNull(t1.Id);
 
             var t2 = Product.SolrOperations.Value.AsQueryable().Where(p => p.Id != null)                
                 .Where(arg => arg.Categories.Any(s => s == "electronics"))

SolrNet.Linq.Tests/MemberExpressionExtensionsTest.cs

@@ -33,6 +33,16 @@ public void DivVariable()
             Assert.Equal("div(sequence_i,12)", MemberContext.ForType<Product>().GetSolrMemberProduct(exp.Body));
         }
 
+        [Fact]
+        public void TransformersValue()
+        {
+            Expression<Func<Product, object>> exp = (Product p) => SolrExpr.Transformers.Value("qwe");
+            Assert.Equal("[value v='qwe']", MemberContext.ForType<Product>().GetSolrMemberProduct(exp.Body));
+
+            exp = (Product p) => SolrExpr.Transformers.Value(1);
+            Assert.Equal("[value v=1 t=int]", MemberContext.ForType<Product>().GetSolrMemberProduct(exp.Body));
+        }
+
         [Fact]
         public void Sub()
         {

SolrNet.Linq/Expressions/MemberExpressionExtensions.cs

@@ -28,7 +28,13 @@ public static class MemberExpressionExtensions
             { typeof(Math).FullName + nameof(Math.Sqrt) ,(c,t) => $"sqrt({c.Arguments[0].GetSolrMemberProduct(t)})" },
         };
 
-        
+        private static readonly Dictionary<string, Func<MethodCallExpression, MemberContext, string>> TransformersHelper = new Dictionary<string, Func<MethodCallExpression, MemberContext, string>> {
+            { nameof(SolrExpr.Transformers.Value) + typeof(string).Name ,(c,t) => $"[value v='{c.Arguments[0].GetSolrMemberProduct(t)}']" },
+            { nameof(SolrExpr.Transformers.Value) + typeof(int).Name ,(c,t) => $"[value v={c.Arguments[0].GetSolrMemberProduct(t)} t=int]" },
+            { 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]" },
+        };
 
         internal static string GetSolrMemberProduct(this Expression exp, MemberContext context, bool disableFunctions = false)
         {
@@ -71,6 +77,15 @@ internal static string GetSolrMemberProduct(this Expression exp, MemberContext c
                         {
                             return CallHelper[key].Invoke(call, context);
                         }
+
+                        if (call.Method.DeclaringType == typeof(SolrExpr.Transformers))
+                        {
+                            string tkey = call.Method.Name + call.Method.ReturnType.Name;
+                            if (TransformersHelper.ContainsKey(tkey))
+                            {
+                                return TransformersHelper[tkey].Invoke(call, context);
+                            }
+                        }
                     }                    
                 }
 

SolrNet.Linq/IAsyncProvider.cs renamed to SolrNet.Linq/Impl/IAsyncProvider.cs

@@ -0,0 +1,42 @@
+using System;
+using SolrNet.Linq.Expressions;
+using SolrNet.Linq.Expressions.Context;
+
+namespace SolrNet.Linq
+{
+    public static class SolrExpr
+    {
+        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 Transformers
+        {
+            public static string Value(string value)
+            {
+                return Throw(value);               
+            }
+
+            public static int Value(int value)
+            {
+                return Throw(value);
+            }
+
+            public static float Value(float value)
+            {
+                return Throw(value);
+            }
+
+            public static double Value(double value)
+            {
+                return Throw(value);
+            }
+
+            public static DateTime Value(DateTime value)
+            {
+                return Throw(value);
+            }
+        }
+    }
+}

SolrNet.Linq/TypeSystem.cs renamed to SolrNet.Linq/Impl/TypeSystem.cs

@@ -11,7 +11,7 @@ public class SolrQuery<TEntity> : IOrderedQueryable<TEntity>
         public SolrQuery(SolrQueryProvider<TEntity> provider)
         {
             this.Provider = provider ?? throw new ArgumentNullException(nameof(provider));
-            this.Expression = Expression.Constant(this);
+            this.Expression = Expression.Constant(this);            
         }
 
         public SolrQuery(SolrQueryProvider<TEntity> provider, Expression expression)