CSHARP-1373, CSHARP-1367: added $stdDevPop and $stdDevSamp expression and group support.

Author: craiggwilson

Docs/reference/content/reference/driver/expressions.md

@@ -803,6 +803,24 @@ p => p.FavoriteNumbers.Skip(3).Take(2)
 { $slice: ['$FavoriteNumbers', 3, 2] }
 ```
 
+#### $stdDevPop
+
+```csharp
+p => p.FavoriteNumbers.StandardDeviationPopulation()
+```
+```json
+{ $stdDevPop: '$FavoriteNumbers' }
+```
+
+#### $stdDevSamp
+
+```csharp
+p => p.FavoriteNumbers.StandardDeviationSample()
+```
+```json
+{ $stdDevPop: '$FavoriteNumbers' }
+```
+
 #### $sum
 
 ```csharp

src/MongoDB.Driver.Tests/Linq/MongoQueryableTests.cs

@@ -906,6 +906,70 @@ public void Skip()
                 "{ $skip: 10 }");
         }
 
+        [Test]
+        public void StandardDeviationPopulation()
+        {
+            var result = CreateQuery().Select(x => x.C.E.F).StandardDeviationPopulation();
+
+            result.Should().Be(50);
+        }
+
+        [Test]
+        public void StandardDeviationPopulation_with_selector()
+        {
+            var result = CreateQuery().StandardDeviationPopulation(x => x.C.E.F);
+
+            result.Should().Be(50);
+        }
+
+        [Test]
+        public async Task StandardDeviationPopulationAsync()
+        {
+            var result = await CreateQuery().Select(x => x.C.E.F).StandardDeviationPopulationAsync();
+
+            result.Should().Be(50);
+        }
+
+        [Test]
+        public async Task StandardDeviationPopulationAsync_with_selector()
+        {
+            var result = await CreateQuery().StandardDeviationPopulationAsync(x => x.C.E.F);
+
+            result.Should().Be(50);
+        }
+
+        [Test]
+        public void StandardDeviationSample()
+        {
+            var result = CreateQuery().Select(x => x.C.E.F).StandardDeviationSample();
+
+            result.Should().BeApproximately(70.7106781186548, .0001);
+        }
+
+        [Test]
+        public void StandardDeviationSample_with_selector()
+        {
+            var result = CreateQuery().StandardDeviationSample(x => x.C.E.F);
+
+            result.Should().BeApproximately(70.7106781186548, .0001);
+        }
+
+        [Test]
+        public async Task StandardDeviationSampleAsync()
+        {
+            var result = await CreateQuery().Select(x => x.C.E.F).StandardDeviationSampleAsync();
+
+            result.Should().BeApproximately(70.7106781186548, .0001);
+        }
+
+        [Test]
+        public async Task StandardDeviationSampleAsync_with_selector()
+        {
+            var result = await CreateQuery().StandardDeviationSampleAsync(x => x.C.E.F);
+
+            result.Should().BeApproximately(70.7106781186548, .0001);
+        }
+
         [Test]
         public void Sum()
         {

src/MongoDB.Driver.Tests/Linq/Translators/AggregateGroupTranslatorTests.cs

@@ -22,6 +22,8 @@
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver;
+using MongoDB.Driver.Core;
+using MongoDB.Driver.Linq;
 using MongoDB.Driver.Linq.Translators;
 using NUnit.Framework;
 
@@ -260,6 +262,50 @@ public async Task Should_translate_push_with_ToList()
             result.Value.Result.Should().Equal(111);
         }
 
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevPop_with_embedded_projector()
+        {
+            var result = await Group(x => 1, g => new { Result = g.StandardDeviationPopulation(x => x.C.E.F) });
+
+            result.Projection.Should().Be("{ _id: 1, Result: { \"$stdDevPop\": \"$C.E.F\" } }");
+
+            result.Value.Result.Should().Be(50);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevPop_with_selected_projector()
+        {
+            var result = await Group(x => 1, g => new { Result = g.Select(x => x.C.E.F).StandardDeviationPopulation() });
+
+            result.Projection.Should().Be("{ _id: 1, Result: { \"$stdDevPop\": \"$C.E.F\" } }");
+
+            result.Value.Result.Should().Be(50);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevSamp_with_embedded_projector()
+        {
+            var result = await Group(x => 1, g => new { Result = g.StandardDeviationSample(x => x.C.E.F) });
+
+            result.Projection.Should().Be("{ _id: 1, Result: { \"$stdDevSamp\": \"$C.E.F\" } }");
+
+            result.Value.Result.Should().BeApproximately(70.7106781156545, .0001);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevSamp_with_selected_projector()
+        {
+            var result = await Group(x => 1, g => new { Result = g.Select(x => x.C.E.F).StandardDeviationSample() });
+
+            result.Projection.Should().Be("{ _id: 1, Result: { \"$stdDevSamp\": \"$C.E.F\" } }");
+
+            result.Value.Result.Should().BeApproximately(70.7106781156545, .0001);
+        }
+
         [Test]
         public async Task Should_translate_sum_with_embedded_projector()
         {

src/MongoDB.Driver.Tests/Linq/Translators/AggregateProjectTranslatorTests.cs

@@ -22,6 +22,7 @@
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core;
+using MongoDB.Driver.Linq;
 using MongoDB.Driver.Linq.Translators;
 using NUnit.Framework;
 
@@ -866,6 +867,50 @@ public async Task Should_translate_select_with_an_anonymous_type_then_where_to_m
             result.Value.Result.Single().F.Should().Be(33);
         }
 
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevPop()
+        {
+            var result = await Project(x => new { Result = x.M.StandardDeviationPopulation() });
+
+            result.Projection.Should().Be("{ Result: { \"$stdDevPop\": \"$M\" }, _id: 0 }");
+
+            result.Value.Result.Should().BeApproximately(1.247219128924647, .0001);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevPop_with_selector()
+        {
+            var result = await Project(x => new { Result = x.G.StandardDeviationPopulation(g => g.E.F) });
+
+            result.Projection.Should().Be("{ Result: { \"$stdDevPop\": \"$G.E.F\" }, _id: 0 }");
+
+            result.Value.Result.Should().Be(11);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevSamp()
+        {
+            var result = await Project(x => new { Result = x.M.StandardDeviationSample() });
+
+            result.Projection.Should().Be("{ Result: { \"$stdDevSamp\": \"$M\" }, _id: 0 }");
+
+            result.Value.Result.Should().BeApproximately(1.5275252316519468, .0001);
+        }
+
+        [Test]
+        [RequiresServer(MinimumVersion = "3.1.7")]
+        public async Task Should_translate_stdDevSamp_with_selector()
+        {
+            var result = await Project(x => new { Result = x.G.StandardDeviationSample(g => g.E.F) });
+
+            result.Projection.Should().Be("{ Result: { \"$stdDevSamp\": \"$G.E.F\" }, _id: 0 }");
+
+            result.Value.Result.Should().BeApproximately(15.556349186104045, .0001);
+        }
+
         [Test]
         public async Task Should_translate_string_equals()
         {

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

@@ -24,6 +24,8 @@ internal enum AccumulatorType
         Min,
         Max,
         Push,
-        Sum
+        StandardDeviationPopulation,
+        StandardDeviationSample,
+        Sum,
     }
 }

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

@@ -0,0 +1,58 @@
+/* Copyright 2015 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.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Linq.Expressions.ResultOperators
+{
+    internal sealed class StandardDeviationResultOperator : ResultOperator, IResultTransformer
+    {
+        private readonly bool _isSample;
+        private readonly Type _type;
+
+        public StandardDeviationResultOperator(Type type, bool isSample)
+        {
+            _type = Ensure.IsNotNull(type, nameof(type));
+            _isSample = isSample;
+        }
+
+        public bool IsSample
+        {
+            get { return _isSample; }
+        }
+
+        public override string Name
+        {
+            get { return "StandardDeviation" + (_isSample ? "Sample" : "Population"); }
+        }
+
+        public override Type Type
+        {
+            get { return _type; }
+        }
+
+        public LambdaExpression CreateAggregator(Type sourceType)
+        {
+            return ResultTransformerHelper.CreateAggregator("Single", sourceType);
+        }
+
+        public LambdaExpression CreateAsyncAggregator(Type sourceType)
+        {
+            return ResultTransformerHelper.CreateAsyncAggregator("SingleAsync", sourceType);
+        }
+    }
+}

src/MongoDB.Driver/Linq/MethodHelper.cs

@@ -68,6 +68,8 @@ public static IEnumerable<MethodInfo> GetEnumerableAndQueryableMethodDefinitions
             return typeof(Enumerable)
                 .GetMethods()
                 .Concat(typeof(Queryable).GetMethods())
+                .Concat(typeof(MongoEnumerable).GetMethods())
+                .Concat(typeof(MongoQueryable).GetMethods())
                 .Where(x => x.Name == name)
                 .Select(x => GetMethodDefinition(x));
         }