Finished implementing CSHARP-433. Implemented using == to compare to a type. Modified Query.Or to handle { } (an empty query matches all document). Use { } instead of nasty $mod trick to match all documents.

Author: rstam

Driver/Builders/QueryBuilder.cs

@@ -572,12 +572,18 @@ public static QueryComplete Or(params IMongoQuery[] queries)
                 }
                 else
                 {
-                    queryArray.Add(queryDocument);
+                    // skip query like { } which matches everything
+                    if (queryDocument.ElementCount != 0)
+                    {
+                        queryArray.Add(queryDocument);
+                    }
                 }
             }
 
             switch (queryArray.Count)
             {
+                case 0:
+                    return new QueryComplete(new QueryDocument()); // all queries were empty queries so just return an empty query
                 case 1:
                     return new QueryComplete(queryArray[0].AsBsonDocument);
                 default:

Driver/Linq/Expressions/ExpressionFormatter.cs

@@ -513,6 +513,13 @@ private void VisitValue(object value)
                 return;
             }
 
+            var type = value as Type;
+            if (type != null)
+            {
+                _sb.AppendFormat("typeof({0})", FriendlyClassName(type));
+                return;
+            }
+
             _sb.Append(value.ToString());
         }
     }

Driver/Linq/Translators/SelectQuery.cs

@@ -396,6 +396,12 @@ private IMongoQuery BuildComparisonQuery(BinaryExpression binaryExpression)
                 return query;
             }
 
+            query = BuildTypeComparisonQuery(variableExpression, operatorType, constantExpression);
+            if (query != null)
+            {
+                return query;
+            }
+
             return BuildComparisonQuery(variableExpression, operatorType, constantExpression);
         }
 
@@ -1251,6 +1257,74 @@ private IMongoQuery BuildStringQuery(MethodCallExpression methodCallExpression)
             return null;
         }
 
+        private IMongoQuery BuildTypeComparisonQuery(Expression variableExpression, ExpressionType operatorType, ConstantExpression constantExpression)
+        {
+            if (operatorType != ExpressionType.Equal)
+            {
+                // TODO: support NotEqual?
+                return null;
+            }
+
+            if (constantExpression.Type != typeof(Type))
+            {
+                return null;
+            }
+            var actualType = (Type)constantExpression.Value;
+
+            var methodCallExpression = variableExpression as MethodCallExpression;
+            if (methodCallExpression == null)
+            {
+                return null;
+            }
+            if (methodCallExpression.Method.Name != "GetType" || methodCallExpression.Object == null)
+            {
+                return null;
+            }
+            if (methodCallExpression.Arguments.Count != 0)
+            {
+                return null;
+            }
+
+            // TODO: would the object ever not be a ParameterExpression?
+            var parameterExpression = methodCallExpression.Object as ParameterExpression;
+            if (parameterExpression == null)
+            {
+                return null;
+            }
+
+            var serializationInfo = GetSerializationInfo(parameterExpression);
+            if (serializationInfo == null)
+            {
+                return null;
+            }
+            var nominalType = serializationInfo.NominalType;
+
+            var discriminatorConvention = BsonDefaultSerializer.LookupDiscriminatorConvention(nominalType);
+            var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
+            if (discriminator == null)
+            {
+                return new QueryDocument(); // matches everything
+            }
+
+            if (discriminator.IsBsonArray)
+            {
+                var discriminatorArray = discriminator.AsBsonArray;
+                var queries = new IMongoQuery[discriminatorArray.Count + 1];
+                queries[0] = Query.Size(discriminatorConvention.ElementName, discriminatorArray.Count);
+                for (var i = 0; i < discriminatorArray.Count; i++)
+                {
+                    queries[i + 1] = Query.EQ(string.Format("{0}.{1}", discriminatorConvention.ElementName, i), discriminatorArray[i]);
+                }
+                return Query.And(queries);
+            }
+            else
+            {
+                return Query.And(
+                    Query.Exists(discriminatorConvention.ElementName + ".0", false), // trick to check that element is not an array
+                    Query.EQ(discriminatorConvention.ElementName, discriminator));
+            }
+        }
+
         private IMongoQuery BuildTypeIsQuery(TypeBinaryExpression typeBinaryExpression)
         {
             var nominalType = typeBinaryExpression.Expression.Type;
@@ -1260,7 +1334,7 @@ private IMongoQuery BuildTypeIsQuery(TypeBinaryExpression typeBinaryExpression)
             var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType);
             if (discriminator == null)
             {
-                return Query.Not("_").Mod(1, 2); // best query I could come up with that's always true
+                return new QueryDocument(); // matches everything
             }
 
             if (discriminator.IsBsonArray)
