[SPARK-40618][SQL] Fix bug in MergeScalarSubqueries rule with nested subqueries

### What changes were proposed in this pull request?

There is a bug in the `MergeScalarSubqueries` rule for queries with subquery expressions nested inside each other, wherein the rule attempts to merge the nested subquery with its enclosing parent subquery. The result is not a valid plan and raises an exception in the optimizer. Here is a minimal reproducing case:

```
sql("create table test(col int) using csv")
checkAnswer(sql("select(select sum((select sum(col) from test)) from test)"), Row(null))
```

To fix, we disable the optimization for subqueries with nested subqueries inside them for now.

### Why are the changes needed?

This fixes a bug.

### Does this PR introduce _any_ user-facing change?

No.

### How was this patch tested?

Updated existing unit tests and added the reproducing case as a new test case.

Closes apache#38052 from dtenedor/fix-merge-subquery-bug.

Authored-by: Daniel Tenedorio <daniel.tenedorio@databricks.com>
Signed-off-by: Gengliang Wang <gengliang@apache.org>

Author: dtenedor

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/MergeScalarSubqueries.scala

@@ -210,6 +210,12 @@ object MergeScalarSubqueries extends Rule[LogicalPlan] {
       cachedPlan: LogicalPlan): Option[(LogicalPlan, AttributeMap[Attribute])] = {
     checkIdenticalPlans(newPlan, cachedPlan).map(cachedPlan -> _).orElse(
       (newPlan, cachedPlan) match {
+        case (_, _) if newPlan.containsPattern(SCALAR_SUBQUERY_REFERENCE) ||
+          cachedPlan.containsPattern(SCALAR_SUBQUERY_REFERENCE) =>
+          // Subquery expressions with nested subquery expressions within are not supported for now.
+          // TODO: support this optimization by collecting the transitive subquery references in the
+          // new plan and recording them in order to suppress merging the new plan into those.
+          None
         case (np: Project, cp: Project) =>
           tryMergePlans(np.child, cp.child).map { case (mergedChild, outputMap) =>
             val (mergedProjectList, newOutputMap) =

sql/core/src/test/scala/org/apache/spark/sql/SubquerySuite.scala

@@ -2157,7 +2157,7 @@ class SubquerySuite extends QueryTest
     }
   }
 
-  test("Merge non-correlated scalar subqueries from different parent plans") {
+  test("SPARK-40618: Do not merge scalar subqueries with nested subqueries inside") {
     Seq(false, true).foreach { enableAQE =>
       withSQLConf(
         SQLConf.ADAPTIVE_EXECUTION_ENABLED.key -> enableAQE.toString) {
@@ -2189,12 +2189,12 @@ class SubquerySuite extends QueryTest
         }
 
         if (enableAQE) {
-          assert(subqueryIds.size == 3, "Missing or unexpected SubqueryExec in the plan")
-          assert(reusedSubqueryIds.size == 3,
+          assert(subqueryIds.size == 4, "Missing or unexpected SubqueryExec in the plan")
+          assert(reusedSubqueryIds.size == 2,
             "Missing or unexpected reused ReusedSubqueryExec in the plan")
         } else {
-          assert(subqueryIds.size == 2, "Missing or unexpected SubqueryExec in the plan")
-          assert(reusedSubqueryIds.size == 4,
+          assert(subqueryIds.size == 3, "Missing or unexpected SubqueryExec in the plan")
+          assert(reusedSubqueryIds.size == 3,
             "Missing or unexpected reused ReusedSubqueryExec in the plan")
         }
       }
@@ -2327,4 +2327,14 @@ class SubquerySuite extends QueryTest
       assert(findProject(df2).size == 3)
     }
   }
+
+  test("SPARK-40618: Regression test for merging subquery bug with nested subqueries") {
+    // This test contains a subquery expression with another subquery expression nested inside.
+    // It acts as a regression test to ensure that the MergeScalarSubqueries rule does not attempt
+    // to merge them together.
+    withTable("t") {
+      sql("create table t(col int) using csv")
+      checkAnswer(sql("select(select sum((select sum(col) from t)) from t)"), Row(null))
+    }
+  }
 }