Relational: Translate SelectMany

SelectMany in linq look something like following (second clause is considered the collection selector)
```C#
from c in cs
from o in c.Orders
select....
```
Following are the translations of SelectMany

Unrelated collection selector
```C#
from c in cs
from o in os
```
Generates CROSS JOIN

Correlated collection selector with correlation being a predicate
```C#
from c in cs
from o in os.Where(o => o.CustomerID == c.CustomerID)
```
Such predicate can be lifted and used in generating a join. So this query generates JOIN.
If collection selector ends with DefaultIfEmpty then it is LEFT JOIN.

Correlated collection selector with correlation not a predicate
```C#
from c in cs
from o in os.Select(o => c.City)
```
Since we cannot generate a join predicate here, this translates to CROSS APPLY.
If collection selector ends with DefaultIfEmpty then it is OUTER APPLY.

Add support for Cross Apply
Add Support for Outer Apply
Convert Cross Apply to Inner Join when possible
Convert Outer Apply to Left Join when possible
Add translation for DefaultIfEmpty
Add translation for both overloads of SelectMany
Handle DefaultIfEmpty & SelectMany without collectionSelector in Navigation Expansion
Ensure columns are in projection when generating join predicate from a correlated subquery

Currently there are no tests for Cross/Outer Apply.
Our earlier Cross Apply got converted to join. N+1 evaluation tests are disabled right now, which would generate Cross Apply.
We never supported Outer Apply in past.

Resolves #15711
Resolves #12567
Resolves #12572
Resolves #12872
Resolves #16330
Resolves #15081
Resolves #16989

Re-enable tests for #12449

src/EFCore.InMemory/Query/Internal/InMemoryExpressionTranslatingExpressionVisitor.cs

@@ -340,7 +340,7 @@ protected override Expression VisitUnary(UnaryExpression unaryExpression)
 
         [DebuggerStepThrough]
         private bool TranslationFailed(Expression original, Expression translation)
-            => original != null && translation is EntityProjectionExpression;
+            => original != null && (translation == null || translation is EntityProjectionExpression);
     }
 
 }

src/EFCore.InMemory/Query/Internal/InMemoryQueryableMethodTranslatingExpressionVisitor.cs

@@ -38,9 +38,6 @@ public InMemoryQueryableMethodTranslatingExpressionVisitor(
             _model = model;
         }
 
-        private static Type CreateTransparentIdentifierType(Type outerType, Type innerType)
-            => typeof(TransparentIdentifier<,>).MakeGenericType(outerType, innerType);
-
         public override ShapedQueryExpression TranslateSubquery(Expression expression)
         {
             return (ShapedQueryExpression)new InMemoryQueryableMethodTranslatingExpressionVisitor(
@@ -217,8 +214,7 @@ protected override ShapedQueryExpression TranslateJoin(ShapedQueryExpression out
                 outer,
                 resultSelector,
                 inner.ShaperExpression,
-                transparentIdentifierType,
-                false);
+                transparentIdentifierType);
         }
 
         protected override ShapedQueryExpression TranslateLastOrDefault(ShapedQueryExpression source, LambdaExpression predicate, Type returnType, bool returnDefault)
@@ -250,9 +246,8 @@ protected override ShapedQueryExpression TranslateLeftJoin(ShapedQueryExpression
             return TranslateResultSelectorForJoin(
                 outer,
                 resultSelector,
-                inner.ShaperExpression,
-                transparentIdentifierType,
-                true);
+                MarkShaperNullable(inner.ShaperExpression),
+                transparentIdentifierType);
         }
 
         protected override ShapedQueryExpression TranslateLongCount(ShapedQueryExpression source, LambdaExpression predicate)
@@ -360,8 +355,7 @@ protected override ShapedQueryExpression TranslateSelectMany(
                         source,
                         resultSelector,
                         inner.ShaperExpression,
-                        transparentIdentifierType,
-                        false);
+                        transparentIdentifierType);
                 }
             }
 

src/EFCore.Relational/Query/QuerySqlGenerator.cs

