CSHARP-1662: added support for $reduce. Also included a new ImmutableTypeClassMapConvention which was needed to support anonymous types in LINQ's Aggregate method.

Author: craiggwilson

src/MongoDB.Bson/MongoDB.Bson.csproj

@@ -176,6 +176,7 @@
     <Compile Include="Serialization\Conventions\MemberNameElementNameConvention.cs" />
     <Compile Include="Serialization\Conventions\NamedExtraElementsMemberConvention.cs" />
     <Compile Include="Serialization\Conventions\NamedIdMemberConvention.cs" />
+    <Compile Include="Serialization\Conventions\ImmutableTypeClassMapConvention.cs" />
     <Compile Include="Serialization\Conventions\NoIdMemberConvention.cs" />
     <Compile Include="Serialization\Conventions\ObjectDiscriminatorConvention.cs" />
     <Compile Include="Serialization\Conventions\ReadWriteMemberFinderConvention.cs" />

src/MongoDB.Bson/Serialization/Conventions/DefaultConventionPack.cs

@@ -40,6 +40,7 @@ private DefaultConventionPack()
                 new NamedIdMemberConvention(new [] { "Id", "id", "_id" }),
                 new NamedExtraElementsMemberConvention(new [] { "ExtraElements" }),
                 new IgnoreExtraElementsConvention(false),
+                new ImmutableTypeClassMapConvention(),
                 new NamedParameterCreatorMapConvention(),
                 new StringObjectIdIdGeneratorConvention(), // should be before LookupIdGeneratorConvention
                 new LookupIdGeneratorConvention()

src/MongoDB.Bson/Serialization/Conventions/ImmutableTypeClassMapConvention.cs

