CSHARP-6017: Support LINQ LeftJoin for joins and includes

Author: damieng

src/MongoDB.Driver/Linq/LeftJoinResult.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-present MongoDB Inc.
+/* 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.
@@ -20,7 +20,7 @@ namespace MongoDB.Driver.Linq
     /// </summary>
     /// <typeparam name="TOuter">The type of the outer documents.</typeparam>
     /// <typeparam name="TInner">The type of the inner documents.</typeparam>
-    public struct LeftJoinResult<TOuter, TInner>
+    public struct LeftJoinResult<TOuter, TInner> where TInner : class
     {
         /// <summary>
         /// The outer document.

src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/JoinMethodToPipelineTranslator.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-present MongoDB Inc.
+/* 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.
@@ -13,8 +13,6 @@
 * limitations under the License.
 */
 
-using System.Collections.Generic;
-using System.Linq;
 using System.Linq.Expressions;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Linq.Linq3Implementation.Ast;
@@ -61,29 +59,36 @@ public static TranslatedPipeline Translate(TranslationContext context, MethodCal
                     outerSerializer = pipeline.OutputSerializer;
                 }
 
-                if (isLeftJoin)
-                {
-                    ThrowIfReservedFieldNames(expression, outerSerializer);
-                }
-
                 var wrapOuterStage = AstStage.Project(
                     AstProject.Set("_outer", outerAst),
                     AstProject.Exclude("_id"));
                 var wrappedOuterSerializer = WrappedValueSerializer.Create("_outer", outerSerializer);
 
-                var (innerCollectionName, innerSerializer) = innerExpression.GetCollectionInfoFromQueryable(containerExpression: expression);
+                string innerCollectionName;
+                IBsonSerializer innerSerializer;
+                AstPipeline innerFilterPipeline = null;
+
+                if (innerExpression is ConstantExpression)
+                {
+                    (innerCollectionName, innerSerializer) = innerExpression.GetCollectionInfoFromQueryable(containerExpression: expression);
+                }
+                else
+                {
+                    var rootInnerExpression = GetRootQueryableExpression(innerExpression);
+                    (innerCollectionName, innerSerializer) = rootInnerExpression.GetCollectionInfoFromQueryable(containerExpression: expression);
+                    var innerTranslation = ExpressionToPipelineTranslator.Translate(context, innerExpression);
+                    innerSerializer = innerTranslation.OutputSerializer;
+                    innerFilterPipeline = innerTranslation.Ast.Stages.Count > 0 ? innerTranslation.Ast : null;
+                }
+
                 var localField = outerKeySelectorLambda.TranslateToDottedFieldName(context, wrappedOuterSerializer);
                 var foreignField = innerKeySelectorLambda.TranslateToDottedFieldName(context, innerSerializer);
 
-                var lookupStage = AstStage.Lookup(
-                    from: innerCollectionName,
-                    localField,
-                    foreignField,
-                    @as: "_inner");
+                var lookupStage = innerFilterPipeline != null
+                    ? AstStage.Lookup(innerCollectionName, localField, foreignField, [], innerFilterPipeline, "_inner")
+                    : AstStage.Lookup(from: innerCollectionName, localField, foreignField, @as: "_inner");
 
-                var unwindStage = isLeftJoin
-                    ? AstStage.Unwind("_inner", preserveNullAndEmptyArrays: true)
-                    : AstStage.Unwind("_inner");
+                var unwindStage = AstStage.Unwind("_inner", preserveNullAndEmptyArrays: isLeftJoin ? true : null);
 
                 var outerParameter = resultSelectorLambda.Parameters[0];
                 var outerField = AstExpression.GetField(AstExpression.RootVar, "_outer");
@@ -108,28 +113,11 @@ public static TranslatedPipeline Translate(TranslationContext context, MethodCal
             throw new ExpressionNotSupportedException(expression);
         }
 
