matvei-zamiatin-db commented on code in PR #58119:
URL: https://github.com/apache/spark/pull/58119#discussion_r3872696535


##########
sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/RewriteWithExpression.scala:
##########
@@ -66,6 +66,34 @@ object RewriteWithExpression extends Rule[LogicalPlan] {
     }
   }
 
+  /**
+   * Rewrites the `With` expressions in a single expression tree by inlining 
their common
+   * expressions. Uses `transformUp` to handle nested `With`. Inlining 
duplicates a definition at
+   * every reference, so this rejects non-foldable definitions: inlining one 
referenced more than
+   * once would evaluate it more than once, breaking `With`'s evaluate-once 
contract.
+   *
+   * Does not descend into subquery plans (e.g. `ScalarSubquery`). A caller 
whose expression
+   * may contain a subquery must rewrite those plans separately.
+   */
+  def applyForExpression(expression: Expression): Expression =

Review Comment:
   Yes, replaced on every `applyForExpression`



##########
sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/RewriteWithExpression.scala:
##########
@@ -66,6 +66,34 @@ object RewriteWithExpression extends Rule[LogicalPlan] {
     }
   }
 
+  /**
+   * Rewrites the `With` expressions in a single expression tree by inlining 
their common
+   * expressions. Uses `transformUp` to handle nested `With`. Inlining 
duplicates a definition at
+   * every reference, so this rejects non-foldable definitions: inlining one 
referenced more than
+   * once would evaluate it more than once, breaking `With`'s evaluate-once 
contract.
+   *
+   * Does not descend into subquery plans (e.g. `ScalarSubquery`). A caller 
whose expression
+   * may contain a subquery must rewrite those plans separately.
+   */
+  def applyForExpression(expression: Expression): Expression =
+    inlineWith(expression, rejectNonFoldableDefs = true)
+
+  // The plan-level rewrite shares this to inline `With` in conditional 
branches, which may not be
+  // evaluated and so can't be pulled into a Project; it passes false to allow 
non-foldable defs.
+  private def inlineWith(expression: Expression, rejectNonFoldableDefs: 
Boolean): Expression = {
+    expression.transformUpWithPruning(_.containsPattern(WITH_EXPRESSION)) {

Review Comment:
   For this case we need to do two traversals to understand which defs are some 
combination of literals, because With is resolved bottom up and defs deciding 
is top down. Added `isPureLiteralTree` which check if expr is some combination 
of literals and top down traversal to memorize ids that are safe to inline



##########
sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/RewriteWithExpression.scala:
##########
@@ -66,6 +66,34 @@ object RewriteWithExpression extends Rule[LogicalPlan] {
     }
   }
 
+  /**
+   * Rewrites the `With` expressions in a single expression tree by inlining 
their common
+   * expressions. Uses `transformUp` to handle nested `With`. Inlining 
duplicates a definition at
+   * every reference, so this rejects non-foldable definitions: inlining one 
referenced more than
+   * once would evaluate it more than once, breaking `With`'s evaluate-once 
contract.
+   *
+   * Does not descend into subquery plans (e.g. `ScalarSubquery`). A caller 
whose expression
+   * may contain a subquery must rewrite those plans separately.
+   */
+  def applyForExpression(expression: Expression): Expression =
+    inlineWith(expression, rejectNonFoldableDefs = true)
+
+  // The plan-level rewrite shares this to inline `With` in conditional 
branches, which may not be
+  // evaluated and so can't be pulled into a Project; it passes false to allow 
non-foldable defs.
+  private def inlineWith(expression: Expression, rejectNonFoldableDefs: 
Boolean): Expression = {
+    expression.transformUpWithPruning(_.containsPattern(WITH_EXPRESSION)) {
+      case With(child, defs) =>
+        if (rejectNonFoldableDefs && !defs.forall(_.child.foldable)) {

Review Comment:
   Replaced with check of ref count for definition:
   - ref count <= 1 -> inline
   - ref count > 1   -> throw exception if it's not a `Literal` tree



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]


---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]

Reply via email to