CSHARP-4763: Support client side projections.

Author: rstam

src/MongoDB.Driver/AggregateOptions.cs

@@ -37,6 +37,15 @@ public class AggregateOptions
         private ExpressionTranslationOptions _translationOptions;
         private bool? _useCursor;
 
+        // implicit conversions
+        /// <summary>
+        /// Creates an AggregateOptions instance with the specified translation options.
+        /// </summary>
+        /// <param name="translationOptions">The translation options.</param>
+        /// <returns>An AggregateOptions instance.</returns>
+        public static implicit operator AggregateOptions(ExpressionTranslationOptions translationOptions) =>
+            new AggregateOptions { TranslationOptions = translationOptions };
+
         // properties
         /// <summary>
         /// Gets or sets a value indicating whether to allow disk use.

src/MongoDB.Driver/ClientSideProjectionDeserializer.cs

@@ -0,0 +1,72 @@
+/* Copyright 2010-present 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.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    internal interface IClientSideProjectionDeserializer
+    {
+    }
+
+    internal static class ClientSideProjectionDeserializer
+    {
+        public static IBsonSerializer Create(
+            IBsonSerializer inputSerializer,
+            LambdaExpression projector)
+        {
+            var inputType = inputSerializer.ValueType;
+            var projectionType = projector.ReturnType;
+            var serializerType = typeof(ClientSideProjectionDeserializer<,>).MakeGenericType(inputType, projectionType);
+            var projectorDelegate = projector.Compile();
+            return (IBsonSerializer)Activator.CreateInstance(serializerType, inputSerializer, projectorDelegate);
+        }
+    }
+
+    /// <summary>
+    /// A deserializer for doing client side projections.
+    /// </summary>
+    /// <typeparam name="TInput">The type of the input.</typeparam>
+    /// <typeparam name="TProjection">The type of the projection.</typeparam>
+    public sealed class ClientSideProjectionDeserializer<TInput, TProjection> : SerializerBase<TProjection>, IClientSideProjectionDeserializer
+    {
+        private readonly Func<TInput, TProjection> _projector;
+        private readonly IBsonSerializer<TInput> _inputSerializer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ClientSideProjectionDeserializer{TInput, TProjection}"/> class.
+        /// </summary>
+        /// <param name="inputSerializer">The input serializer.</param>
+        /// <param name="projector">The client side projector.</param>
+        public ClientSideProjectionDeserializer(
+            IBsonSerializer<TInput> inputSerializer,
+            Func<TInput, TProjection> projector)
+        {
+            _inputSerializer = Ensure.IsNotNull(inputSerializer, nameof(inputSerializer));
+            _projector = Ensure.IsNotNull(projector, nameof(projector));
+        }
+
+        /// <inheritdoc/>
+        public override TProjection Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            var document = _inputSerializer.Deserialize(context);
+            return _projector(document);
+        }
+    }
+}

src/MongoDB.Driver/ExpressionTranslationOptions.cs

@@ -11,7 +11,7 @@
 * 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.
-* 
+*
 */
 
 namespace MongoDB.Driver
@@ -26,30 +26,51 @@ public sealed class ExpressionTranslationOptions
         /// </summary>
         public ServerVersion? CompatibilityLevel { get; set; }
 
+        /// <summary>
+        /// Gets or sets whether client side projections are enabled.
+        /// </summary>
+        public bool? EnableClientSideProjections { get; set; }
+
         /// <inheritdoc/>
         public override bool Equals(object obj)
         {
             if (object.ReferenceEquals(obj, null)) { return false; }
             if (object.ReferenceEquals(this, obj)) { return true; }
             return
-                base.Equals(obj) &&
+                GetType().Equals(obj.GetType()) &&
                 obj is ExpressionTranslationOptions other &&
-                CompatibilityLevel.Equals(other.CompatibilityLevel);
+                CompatibilityLevel.Equals(other.CompatibilityLevel) &&
+                EnableClientSideProjections.Equals(other.EnableClientSideProjections);
         }
 
         /// <inheritdoc/>
         public override int GetHashCode() => 0;
 
         /// <inheritdoc/>
-        public override string ToString() => $"{{ CompatibilityLevel = {CompatibilityLevel} }}";
+        public override string ToString()
+        {
+            var compatibilityLevel = CompatibilityLevel.HasValue ? CompatibilityLevel.ToString() : "null";
+            var enableClientSideProjections = EnableClientSideProjections.HasValue ? EnableClientSideProjections.ToString() : "null";
+            return $"{{ CompatibilityLevel = {compatibilityLevel}, EnableClientSideProjections = {enableClientSideProjections} }}";
+        }
     }
 
     internal static class ExpressionTranslationOptionsExtensions
     {
         public static ExpressionTranslationOptions AddMissingOptionsFrom(this ExpressionTranslationOptions translationOptions, ExpressionTranslationOptions from)
         {
-            // in the future ExpressionTranslationOptions might have more properties
-            return (translationOptions?.CompatibilityLevel).HasValue ? translationOptions : from;
+            if (translationOptions == null || from == null)
+            {
+                return translationOptions ?? from;
+            }
+            else
+            {
+                return new ExpressionTranslationOptions
+                {
+                    CompatibilityLevel = translationOptions.CompatibilityLevel ?? from.CompatibilityLevel,
+                    EnableClientSideProjections = translationOptions.EnableClientSideProjections ?? from.EnableClientSideProjections
+                };
+            }
         }
     }
 }

