Some refactoring of LINQ code. Removed some premature optimizations (might come back but only if proven worthwhile).

Author: rstam

Driver/Driver.csproj

@@ -180,7 +180,8 @@
     <Compile Include="Internal\MongoReplyMessage.cs" />
     <Compile Include="Internal\MongoUpdateMessage.cs" />
     <Compile Include="Internal\ReplicaSetConnector.cs" />
-    <Compile Include="Linq\Evaluator.cs" />
+    <Compile Include="Linq\Nominator.cs" />
+    <Compile Include="Linq\PartialEvaluator.cs" />
     <Compile Include="Linq\ExpressionPrettyPrinter.cs" />
     <Compile Include="Linq\ExpressionVisitor.cs" />
     <Compile Include="Linq\TranslatedFindQuery.cs" />

Driver/Linq/ExpressionVisitor.cs

@@ -21,9 +21,6 @@
 using System.Text;
 using System.Threading;
 
-// taken from Part 2 of Matt Warren's blogs on building a LINQ provider
-// see: http://blogs.msdn.com/b/mattwar/archive/2007/07/31/linq-building-an-iqueryable-provider-part-ii.aspx
-
 namespace MongoDB.Driver.Linq
 {
     /// <summary>

Driver/Linq/MongoQueryProvider.cs

@@ -21,39 +21,19 @@
 using System.Threading;
 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>
     /// An implementation of IQueryProvider for querying a MongoDB collection.
     /// </summary>
     public class MongoQueryProvider : IQueryProvider
     {
-        // private static fields
-        private static Dictionary<Type, Func<MongoQueryProvider, Expression, IQueryable>> __createQueryDelegates = new Dictionary<Type, Func<MongoQueryProvider, Expression, IQueryable>>();
-        private static MethodInfo __createQueryGenericMethodDefinition;
-        private static Dictionary<Type, Func<MongoQueryProvider, Expression, object>> __executeDelegates = new Dictionary<Type, Func<MongoQueryProvider, Expression, object>>();
-        private static MethodInfo __executeGenericMethodDefinition;
-        private static object __staticLock = new object();
-
         // private fields
         private MongoCollection _collection;
 
-        // static constructor
-        static MongoQueryProvider()
-        {
-            foreach (var methodInfo in typeof(MongoQueryProvider).GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
-            {
-                if (methodInfo.Name == "CreateQuery" && methodInfo.IsGenericMethodDefinition)
-                {
-                    __createQueryGenericMethodDefinition = methodInfo;
-                }
-                if (methodInfo.Name == "Execute" && methodInfo.IsGenericMethodDefinition)
-                {
-                    __executeGenericMethodDefinition = methodInfo;
-                }
-            }
-        }
-
         // constructors
         /// <summary>
         /// Initializes a new instance of the MongoQueryProvider class.
@@ -67,61 +47,6 @@ public MongoQueryProvider(MongoCollection collection)
             _collection = collection;
         }
 
-        // private static methods
-        private static Func<MongoQueryProvider, Expression, IQueryable> GetCreateQueryDelegate(Type type)
-        {
-            lock (__staticLock)
-            {
-                Func<MongoQueryProvider, Expression, IQueryable> createQueryDelegate;
-                if (!__createQueryDelegates.TryGetValue(type, out createQueryDelegate))
-                {
-                    var createQueryMethodInfo = __createQueryGenericMethodDefinition.MakeGenericMethod(type);
-
-                    // lambdaExpression = (provider, expression) => (IQueryable) provider.CreateQuery<T>(expression)
-                    var providerParameter = Expression.Parameter(typeof(MongoQueryProvider), "provider");
-                    var expressionParameter = Expression.Parameter(typeof(Expression), "expression");
-                    var lambdaExpression = Expression.Lambda<Func<MongoQueryProvider, Expression, IQueryable>>(
-                        Expression.Convert(
-                            Expression.Call(providerParameter, createQueryMethodInfo, expressionParameter),
-                            typeof(IQueryable)
-                        ),
-                        providerParameter,
-                        expressionParameter
-                    );
-                    createQueryDelegate = lambdaExpression.Compile();
-                    __createQueryDelegates.Add(type, createQueryDelegate);
-                }
-                return createQueryDelegate;
-            }
-        }
-
-        private static Func<MongoQueryProvider, Expression, object> GetExecuteDelegate(Type type)
-        {
-            lock (__staticLock)
-            {
-                Func<MongoQueryProvider, Expression, object> executeDelegate;
-                if (!__executeDelegates.TryGetValue(type, out executeDelegate))
-                {
-                    var executeMethodInfo = __executeGenericMethodDefinition.MakeGenericMethod(type);
-
-                    // lambdaExpression = (provider, expression) => (object) provider.Execute<T>(expression)
-                    var providerParameter = Expression.Parameter(typeof(MongoQueryProvider), "provider");
-                    var expressionParameter = Expression.Parameter(typeof(Expression), "expression");
-                    var lambdaExpression = Expression.Lambda<Func<MongoQueryProvider, Expression, object>>(
-                        Expression.Convert(
-                            Expression.Call(providerParameter, executeMethodInfo, expressionParameter),
-                            typeof(object)
-                        ),
-                        providerParameter,
-                        expressionParameter
-                    );
-                    executeDelegate = lambdaExpression.Compile();
-                    __executeDelegates.Add(type, executeDelegate);
-                }
-                return executeDelegate;
-            }
-        }
-
         // public methods
         /// <summary>
         /// Creates a new instance of MongoQueryable{{T}} for this provider.
@@ -154,11 +79,11 @@ public IQueryable CreateQuery(Expression expression)
             {
                 throw new ArgumentNullException("expression");
             }
+            var elementType = TypeSystem.GetElementType(expression.Type);
             try
             {
-                var elementType = TypeSystem.GetElementType(expression.Type);
-                var createQueryDelegate = GetCreateQueryDelegate(elementType);
-                return createQueryDelegate(this, expression);
+                var queryableType = typeof(MongoQueryable<>).MakeGenericType(elementType);
+                return (IQueryable)Activator.CreateInstance(queryableType, new object[] { this, expression });
             }
             catch (TargetInvocationException ex)
             {
@@ -182,8 +107,7 @@ public TResult Execute<TResult>(Expression expression)
             {
                 throw new ArgumentException("Argument expression is not valid.");
             }
-            var translatedQuery = MongoQueryTranslator.Translate(_collection, expression);
-            return (TResult)translatedQuery.Execute();
+            return (TResult)Execute(expression);
         }
 
         /// <summary>
@@ -197,36 +121,8 @@ public object Execute(Expression expression)
             {
                 throw new ArgumentNullException("expression");
             }
-            try
-            {
-                var resultType = expression.Type;
-                var executeDelegate = GetExecuteDelegate(resultType);
-                return executeDelegate(this, expression);
-            }
-            catch (TargetInvocationException ex)
-            {
-                throw ex.InnerException;
-            }
-        }
-
-        /// <summary>
-        /// Gets an enumerator by executing the query.
-        /// </summary>
-        /// <typeparam name="T">Type element type.</typeparam>
-        /// <param name="expression">The LINQ expression.</param>
-        /// <returns>An enumerator for the results of the query.</returns>
-        public IEnumerator<T> GetEnumerator<T>(Expression expression)
-        {
-            if (expression == null)
-            {
-                throw new ArgumentNullException("expression");
-            }
-            if (!typeof(IEnumerable<T>).IsAssignableFrom(expression.Type))
-            {
-                throw new ArgumentException("Argument expression is not valid.");
-            }
             var translatedQuery = MongoQueryTranslator.Translate(_collection, expression);
-            return translatedQuery.GetEnumerator<T>();
+            return translatedQuery.Execute();
         }
 
         /// <summary>

Driver/Linq/MongoQueryTranslator.cs

@@ -36,11 +36,12 @@ public static class MongoQueryTranslator
         /// <returns>An instance of MongoLinqQuery.</returns>
         public static TranslatedQuery Translate(MongoCollection collection, Expression expression)
         {
-            expression = Evaluator.PartialEval(expression);
+            expression = PartialEvaluator.Evaluate(expression);
 
             // total hack just to test the initial LINQ framework
             var query = MongoDB.Driver.Builders.Query.EQ("X", 1);
-            return new TranslatedFindQuery(collection, query);
+            var documentType = TypeSystem.GetElementType(expression.Type);
+            return new TranslatedFindQuery(collection, query, documentType);
         }
     }
 }

