Added .WithIndex method to Linq queries for index hinting.

.WithIndex can take a string or a BsonDocument as an index hint.
It's an extension method on IQueryable<T> and returns IQueryable<T>.
Example:

var results = _collection.AsQueryable<T>.WithIndex("foo").Where(x=>x.Name == 1).ToList()

Author: Einar Egilsson

MongoDB.Driver/Linq/LinqToMongo.cs

@@ -16,6 +16,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
 using MongoDB.Bson;
 
 namespace MongoDB.Driver.Linq
@@ -25,6 +27,7 @@ namespace MongoDB.Driver.Linq
     /// </summary>
     public static class LinqToMongo
     {
+        // public static methods
         /// <summary>
         /// Determines whether a sequence contains all of the specified values.
         /// </summary>
@@ -49,29 +52,6 @@ public static bool ContainsAny<TSource>(this IEnumerable<TSource> source, IEnume
             return source.Any(s => values.Contains(s));
         }
 
-
-        /// <summary>
-        /// Determines whether a specified value is contained in a sequence.
-        /// </summary>
-        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
-        /// <param name="value">The value to locate in the sequence.</param>
-        /// <param name="source">A sequence in which to locate the values.</param>
-        /// <returns>True if the value is contained in the sequence.</returns>
-        public static bool In<TSource>(this TSource value, IEnumerable<TSource> source)
-        {
-            return source.Contains(value);
-        }
-
-        /// <summary>
-        /// Injects a low level IMongoQuery into a LINQ where clause. Can only be used in LINQ queries.
-        /// </summary>
-        /// <param name="query">The low level query.</param>
-        /// <returns>Throws an InvalidOperationException if called.</returns>
-        public static bool Inject(this IMongoQuery query)
-        {
-            throw new InvalidOperationException("The LinqToMongo.Inject method is only intended to be used in LINQ Where clauses.");
-        }
-
         /// <summary>
         /// Returns an explanation of how the query was executed (instead of the results).
         /// </summary>
@@ -104,5 +84,60 @@ public static BsonDocument Explain<T>(this IQueryable<T> query, bool verbose)
             }
             return projector.Cursor.Explain(verbose);
         }
+
+        /// <summary>
+        /// Determines whether a specified value is contained in a sequence.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+        /// <param name="value">The value to locate in the sequence.</param>
+        /// <param name="source">A sequence in which to locate the values.</param>
+        /// <returns>True if the value is contained in the sequence.</returns>
+        public static bool In<TSource>(this TSource value, IEnumerable<TSource> source)
+        {
+            return source.Contains(value);
+        }
+
+        /// <summary>
+        /// Injects a low level IMongoQuery into a LINQ where clause. Can only be used in LINQ queries.
+        /// </summary>
+        /// <param name="query">The low level query.</param>
+        /// <returns>Throws an InvalidOperationException if called.</returns>
+        public static bool Inject(this IMongoQuery query)
+        {
+            throw new InvalidOperationException("The LinqToMongo.Inject method is only intended to be used in LINQ Where clauses.");
+        }
+
+        /// <summary>
+        /// Sets an index hint on the query that's being built.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+        /// <param name="query">The query being built.</param>
+        /// <param name="indexName">The name of the index to use.</param>
+        /// <returns>New query where the expression includes a WithIndex method call.</returns>
+        public static IQueryable<TSource> WithIndex<TSource>(this IQueryable<TSource> query, string indexName)
+        {
+            return WithIndex(query, (BsonValue)indexName);
+        }
+
+        /// <summary>
+        /// Sets an index hint on the query that's being built.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+        /// <param name="query">The query being built.</param>
+        /// <param name="indexHint">Hint for what index to use.</param>
+        /// <returns>New query where the expression includes a WithIndex method call.</returns>
+        public static IQueryable<TSource> WithIndex<TSource>(this IQueryable<TSource> query, BsonDocument indexHint)
+        {
+            return WithIndex(query, (BsonValue)indexHint);
+        }
+
+        // private static methods
+        private static IQueryable<TSource> WithIndex<TSource>(IQueryable<TSource> query, BsonValue index)
+        {
+            var method = ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource));
+            var args = new[] { query.Expression, Expression.Constant(index) };
+            var expression = Expression.Call(null, method, args);
+            return query.Provider.CreateQuery<TSource>(expression);
+        }
     }
 }

