Rename Cross/Outer Apply to Inner/Left Join Lateral

To match with SQL standard
dotnet · Aug 12, 2019 · b09483b · b09483b
1 parent 8273469
commit b09483b
Show file tree

Hide file tree

Showing 8 changed files with 56 additions and 41 deletions.
diff --git a/src/EFCore.Relational/Query/QuerySqlGenerator.cs b/src/EFCore.Relational/Query/QuerySqlGenerator.cs
@@ -706,20 +706,20 @@ protected override Expression VisitCrossJoin(CrossJoinExpression crossJoinExpres
             return crossJoinExpression;
         }
 
-        protected override Expression VisitCrossApply(CrossApplyExpression crossApplyExpression)
+        protected override Expression VisitInnerJoinLateral(InnerJoinLateralExpression innerJoinLateralExpression)
         {
-            _relationalCommandBuilder.Append("CROSS APPLY ");
-            Visit(crossApplyExpression.Table);
+            _relationalCommandBuilder.Append("INNER JOIN LATERAL ");
+            Visit(innerJoinLateralExpression.Table);
 
-            return crossApplyExpression;
+            return innerJoinLateralExpression;
         }
 
-        protected override Expression VisitOuterApply(OuterApplyExpression outerApplyExpression)
+        protected override Expression VisitLeftJoinLateral(LeftJoinLateralExpression leftJoinLateralExpression)
         {
-            _relationalCommandBuilder.Append("OUTER APPLY ");
-            Visit(outerApplyExpression.Table);
+            _relationalCommandBuilder.Append("LEFT JOIN LATERAL ");
+            Visit(leftJoinLateralExpression.Table);
 
-            return outerApplyExpression;
+            return leftJoinLateralExpression;
         }
 
         protected override Expression VisitInnerJoin(InnerJoinExpression innerJoinExpression)