@@ -1355,10 +1429,26 @@ private object ExecuteDistinct(IMongoQuery query)
 
         private BsonSerializationInfo GetSerializationInfo(Expression expression)
         {
+            var parameterExpression = expression as ParameterExpression;
+            if (parameterExpression != null)
+            {
+                var serializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
+                return new BsonSerializationInfo(
+                    null, // elementName
+                    serializer,
+                    parameterExpression.Type, // nominalType
+                    null); // serialization options
+            }
+
             // when using OfType the documentType used by the parameter might be a subclass of the DocumentType from the collection
-            var parameterExpression = ExpressionParameterFinder.FindParameter(expression);
-            var documentSerializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
-            return GetSerializationInfo(documentSerializer, expression);
+            parameterExpression = ExpressionParameterFinder.FindParameter(expression);
+            if (parameterExpression != null)
+            {
+                var serializer = BsonSerializer.LookupSerializer(parameterExpression.Type);
+                return GetSerializationInfo(serializer, expression);
+            }
+
+            return null;
         }
 
         private BsonSerializationInfo GetSerializationInfo(IBsonSerializer serializer, Expression expression)

DriverUnitTests/Builders/QueryBuilderTests.cs

@@ -97,6 +97,36 @@ public void TestAndNullSecond()
             Assert.IsTrue(ex.Message.StartsWith("One of the queries is null."));
         }
 
+        [Test]
+        public void TestAndWithEmptyQuery()
+        {
+            var emptyQuery = new QueryDocument();
+
+            var query = Query.And(emptyQuery);
+            var expected = "{ }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.And(emptyQuery, emptyQuery);
+            expected = "{ }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.And(emptyQuery, Query.EQ("x", 1));
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.And(Query.EQ("x", 1), emptyQuery);
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.And(emptyQuery, Query.EQ("x", 1), emptyQuery);
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.And(Query.EQ("x", 1), emptyQuery, Query.EQ("y", 2));
+            expected = "{ \"x\" : 1, \"y\" : 2 }";
+            Assert.AreEqual(expected, query.ToJson());
+        }
+
         [Test]
         public void TestElementMatch()
         {
@@ -387,6 +417,36 @@ public void TestOrNullSecond()
             Assert.IsTrue(ex.Message.StartsWith("One of the queries is null."));
         }
 
+        [Test]
+        public void TestOrWithEmptyQuery()
+        {
+            var emptyQuery = new QueryDocument();
+
+            var query = Query.Or(emptyQuery);
+            var expected = "{ }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.Or(emptyQuery, emptyQuery);
+            expected = "{ }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.Or(emptyQuery, Query.EQ("x", 1));
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.Or(Query.EQ("x", 1), emptyQuery);
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.Or(emptyQuery, Query.EQ("x", 1), emptyQuery);
+            expected = "{ \"x\" : 1 }";
+            Assert.AreEqual(expected, query.ToJson());
+
+            query = Query.Or(Query.EQ("x", 1), emptyQuery, Query.EQ("y", 2));
+            expected = "{ \"$or\" : [{ \"x\" : 1 }, { \"y\" : 2 }] }";
+            Assert.AreEqual(expected, query.ToJson());
+        }
+
         [Test]
         public void TestRegex()
         {

DriverUnitTests/Linq/SelectOfTypeHierarchicalTests.cs

@@ -249,6 +249,81 @@ where b is D
             Assert.AreEqual(1, Consume(query));
         }
 