@@ -706,6 +706,22 @@ protected override Expression VisitCrossJoin(CrossJoinExpression crossJoinExpres
             return crossJoinExpression;
         }
 
+        protected override Expression VisitCrossApply(CrossApplyExpression crossApplyExpression)
+        {
+            _relationalCommandBuilder.Append("CROSS APPLY ");
+            Visit(crossApplyExpression.Table);
+
+            return crossApplyExpression;
+        }
+
+        protected override Expression VisitOuterApply(OuterApplyExpression outerApplyExpression)
+        {
+            _relationalCommandBuilder.Append("OUTER APPLY ");
+            Visit(outerApplyExpression.Table);
+
+            return outerApplyExpression;
+        }
+
         protected override Expression VisitInnerJoin(InnerJoinExpression innerJoinExpression)
         {
             _relationalCommandBuilder.Append("INNER JOIN ");

src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs

@@ -242,7 +242,18 @@ protected override ShapedQueryExpression TranslateCount(ShapedQueryExpression so
             return source;
         }
 
-        protected override ShapedQueryExpression TranslateDefaultIfEmpty(ShapedQueryExpression source, Expression defaultValue) => throw new NotImplementedException();
+        protected override ShapedQueryExpression TranslateDefaultIfEmpty(ShapedQueryExpression source, Expression defaultValue)
+        {
+            if (defaultValue == null)
+            {
+                ((SelectExpression)source.QueryExpression).ApplyDefaultIfEmpty(_sqlExpressionFactory);
+                source.ShaperExpression = MarkShaperNullable(source.ShaperExpression);
+
+                return source;
+            }
+
+            throw new NotImplementedException();
+        }
 
         protected override ShapedQueryExpression TranslateDistinct(ShapedQueryExpression source)
         {
@@ -459,8 +470,7 @@ protected override ShapedQueryExpression TranslateJoin(
                     outer,
                     resultSelector,
                     inner.ShaperExpression,
-                    transparentIdentifierType,
-                    false);
+                    transparentIdentifierType);
             }
 
             throw new NotImplementedException();
@@ -481,9 +491,8 @@ protected override ShapedQueryExpression TranslateLeftJoin(ShapedQueryExpression
                 return TranslateResultSelectorForJoin(
                     outer,
                     resultSelector,
-                    inner.ShaperExpression,
-                    transparentIdentifierType,
-                    true);
+                    MarkShaperNullable(inner.ShaperExpression),
+                    transparentIdentifierType);
             }
 
             throw new NotImplementedException();
@@ -710,33 +719,57 @@ protected override ShapedQueryExpression TranslateSelect(ShapedQueryExpression s
             return source;
         }
 
