peter-toth commented on a change in pull request #32298: URL: https://github.com/apache/spark/pull/32298#discussion_r627659518
########## File path: sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/MergeScalarSubqueries.scala ########## @@ -0,0 +1,184 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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. + */ + +package org.apache.spark.sql.catalyst.optimizer + +import scala.collection.mutable.ArrayBuffer + +import org.apache.spark.sql.catalyst.expressions._ +import org.apache.spark.sql.catalyst.plans.logical.{Aggregate, LeafNode, LogicalPlan, Project} +import org.apache.spark.sql.catalyst.rules.Rule +import org.apache.spark.sql.catalyst.trees.TreePattern.{MULTI_SCALAR_SUBQUERY, SCALAR_SUBQUERY} + +/** + * This rule tries to merge multiple non-correlated [[ScalarSubquery]]s into a + * [[MultiScalarSubquery]] to compute multiple scalar values once. + * + * The process is the following: + * - While traversing through the plan each [[ScalarSubquery]] plan is tried to merge into the cache + * of already seen subquery plans. If merge is possible then cache is updated with the merged + * subquery plan, if not then the new subquery plan is added to the cache. + * - The original [[ScalarSubquery]] expression is replaced to a reference pointing to its cached + * version in this form: `GetStructField(MultiScalarSubquery(SubqueryReference(...)))`. + * - A second traversal checks if a [[SubqueryReference]] is pointing to a subquery plan that + * returns multiple values and either replaces only [[SubqueryReference]] to the cached plan or + * restores the whole expression to its original [[ScalarSubquery]] form. + * - [[ReuseSubquery]] rule makes sure that merged subqueries are computed once. + * + * Eg. the following query: + * + * SELECT + * (SELECT avg(a) FROM t GROUP BY b), + * (SELECT sum(b) FROM t GROUP BY b) + * + * is optimized from: + * + * Project [scalar-subquery#231 [] AS scalarsubquery()#241, + * scalar-subquery#232 [] AS scalarsubquery()#242L] + * : :- Aggregate [b#234], [avg(a#233) AS avg(a)#236] + * : : +- Relation default.t[a#233,b#234] parquet + * : +- Aggregate [b#240], [sum(b#240) AS sum(b)#238L] + * : +- Project [b#240] + * : +- Relation default.t[a#239,b#240] parquet Review comment: I think that is smart rewrite way but let's check a more complex example: E.g. can we rewrite ``` SELECT * FROM r JOIN r2 ON r2.x = r.x WHERE r.y = (SELECT sum(b) FROM t) AND r2.y = (SELECT avg(b) FROM t) ``` ? Maybe ``` SELECT * FROM ( SELECT ( SELECT STRUCT(sum(b) AS sum_b, avg(b) AS avg_b) FROM t) AS st, x, y FROM r ) AS r ) JOIN r2 ON r2.x = r.x WHERE r.y = r.st.sum_b AND r2.y = r.st.avg_b ``` ? Does this work with outer joins? And isn't this more complex than the reuse way in this PR? I was also thinking about "whole plan subquery merge" (similar to my "whole plan reuse" suggestion: https://github.com/apache/spark/pull/28885) where subqueries at "different level" could be merged (and reused) as a possible improvement to this PR in the future. BTW, the `ReuseExchangeAndSubquery` rule you mentioned is suggested in my "whole plan reuse" PR, which got stuck a bit due to lack of reviews. Do you also have a similar rule in production or you just saw my PR? If you have some time, any feedback is appreciated there as well. :) I didn't check how correlated subqueries could benefit from rewriting the query (this PR focuses on uncorrelated ones), but I think at this point in the optimizer those have been transformed to joins. Can you please elaborate on the "reading from tables v.s. reading from an array column" part? -- 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. For queries about this service, please contact Infrastructure at: [email protected] --------------------------------------------------------------------- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
