rename ReuseMap methods

Author: peter-toth

sql/catalyst/src/main/scala/org/apache/spark/sql/util/ReuseMap.scala

@@ -42,7 +42,7 @@ class ReuseMap[T <: QueryPlan[_]] {
    * @param plan the input plan
    * @return the matching plan or the input plan
    */
-  def lookup(plan: T): T = {
+  def lookupOrElseAdd(plan: T): T = {
     val (firstSameSchemaPlan, sameResultPlans) = map.getOrElseUpdate(plan.schema, plan -> Map())
     if (firstSameSchemaPlan ne plan) {
       if (sameResultPlans.isEmpty) {
@@ -62,8 +62,8 @@ class ReuseMap[T <: QueryPlan[_]] {
    * @param f the function to apply
    * @return the matching plan with `f` applied or the input plan
    */
-  def addOrElse[T2 >: T](plan: T, f: T => T2): T2 = {
-    val found = lookup(plan)
+  def reuseOrElseAdd[T2 >: T](plan: T, f: T => T2): T2 = {
+    val found = lookupOrElseAdd(plan)
     if (found eq plan) {
       plan
     } else {

sql/core/src/main/scala/org/apache/spark/sql/execution/reuse/ReuseExchangeAndSubquery.scala

@@ -36,14 +36,14 @@ case class ReuseExchangeAndSubquery(conf: SQLConf) extends Rule[SparkPlan] {
 
       def reuse(plan: SparkPlan): SparkPlan = plan.transformUp {
         case exchange: Exchange if conf.exchangeReuseEnabled =>
-          exchanges.addOrElse(exchange, ReusedExchangeExec(exchange.output, _))
+          exchanges.reuseOrElseAdd(exchange, ReusedExchangeExec(exchange.output, _))
 
         case other => other.transformExpressionsUp {
           case sub: ExecSubqueryExpression =>
             val subquery = reuse(sub.plan).asInstanceOf[BaseSubqueryExec]
             sub.withNewPlan(
               if (conf.subqueryReuseEnabled) {
-                subqueries.addOrElse(subquery, ReusedSubqueryExec(_))
+                subqueries.reuseOrElseAdd(subquery, ReusedSubqueryExec(_))
               } else {
                 subquery
               }