src/MongoDB.Driver/FindFluent.cs

@@ -144,6 +144,7 @@ public override IFindFluent<TDocument, TNewProjection> Project<TNewProjection>(P
                 ShowRecordId = _options.ShowRecordId,
                 Skip = _options.Skip,
                 Sort = _options.Sort,
+                TranslationOptions = _options.TranslationOptions
             };
             return new FindFluent<TDocument, TNewProjection>(_session, _collection, _filter, newOptions);
         }

src/MongoDB.Driver/FindOptions.cs

@@ -41,6 +41,7 @@ public abstract class FindOptionsBase
         private bool? _oplogReplay;
         private bool? _returnKey;
         private bool? _showRecordId;
+        private ExpressionTranslationOptions _translationOptions;
 
         // constructors
         /// <summary>
@@ -196,6 +197,15 @@ public bool? ShowRecordId
             get { return _showRecordId; }
             set { _showRecordId = value; }
         }
+
+        /// <summary>
+        /// Gets or sets the translation options.
+        /// </summary>
+        public ExpressionTranslationOptions TranslationOptions
+        {
+            get { return _translationOptions; }
+            set { _translationOptions = value; }
+        }
     }
 
     /// <summary>

src/MongoDB.Driver/IMongoCollectionExtensions.cs

@@ -1200,6 +1200,7 @@ private static IFindFluent<TDocument, TDocument> FindHelper<TDocument>(IClientSe
 #pragma warning restore 618
                     ReturnKey = options.ReturnKey,
                     ShowRecordId = options.ShowRecordId,
+                    TranslationOptions = options.TranslationOptions
                 };
             }
 

src/MongoDB.Driver/Linq/Linq3Implementation/Misc/ClientSideProjectionHelper.cs

@@ -0,0 +1,60 @@
+/* Copyright 2010-present 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 System.Reflection;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Misc
+{
+    internal static class ClientSideProjectionHelper
+    {
+        // public static methods
+        public static void ThrowIfClientSideProjection(
+            Expression expression,
+            AstPipeline pipeline,
+            MethodInfo method)
+        {
+            if (pipeline.OutputSerializer is IClientSideProjectionDeserializer)
+            {
+                throw new ExpressionNotSupportedException(expression, because: $"{method.Name} cannot follow a client side projection");
+            }
+        }
+
+        public static void ThrowIfClientSideProjection(
+            Expression expression,
+            AstPipeline pipeline,
+            MethodInfo method,
+            string methodOverload)
+        {
+            if (pipeline.OutputSerializer is IClientSideProjectionDeserializer)
+            {
+                throw new ExpressionNotSupportedException(expression, because: $"{method.Name} {methodOverload} cannot follow a client side projection");
+            }
+        }
+
+        public static void ThrowIfClientSideProjection(
+            IBsonSerializer inputSerializer,
+            string stageName)
+        {
+            if (inputSerializer is IClientSideProjectionDeserializer)
+            {
+                throw new NotSupportedException($"A {stageName} stage cannot follow a client side projection");
+            }
+        }
+    }
+}

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToExecutableQueryTranslators/AllMethodToExecutableQueryTranslator.cs

@@ -47,6 +47,7 @@ public static ExecutableQuery<TDocument, bool> Translate<TDocument>(MongoQueryPr
             {
                 var sourceExpression = arguments[0];
                 var pipeline = ExpressionToPipelineTranslator.Translate(context, sourceExpression);
+                ClientSideProjectionHelper.ThrowIfClientSideProjection(expression, pipeline, method);
 
                 var predicateLambda = ExpressionHelper.UnquoteLambda(arguments[1]);
                 var predicateFilter = ExpressionToFilterTranslator.TranslateLambda(context, predicateLambda, parameterSerializer: pipeline.OutputSerializer, asRoot: true);

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToExecutableQueryTranslators/AnyMethodToExecutableQueryTranslator.cs

@@ -70,6 +70,8 @@ public static ExecutableQuery<TDocument, bool> Translate<TDocument>(MongoQueryPr
 
                 if (method.IsOneOf(__anyWithPredicateMethods))
                 {
+                    ClientSideProjectionHelper.ThrowIfClientSideProjection(expression, pipeline, method, "with a predicate");
+
                     var predicateLambda = ExpressionHelper.UnquoteLambda(arguments[1]);
                     var predicateFilter = ExpressionToFilterTranslator.TranslateLambda(context, predicateLambda, parameterSerializer: pipeline.OutputSerializer, asRoot: true);
 

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToExecutableQueryTranslators/AverageMethodToExecutableQueryTranslator.cs

@@ -120,8 +120,9 @@ public static ExecutableQuery<TDocument, TOutput> Translate<TDocument>(MongoQuer
             {
                 var sourceExpression = arguments[0];
                 var pipeline = ExpressionToPipelineTranslator.Translate(context, sourceExpression);
-                var sourceSerializer = pipeline.OutputSerializer;
+                ClientSideProjectionHelper.ThrowIfClientSideProjection(expression, pipeline, method);
 
+                var sourceSerializer = pipeline.OutputSerializer;
                 AstExpression valueExpression;
                 if (method.IsOneOf(__averageWithSelectorMethods))
                 {