-        private static readonly MethodInfo _defaultIfEmptyWithoutArgMethodInfo = typeof(Enumerable).GetTypeInfo()
-            .GetDeclaredMethods(nameof(Enumerable.DefaultIfEmpty)).Single(mi => mi.GetParameters().Length == 1);
-
         protected override ShapedQueryExpression TranslateSelectMany(
             ShapedQueryExpression source, LambdaExpression collectionSelector, LambdaExpression resultSelector)
         {
-            var collectionSelectorBody = collectionSelector.Body;
-            //var defaultIfEmpty = false;
-
-            if (collectionSelectorBody is MethodCallExpression collectionEndingMethod
+            var defaultIfEmpty = false;
+            if (collectionSelector.Body is MethodCallExpression collectionEndingMethod
                 && collectionEndingMethod.Method.IsGenericMethod
-                && collectionEndingMethod.Method.GetGenericMethodDefinition() == _defaultIfEmptyWithoutArgMethodInfo)
+                && collectionEndingMethod.Method.GetGenericMethodDefinition() == QueryableMethodProvider.DefaultIfEmptyWithoutArgumentMethodInfo)
             {
-                //defaultIfEmpty = true;
-                collectionSelectorBody = collectionEndingMethod.Arguments[0];
+                defaultIfEmpty = true;
+                collectionSelector = Expression.Lambda(collectionEndingMethod.Arguments[0], collectionSelector.Parameters);
             }
 
-            var correlated = new CorrelationFindingExpressionVisitor().IsCorrelated(collectionSelectorBody, collectionSelector.Parameters[0]);
+            var correlated = new CorrelationFindingExpressionVisitor().IsCorrelated(collectionSelector);
             if (correlated)
             {
-                // TODO visit inner with outer parameter;
-                throw new NotImplementedException();
+                var collectionSelectorBody = RemapLambdaBody(source, collectionSelector);
+                if (Visit(collectionSelectorBody) is ShapedQueryExpression inner)
+                {
+                    var transparentIdentifierType = TransparentIdentifierFactory.Create(
+                        resultSelector.Parameters[0].Type,
+                        resultSelector.Parameters[1].Type);
+
+                    var innerShaperExpression = inner.ShaperExpression;
+                    if (defaultIfEmpty)
+                    {
+                        ((SelectExpression)source.QueryExpression).AddOuterApply(
+                            (SelectExpression)inner.QueryExpression, transparentIdentifierType);
+                        innerShaperExpression = MarkShaperNullable(innerShaperExpression);
+                    }
+                    else
+                    {
+                        ((SelectExpression)source.QueryExpression).AddCrossApply(
+                           (SelectExpression)inner.QueryExpression, transparentIdentifierType);
+                    }
+
+                    return TranslateResultSelectorForJoin(
+                        source,
+                        resultSelector,
+                        innerShaperExpression,
+                        transparentIdentifierType);
+                }
             }
             else
             {
-                if (Visit(collectionSelectorBody) is ShapedQueryExpression inner)
+                if (Visit(collectionSelector.Body) is ShapedQueryExpression inner)
                 {
+                    if (defaultIfEmpty)
+                    {
+                        inner = TranslateDefaultIfEmpty(inner, null);
+                    }
+
                     var transparentIdentifierType = TransparentIdentifierFactory.Create(
                         resultSelector.Parameters[0].Type,
                         resultSelector.Parameters[1].Type);
@@ -748,8 +781,7 @@ protected override ShapedQueryExpression TranslateSelectMany(
                         source,
                         resultSelector,
                         inner.ShaperExpression,
-                        transparentIdentifierType,
-                        false);
+                        transparentIdentifierType);
                 }
             }
 
