added support for elemMatch queries when array elements are documents.

Author: craiggwilson

Driver/Linq/Translators/SelectQuery.cs

@@ -36,6 +36,7 @@ namespace MongoDB.Driver.Linq
     public class SelectQuery : TranslatedQuery
     {
         // private fields
+        private readonly Dictionary<ParameterExpression, IBsonSerializer> _parameterSerializers;
         private LambdaExpression _where;
         private Type _ofType;
         private List<OrderByClause> _orderBy;
@@ -54,6 +55,7 @@ public class SelectQuery : TranslatedQuery
         public SelectQuery(MongoCollection collection, Type documentType)
             : base(collection, documentType)
         {
+            _parameterSerializers = new Dictionary<ParameterExpression, IBsonSerializer>();
         }
 
         // public properties
@@ -247,19 +249,41 @@ private IMongoQuery BuildAnyQuery(MethodCallExpression methodCallExpression)
             if (methodCallExpression.Method.DeclaringType == typeof(Enumerable))
             {
                 var arguments = methodCallExpression.Arguments.ToArray();
+                var serializationInfo = GetSerializationInfo(arguments[0]);
+                var itemSerializerProvider = serializationInfo.Serializer as IBsonItemSerializationInfoProvider;
+                if (itemSerializerProvider == null)
+                {
+                    return null;
+                }
+
+                var itemSerializationInfo = itemSerializerProvider.GetItemSerializationInfo();
+                if (itemSerializationInfo == null)
+                {
+                    return null;
+                }
+
                 if (arguments.Length == 1)
                 {
-                    var serializationInfo = GetSerializationInfo(arguments[0]);
-                    if (serializationInfo != null)
-                    {
-                        return Query.And(
-                            Query.NE(serializationInfo.ElementName, BsonNull.Value),
-                            Query.Not(serializationInfo.ElementName).Size(0));
-                    }
+                    return Query.And(
+                        Query.NE(serializationInfo.ElementName, BsonNull.Value),
+                        Query.Not(serializationInfo.ElementName).Size(0));
                 }
                 else if (arguments.Length == 2)
                 {
-                    throw new NotSupportedException("Enumerable.Any with a predicate is not supported.");
+                    if (!(itemSerializationInfo.Serializer is IBsonMemberSerializationInfoProvider))
+                    {
+                        var message = string.Format("Any is only support for items that serialize into documents. The current serializer is {0} and must implement {1} for participation in Any queries.",
+                            BsonUtils.GetFriendlyTypeName(itemSerializationInfo.GetType()),
+                            BsonUtils.GetFriendlyTypeName(typeof(IBsonMemberSerializationInfoProvider)));
+                        throw new NotSupportedException(message);
+                    }
+                    var itemSerializer = itemSerializationInfo.Serializer;
+                    var lambda = (LambdaExpression)arguments[1];
+                    _parameterSerializers[lambda.Parameters[0]] = itemSerializer;
+                    var query = BuildQuery(lambda.Body);
+                    query = Query.ElemMatch(serializationInfo.ElementName, query);
+                    _parameterSerializers.Remove(lambda.Parameters[0]);
+                    return query;
                 }
             }
             return null;
@@ -1481,7 +1505,9 @@ private BsonSerializationInfo GetSerializationInfo(Expression expression)
             var parameterExpression = expression as ParameterExpression;
             if (parameterExpression != null)
             {
-                var serializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
+                IBsonSerializer serializer;
+                if(!_parameterSerializers.TryGetValue(parameterExpression, out serializer))
+                    serializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
                 return new BsonSerializationInfo(
                     null, // elementName
                     serializer,
@@ -1493,8 +1519,8 @@ private BsonSerializationInfo GetSerializationInfo(Expression expression)
             parameterExpression = ExpressionParameterFinder.FindParameter(expression);
             if (parameterExpression != null)
             {
-                var serializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
-                return GetSerializationInfo(serializer, expression);
+                var info = GetSerializationInfo(parameterExpression);
+                return GetSerializationInfo(info.Serializer, expression);
             }
 
             return null;

DriverUnitTests/Linq/SelectQueryTests.cs

@@ -48,6 +48,8 @@ public class C
             public int Y { get; set; }
             [BsonElement("d")]
             public D D { get; set; }
+            [BsonElement("da")]
+            public List<D> DA { get; set; }
             [BsonElement("s")]
             [BsonIgnoreIfNull]
             public string S { get; set; }
@@ -149,11 +151,11 @@ public void Setup()
 
             // documents inserted deliberately out of order to test sorting
             _collection.Drop();
-            _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 = _id2, X = 2, Y = 11, D = new D { Z = 22 }, A = new [] { 2, 3, 4 }, DA = new List<D> { new D { Z = 111 }, new D { Z = 222 } }, L = new List<int> { 2, 3, 4 } });
             _collection.Insert(new C { Id = _id1, X = 1, Y = 11, D = new D { Z = 11 }, S = "abc", 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 }, S = "   xyz   " });
