CSHARP-1974: Fix Count with a predicate in aggregate group.

Author: DmitryLukyanov

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

@@ -134,7 +134,7 @@ private bool TryGetAccumulatorTypeAndArgument(PipelineExpression node, out Accum
  if (resultOperator is CountResultOperator)
  {
  accumulatorType = AccumulatorType.Sum;
- argument = Expression.Constant(1);
+ argument = GetCountAccumulatorArgument(node.Source);
  return true;
  }
  if (resultOperator is FirstResultOperator)
@@ -198,6 +198,29 @@ private bool TryGetAccumulatorTypeAndArgument(PipelineExpression node, out Accum
  return false;
  }
 
+ private Expression GetCountAccumulatorArgument(Expression node)
+ {
+ var where = node as WhereExpression;
+ if (where != null)
+ {
+ return Expression.IfThenElse(where.Predicate, Expression.Constant(1), Expression.Constant(0));
+ }
+
+ var document = node as DocumentExpression;
+ if (document != null)
+ {
+ return Expression.Constant(1);
+ }
+
+ var select = node as SelectExpression;
+ if (select != null)
+ {
+ return Expression.Constant(1);
+ }
+
+ throw new NotSupportedException();
+ }
+
  private Expression GetAccumulatorArgument(Expression node)
  {
  // we are looking for a Map
@@ -210,4 +233,4 @@ private Expression GetAccumulatorArgument(Expression node)
  throw new NotSupportedException();
  }
  }
-}
+}

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

@@ -17,13 +17,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Threading.Tasks;
 using FluentAssertions;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
-using MongoDB.Bson.TestHelpers.XunitExtensions;
-using MongoDB.Driver;
-using MongoDB.Driver.Core;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Linq;
 using MongoDB.Driver.Linq.Translators;
@@ -125,6 +121,46 @@ public void Should_translate_count()
  result.Value.Result.Should().Be(1);
  }
 
+ [Fact]
+ public void Should_translate_count_with_a_predicate()
+ {
+ var result = Group(x => x.A, g => new { Result = g.Count(x => x.A != "Awesome") });
+
+ result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+ result.Value.Result.Should().Be(1);
+ }
+
+ [Fact]
+ public void Should_translate_where_with_a_predicate_and_count()
+ {
+ var result = Group(x => x.A, g => new { Result = g.Where(x => x.A != "Awesome").Count() });
+
+ result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+ result.Value.Result.Should().Be(1);
+ }
+
+ [Fact]
+ public void Should_translate_where_select_and_count_with_predicates()
+ {
+ var result = Group(x => x.A, g => new { Result = g.Select(x => new { A = x.A }).Count(x => x.A != "Awesome") });
+
+ result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+ result.Value.Result.Should().Be(1);
+ }
+
+ [Fact]
+ public void Should_translate_where_select_with_predicate_and_count()
+ {
+ var result = Group(x => x.A, g => new { Result = g.Select(x => new { A = x.A }).Count() });
+
+ result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : 1 } }");
+
+ result.Value.Result.Should().Be(1);
+ }
+
  [Fact]
  public void Should_translate_long_count()
  {
@@ -394,4 +430,4 @@ private class ProjectedResult<T>
  public T Value;
  }
  }
-}
+}