@@ -760,12 +792,14 @@ private class CorrelationFindingExpressionVisitor : ExpressionVisitor
         {
             private ParameterExpression _outerParameter;
             private bool _isCorrelated;
-            public bool IsCorrelated(Expression tree, ParameterExpression outerParameter)
+
+            public bool IsCorrelated(LambdaExpression lambdaExpression)
             {
+                Debug.Assert(lambdaExpression.Parameters.Count == 1, "Multiparameter lambda passed to CorrelationFindingExpressionVisitor");
                 _isCorrelated = false;
-                _outerParameter = outerParameter;
+                _outerParameter = lambdaExpression.Parameters[0];
 
-                Visit(tree);
+                Visit(lambdaExpression.Body);
 
                 return _isCorrelated;
             }
@@ -783,7 +817,16 @@ protected override Expression VisitParameter(ParameterExpression parameterExpres
 
         protected override ShapedQueryExpression TranslateSelectMany(ShapedQueryExpression source, LambdaExpression selector)
         {
-            throw new NotImplementedException();
+            var innerParameter = Expression.Parameter(selector.ReturnType.TryGetSequenceType(), "i");
+            var resultSelector = Expression.Lambda(
+                innerParameter,
+                new[]
+                {
+                    Expression.Parameter(source.Type.TryGetSequenceType()),
+                    innerParameter
+                });
+
+            return TranslateSelectMany(source, selector, resultSelector);
         }
 
         protected override ShapedQueryExpression TranslateSingleOrDefault(ShapedQueryExpression source, LambdaExpression predicate, Type returnType, bool returnDefault)

src/EFCore.Relational/Query/SqlExpressionVisitor.cs

@@ -22,6 +22,12 @@ protected override Expression VisitExtension(Expression extensionExpression)
                 case CrossJoinExpression crossJoinExpression:
                     return VisitCrossJoin(crossJoinExpression);
 
+                case CrossApplyExpression crossApplyExpression:
+                    return VisitCrossApply(crossApplyExpression);
+
+                case OuterApplyExpression outerApplyExpression:
+                    return VisitOuterApply(outerApplyExpression);
+
                 case ExistsExpression existsExpression:
                     return VisitExists(existsExpression);
 
@@ -80,6 +86,8 @@ protected override Expression VisitExtension(Expression extensionExpression)
         protected abstract Expression VisitExists(ExistsExpression existsExpression);
         protected abstract Expression VisitIn(InExpression inExpression);
         protected abstract Expression VisitCrossJoin(CrossJoinExpression crossJoinExpression);
+        protected abstract Expression VisitCrossApply(CrossApplyExpression crossApplyExpression);
+        protected abstract Expression VisitOuterApply(OuterApplyExpression outerApplyExpression);
         protected abstract Expression VisitFromSql(FromSqlExpression fromSqlExpression);
         protected abstract Expression VisitInnerJoin(InnerJoinExpression innerJoinExpression);
         protected abstract Expression VisitLeftJoin(LeftJoinExpression leftJoinExpression);

src/EFCore.Relational/Query/SqlExpressions/CrossApplyExpression.cs

@@ -0,0 +1,41 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Linq.Expressions;
+
+namespace Microsoft.EntityFrameworkCore.Query.SqlExpressions
+{
+    public class CrossApplyExpression : JoinExpressionBase
+    {
+        public CrossApplyExpression(TableExpressionBase table)
+            : base(table)
+        {
+        }
+
+        protected override Expression VisitChildren(ExpressionVisitor visitor)
+            => Update((TableExpressionBase)visitor.Visit(Table));
+
+        public virtual CrossApplyExpression Update(TableExpressionBase table)
+            => table != Table
+                ? new CrossApplyExpression(table)
+                : this;
+
+        public override void Print(ExpressionPrinter expressionPrinter)
+        {
+            expressionPrinter.StringBuilder.Append("CROSS APPLY ");
+            expressionPrinter.Visit(Table);
+        }
+
+        public override bool Equals(object obj)
+            => obj != null
+            && (ReferenceEquals(this, obj)
+                || obj is CrossApplyExpression crossApplyExpression
+                    && Equals(crossApplyExpression));
+
+        private bool Equals(CrossApplyExpression crossApplyExpression)
+            => base.Equals(crossApplyExpression);
+
+        public override int GetHashCode() => base.GetHashCode();
+    }
+}

src/EFCore.Relational/Query/SqlExpressions/OuterApplyExpression.cs

@@ -0,0 +1,40 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Linq.Expressions;
+
+namespace Microsoft.EntityFrameworkCore.Query.SqlExpressions
+{
+    public class OuterApplyExpression : JoinExpressionBase
+    {
+        public OuterApplyExpression(TableExpressionBase table)
+            : base(table)
+        {
+        }
+
+        protected override Expression VisitChildren(ExpressionVisitor visitor)
+            => Update((TableExpressionBase)visitor.Visit(Table));
+
+        public virtual OuterApplyExpression Update(TableExpressionBase table)
+            => table != Table
+                ? new OuterApplyExpression(table)
+                : this;
+
+        public override void Print(ExpressionPrinter expressionPrinter)
+        {
+            expressionPrinter.StringBuilder.Append("OUTER APPLY ");
+            expressionPrinter.Visit(Table);
+        }
+
+        public override bool Equals(object obj)
+            => obj != null
+            && (ReferenceEquals(this, obj)
+                || obj is OuterApplyExpression outerApplyExpression
+                    && Equals(outerApplyExpression));
+
+        private bool Equals(OuterApplyExpression outerApplyExpression)
+            => base.Equals(outerApplyExpression);
+
+        public override int GetHashCode() => base.GetHashCode();
+    }
+}