Implemented the Distinct LINQ query operator. Note that because the implementation is based on the Distinct method of MongoCollection the Distinct query operator must be used with a Select that identifies the field whose distinct values are desired.

Author: rstam

Driver/Driver.csproj

@@ -184,6 +184,7 @@
     <Compile Include="Linq\Expressions\ExpressionFormatter.cs" />
     <Compile Include="Linq\Expressions\ExpressionParameterReplacer.cs" />
     <Compile Include="Linq\LinqToMongo.cs" />
+    <Compile Include="Linq\Translators\DeserializationProjector.cs" />
     <Compile Include="Linq\Translators\Nominator.cs" />
     <Compile Include="Linq\Translators\OrderByDirection.cs" />
     <Compile Include="Linq\Translators\OrderByClause.cs" />

Driver/Linq/Translators/DeserializationProjector.cs

@@ -0,0 +1,77 @@
+/* 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;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+using MongoDB.Bson;
+using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver.Linq
+{
+    /// <summary>
+    /// Represents a projection that deserializes BsonValues.
+    /// </summary>
+    /// <typeparam name="TResult">The type of the result objects.</typeparam>
+    public class DeserializationProjector<TResult> : IEnumerable<TResult>
+    {
+        // private fields
+        private IEnumerable<BsonValue> _source;
+        private BsonSerializationInfo _serializationInfo;
+
+        // constructors
+        /// <summary>
+        /// Initializes a new instance of the DeserializationProjector class.
+        /// </summary>
+        /// <param name="source">The enumerable object that supplies the source objects.</param>
+        /// <param name="serializationInfo">Serialization info for deserializing source objects into result objects.</param>
+        public DeserializationProjector(IEnumerable<BsonValue> source, BsonSerializationInfo serializationInfo)
+        {
+            _source = source;
+            _serializationInfo = serializationInfo;
+        }
+
+        // public methods
+        /// <summary>
+        /// Gets an enumerator for the result objects.
+        /// </summary>
+        /// <returns></returns>
+        public IEnumerator<TResult> GetEnumerator()
+        {
+            foreach (var value in _source)
+            {
+                var document = new BsonDocument("_v", value);
+                using (var bsonReader = BsonReader.Create(document))
+                {
+                    bsonReader.ReadStartDocument();
+                    bsonReader.ReadName("_v");
+                    yield return (TResult)_serializationInfo.Serializer.Deserialize(bsonReader, _serializationInfo.NominalType, _serializationInfo.SerializationOptions);
+                    bsonReader.ReadEndDocument();
+                }
+            }
+        }
+
+        // explicit interface implementation
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

Driver/Linq/Translators/SelectQuery.cs

@@ -44,6 +44,7 @@ public class SelectQuery : TranslatedQuery
         private Expression _skip;
         private Expression _take;
         private Func<IEnumerable, object> _elementSelector; // used for First, Last, etc...
+        private bool _distinct;
 
         // constructors
         /// <summary>
@@ -122,6 +123,12 @@ public IMongoQuery BuildQuery()
         public override object Execute()
         {
             var query = BuildQuery();
+
+            if (_distinct)
+            {
+                return ExecuteDistinct(query);
+            }
+
             var cursor = Collection.FindAs(DocumentType, query);
 
             if (_orderBy != null)
@@ -207,6 +214,9 @@ public void Translate(Expression expression)
                 case "LongCount":
                     TranslateCount(methodCallExpression);
                     break;
+                case "Distinct":
+                    TranslateDistinct(methodCallExpression);
+                    break;
                 case "ElementAt":
                 case "ElementAtOrDefault":
                     TranslateElementAt(methodCallExpression);
@@ -818,6 +828,36 @@ private void CombinePredicateWithWhereClause(MethodCallExpression methodCallExpr
             }
         }
 
+        private object ExecuteDistinct(IMongoQuery query)
+        {
+            if (_orderBy != null)
+            {
+                throw new NotSupportedException("Distinct cannot be used with OrderBy.");
+            }
+            if (_skip != null || _take != null)
+            {
+                throw new NotSupportedException("Distinct cannot be used with Skip or Take.");
+            }
+            if (_projection == null)
+            {
+                throw new NotSupportedException("Distinct must be used with Select to identify the field whose distinct values are to be found.");
+            }
+
+            var keyExpression = _projection.Body;
+            var serializationInfo = GetSerializationInfo(keyExpression);
+            if (serializationInfo == null)
+            {
+                var message = string.Format("Select used with Distinct is not valid: {0}.", ExpressionFormatter.ToString(keyExpression));
+                throw new NotSupportedException(message);
+            }
+            var dottedElementName = serializationInfo.ElementName;
+            var source = Collection.Distinct(dottedElementName, query);
+
+            var deserializationProjectorGenericDefinition = typeof(DeserializationProjector<>);
+            var deserializationProjectorType = deserializationProjectorGenericDefinition.MakeGenericType(keyExpression.Type);
+            return Activator.CreateInstance(deserializationProjectorType, source, serializationInfo);
+        }
+
         private BsonSerializationInfo GetSerializationInfo(Expression expression)
         {
             var documentSerializer = BsonSerializer.LookupSerializer(DocumentType);
@@ -1014,6 +1054,19 @@ private void TranslateCount(MethodCallExpression methodCallExpression)
             }
         }
 
+        private void TranslateDistinct(MethodCallExpression methodCallExpression)
+        {
+            var arguments = methodCallExpression.Arguments.ToArray();
+            if (arguments.Length != 1)
+            {
+                var message = "The version of the Distinct query operator with an equality comparer is not supported.";
+                throw new InvalidOperationException(message);
+            }
+
+            Translate(arguments[0]);
+            _distinct = true;
+        }
+
         private void TranslateElementAt(MethodCallExpression methodCallExpression)
         {
             if (methodCallExpression.Arguments.Count != 2)

DriverOnlineTests/Linq/SelectQueryTests.cs

@@ -81,6 +81,17 @@ public class D
         {
             [BsonElement("z")]
             public int Z; // use field instead of property to test fields also
+
+            public override bool Equals(object obj)
+            {
+                if (obj == null || GetType() != obj.GetType()) { return false; }
+                return Z == ((D)obj).Z;
+            }
+
+            public override int GetHashCode()
+            {
+                return Z.GetHashCode();
+            }
         }
 
         // used to test some query operators that have an IEqualityComparer parameter
@@ -115,6 +126,11 @@ public int GetHashCode(int obj)
         private MongoDatabase _database;
         private MongoCollection<C> _collection;
         private MongoCollection<SystemProfileInfo> _systemProfileCollection;
+        private ObjectId id1 = ObjectId.GenerateNewId();
+        private ObjectId id2 = ObjectId.GenerateNewId();
+        private ObjectId id3 = ObjectId.GenerateNewId();
+        private ObjectId id4 = ObjectId.GenerateNewId();
+        private ObjectId id5 = ObjectId.GenerateNewId();
 
         [TestFixtureSetUp]
         public void Setup()
@@ -127,11 +143,11 @@ public void Setup()
 
             // documents inserted deliberately out of order to test sorting
             _collection.Drop();
-            _collection.Insert(new C { X = 2, Y = 11, D = new D { Z = 22 }, A = new [] { 2, 3, 4 }, L = new List<int> { 2, 3, 4 } });
-            _collection.Insert(new C { X = 1, Y = 11, D = new D { Z = 11 }, S = "x is 1", SA = new string[] { "Tom", "Dick", "Harry" } });
-            _collection.Insert(new C { X = 3, Y = 33, D = new D { Z = 33 }, B = true, BA = new bool[] { true }, E = E.A, EA = new E[] { E.A, E.B } });
-            _collection.Insert(new C { X = 5, Y = 44, D = new D { Z = 55 }, DBRef = new MongoDBRef("db", "c", 1) });
-            _collection.Insert(new C { X = 4, Y = 44, D = new D { Z = 44 } });
+            _collection.Insert(new C { Id = id2, X = 2, Y = 11, D = new D { Z = 22 }, A = new [] { 2, 3, 4 }, L = new List<int> { 2, 3, 4 } });
+            _collection.Insert(new C { Id = id1, X = 1, Y = 11, D = new D { Z = 11 }, S = "x is 1", SA = new string[] { "Tom", "Dick", "Harry" } });
+            _collection.Insert(new C { Id = id3, X = 3, Y = 33, D = new D { Z = 33 }, B = true, BA = new bool[] { true }, E = E.A, EA = new E[] { E.A, E.B } });
+            _collection.Insert(new C { Id = id5, X = 5, Y = 44, D = new D { Z = 55 }, DBRef = new MongoDBRef("db", "c", 1) });
+            _collection.Insert(new C { Id = id4, X = 4, Y = 44, D = new D { Z = 44 } });
         }
 
         [Test]
@@ -359,15 +375,116 @@ public void TestDefaultIfEmptyWithDefaultValue()
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "The Distinct query operator is not supported.")]
-        public void TestDistinct()
+        public void TestDistinctB()
         {
-            var query = _collection.AsQueryable<C>().Distinct();
-            query.ToList(); // execute query
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.B).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(2, results.Count);
+            Assert.IsTrue(results.Contains(false));
+            Assert.IsTrue(results.Contains(true));
+        }
+
+        [Test]
+        public void TestDistinctD()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.D).Distinct();
+            var results = query.ToList(); // execute query
+            Assert.AreEqual(5, results.Count);
+            Assert.IsTrue(results.Contains(new D { Z = 11 }));
+            Assert.IsTrue(results.Contains(new D { Z = 22 }));
+            Assert.IsTrue(results.Contains(new D { Z = 33 }));
+            Assert.IsTrue(results.Contains(new D { Z = 44 }));
+            Assert.IsTrue(results.Contains(new D { Z = 55 }));
+        }
+
+        [Test]
+        public void TestDistinctDBRef()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.DBRef).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(1, results.Count);
+            Assert.IsTrue(results.Contains(new MongoDBRef("db", "c", 1)));
+        }
+
+        [Test]
+        public void TestDistinctDZ()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.D.Z).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(5, results.Count);
+            Assert.IsTrue(results.Contains(11));
+            Assert.IsTrue(results.Contains(22));
+            Assert.IsTrue(results.Contains(33));
+            Assert.IsTrue(results.Contains(44));
+            Assert.IsTrue(results.Contains(55));
+        }
+
+        [Test]
+        public void TestDistinctE()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.E).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(1, results.Count);
+            Assert.IsTrue(results.Contains(E.A));
+        }
+
+        [Test]
+        public void TestDistinctId()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.Id).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(5, results.Count);
+            Assert.IsTrue(results.Contains(id1));
+            Assert.IsTrue(results.Contains(id2));
+            Assert.IsTrue(results.Contains(id3));
+            Assert.IsTrue(results.Contains(id4));
+            Assert.IsTrue(results.Contains(id5));
+        }
+
+        [Test]
+        public void TestDistinctS()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.S).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(1, results.Count);
+            Assert.IsTrue(results.Contains("x is 1"));
         }
 
         [Test]
-        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "The Distinct query operator is not supported.")]
+        public void TestDistinctX()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.X).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(5, results.Count);
+            Assert.IsTrue(results.Contains(1));
+            Assert.IsTrue(results.Contains(2));
+            Assert.IsTrue(results.Contains(3));
+            Assert.IsTrue(results.Contains(4));
+            Assert.IsTrue(results.Contains(5));
+        }
+
+        [Test]
+        public void TestDistinctY()
+        {
+            var query = (from c in _collection.AsQueryable<C>()
+                         select c.Y).Distinct();
+            var results = query.ToList();
+            Assert.AreEqual(3, results.Count);
+            Assert.IsTrue(results.Contains(11));
+            Assert.IsTrue(results.Contains(33));
+            Assert.IsTrue(results.Contains(44));
+        }
+
+        [Test]
+        [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "The version of the Distinct query operator with an equality comparer is not supported.")]
         public void TestDistinctWithEqualityComparer()
         {
             var query = _collection.AsQueryable<C>().Distinct(new CEqualityComparer());
@@ -1237,10 +1354,10 @@ public void TestProjection()
 
             Assert.IsNull(selectQuery.BuildQuery());
 
-            var result = query.ToList();
-            Assert.AreEqual(5, result.Count);
-            Assert.AreEqual(2, result.First());
-            Assert.AreEqual(4, result.Last());
+            var results = query.ToList();
+            Assert.AreEqual(5, results.Count);
+            Assert.AreEqual(2, results.First());
+            Assert.AreEqual(4, results.Last());
         }
 
         [Test]