+            _collection.Insert(new C { Id = _id4, X = 4, Y = 44, D = new D { Z = 44 }, S = "   xyz   ", DA = new List<D> { new D { Z = 333 }, new D { Z = 444 } } });
         }
 
         [Test]
@@ -1939,13 +1941,27 @@ where c.A.Any()
         }
 
         [Test]
-        [ExpectedException(typeof(NotSupportedException), ExpectedMessage = "Enumerable.Any with a predicate is not supported.")]
+        [ExpectedException(typeof(NotSupportedException), ExpectedMessage = "Any is only support for items that serialize into documents. The current serializer is BsonSerializationInfo and must implement IBsonMemberSerializationInfoProvider for participation in Any queries.")]
         public void TestWhereAAnyWithPredicate()
         {
             var query = from c in _collection.AsQueryable<C>()
                         where c.A.Any(a => a > 3)
                         select c;
-            query.ToList(); // execute query
+
+            var translatedQuery = MongoQueryTranslator.Translate(query);
+            Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+            Assert.AreSame(_collection, translatedQuery.Collection);
+            Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+            var selectQuery = (SelectQuery)translatedQuery;
+            Assert.AreEqual("(C c) => Enumerable.Any<Int32>(c.A, (Int32 a) => (a > 3))", ExpressionFormatter.ToString(selectQuery.Where));
+            Assert.IsNull(selectQuery.OrderBy);
+            Assert.IsNull(selectQuery.Projection);
+            Assert.IsNull(selectQuery.Skip);
+            Assert.IsNull(selectQuery.Take);
+
+            Assert.AreEqual("{ \"a\" : 2 }", selectQuery.BuildQuery().ToJson());
+            Assert.AreEqual(1, Consume(query));
         }
 
         [Test]
@@ -3033,6 +3049,29 @@ public void TestWhereDNotEquals11Not()
             Assert.AreEqual(1, Consume(query));
         }
 
+        [Test]
+        public void TestWhereDAAnyWithPredicate()
+        {
+            var query = from c in _collection.AsQueryable<C>()
+                        where c.DA.Any(x => x.Z == 333)
+                        select c;
+
+            var translatedQuery = MongoQueryTranslator.Translate(query);
+            Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+            Assert.AreSame(_collection, translatedQuery.Collection);
+            Assert.AreSame(typeof(C), translatedQuery.DocumentType);
+
+            var selectQuery = (SelectQuery)translatedQuery;
+            Assert.AreEqual("(C c) => Enumerable.Any<D>(c.DA, (D x) => (x.Z == 333))", ExpressionFormatter.ToString(selectQuery.Where));
+            Assert.IsNull(selectQuery.OrderBy);
+            Assert.IsNull(selectQuery.Projection);
+            Assert.IsNull(selectQuery.Skip);
+            Assert.IsNull(selectQuery.Take);
+
+            Assert.AreEqual("{ \"da\" : { \"$elemMatch\" : { \"z\" : 333 } } }", selectQuery.BuildQuery().ToJson());
+            Assert.AreEqual(1, Consume(query));
+        }
+
         [Test]
         public void TestWhereEAContainsAll()
         {