-        private static readonly HashSet<string> __reservedFieldNames = new HashSet<string> { "_outer", "_inner" };
-
-        private static void ThrowIfReservedFieldNames(MethodCallExpression expression, IBsonSerializer serializer)
+        private static Expression GetRootQueryableExpression(Expression expression)
         {
-            if (serializer is not IBsonDocumentSerializer documentSerializer)
-                return;
-
-            var conflicting = new List<string>();
-            foreach (var member in serializer.ValueType.GetMembers())
-            {
-                if (documentSerializer.TryGetMemberSerializationInfo(member.Name, out var info) &&
-                    __reservedFieldNames.Contains(info.ElementName))
-                {
-                    conflicting.Add(info.ElementName);
-                }
-            }
-
-            if (conflicting.Count > 0)
-            {
-                throw new ExpressionNotSupportedException(expression,
-                    because: $"the outer document type uses reserved field name(s) {string.Join(", ", conflicting.Select(n => $"'{n}'"))} which are used internally by LeftJoin");
-            }
+            while (expression is MethodCallExpression methodCall)
+                expression = methodCall.Arguments[0];
+            return expression;
         }
     }
 }

src/MongoDB.Driver/Linq/MongoQueryable.cs

@@ -821,33 +821,6 @@ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQuer
             return Queryable.Join(outer, inner.AsQueryable(), outerKeySelector, innerKeySelector, resultSelector);
         }
 
-        /// <summary>
-        /// Correlates the elements of two sequences based on matching keys, preserving all outer elements
-        /// even when no matching inner element exists (left outer join semantics).
-        /// </summary>
-        /// <typeparam name="TOuter">The type of the elements of the first sequence.</typeparam>
-        /// <typeparam name="TInner">The type of the elements of the second sequence.</typeparam>
-        /// <typeparam name="TKey">The type of the keys returned by the key selector functions.</typeparam>
-        /// <typeparam name="TResult">The type of the result elements.</typeparam>
-        /// <param name="outer">The first sequence to join.</param>
-        /// <param name="inner">The collection to join to the first sequence.</param>
-        /// <param name="outerKeySelector">A function to extract the join key from each element of the first sequence.</param>
-        /// <param name="innerKeySelector">A function to extract the join key from each element of the second sequence.</param>
-        /// <param name="resultSelector">A function to create a result element from an outer element and a matching inner element (or null).</param>
-        /// <returns>
-        /// An <see cref="IQueryable{TResult}" /> that contains elements of type <typeparamref name="TResult" /> obtained by performing a left outer join on two sequences.
-        /// </returns>
-        public static IQueryable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IMongoCollection<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector)
-        {
-            Ensure.IsNotNull(outer, nameof(outer));
-            Ensure.IsNotNull(inner, nameof(inner));
-            Ensure.IsNotNull(outerKeySelector, nameof(outerKeySelector));
-            Ensure.IsNotNull(innerKeySelector, nameof(innerKeySelector));
-            Ensure.IsNotNull(resultSelector, nameof(resultSelector));
-
-            return LeftJoin(outer, inner.AsQueryable(), outerKeySelector, innerKeySelector, resultSelector);
-        }
-
         /// <summary>
         /// Correlates the elements of two sequences based on matching keys, preserving all outer elements
         /// even when no matching inner element exists (left outer join semantics).
@@ -860,7 +833,7 @@ public static IQueryable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(this I
         /// <param name="inner">The sequence to join to the first sequence.</param>
         /// <param name="outerKeySelector">A function to extract the join key from each element of the first sequence.</param>
         /// <param name="innerKeySelector">A function to extract the join key from each element of the second sequence.</param>
-        /// <param name="resultSelector">A function to create a result element from an outer element and a matching inner element (or null).</param>
+        /// <param name="resultSelector">A function to create a result element from an outer element and a matching inner element (or default if no match).</param>
         /// <returns>
         /// An <see cref="IQueryable{TResult}" /> that contains elements of type <typeparamref name="TResult" /> obtained by performing a left outer join on two sequences.
         /// </returns>
@@ -877,7 +850,7 @@ public static IQueryable<TResult> LeftJoin<TOuter, TInner, TKey, TResult>(this I
                     null,
                     GetMethodInfo(LeftJoin, outer, inner, outerKeySelector, innerKeySelector, resultSelector),
                     outer.Expression,
-                    Expression.Constant(inner),
+                    inner.Expression,
                     Expression.Quote(outerKeySelector),
                     Expression.Quote(innerKeySelector),
                     Expression.Quote(resultSelector)));