CSHARP-1715: Added support for $facet aggregation stage.

Author: rstam

src/MongoDB.Driver.Core/Core/Misc/Feature.cs

@@ -29,6 +29,7 @@ public class Feature
         private static readonly Feature __aggregateCountStage = new Feature("AggregateCountStage", new SemanticVersion(3, 3, 11));
         private static readonly Feature __aggregateCursorResult = new Feature("AggregateCursorResult", new SemanticVersion(2, 6, 0));
         private static readonly Feature __aggregateExplain = new Feature("AggregateExplain", new SemanticVersion(2, 6, 0));
+        private static readonly Feature __aggregateFacetStage = new Feature("AggregateFacetStage", new SemanticVersion(3, 4, 0, "rc0"));
         private static readonly Feature __aggregateOut = new Feature("Aggregate", new SemanticVersion(2, 6, 0));
         private static readonly Feature __bypassDocumentValidation = new Feature("BypassDocumentValidation", new SemanticVersion(3, 2, 0));
         private static readonly CollationFeature __collation = new CollationFeature("Collation", new SemanticVersion(3, 3, 11));
@@ -82,6 +83,11 @@ public class Feature
         /// </summary>
         public static Feature AggregateExplain => __aggregateExplain;
 
+        /// <summary>
+        /// Gets the aggregate $facet stage feature.
+        /// </summary>
+        public static Feature AggregateFacetStage => __aggregateFacetStage;
+
         /// <summary>
         /// Gets the aggregate out feature.
         /// </summary>

src/MongoDB.Driver/AggregateFacet.cs