@@ -0,0 +1,67 @@
+/* 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;
+using System.Reflection;
+
+namespace MongoDB.Bson.Serialization.Conventions
+{
+    /// <summary>
+    /// Maps a fully immutable type. This will include anonymous types.
+    /// </summary>
+    public class ImmutableTypeClassMapConvention : ConventionBase, IClassMapConvention
+    {
+        /// <inheritdoc />
+        public void Apply(BsonClassMap classMap)
+        {
+            var typeInfo = classMap.ClassType.GetTypeInfo();
+            if (typeInfo.IsAbstract)
+            {
+                return;
+            }
+
+            if (typeInfo.GetConstructor(Type.EmptyTypes) != null)
+            {
+                return;
+            }
+
+            foreach (var ctor in typeInfo.GetConstructors())
+            {
+                var parameters = ctor.GetParameters();
+                var properties = typeInfo.GetProperties();
+                if (parameters.Length != properties.Length)
+                {
+                    continue;
+                }
+
+                var matches = parameters
+                    .GroupJoin(properties,
+                        parameter => parameter.Name,
+                        property => property.Name,
+                        (parameter, props) => new { parameter, properties = props },
+                        StringComparer.OrdinalIgnoreCase);
+
+                if (matches.Any(m => m.properties.Count() != 1 || m.properties.ElementAt(0).CanWrite))
+                {
+                    continue;
+                }
+
+                classMap.MapConstructor(ctor);
+            }
+        }
+    }
+}

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

@@ -132,6 +132,8 @@ public bool Compare(Expression a, Expression b)
                             return CompareDocumentWrappedField((FieldAsDocumentExpression)a, (FieldAsDocumentExpression)b);
                         case ExtensionExpressionType.Field:
                             return CompareField((FieldExpression)a, (FieldExpression)b);
+                        case ExtensionExpressionType.SerializedConstant:
+                            return CompareSerializedConstant((SerializedConstantExpression)a, (SerializedConstantExpression)b);
                         default:
                             throw new MongoInternalException(string.Format("Unhandled mongo expression type: '{0}'", extensionA.ExtensionType));
                     }
@@ -166,6 +168,11 @@ private bool CompareField(FieldExpression a, FieldExpression b)
                 && Compare(a.Original, b.Original);
         }
 
+        private bool CompareSerializedConstant(SerializedConstantExpression a, SerializedConstantExpression b)
+        {
+            return CompareConstantValues(a.Value, b.Value);
+        }
+
         private bool CompareUnary(UnaryExpression a, UnaryExpression b)
         {
             return a.NodeType == b.NodeType

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

@@ -49,6 +49,7 @@ internal enum ExtensionExpressionType
         Field,
         GroupingKey,
         InjectedFilter,
+        SerializedConstant,
 
         // Temporary
         Correlated,

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

@@ -43,7 +43,7 @@ protected internal virtual Expression VisitCollection(CollectionExpression node)
             return node;
         }
 
-        internal Expression VisitInjectedFilter(InjectedFilterExpression node)
+        protected internal virtual Expression VisitInjectedFilter(InjectedFilterExpression node)
         {
             return node;
         }
@@ -197,6 +197,11 @@ protected internal virtual Expression VisitSelectMany(SelectManyExpression node)
                 Visit(node.ResultSelector));
         }
 
+        protected internal virtual Expression VisitSerializedConstant(SerializedConstantExpression node)
+        {
+            return node;
+        }
+
         protected internal virtual Expression VisitSkip(SkipExpression node)
         {
             return node.Update(

src/MongoDB.Driver/Linq/Expressions/ResultOperators/AggregateResultOperator.cs

@@ -0,0 +1,97 @@
+/* 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.Linq.Expressions;
+using System.Text;
+using System.Threading.Tasks;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Expressions.ResultOperators
+{
+    internal sealed class AggregateResultOperator : ResultOperator
+    {
+        private readonly Expression _finalizer;
+        private readonly string _itemName;
+        private readonly Expression _reducer;
+        private readonly Expression _seed;
+        private readonly IBsonSerializer _serializer;
+
+        public AggregateResultOperator(Expression seed, Expression reducer, Expression finalizer, string itemName, IBsonSerializer serializer)
+        {
+            _seed = Ensure.IsNotNull(seed, nameof(seed));
+            _reducer = Ensure.IsNotNull(reducer, nameof(reducer));
+            _serializer = Ensure.IsNotNull(serializer, nameof(serializer));
+
+            _finalizer = finalizer;
+            _itemName = itemName;
+        }
+
+        public Expression Finalizer
+        {
+            get { return _finalizer; }
+        }
+
+        public string ItemName
+        {
+            get { return _itemName; }
+        }
+
+        public override string Name
+        {
+            get { return "Aggregate"; }
+        }
+
+        public Expression Reducer
+        {
+            get { return _reducer; }
+        }
+
+        public Expression Seed
+        {
+            get { return _seed; }
+        }
+
+        public override IBsonSerializer Serializer
+        {
+            get { return _serializer; }
+        }
+
+        public override Type Type
+        {
+            get { return _serializer.ValueType; }
+        }
+
+        protected internal override ResultOperator Update(ExtensionExpressionVisitor visitor)
+        {
+            var seed = visitor.Visit(_seed);
+            var reducer = visitor.Visit(_reducer);
+            Expression finalizer = null;
+            if (_finalizer != null)
+            {
+                finalizer = visitor.Visit(_finalizer);
+            }
+            if (seed != _seed || reducer != _reducer || finalizer != _finalizer)
+            {
+                return new AggregateResultOperator(seed, reducer, finalizer, _itemName, _serializer);
+            }
+
+            return this;
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+/* 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.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Expressions
+{
+    internal sealed class SerializedConstantExpression : SerializationExpression
+    {
+        private readonly object _value;
+        private readonly IBsonSerializer _serializer;
+
+        public SerializedConstantExpression(object value, IBsonSerializer serializer)
+        {
+            _value = Ensure.IsNotNull(value, nameof(value));
+            _serializer = Ensure.IsNotNull(serializer, nameof(serializer));
+        }
+
+        public override ExtensionExpressionType ExtensionType
+        {
+            get { return ExtensionExpressionType.SerializedConstant; }
+        }
+
+        public override IBsonSerializer Serializer
+        {
+            get { return _serializer; }
+        }
+
+        public override Type Type
+        {
+            get { return _serializer.ValueType; }
+        }
+
+        public object Value
+        {
+            get { return _value; }
+        }
+
+        public override string ToString()
+        {
+            return $"Constant({_value.ToString()})";
+        }
+
+        protected internal override Expression Accept(ExtensionExpressionVisitor visitor)
+        {
+            return visitor.VisitSerializedConstant(this);
+        }
+    }
+}

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

@@ -29,6 +29,7 @@ internal sealed class EmbeddedPipelineBinder : PipelineBinderBase<EmbeddedPipeli
         static EmbeddedPipelineBinder()
         {
             var infoBinder = new MethodInfoMethodCallBinder<EmbeddedPipelineBindingContext>();
+            infoBinder.Register(new AggregateBinder(), AggregateBinder.GetSupportedMethods());
             infoBinder.Register(new AllBinder(), AllBinder.GetSupportedMethods());
             infoBinder.Register(new AnyBinder(), AnyBinder.GetSupportedMethods());
             infoBinder.Register(new AsQueryableBinder(), AsQueryableBinder.GetSupportedMethods());

src/MongoDB.Driver/Linq/Processors/EmbeddedPipeline/MethodCallBinders/AggregateBinder.cs

@@ -0,0 +1,89 @@
+/* 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.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using MongoDB.Driver.Linq.Expressions;
+using MongoDB.Driver.Linq.Expressions.ResultOperators;
+using MongoDB.Driver.Support;
+
+namespace MongoDB.Driver.Linq.Processors.EmbeddedPipeline.MethodCallBinders
+{
+    internal sealed class AggregateBinder : IMethodCallBinder<EmbeddedPipelineBindingContext>
+    {
+        public static IEnumerable<MethodInfo> GetSupportedMethods()
+        {
+            yield return MethodHelper.GetMethodDefinition(() => Enumerable.Aggregate<object>(null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Enumerable.Aggregate<object, object>(null, null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Enumerable.Aggregate<object, object, object>(null, null, null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Queryable.Aggregate<object>(null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Queryable.Aggregate<object, object>(null, null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Queryable.Aggregate<object, object, object>(null, null, null, null));
+        }
+
+        public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable<Expression> arguments)
+        {
+            var sourceSerializer = pipeline.Projector.Serializer;
+            var accumulatorSerializer = sourceSerializer;
+            Expression seed;
+            LambdaExpression lambda;
+            var argumentCount = arguments.Count();
+            if (argumentCount == 1)
+            {
+                lambda = ExpressionHelper.GetLambda(arguments.Single());
+                seed = Expression.Constant(accumulatorSerializer.ValueType.GetDefaultValue());
+            }
+            else
+            {
+                seed = arguments.First();
+                accumulatorSerializer = bindingContext.GetSerializer(seed.Type, seed);
+                lambda = ExpressionHelper.GetLambda(arguments.ElementAt(1));
+            }
+
+            if (seed.NodeType == ExpressionType.Constant)
+            {
+                seed = new SerializedConstantExpression(((ConstantExpression)seed).Value, accumulatorSerializer);
+            }
+
+            var valueField = new FieldExpression("$value", accumulatorSerializer);
+            var thisField = new FieldExpression("$this", sourceSerializer);
+
+            bindingContext.AddExpressionMapping(lambda.Parameters[0], valueField);
+            bindingContext.AddExpressionMapping(lambda.Parameters[1], thisField);
+
+            var reducer = bindingContext.Bind(lambda.Body);
+            var serializer = bindingContext.GetSerializer(reducer.Type, reducer);
+
+            Expression finalizer = null;
+            string itemName = null;
+            if (argumentCount == 3)
+            {
+                lambda = ExpressionHelper.GetLambda(arguments.Last());
+                itemName = lambda.Parameters[0].Name;
+                var variable = new FieldExpression("$" + itemName, serializer);
+                bindingContext.AddExpressionMapping(lambda.Parameters[0], variable);
+                finalizer = bindingContext.Bind(lambda.Body);
+                serializer = bindingContext.GetSerializer(finalizer.Type, finalizer);
+            }
+
+            return new PipelineExpression(
+                pipeline.Source,
+                new DocumentExpression(serializer),
+                new AggregateResultOperator(seed, reducer, finalizer, itemName, serializer));
+        }
+    }
+}