+        [Test]
+        public void TestWhereBTypeEqualsB()
+        {
+            var query =
+                from b in _collection.AsQueryable<B>()
+                where b.GetType() == typeof(B)
+                select b;
+
+            var translatedQuery = MongoQueryTranslator.Translate(query);
+            Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+            Assert.AreSame(_collection, translatedQuery.Collection);
+            Assert.AreSame(typeof(B), translatedQuery.DocumentType);
+
+            var selectQuery = (SelectQuery)translatedQuery;
+            Assert.AreEqual("(B b) => (b.GetType() == typeof(B))", ExpressionFormatter.ToString(selectQuery.Where));
+            Assert.AreEqual(null, selectQuery.OfType); // OfType ignored because <T> was the same as <TDocument>
+            Assert.IsNull(selectQuery.OrderBy);
+            Assert.IsNull(selectQuery.Projection);
+            Assert.IsNull(selectQuery.Skip);
+            Assert.IsNull(selectQuery.Take);
+
+            Assert.AreEqual("{ \"_t.0\" : { \"$exists\" : false }, \"_t\" : \"B\" }", selectQuery.BuildQuery().ToJson());
+            Assert.AreEqual(1, Consume(query));
+        }
+
+        [Test]
+        public void TestWhereBTypeEqualsC()
+        {
+            var query =
+                from b in _collection.AsQueryable<B>()
+                where b.GetType() == typeof(C)
+                select b;
+
+            var translatedQuery = MongoQueryTranslator.Translate(query);
+            Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+            Assert.AreSame(_collection, translatedQuery.Collection);
+            Assert.AreSame(typeof(B), translatedQuery.DocumentType);
+
+            var selectQuery = (SelectQuery)translatedQuery;
+            Assert.AreEqual("(B b) => (b.GetType() == typeof(C))", ExpressionFormatter.ToString(selectQuery.Where));
+            Assert.AreEqual(null, selectQuery.OfType);
+            Assert.IsNull(selectQuery.OrderBy);
+            Assert.IsNull(selectQuery.Projection);
+            Assert.IsNull(selectQuery.Skip);
+            Assert.IsNull(selectQuery.Take);
+
+            Assert.AreEqual("{ \"_t\" : { \"$size\" : 2 }, \"_t.0\" : \"B\", \"_t.1\" : \"C\" }", selectQuery.BuildQuery().ToJson());
+            Assert.AreEqual(1, Consume(query));
+        }
+
+        [Test]
+        public void TestWhereBTypeEqualsD()
+        {
+            var query =
+                from b in _collection.AsQueryable<B>()
+                where b.GetType() == typeof(D)
+                select b;
+
+            var translatedQuery = MongoQueryTranslator.Translate(query);
+            Assert.IsInstanceOf<SelectQuery>(translatedQuery);
+            Assert.AreSame(_collection, translatedQuery.Collection);
+            Assert.AreSame(typeof(B), translatedQuery.DocumentType);
+
+            var selectQuery = (SelectQuery)translatedQuery;
+            Assert.AreEqual("(B b) => (b.GetType() == typeof(D))", ExpressionFormatter.ToString(selectQuery.Where));
+            Assert.AreEqual(null, selectQuery.OfType);
+            Assert.IsNull(selectQuery.OrderBy);
+            Assert.IsNull(selectQuery.Projection);
+            Assert.IsNull(selectQuery.Skip);
+            Assert.IsNull(selectQuery.Take);
+
+            Assert.AreEqual("{ \"_t\" : { \"$size\" : 3 }, \"_t.0\" : \"B\", \"_t.1\" : \"C\", \"_t.2\" : \"D\" }", selectQuery.BuildQuery().ToJson());
+            Assert.AreEqual(1, Consume(query));
+        }
+
         private int Consume<T>(IQueryable<T> query)
         {
             var count = 0;