Driver/Linq/MongoQueryable.cs

@@ -21,9 +21,6 @@
 using System.Text;
 using System.Threading;
 
-// adapted from Part 1 of Matt Warren's blogs on building a LINQ provider
-// see: http://blogs.msdn.com/b/mattwar/archive/2007/07/30/linq-building-an-iqueryable-provider-part-i.aspx
-
 namespace MongoDB.Driver.Linq
 {
     /// <summary>
@@ -78,7 +75,7 @@ public MongoQueryable(MongoQueryProvider provider, Expression expression)
         /// <returns></returns>
         public IEnumerator<T> GetEnumerator()
         {
-            return _provider.GetEnumerator<T>(_expression);
+            return ((IEnumerable<T>)_provider.Execute(_expression)).GetEnumerator();
         }
 
         /// <summary>
@@ -93,7 +90,7 @@ public override string ToString()
         // explicit implementation of IEnumerable
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return GetEnumerator();
+            return ((IEnumerable)_provider.Execute(_expression)).GetEnumerator();
         }
 
         // explicit implementation of IQueryable

Driver/Linq/Nominator.cs

@@ -0,0 +1,75 @@
+/* Copyright 2010-2012 10gen Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+using System.Threading;
+
+using MongoDB.Driver.Linq;
+
+namespace MongoDB.Driver.Linq
+{
+    /// <summary>
+    /// Performs bottom-up analysis to find maximal subtrees that satisfy a predicate.
+    /// </summary>
+    class Nominator : ExpressionVisitor
+    {
+        Func<Expression, bool> _predicate;
+        HashSet<Expression> _candidates;
+        bool _isBlocked;
+
+        internal Nominator(Func<Expression, bool> predicate)
+        {
+            if (predicate == null)
+            {
+                throw new ArgumentNullException("predicate");
+            }
+            _predicate = predicate;
+        }
+
+        internal HashSet<Expression> Nominate(Expression expression)
+        {
+            _candidates = new HashSet<Expression>();
+            this.Visit(expression);
+            return _candidates;
+        }
+
+        protected override Expression Visit(Expression expression)
+        {
+            if (expression != null)
+            {
+                bool wasBlocked = _isBlocked;
+                _isBlocked = false;
+                base.Visit(expression);
+                if (!_isBlocked)
+                {
+                    if (_predicate(expression))
+                    {
+                        _candidates.Add(expression);
+                    }
+                    else
+                    {
+                        _isBlocked = true;
+                    }
+                }
+                _isBlocked |= wasBlocked;
+            }
+            return expression;
+        }
+    }
+}