refactored SelectQuery into BsonSerializationInfoHelper and PredicateTranslator

Author: craiggwilson

Driver/Driver.csproj

@@ -194,13 +194,15 @@
     <Compile Include="Linq\Translators\PartialEvaluator.cs" />
     <Compile Include="Linq\Expressions\ExpressionPrettyPrinter.cs" />
     <Compile Include="Linq\Expressions\ExpressionVisitor.cs" />
+    <Compile Include="Linq\Translators\PredicateTranslator.cs" />
     <Compile Include="Linq\Translators\Projector.cs" />
     <Compile Include="Linq\Translators\SelectQuery.cs" />
     <Compile Include="Linq\LinqExtensionMethods.cs" />
     <Compile Include="Linq\MongoQueryable.cs" />
     <Compile Include="Linq\MongoQueryProvider.cs" />
     <Compile Include="Linq\Translators\MongoQueryTranslator.cs" />
     <Compile Include="Linq\Translators\TranslatedQuery.cs" />
+    <Compile Include="Linq\Utils\BsonSerializationInfoHelper.cs" />
     <Compile Include="Linq\Utils\TypeHelper.cs" />
     <Compile Include="MongoUtils.cs" />
     <Compile Include="MongoDefaults.cs" />

Driver/Linq/Expressions/ExpressionNormalizer.cs

@@ -97,7 +97,7 @@ protected override Expression VisitBinary(BinaryExpression node)
         /// <returns>The UnaryExpression (possibly modified).</returns>
         protected override Expression VisitUnary(UnaryExpression node)
         {
-            if (node.NodeType == ExpressionType.Convert)
+            if (node.NodeType == ExpressionType.Convert || node.NodeType == ExpressionType.ConvertChecked)
             {
                 if (node.Type.IsAssignableFrom(node.Operand.Type))
                 {

Driver/Linq/MongoQueryProvider.cs

@@ -20,9 +20,6 @@
 using System.Text;
 using System.Reflection;
 
-// for a good blog post on implementing LINQ query providers see Matt Warren's blog posts
-// see: http://blogs.msdn.com/b/mattwar/archive/2008/11/18/linq-links.aspx
-
 namespace MongoDB.Driver.Linq
 {
     /// <summary>
@@ -146,46 +143,5 @@ public object Execute(Expression expression)
             var translatedQuery = MongoQueryTranslator.Translate(this, expression);
             return translatedQuery.Execute();
         }
-
-        // private methods
-        internal bool CanBeEvaluatedLocally(Expression expression)
-        {
-            // any operation on a query can't be done locally
-            var constantExpression = expression as ConstantExpression;
-            if (constantExpression != null)
-            {
-                var query = constantExpression.Value as IQueryable;
-                if (query != null && query.Provider == this)
-                {
-                    return false;
-                }
-            }
-
-            var methodCallExpression = expression as MethodCallExpression;
-            if (methodCallExpression != null)
-            {
-                var declaringType = methodCallExpression.Method.DeclaringType;
-                if (declaringType == typeof(Enumerable) || declaringType == typeof(Queryable))
-                {
-                    return false;
-                }
-                if (declaringType == typeof(LinqToMongo))
-                {
-                    return false;
-                }
-            }
-
-            if (expression.NodeType == ExpressionType.Convert && expression.Type == typeof(object))
-            {
-                return true;
-            }
-
-            if (expression.NodeType == ExpressionType.Parameter || expression.NodeType == ExpressionType.Lambda)
-            {
-                return false;
-            }
-
-            return true;
-        }
     }
 }

Driver/Linq/Translators/MongoQueryTranslator.cs

@@ -45,7 +45,7 @@ public static TranslatedQuery Translate(IQueryable query)
         /// <returns>A TranslatedQuery.</returns>
         public static TranslatedQuery Translate(MongoQueryProvider provider, Expression expression)
         {
-            expression = PartialEvaluator.Evaluate(expression, provider.CanBeEvaluatedLocally);
+            expression = PartialEvaluator.Evaluate(expression, provider);
             expression = ExpressionNormalizer.Normalize(expression);
             // assume for now it's a SelectQuery
             var documentType = GetDocumentType(expression);

Driver/Linq/Translators/PartialEvaluator.cs

@@ -27,29 +27,64 @@ namespace MongoDB.Driver.Linq
     public static class PartialEvaluator
     {
         /// <summary>
-        /// Performs evaluation and replacement of independent sub-trees.
+        /// Performs evaluation and replacement of independent sub-trees
         /// </summary>
         /// <param name="expression">The root of the expression tree.</param>
-        /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param>
         /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        public static Expression Evaluate(Expression expression, Func<Expression, bool> fnCanBeEvaluated)
+        public static Expression Evaluate(Expression expression)
         {
-            return new SubtreeEvaluator(new Nominator(fnCanBeEvaluated).Nominate(expression)).Evaluate(expression);
+            return Evaluate(expression, null);
         }
 
         /// <summary>
-        /// Performs evaluation and replacement of independent sub-trees
+        /// Performs evaluation and replacement of independent sub-trees.
         /// </summary>
         /// <param name="expression">The root of the expression tree.</param>
+        /// <param name="fnCanBeEvaluated">A function that decides whether a given expression node can be part of the local function.</param>
         /// <returns>A new tree with sub-trees evaluated and replaced.</returns>
-        public static Expression Evaluate(Expression expression)
+        public static Expression Evaluate(Expression expression, IQueryProvider queryProvider)
         {
-            return Evaluate(expression, PartialEvaluator.CanBeEvaluatedLocally);
+            return new SubtreeEvaluator(new Nominator(e => CanBeEvaluatedLocally(e, queryProvider)).Nominate(expression)).Evaluate(expression);
         }
 
-        private static bool CanBeEvaluatedLocally(Expression expression)
+        private static bool CanBeEvaluatedLocally(Expression expression, IQueryProvider queryProvider)
         {
-            return expression.NodeType != ExpressionType.Parameter;
+            // any operation on a query can't be done locally
+            var constantExpression = expression as ConstantExpression;
+            if (constantExpression != null)
+            {
+                var query = constantExpression.Value as IQueryable;
+                if (query != null && (queryProvider == null || query.Provider == queryProvider))
+                {
+                    return false;
+                }
+            }
+
+            var methodCallExpression = expression as MethodCallExpression;
+            if (methodCallExpression != null)
+            {
+                var declaringType = methodCallExpression.Method.DeclaringType;
+                if (declaringType == typeof(Enumerable) || declaringType == typeof(Queryable))
+                {
+                    return false;
+                }
+                if (declaringType == typeof(LinqToMongo))
+                {
+                    return false;
+                }
+            }
+
+            if (expression.NodeType == ExpressionType.Convert && expression.Type == typeof(object))
+            {
+                return true;
+            }
+
+            if (expression.NodeType == ExpressionType.Parameter || expression.NodeType == ExpressionType.Lambda)
+            {
+                return false;
+            }
+
+            return true;
         }
 
         /// <summary>