CSHARP-4880: Support SequenceEqual in aggregation expressions.

Author: rstam

src/MongoDB.Driver/Linq/Linq3Implementation/Reflection/QueryableMethod.cs

@@ -93,6 +93,7 @@ internal static class QueryableMethod
  private static readonly MethodInfo __selectManyWithCollectionSelectorTakingIndexAndResultSelector;
  private static readonly MethodInfo __selectManyWithSelectorTakingIndex;
  private static readonly MethodInfo __selectWithSelectorTakingIndex;
+ private static readonly MethodInfo __sequenceEqual;
  private static readonly MethodInfo __single;
  private static readonly MethodInfo __singleOrDefault;
  private static readonly MethodInfo __singleOrDefaultWithPredicate;
@@ -198,6 +199,7 @@ static QueryableMethod()
  __selectManyWithCollectionSelectorTakingIndexAndResultSelector = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, int, IEnumerable<object>>> collectionSelector, Expression<Func<object, object, object>> resultSelector) => source.SelectMany(collectionSelector, resultSelector));
  __selectManyWithSelectorTakingIndex = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, int, IEnumerable<object>>> selector) => source.SelectMany(selector));
  __selectWithSelectorTakingIndex = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, int, object>> selector) => source.Select(selector));
+ __sequenceEqual = ReflectionInfo.Method((IQueryable<object> source1, IEnumerable<object> source2) => source1.SequenceEqual(source2));
  __single = ReflectionInfo.Method((IQueryable<object> source) => source.Single());
  __singleOrDefault = ReflectionInfo.Method((IQueryable<object> source) => source.SingleOrDefault());
  __singleOrDefaultWithPredicate = ReflectionInfo.Method((IQueryable<object> source, Expression<Func<object, bool>> predicate) => source.SingleOrDefault(predicate));
@@ -302,6 +304,7 @@ static QueryableMethod()
  public static MethodInfo SelectManyWithCollectionSelectorTakingIndexAndResultSelector => __selectManyWithCollectionSelectorTakingIndexAndResultSelector;
  public static MethodInfo SelectManyWithSelectorTakingIndex => __selectManyWithSelectorTakingIndex;
  public static MethodInfo SelectWithSelectorTakingIndex => __selectWithSelectorTakingIndex;
+ public static MethodInfo SequenceEqual => __sequenceEqual;
  public static MethodInfo Single => __single;
  public static MethodInfo SingleOrDefault => __singleOrDefault;
  public static MethodInfo SingleOrDefaultWithPredicate => __singleOrDefaultWithPredicate;

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodCallExpressionToAggregationExpressionTranslator.cs

