CSHARP-1620: added support for $zip.

Author: craiggwilson

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

@@ -38,6 +38,7 @@ internal enum ExtensionExpressionType
         Take,
         Union,
         Where,
+        Zip,
 
         // Bindings
         Accumulator,

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

@@ -224,5 +224,12 @@ protected internal virtual Expression VisitWhere(WhereExpression node)
                 Visit(node.Source),
                 Visit(node.Predicate));
         }
+
+        protected internal virtual Expression VisitZip(ZipExpression node)
+        {
+            return node.Update(
+                Visit(node.Source),
+                Visit(node.Other));
+        }
     }
 }

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

@@ -0,0 +1,76 @@
+/* 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
+{
+    internal sealed class ZipExpression : ExtensionExpression, ISourcedExpression
+    {
+        private readonly Expression _other;
+        private readonly Expression _source;
+        private readonly Type _type;
+
+        public ZipExpression(Type type, Expression source, Expression other)
+        {
+            _type = Ensure.IsNotNull(type, nameof(type));
+            _source = Ensure.IsNotNull(source, nameof(source));
+            _other = Ensure.IsNotNull(other, nameof(other));
+        }
+
+        public override ExtensionExpressionType ExtensionType
+        {
+            get { return ExtensionExpressionType.Zip; }
+        }
+
+        public Expression Other
+        {
+            get { return _other; }
+        }
+
+        public Expression Source
+        {
+            get { return _source; }
+        }
+
+        public override Type Type
+        {
+            get { return _type; }
+        }
+
+        public override string ToString()
+        {
+            return string.Format("{0}.Zip({1})", _source.ToString(), _other.ToString());
+        }
+
+        public ZipExpression Update(Expression source, Expression other)
+        {
+            if (source != _source ||
+                other != _other)
+            {
+                return new ZipExpression(_type, source, other);
+            }
+
+            return this;
+        }
+
+        protected internal override Expression Accept(ExtensionExpressionVisitor visitor)
+        {
+            return visitor.VisitZip(this);
+        }
+    }
+}

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

@@ -54,6 +54,7 @@ static EmbeddedPipelineBinder()
             infoBinder.Register(new ToListBinder(), ToListBinder.GetSupportedMethods());
             infoBinder.Register(new UnionBinder(), UnionBinder.GetSupportedMethods());
             infoBinder.Register(new WhereBinder(), WhereBinder.GetSupportedMethods());
+            infoBinder.Register(new ZipBinder(), ZipBinder.GetSupportedMethods());
 
             var nameBinder = new NameBasedMethodCallBinder<EmbeddedPipelineBindingContext>();
             nameBinder.Register(new ContainsBinder(), ContainsBinder.IsSupported, ContainsBinder.SupportedMethodNames);

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

@@ -0,0 +1,69 @@
+/* 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.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using MongoDB.Bson.Serialization;
+using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Driver.Linq.Expressions;
+
+namespace MongoDB.Driver.Linq.Processors.EmbeddedPipeline.MethodCallBinders
+{
+    internal sealed class ZipBinder : IMethodCallBinder<EmbeddedPipelineBindingContext>
+    {
+        public static IEnumerable<MethodInfo> GetSupportedMethods()
+        {
+            yield return MethodHelper.GetMethodDefinition(() => Enumerable.Zip<object, object, object>(null, null, null));
+            yield return MethodHelper.GetMethodDefinition(() => Queryable.Zip<object, object, object>(null, null, null));
+        }
+
+        public Expression Bind(PipelineExpression pipeline, EmbeddedPipelineBindingContext bindingContext, MethodCallExpression node, IEnumerable<Expression> arguments)
+        {
+            var source = new ZipExpression(
+                node.Type,
+                pipeline.Source,
+                arguments.First());
+
+            var lambda = ExpressionHelper.GetLambda(arguments.Last());
+            var input = new DocumentExpression(bindingContext.GetSerializer(typeof(object[]), null));
+
+            var itemA = new ArrayIndexExpression(
+                input,
+                Expression.Constant(0),
+                bindingContext.GetSerializer(lambda.Parameters[0].Type, source.Source));
+            var itemB = new ArrayIndexExpression(
+                input,
+                Expression.Constant(1),
+                bindingContext.GetSerializer(lambda.Parameters[1].Type, source.Other));
+
+            bindingContext.AddExpressionMapping(lambda.Parameters[0], itemA);
+            bindingContext.AddExpressionMapping(lambda.Parameters[1], itemB);
+
+            var selector = bindingContext.Bind(lambda.Body);
+
+            var serializer = bindingContext.GetSerializer(selector.Type, selector);
+
+            return new PipelineExpression(
+                new SelectExpression(
+                    source,
+                    lambda.Parameters[0].Name + "_" + lambda.Parameters[1].Name,
+                    selector),
+                new DocumentExpression(serializer));
+        }
+    }
+}

src/MongoDB.Driver/Linq/Translators/AggregateLanguageTranslator.cs

@@ -133,6 +133,8 @@ private BsonValue TranslateValue(Expression node)
                                 return TranslateUnion((UnionExpression)node);
                             case ExtensionExpressionType.Where:
                                 return TranslateWhere((WhereExpression)node);
+                            case ExtensionExpressionType.Zip:
+                                return TranslateZip((ZipExpression)node);
                         }
                     }
                     break;
@@ -553,6 +555,13 @@ private BsonValue TranslateWhere(WhereExpression node)
             });
         }
 
+        private BsonValue TranslateZip(ZipExpression node)
+        {
+            var inputs = new[] { TranslateValue(node.Source), TranslateValue(node.Other) };
+
+            return new BsonDocument("$zip", new BsonDocument("inputs", new BsonArray(inputs)));
+        }
+
         private bool TryTranslateAvgResultOperator(PipelineExpression node, out BsonValue result)
         {
             var resultOperator = node.ResultOperator as AverageResultOperator;

src/MongoDB.Driver/MongoDB.Driver.csproj

@@ -124,6 +124,7 @@
     <Compile Include="Linq\Expressions\IntersectExpression.cs" />
     <Compile Include="Linq\Expressions\SampleExpression.cs" />
     <Compile Include="Linq\Expressions\ReverseExpression.cs" />
+    <Compile Include="Linq\Expressions\ZipExpression.cs" />
     <Compile Include="Linq\Expressions\UnionExpression.cs" />
     <Compile Include="Linq\Expressions\WhereExpression.cs" />
     <Compile Include="Linq\Expressions\ISerializationExpression.cs" />
@@ -167,6 +168,7 @@
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\TakeBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ToHashSetBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ReverseBinder.cs" />
+    <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ZipBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\UnionBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\IntersectBinder.cs" />
     <Compile Include="Linq\Processors\EmbeddedPipeline\MethodCallBinders\ExceptBinder.cs" />
@@ -453,4 +455,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

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

@@ -1335,6 +1335,34 @@ public void Should_translate_year()
             result.Value.Result.Should().Be(2012);
         }
 
+        [SkippableFact]
+        public void Should_translate_zip_with_operation()
+        {
+            RequireServer.Where(minimumVersion: "3.3.4");
+
+            var result = Project(x => new { Result = x.M.Zip(x.O, (a, b) => a + b) });
+
+            result.Projection.Should().Be("{ Result: { \"$map\": { input: { \"$zip\": { inputs: [\"$M\", \"$O\"] } }, as: \"a_b\", in: { $add: [{ $arrayElemAt: [\"$$a_b\", 0] }, { $arrayElemAt: [\"$$a_b\", 1] }] } } }, _id: 0 }");
+
+            result.Value.Result.Should().BeEquivalentTo(12L, 24L, 35L);
+        }
+
+        [SkippableFact]
+        public void Should_translate_zip_with_anonymous_type()
+        {
+            RequireServer.Where(minimumVersion: "3.3.4");
+
+            var result = Project(x => new { Result = x.M.Zip(x.O, (a, b) => new { a, b }) });
+
+            result.Projection.Should().Be("{ Result: { \"$map\": { input: { \"$zip\": { inputs: [\"$M\", \"$O\"] } }, as: \"a_b\", in: { a: { $arrayElemAt: [\"$$a_b\", 0] }, b: { $arrayElemAt: [\"$$a_b\", 1] } } } }, _id: 0 }");
+
+            var aResults = result.Value.Result.Select(x => x.a);
+            var bResults = result.Value.Result.Select(x => x.b);
+
+            aResults.Should().BeEquivalentTo(2, 4, 5);
+            bResults.Should().BeEquivalentTo(10L, 20L, 30L);
+        }
+
         [Fact]
         public void Should_translate_array_projection()
         {