MongoDB.Driver/Linq/Translators/SelectQuery.cs

@@ -36,6 +36,7 @@ public class SelectQuery : TranslatedQuery
         private LambdaExpression _where;
         private Type _ofType;
         private List<OrderByClause> _orderBy;
+        private BsonValue _indexHint;
         private LambdaExpression _projection;
         private int? _skip;
         private int? _take;
@@ -96,6 +97,14 @@ public int? Take
             get { return _take; }
         }
 
+        /// <summary>
+        /// Gets the BsonValue (string or document) that defines which index to use (or null if not specified);
+        /// </summary>
+        public BsonValue IndexHint
+        {
+            get { return _indexHint; }
+        }
+
         /// <summary>
         /// Gets the LambdaExpression that defines the where clause (or null if not specified).
         /// </summary>
@@ -168,6 +177,22 @@ public override object Execute()
                 cursor.SetLimit(_take.Value);
             }
 
+            if (_indexHint != null)
+            {
+                if (_indexHint.IsString)
+                {
+                    cursor.SetHint(_indexHint.AsString);
+                }
+                else if (_indexHint.IsBsonDocument)
+                {
+                    cursor.SetHint(_indexHint.AsBsonDocument);
+                }
+                else
+                {
+                    throw new NotSupportedException("Index hints must be strings or documents");
+                }
+            }
+
             var projection = _projection;
             if (_ofType != null)
             {
@@ -434,6 +459,12 @@ private void TranslateDistinct(MethodCallExpression methodCallExpression)
                 throw new NotSupportedException(message);
             }
 
+            if (_indexHint != null)
+            {
+                var message = "Distinct cannot be used together with WithIndex.";
+                throw new NotSupportedException(message);
+            }
+
             _distinct = _projection;
             _projection = null;
         }
@@ -677,6 +708,9 @@ private void TranslateMethodCall(MethodCallExpression methodCallExpression)
                 case "ThenByDescending":
                     TranslateThenBy(methodCallExpression);
                     break;
+                case "WithIndex":
+                    TranslateWithIndex(methodCallExpression);
+                    break;
                 case "Where":
                     TranslateWhere(methodCallExpression);
                     break;
@@ -863,6 +897,47 @@ private void TranslateThenBy(MethodCallExpression methodCallExpression)
             _orderBy.Add(clause);
         }
 
+        private void TranslateWithIndex(MethodCallExpression methodCallExpression)
+        {
+            if (methodCallExpression.Arguments.Count != 2)
+            {
+                throw new ArgumentOutOfRangeException("methodCallExpression");
+            }
+
+            var method = methodCallExpression.Method;
+
+            if (method.DeclaringType != typeof(LinqToMongo))
+            {
+                var message = string.Format("WithIndex method of class {0} is not supported.", BsonUtils.GetFriendlyTypeName(method.DeclaringType));
+                throw new NotSupportedException(message);
+            }
+
+            if (_indexHint != null)
+            {
+                throw new NotSupportedException("Only one index can be used for each query");
+            }
+
+            if (_distinct != null)
+            {
+                var message = "WithIndex cannot be used together with Distinct.";
+                throw new NotSupportedException(message);
+            }
+
+            Expression expression = methodCallExpression.Arguments[1];
+            if (expression.Type != typeof(BsonString) && expression.Type != typeof(BsonDocument))
+            {
+                throw new ArgumentOutOfRangeException("methodCallExpression", "Expected an Expression of Type BsonString or BsonDocument.");
+            }
+
+            var constantExpression = expression as ConstantExpression;
+            if (constantExpression == null)
+            {
+                throw new ArgumentOutOfRangeException("methodCallExpression", "Expected a ConstantExpression.");
+            }
+
+            _indexHint = (BsonValue)constantExpression.Value;
+        }
+
         private void TranslateWhere(MethodCallExpression methodCallExpression)
         {
             if (methodCallExpression.Arguments.Count != 2)

DriverUnitTests/Linq/ExplainTests.cs renamed to MongoDB.DriverUnitTests/Linq/ExplainTests.cs

@@ -1,4 +1,4 @@
-???/* Copyright 2010-2012 10gen Inc.
+/* 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.