@@ -0,0 +1,119 @@
+/* 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 MongoDB.Bson;
+using MongoDB.Bson.Serialization;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents static methods for creating facets.
+    /// </summary>
+    public static class AggregateFacet
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="AggregateFacet{TInput, TOutput}" /> class.
+        /// </summary>
+        /// <typeparam name="TInput">The type of the input documents.</typeparam>
+        /// <typeparam name="TOutput">The type of the output documents.</typeparam>
+        /// <param name="name">The facet name.</param>
+        /// <param name="pipeline">The facet pipeline.</param>
+        /// <returns>
+        /// A new instance of the <see cref="AggregateFacet{TInput, TOutput}" /> class
+        /// </returns>
+        public static AggregateFacet<TInput, TOutput> Create<TInput, TOutput>(string name, PipelineDefinition<TInput, TOutput> pipeline)
+        {
+            return new AggregateFacet<TInput, TOutput>(name, pipeline);
+        }
+    }
+
+    /// <summary>
+    /// Represents a facet to be passed to the Facet method.
+    /// </summary>
+    /// <typeparam name="TInput">The type of the input documents.</typeparam>
+    public abstract class AggregateFacet<TInput>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateFacet{TInput}"/> class.
+        /// </summary>
+        /// <param name="name">The facet name.</param>
+        protected AggregateFacet(string name)
+        {
+            Name = Ensure.IsNotNull(name, nameof(name));
+        }
+
+        /// <summary>
+        /// Gets the facet name.
+        /// </summary>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// Gets the output serializer.
+        /// </summary>
+        public abstract IBsonSerializer OutputSerializer { get; }
+
+        /// <summary>
+        /// Gets the type of the output documents.
+        /// </summary>
+        public abstract Type OutputType { get; }
+
+        /// <summary>
+        /// Renders the facet pipeline.
+        /// </summary>
+        /// <param name="inputSerializer">The input serializer.</param>
+        /// <param name="serializerRegistry">The serializer registry.</param>
+        /// <returns>The rendered pipeline.</returns>
+        public abstract BsonArray RenderPipeline(IBsonSerializer<TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry);
+    }
+
+    /// <summary>
+    /// Represents a facet to be passed to the Facet method.
+    /// </summary>
+    /// <typeparam name="TInput">The type of the input documents.</typeparam>
+    /// <typeparam name="TOutput">The type of the otuput documents.</typeparam>
+    public class AggregateFacet<TInput, TOutput> : AggregateFacet<TInput>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateFacet{TInput, TOutput}"/> class.
+        /// </summary>
+        /// <param name="name">The facet name.</param>
+        /// <param name="pipeline">The facet pipeline.</param>
+        public AggregateFacet(string name, PipelineDefinition<TInput, TOutput> pipeline)
+            : base(name)
+        {
+            Pipeline = Ensure.IsNotNull(pipeline, nameof(pipeline));
+        }
+
+        /// <inheritdoc/>
+        public override IBsonSerializer OutputSerializer => Pipeline.OutputSerializer;
+
+        /// <inheritdoc/>
+        public override Type OutputType => typeof(TOutput);
+
+        /// <summary>
+        /// Gets the facet pipeline.
+        /// </summary>
+        public PipelineDefinition<TInput, TOutput> Pipeline { get; private set; }
+
+        /// <inheritdoc/>
+        public override BsonArray RenderPipeline(IBsonSerializer<TInput> inputSerializer, IBsonSerializerRegistry serializerRegistry)
+        {
+            var renderedPipeline = Pipeline.Render(inputSerializer, serializerRegistry);
+            return new BsonArray(renderedPipeline.Documents);
+        }
+    }
+}

src/MongoDB.Driver/AggregateFacetOptions.cs

@@ -0,0 +1,37 @@
+/* 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 MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Options for the aggregate $facet stage.
+    /// </summary>
+    /// <typeparam name="TNewResult">The type of the new result.</typeparam>
+    public sealed class AggregateFacetOptions<TNewResult>
+    {
+        private IBsonSerializer<TNewResult> _newResultSerializer;
+
+        /// <summary>
+        /// Gets or sets the new result serializer.
+        /// </summary>
+        public IBsonSerializer<TNewResult> NewResultSerializer
+        {
+            get { return _newResultSerializer; }
+            set { _newResultSerializer = value; }
+        }
+    }
+}

src/MongoDB.Driver/AggregateFacetResult.cs

@@ -0,0 +1,85 @@
+/* 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 MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents an abstract AggregateFacetResult with an arbitrary TOutput type.
+    /// </summary>
+    public abstract class AggregateFacetResult
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateFacetResult" /> class.
+        /// </summary>
+        /// <param name="name">The name of the facet.</param>
+        internal AggregateFacetResult(string name)
+        {
+            Name = Ensure.IsNotNull(name, nameof(name));
+        }
+
+        /// <summary>
+        /// Gets the name of the facet.
+        /// </summary>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// Gets the output of the facet.
+        /// </summary>
+        public IReadOnlyList<TOutput> Output<TOutput>()
+        {
+            return ((AggregateFacetResult<TOutput>)this).Output;
+        }
+    }
+
+    /// <summary>
+    /// Represents the result of a single facet.
+    /// </summary>
+    /// <typeparam name="TOutput">The type of the output.</typeparam>
+    public sealed class AggregateFacetResult<TOutput> : AggregateFacetResult
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateFacetResult{TOutput}"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="output">The output.</param>
+        public AggregateFacetResult(string name, IEnumerable<TOutput> output)
+            : base(name)
+        {
+            Ensure.IsNotNull(output, nameof(output));
+
+            var readOnlyList = output as IReadOnlyList<TOutput>;
+            if (readOnlyList != null)
+            {
+                Output = readOnlyList;
+            }
+            else
+            {
+                Output = output.ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the output.
+        /// </summary>
+        /// <value>
+        /// The output.
+        /// </value>
+        public IReadOnlyList<TOutput> Output { get; set; }
+    }
+}

src/MongoDB.Driver/AggregateFacetResults.cs

@@ -0,0 +1,102 @@
+/* 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.Reflection;
+using MongoDB.Bson;
+using MongoDB.Bson.IO;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Represents the results of a $facet stage with an arbitrary number of facets.
+    /// </summary>
+    public class AggregateFacetResults
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateFacetResults"/> class.
+        /// </summary>
+        /// <param name="facets">The facets.</param>
+        public AggregateFacetResults(AggregateFacetResult[] facets)
+        {
+            Facets = Ensure.IsNotNull(facets, nameof(facets));
+        }
+
+        /// <summary>
+        /// Gets the facets.
+        /// </summary>
+        public IReadOnlyList<AggregateFacetResult> Facets { get; private set; }
+    }
+
+    internal class AggregateFacetResultsSerializer : SerializerBase<AggregateFacetResults>
+    {
+        private readonly string[] _names;
+        private readonly IBsonSerializer[] _serializers;
+
+        public AggregateFacetResultsSerializer(IEnumerable<string> names, IEnumerable<IBsonSerializer> serializers)
+        {
+            _names = names.ToArray();
+            _serializers = serializers.ToArray();
+        }
+
+        public override AggregateFacetResults Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
+        {
+            var facets = new AggregateFacetResult[_names.Length];
+
+            var reader = context.Reader;
+            reader.ReadStartDocument();
+            while (reader.ReadBsonType() != 0)
+            {
+                var name = reader.ReadName();
+                var index = Array.IndexOf(_names, name);
+                if (index != -1)
+                {
+                    var itemSerializer = _serializers[index];
+                    var itemType = itemSerializer.ValueType;
+                    var itemSerializerType = typeof(IBsonSerializer<>).MakeGenericType(itemType);
+                    var arraySerializerType = typeof(ArraySerializer<>).MakeGenericType(itemType);
+                    var arraySerializerConstructor = arraySerializerType.GetTypeInfo().GetConstructor(new[] { itemSerializerType });
+                    var arraySerializer = (IBsonSerializer)arraySerializerConstructor.Invoke(new object[] { itemSerializer });
+                    var output = (Array)arraySerializer.Deserialize(context);
+                    var facetType = typeof(AggregateFacetResult<>).MakeGenericType(itemType);
+                    var ienumerableItemType = typeof(IEnumerable<>).MakeGenericType(itemType);
+                    var facetConstructor = facetType.GetTypeInfo().GetConstructor(new[] { typeof(string), ienumerableItemType });
+                    var facet = (AggregateFacetResult)facetConstructor.Invoke(new object[] { name, output });
+                    facets[index] = facet;
+                }
+                else
+                {
+                    throw new BsonSerializationException($"Unexpected field name '{name}' in $facet result.");
+                }
+            }
+            reader.ReadEndDocument();
+
+            var missingIndex = Array.IndexOf(facets, null);
+            if (missingIndex != -1)
+            {
+                var missingName = _names[missingIndex];
+                throw new BsonSerializationException($"Field name '{missingName}' in $facet result.");
+            }
+
+
+            return new AggregateFacetResults(facets);
+        }
+    }
+}

src/MongoDB.Driver/AggregateFluent.cs

@@ -231,6 +231,30 @@ public override IAggregateFluent<AggregateCountResult> Count()
             return AppendStage<AggregateCountResult>(stage);
         }
 
+        public override IAggregateFluent<TNewResult> Facet<TNewResult>(
+            IEnumerable<AggregateFacet<TResult>> facets,
+            AggregateFacetOptions<TNewResult> options = null)
+        {
+            const string operatorName = "$facet";
+            var materializedFacets = facets.ToArray();
+            var stage = new DelegatedPipelineStageDefinition<TResult, TNewResult>(
+                operatorName,
+                (s, sr) =>
+                {
+                    var facetsDocument = new BsonDocument();
+                    foreach (var facet in materializedFacets)
+                    {
+                        var renderedPipeline = facet.RenderPipeline(s, sr);
+                        facetsDocument.Add(facet.Name, renderedPipeline);
+                    }
+                    var document = new BsonDocument("$facet", facetsDocument);
+                    var resultSerializer = options?.NewResultSerializer ?? sr.GetSerializer<TNewResult>();
+                    return new RenderedPipelineStageDefinition<TNewResult>(operatorName, document, resultSerializer);
+                });
+
+            return AppendStage<TNewResult>(stage);
+        }
+
         public override IAggregateFluent<TNewResult> Group<TNewResult>(ProjectionDefinition<TResult, TNewResult> group)
         {
             const string operatorName = "$group";