diff --git a/src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs b/src/EFCore.Relational/Query/RelationalQueryableMethodTranslatingExpressionVisitor.cs
@@ -744,13 +744,13 @@ protected override ShapedQueryExpression TranslateSelectMany(
                     var innerShaperExpression = inner.ShaperExpression;
                     if (defaultIfEmpty)
                     {
-                        ((SelectExpression)source.QueryExpression).AddOuterApply(
+                        ((SelectExpression)source.QueryExpression).AddLeftJoinLateral(
                             (SelectExpression)inner.QueryExpression, transparentIdentifierType);
                         innerShaperExpression = MarkShaperNullable(innerShaperExpression);
                     }
                     else
                     {
-                        ((SelectExpression)source.QueryExpression).AddCrossApply(
+                        ((SelectExpression)source.QueryExpression).AddInnerJoinLateral(
                            (SelectExpression)inner.QueryExpression, transparentIdentifierType);
                     }
 

diff --git a/src/EFCore.Relational/Query/SqlExpressionVisitor.cs b/src/EFCore.Relational/Query/SqlExpressionVisitor.cs
@@ -22,11 +22,11 @@ protected override Expression VisitExtension(Expression extensionExpression)
                 case CrossJoinExpression crossJoinExpression:
                     return VisitCrossJoin(crossJoinExpression);
 
-                case CrossApplyExpression crossApplyExpression:
-                    return VisitCrossApply(crossApplyExpression);
+                case InnerJoinLateralExpression innerJoinLateralExpression:
+                    return VisitInnerJoinLateral(innerJoinLateralExpression);
 
-                case OuterApplyExpression outerApplyExpression:
-                    return VisitOuterApply(outerApplyExpression);
+                case LeftJoinLateralExpression leftJoinLateralExpression:
+                    return VisitLeftJoinLateral(leftJoinLateralExpression);
 
                 case ExistsExpression existsExpression:
                     return VisitExists(existsExpression);
@@ -86,8 +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 VisitInnerJoinLateral(InnerJoinLateralExpression innerJoinLateralExpression);
+        protected abstract Expression VisitLeftJoinLateral(LeftJoinLateralExpression leftJoinLateralExpression);
         protected abstract Expression VisitFromSql(FromSqlExpression fromSqlExpression);
         protected abstract Expression VisitInnerJoin(InnerJoinExpression innerJoinExpression);
         protected abstract Expression VisitLeftJoin(LeftJoinExpression leftJoinExpression);

diff --git a/src/EFCore.Relational/Query/SqlExpressions/CrossApplyExpression.cs b/src/EFCore.Relational/Query/SqlExpressions/CrossApplyExpression.cs
@@ -1,40 +1,39 @@
 // 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 class InnerJoinLateralExpression : JoinExpressionBase
     {
-        public CrossApplyExpression(TableExpressionBase table)
+        public InnerJoinLateralExpression(TableExpressionBase table)
             : base(table)
         {
         }
 
         protected override Expression VisitChildren(ExpressionVisitor visitor)
             => Update((TableExpressionBase)visitor.Visit(Table));
 
-        public virtual CrossApplyExpression Update(TableExpressionBase table)
+        public virtual InnerJoinLateralExpression Update(TableExpressionBase table)
             => table != Table
-                ? new CrossApplyExpression(table)
+                ? new InnerJoinLateralExpression(table)
                 : this;
 
         public override void Print(ExpressionPrinter expressionPrinter)
         {
-            expressionPrinter.StringBuilder.Append("CROSS APPLY ");
+            expressionPrinter.StringBuilder.Append("INNER JOIN LATERAL ");
             expressionPrinter.Visit(Table);
         }
 
         public override bool Equals(object obj)
             => obj != null
             && (ReferenceEquals(this, obj)
-                || obj is CrossApplyExpression crossApplyExpression
-                    && Equals(crossApplyExpression));
+                || obj is InnerJoinLateralExpression innerJoinLateralExpression
+                    && Equals(innerJoinLateralExpression));
 
-        private bool Equals(CrossApplyExpression crossApplyExpression)
-            => base.Equals(crossApplyExpression);
+        private bool Equals(InnerJoinLateralExpression innerJoinLateralExpression)
+            => base.Equals(innerJoinLateralExpression);
 
         public override int GetHashCode() => base.GetHashCode();
     }

diff --git a/src/EFCore.Relational/Query/SqlExpressions/OuterApplyExpression.cs b/src/EFCore.Relational/Query/SqlExpressions/OuterApplyExpression.cs
@@ -5,35 +5,35 @@
 
 namespace Microsoft.EntityFrameworkCore.Query.SqlExpressions
 {
-    public class OuterApplyExpression : JoinExpressionBase
+    public class LeftJoinLateralExpression : JoinExpressionBase
     {
-        public OuterApplyExpression(TableExpressionBase table)
+        public LeftJoinLateralExpression(TableExpressionBase table)
             : base(table)
         {
         }
 
         protected override Expression VisitChildren(ExpressionVisitor visitor)
             => Update((TableExpressionBase)visitor.Visit(Table));
 
-        public virtual OuterApplyExpression Update(TableExpressionBase table)
+        public virtual LeftJoinLateralExpression Update(TableExpressionBase table)
             => table != Table
-                ? new OuterApplyExpression(table)
+                ? new LeftJoinLateralExpression(table)
                 : this;
 
         public override void Print(ExpressionPrinter expressionPrinter)
         {
-            expressionPrinter.StringBuilder.Append("OUTER APPLY ");
+            expressionPrinter.StringBuilder.Append("LEFT JOIN LATERAL ");
             expressionPrinter.Visit(Table);
         }
 
         public override bool Equals(object obj)
             => obj != null
             && (ReferenceEquals(this, obj)
-                || obj is OuterApplyExpression outerApplyExpression
-                    && Equals(outerApplyExpression));
+                || obj is LeftJoinLateralExpression leftJoinLateralExpression
+                    && Equals(leftJoinLateralExpression));
 
-        private bool Equals(OuterApplyExpression outerApplyExpression)
-            => base.Equals(outerApplyExpression);
+        private bool Equals(LeftJoinLateralExpression leftJoinLateralExpression)
+            => base.Equals(leftJoinLateralExpression);
 
         public override int GetHashCode() => base.GetHashCode();
     }

diff --git a/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs b/src/EFCore.Relational/Query/SqlExpressions/SelectExpression.cs
@@ -1093,7 +1093,7 @@ public void AddCrossJoin(SelectExpression innerSelectExpression, Type transparen
             _projectionMapping = projectionMapping;
         }
 
-        public void AddCrossApply(SelectExpression innerSelectExpression, Type transparentIdentifierType)
+        public void AddInnerJoinLateral(SelectExpression innerSelectExpression, Type transparentIdentifierType)
         {
             var joinPredicate = TryExtractJoinKey(innerSelectExpression);
             if (joinPredicate != null)
@@ -1121,7 +1121,7 @@ public void AddCrossApply(SelectExpression innerSelectExpression, Type transpare
             }
 
             _identifier.AddRange(innerSelectExpression._identifier);
-            var joinTable = new CrossApplyExpression(innerSelectExpression.Tables.Single());
+            var joinTable = new InnerJoinLateralExpression(innerSelectExpression.Tables.Single());
             _tables.Add(joinTable);
 
             var outerMemberInfo = transparentIdentifierType.GetTypeInfo().GetDeclaredField("Outer");
@@ -1140,7 +1140,7 @@ public void AddCrossApply(SelectExpression innerSelectExpression, Type transpare
             _projectionMapping = projectionMapping;
         }
 
-        public void AddOuterApply(SelectExpression innerSelectExpression, Type transparentIdentifierType)
+        public void AddLeftJoinLateral(SelectExpression innerSelectExpression, Type transparentIdentifierType)
         {
             var joinPredicate = TryExtractJoinKey(innerSelectExpression);
             if (joinPredicate != null)
@@ -1168,7 +1168,7 @@ public void AddOuterApply(SelectExpression innerSelectExpression, Type transpare
             }
 
             _identifier.AddRange(innerSelectExpression._identifier);
-            var joinTable = new OuterApplyExpression(innerSelectExpression.Tables.Single());
+            var joinTable = new LeftJoinLateralExpression(innerSelectExpression.Tables.Single());
             _tables.Add(joinTable);
 
             var outerMemberInfo = transparentIdentifierType.GetTypeInfo().GetDeclaredField("Outer");

diff --git a/src/EFCore.SqlServer/Query/Internal/SearchConditionConvertingExpressionVisitor.cs b/src/EFCore.SqlServer/Query/Internal/SearchConditionConvertingExpressionVisitor.cs
@@ -317,7 +317,7 @@ protected override Expression VisitCrossJoin(CrossJoinExpression crossJoinExpres
             return crossJoinExpression.Update(table);
         }
 
-        protected override Expression VisitCrossApply(CrossApplyExpression crossApplyExpression)
+        protected override Expression VisitInnerJoinLateral(InnerJoinLateralExpression crossApplyExpression)
         {
             var parentSearchCondition = _isSearchCondition;
             _isSearchCondition = false;
@@ -327,7 +327,7 @@ protected override Expression VisitCrossApply(CrossApplyExpression crossApplyExp
             return crossApplyExpression.Update(table);
         }
 
-        protected override Expression VisitOuterApply(OuterApplyExpression outerApplyExpression)
+        protected override Expression VisitLeftJoinLateral(LeftJoinLateralExpression outerApplyExpression)
         {
             var parentSearchCondition = _isSearchCondition;
             _isSearchCondition = false;

diff --git a/src/EFCore.SqlServer/Query/Internal/SqlServerQuerySqlGenerator.cs b/src/EFCore.SqlServer/Query/Internal/SqlServerQuerySqlGenerator.cs
@@ -67,5 +67,21 @@ protected override Expression VisitSqlFunction(SqlFunctionExpression sqlFunction
 
             return base.VisitSqlFunction(sqlFunctionExpression);
         }
+
+        protected override Expression VisitInnerJoinLateral(InnerJoinLateralExpression innerJoinLateralExpression)
+        {
+            Sql.Append("CROSS APPLY ");
+            Visit(innerJoinLateralExpression.Table);
+
+            return innerJoinLateralExpression;
+        }
+
+        protected override Expression VisitLeftJoinLateral(LeftJoinLateralExpression leftJoinLateralExpression)
+        {
+            Sql.Append("OUTER APPLY ");
+            Visit(leftJoinLateralExpression.Table);
+
+            return leftJoinLateralExpression;
+        }
     }
 }