[SPARK-52046][SQL] Prettify OuterReference on AggregateExpression names when using toPrettySQL

### What changes were proposed in this pull request?
In this PR I propose that we remove backticks, qualifiers from `OuterReference` over `AggregateExpression` when creating name. In other words, name for `column` which is an outer reference would be `outer(min(column))` instead of `outer('min(col)')`.
We also introduce a flag to guard the behavior as it changes the schema of some specific `LATERAL JOIN` queries.

### Why are the changes needed?
To ease development of single-pass analyzer and improve names in fixed-point implementation.

### Does this PR introduce _any_ user-facing change?
Schema changes in a way that `OuterReference` over `AggregateExpression` name doesn't contain backticks and qualifiers.

### How was this patch tested?
Existing tests.

### Was this patch authored or co-authored using generative AI tooling?
No.

Closes apache#50836 from mihailoale-db/prettifyouterrefname.

Authored-by: mihailoale-db <[email protected]>
Signed-off-by: Wenchen Fan <[email protected]>

Author: mihailoale-db

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

@@ -27,11 +27,12 @@ import org.apache.spark.internal.Logging
 import org.apache.spark.sql.catalyst.expressions._
 import org.apache.spark.sql.catalyst.expressions.aggregate.AggregateExpression
 import org.apache.spark.sql.connector.catalog.MetadataColumn
+import org.apache.spark.sql.internal.SQLConf
 import org.apache.spark.sql.types.{MetadataBuilder, NumericType, StringType, StructType}
 import org.apache.spark.unsafe.types.UTF8String
 import org.apache.spark.util.{SparkErrorUtils, Utils}
 
-package object util extends Logging {
+package object util extends Logging with SQLConfHelper {
 
   /** Silences output to stderr or stdout for the duration of f */
   def quietly[A](f: => A): A = {
@@ -103,13 +104,27 @@ package object util extends Logging {
   private def usePrettyExpression(e: Expression, stripOuterReference: Boolean = true): Expression =
     e transform {
       case aggregateExpression: AggregateExpression
-        if stripOuterReference && SubExprUtils.containsOuter(aggregateExpression) =>
+        if stripOuterReference && conf.getConf(
+          SQLConf.PRETTY_ALIAS_NAME_FOR_CORRELATED_AGGREGATE_FUNCTION
+        ) && SubExprUtils.containsOuter(aggregateExpression) =>
         val strippedAggregateExpression = SubExprUtils.stripOuterReference(aggregateExpression)
         OuterReference(
           new PrettyAttribute(
             Alias(
               strippedAggregateExpression,
-              toPrettySQL(strippedAggregateExpression)
+              toPrettySQL(strippedAggregateExpression, stripOuterReference)
+            )().toAttribute
+          )
+        )
+      case _ @ OuterReference(aggregateExpression: AggregateExpression)
+        if conf.getConf(
+          SQLConf.PRETTY_ALIAS_NAME_FOR_CORRELATED_AGGREGATE_FUNCTION
+        ) =>
+        OuterReference(
+          new PrettyAttribute(
+            Alias(
+              aggregateExpression,
+              toPrettySQL(aggregateExpression, stripOuterReference)
             )().toAttribute
           )
         )
@@ -119,16 +134,24 @@ package object util extends Logging {
       case Literal(null, dataType) => PrettyAttribute("NULL", dataType)
       case e: GetStructField =>
         val name = e.name.getOrElse(e.childSchema(e.ordinal).name)
-        PrettyAttribute(usePrettyExpression(e.child).sql + "." + name, e.dataType)
+        PrettyAttribute(
+          usePrettyExpression(e.child, stripOuterReference).sql + "." + name,
+          e.dataType
+        )
       case e: GetArrayStructFields =>
-        PrettyAttribute(s"${usePrettyExpression(e.child)}.${e.field.name}", e.dataType)
+        PrettyAttribute(
+          s"${usePrettyExpression(e.child, stripOuterReference)}.${e.field.name}",
+          e.dataType
+        )
       case r: InheritAnalysisRules =>
         PrettyAttribute(
-          r.makeSQLString(r.parameters.map(parameter => toPrettySQL(parameter))),
+          r.makeSQLString(
+            r.parameters.map(parameter => toPrettySQL(parameter, stripOuterReference))
+          ),
           r.dataType
         )
       case c: Cast if c.getTagValue(Cast.USER_SPECIFIED_CAST).isEmpty =>
-        PrettyAttribute(usePrettyExpression(c.child).sql, c.dataType)
+        PrettyAttribute(usePrettyExpression(c.child, stripOuterReference).sql, c.dataType)
       case p: PythonFuncExpression => PrettyPythonUDF(p.name, p.dataType, p.children)
     }
 

sql/catalyst/src/main/scala/org/apache/spark/sql/internal/SQLConf.scala

@@ -5818,6 +5818,14 @@ object SQLConf {
       .booleanConf
       .createWithDefault(true)
 
+  val PRETTY_ALIAS_NAME_FOR_CORRELATED_AGGREGATE_FUNCTION =
+    buildConf("spark.sql.prettyAliasNameForCorrelatedAggFunc.enabled")
+      .internal()
+      .doc("When true, use prettified name for correlated aggregate functions.")
+      .version("4.1.0")
+      .booleanConf
+      .createWithDefault(true)
+
   /**
    * Holds information about keys that have been deprecated.
    *