@@ -73,6 +73,7 @@ public static AggregationExpression Translate(TranslationContext context, Method
  case "Round": return RoundMethodToAggregationExpressionTranslator.Translate(context, expression);
  case "Select": return SelectMethodToAggregationExpressionTranslator.Translate(context, expression);
  case "SelectMany": return SelectManyMethodToAggregationExpressionTranslator.Translate(context, expression);
+ case "SequenceEqual": return SequenceEqualMethodToAggregationExpressionTranslator.Translate(context, expression);
  case "SetEquals": return SetEqualsMethodToAggregationExpressionTranslator.Translate(context, expression);
  case "Shift": return ShiftMethodToAggregationExpressionTranslator.Translate(context, expression);
  case "Split": return SplitMethodToAggregationExpressionTranslator.Translate(context, expression);

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToAggregationExpressionTranslators/MethodTranslators/SequenceEqualMethodToAggregationExpressionTranslator.cs

@@ -0,0 +1,63 @@
+/* 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.Linq.Expressions;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Linq3Implementation.Ast.Expressions;
+using MongoDB.Driver.Linq.Linq3Implementation.Misc;
+using MongoDB.Driver.Linq.Linq3Implementation.Reflection;
+
+namespace MongoDB.Driver.Linq.Linq3Implementation.Translators.ExpressionToAggregationExpressionTranslators.MethodTranslators
+{
+ internal static class SequenceEqualMethodToAggregationExpressionTranslator
+ {
+ public static AggregationExpression Translate(TranslationContext context, MethodCallExpression expression)
+ {
+ var method = expression.Method;
+ var arguments = expression.Arguments;
+
+ if (method.IsOneOf(EnumerableMethod.SequenceEqual, QueryableMethod.SequenceEqual))
+ {
+ var firstExpression = arguments[0];
+ var secondExpression = arguments[1];
+
+ var firstTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, firstExpression);
+ var secondTranslation = ExpressionToAggregationExpressionTranslator.Translate(context, secondExpression);
+
+ var (firstVarBinding, firstAst) = AstExpression.UseVarIfNotSimple("first", firstTranslation.Ast);
+ var (secondVarBinding, secondAst) = AstExpression.UseVarIfNotSimple("second", secondTranslation.Ast);
+ var pairVar = AstExpression.Var("pair");
+
+ var ast = AstExpression.Let(
+ firstVarBinding,
+ secondVarBinding,
+ @in : AstExpression.And(
+ AstExpression.Eq(AstExpression.Type(firstAst), "array"),
+ AstExpression.Eq(AstExpression.Type(secondAst), "array"),
+ AstExpression.Eq(AstExpression.Size(firstAst), AstExpression.Size(secondAst)),
+ AstExpression.AllElementsTrue(
+ AstExpression.Map(
+ input: AstExpression.Zip([firstAst, secondAst]),
+ @as: pairVar,
+ @in : AstExpression.Eq(AstExpression.ArrayElemAt(pairVar, 0), AstExpression.ArrayElemAt(pairVar, 1)))))
+ );
+
+ return new AggregationExpression(expression, ast, new BooleanSerializer());
+ }
+
+ throw new ExpressionNotSupportedException(expression);
+ }
+ }
+}

tests/MongoDB.Driver.Tests/Linq/Linq3Implementation/Jira/CSharp4880Tests.cs

@@ -0,0 +1,66 @@
+/* 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.Linq;
+using FluentAssertions;
+using MongoDB.Bson;
+using MongoDB.TestHelpers.XunitExtensions;
+using Xunit;
+
+namespace MongoDB.Driver.Tests.Linq.Linq3Implementation.Jira
+{
+ public class CSharp4880Tests : Linq3IntegrationTest
+ {
+ [Theory]
+ [ParameterAttributeData]
+ public void Select_SequenceEqual_should_work(
+ [Values(false, true)] bool withNestedAsQueryable)
+ {
+ var collection = GetCollection();
+
+ var queryable = withNestedAsQueryable ?
+ collection.AsQueryable().Select(x => x.A.AsQueryable().SequenceEqual(x.B)) :
+ collection.AsQueryable().Select(x => x.A.SequenceEqual(x.B));
+
+ var stages = Translate(collection, queryable);
+ AssertStages(stages, "{ $project : { _v : { $and : [{ $eq : [{ $type : '$A' }, 'array'] }, { $eq : [{ $type : '$B' }, 'array'] }, { $eq : [{ $size : '$A' }, { $size : '$B' }] }, { $allElementsTrue : { $map : { input : { $zip : { inputs : ['$A', '$B'] } }, as : 'pair', in: { $eq : [{ $arrayElemAt : ['$$pair', 0] }, { $arrayElemAt : ['$$pair', 1] }] } } } }] }, _id : 0 } }");
+
+ var results = queryable.ToList();
+ results.Should().Equal(false, false, false, false, true, false, false);
+ }
+
+ private IMongoCollection<C> GetCollection()
+ {
+ var collection = GetCollection<C>("test");
+ CreateCollection(
+ collection.Database.GetCollection<BsonDocument>(collection.CollectionNamespace.CollectionName),
+ BsonDocument.Parse("{ _id : 1, A : null, B : null }"),
+ BsonDocument.Parse("{ _id : 2, A : null, B : [1, 2, 3] }"),
+ BsonDocument.Parse("{ _id : 3, A : [1, 2, 3], B : null }"),
+ BsonDocument.Parse("{ _id : 4, A : [1, 2, 3], B : [1, 2] }"),
+ BsonDocument.Parse("{ _id : 5, A : [1, 2, 3], B : [1, 2, 3] }"),
+ BsonDocument.Parse("{ _id : 6, A : [1, 2, 3], B : [4, 5, 6] }"),
+ BsonDocument.Parse("{ _id : 7, A : [1, 2, 3], B : [1, 2, 3, 4] }"));
+ return collection;
+ }
+
+ private class C
+ {
+ public int Id { get; set; }
+ public int[] A { get; set; }
+ public int[] B { get; set; }
+ }
+ }
+}