CSHARP-1445: Added support for injecting arbitrary FilterDefinitions.

Author: craiggwilson

src/MongoDB.Driver/Linq/Expressions/ExtensionExpressionType.cs

@@ -46,6 +46,7 @@ internal enum ExtensionExpressionType
         FieldAsDocument,
         Field,
         GroupingKey,
+        InjectedFilter,
 
         // Temporary
         Correlated,

src/MongoDB.Driver/Linq/Expressions/ExtensionExpressionVisitor.cs

@@ -43,6 +43,11 @@ protected internal virtual Expression VisitCollection(CollectionExpression node)
             return node;
         }
 
+        internal Expression VisitInjectedFilter(InjectedFilterExpression node)
+        {
+            return node;
+        }
+
         protected internal virtual Expression VisitConcat(ConcatExpression node)
         {
             return node.Update(

src/MongoDB.Driver/Linq/Expressions/InjectedFilterExpression.cs

@@ -0,0 +1,46 @@
+/* Copyright 2016 MongoDB 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.Linq.Expressions;
+using MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Expressions
+{
+    internal sealed class InjectedFilterExpression : ExtensionExpression
+    {
+        private readonly BsonDocument _filter;
+
+        public InjectedFilterExpression(BsonDocument filter)
+        {
+            _filter = Ensure.IsNotNull(filter, nameof(filter));
+        }
+
+        public override ExtensionExpressionType ExtensionType => ExtensionExpressionType.InjectedFilter;
+
+        public BsonDocument Filter => _filter;
+
+        public override Type Type => typeof(bool);
+
+        public override string ToString() => _filter.ToString();
+
+        protected internal override Expression Accept(ExtensionExpressionVisitor visitor)
+        {
+            return visitor.VisitInjectedFilter(this);
+        }
+    }
+}

src/MongoDB.Driver/Linq/LinqExtensions.cs

@@ -0,0 +1,42 @@
+/* Copyright 2016 MongoDB 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.Text;
+using System.Threading.Tasks;
+
+namespace MongoDB.Driver.Linq
+{
+    /// <summary>
+    /// This static class holds methods that can be used to express MongoDB specific operations in LINQ queries.
+    /// </summary>
+    public static class LinqExtensions
+    {
+        /// <summary>
+        /// Injects a low level FilterDefinition{T} into a LINQ where clause. Can only be used in LINQ queries.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="filter">The filter.</param>
+        /// <returns>
+        /// Throws an InvalidOperationException if called.
+        /// </returns>
+        public static bool Inject<T>(this FilterDefinition<T> filter)
+        {
+            throw new InvalidOperationException("The LinqExtensions.Inject method is only intended to be used in LINQ Where clauses.");
+        }
+    }
+}

src/MongoDB.Driver/Linq/Processors/EmbeddedPipeline/EmbeddedPipelineBindingContext.cs

@@ -38,6 +38,11 @@ public EmbeddedPipelineBindingContext(IBindingContext parent)
             _memberMapping = new Dictionary<MemberInfo, Expression>();
         }
 
+        public IBsonSerializerRegistry SerializerRegistry
+        {
+            get { return _parent.SerializerRegistry; }
+        }
+
         public void AddCorrelatingId(Expression node, Guid correlatingId)
         {
             _correlationMapping.Add(node, correlatingId);

src/MongoDB.Driver/Linq/Processors/IBindingContext.cs

@@ -22,6 +22,8 @@ namespace MongoDB.Driver.Linq.Processors
 {
     internal interface IBindingContext
     {
+        IBsonSerializerRegistry SerializerRegistry { get; }
+
         void AddCorrelatingId(Expression node, Guid correlatingId);
 
         void AddExpressionMapping(Expression original, Expression replacement);

src/MongoDB.Driver/Linq/Processors/PartialEvaluator.cs

@@ -169,7 +169,14 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                     }
                 }
 
-                return base.VisitMethodCall(node);
+                node = (MethodCallExpression)base.VisitMethodCall(node);
+                if (node.Object == null && node.Method.DeclaringType == typeof(LinqExtensions) &&
+                    node.Method.Name == "Inject")
+                {
+                    _isBlocked = true;
+                }
+
+                return node;
             }
 
             protected override Expression VisitParameter(ParameterExpression node)

src/MongoDB.Driver/Linq/Processors/Pipeline/PipelineBindingContext.cs

@@ -38,6 +38,11 @@ public PipelineBindingContext(IBsonSerializerRegistry serializerRegistry)
             _memberMapping = new Dictionary<MemberInfo, Expression>();
         }
 
+        public IBsonSerializerRegistry SerializerRegistry
+        {
+            get { return _serializerRegistry; }
+        }
+
         public void AddCorrelatingId(Expression node, Guid correlatingId)
         {
             Ensure.IsNotNull(node, nameof(node));

src/MongoDB.Driver/Linq/Processors/SerializationBinder.cs

@@ -18,6 +18,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Linq.Expressions;
 using MongoDB.Driver.Linq.Processors.EmbeddedPipeline;
@@ -169,6 +170,8 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                     return BindElementAt(node);
                 case "get_Item":
                     return BindGetItem(node);
+                case "Inject":
+                    return BindInject(node);
             }
 
             // Select and SelectMany are the only supported client-side projection operators
@@ -341,6 +344,28 @@ private Expression BindGetItem(MethodCallExpression node)
             return node; // return the original node because we can't translate this expression.
         }
 
+
+        private Expression BindInject(MethodCallExpression node)
+        {
+            if (node.Method.DeclaringType == typeof(LinqExtensions))
+            {
+                var arg = node.Arguments[0] as ConstantExpression;
+                if (arg != null)
+                {
+                    var docType = node.Method.GetGenericArguments()[0];
+                    var serializer = _bindingContext.GetSerializer(node.Method.GetGenericArguments()[0], arg);
+                    var renderedFilter = (BsonDocument)typeof(FilterDefinition<>).MakeGenericType(docType)
+                        .GetTypeInfo()
+                        .GetMethod("Render")
+                        .Invoke(arg.Value, new object[] { serializer, _bindingContext.SerializerRegistry });
+
+                    return new InjectedFilterExpression(renderedFilter);
+                }
+            }
+
+            return node;
+        }
+
         private Expression BindClientSideProjector(MethodCallExpression node)
         {
             var arguments = new List<Expression>();

src/MongoDB.Driver/Linq/Translators/PredicateTranslator.cs

@@ -117,6 +117,8 @@ private FilterDefinition<BsonDocument> Translate(Expression node)
                                     filter = TranslateBoolean(mongoExpression);
                                 }
                                 break;
+                            case ExtensionExpressionType.InjectedFilter:
+                                return TranslateInjectedFilter((InjectedFilterExpression)node);
                             case ExtensionExpressionType.Pipeline:
                                 filter = TranslatePipeline((PipelineExpression)node);
                                 break;
@@ -663,6 +665,11 @@ private FilterDefinition<BsonDocument> TranslateIn(MethodCallExpression methodCa
             return null;
         }
 
+        private FilterDefinition<BsonDocument> TranslateInjectedFilter(InjectedFilterExpression node)
+        {
+            return new BsonDocumentFilterDefinition<BsonDocument>(node.Filter);
+        }
+
         private FilterDefinition<BsonDocument> TranslateIsMatch(MethodCallExpression methodCallExpression)
         {
             if (methodCallExpression.Method.DeclaringType == typeof(Regex))

src/MongoDB.Driver/MongoDB.Driver.csproj

@@ -88,6 +88,7 @@
     <Compile Include="Linq\ExpressionHelper.cs" />
     <Compile Include="Linq\Expressions\AccumulatorExpression.cs" />
     <Compile Include="Linq\Expressions\AccumulatorType.cs" />
+    <Compile Include="Linq\Expressions\InjectedFilterExpression.cs" />
     <Compile Include="Linq\Expressions\CollectionExpression.cs" />
     <Compile Include="Linq\Expressions\CorrelatedExpression.cs" />
     <Compile Include="Linq\Expressions\ConcatExpression.cs" />
@@ -143,6 +144,7 @@
     <Compile Include="Linq\IMongoQueryable.cs" />
     <Compile Include="Linq\IMongoQueryProvider.cs" />
     <Compile Include="Linq\IResultTransformer.cs" />
+    <Compile Include="Linq\LinqExtensions.cs" />
     <Compile Include="Linq\MethodHelper.cs" />
     <Compile Include="Linq\MongoEnumerable.cs" />
     <Compile Include="Linq\MongoQueryable.cs" />

tests/MongoDB.Driver.Tests/Linq/Translators/PredicateTranslatorTests.cs

@@ -25,6 +25,7 @@
 using MongoDB.Bson.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Core;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using MongoDB.Driver.Linq;
 using MongoDB.Driver.Linq.Translators;
 using Xunit;
 
@@ -775,6 +776,28 @@ public void Binding_through_an_unnecessary_conversion_with_a_builder()
             root.A.Should().Be("Awesome");
         }
 
+        [Fact]
+        public void Injecting_a_filter()
+        {
+            var filter = Builders<Root>.Filter.Eq(x => x.B, "Balloon");
+            var root = __collection.FindSync(x => filter.Inject()).Single();
+
+            root.Should().NotBeNull();
+            root.A.Should().Be("Awesome");
+            root.B.Should().Be("Balloon");
+        }
+
+        [Fact]
+        public void Injecting_a_filter_with_a_conjunction()
+        {
+            var filter = Builders<Root>.Filter.Eq(x => x.B, "Balloon");
+            var root = __collection.FindSync(x => x.A == "Awesome" && filter.Inject()).Single();
+
+            root.Should().NotBeNull();
+            root.A.Should().Be("Awesome");
+            root.B.Should().Be("Balloon");
+        }
+
         private T FindFirstOrDefault<T>(IMongoCollection<T> collection, int id) where T : IRoot
         {
             return collection.FindSync(x => x.Id == id).FirstOrDefault();