Restore Sort unparser guard for correct ORDER BY placement (apache#20658)

## Which issue does this PR close?

- closes apache#20905
- closes apache#20923

Restore the `already_projected()` guard in the Sort case of
`select_to_sql_recursively`. Without it, queries with ORDER BY
expressions generate invalid SQL when the Sort node follows an outer
Projection.

## Problem ##

Two regressions in the DuckDB federation unparser after upgrading to
DataFusion 52:

1. clickbench q25: Queries like `SELECT "SearchPhrase" ... ORDER BY
to_timestamp("EventTime") LIMIT 10` produce ORDER BY outside the
subquery, referencing table names ("hits") that are out of scope.
2. tpcds q36: ORDER BY with `GROUPING()` expressions loses the
`derived_sort` subquery alias, placing sort references outside their
valid scope.

## Root Cause ##

DF52's optimizer merges `Limit` into `Sort` as a fetch parameter,
changing the plan shape from `Projection → Limit → Sort → ...` to
`Projection → Sort(fetch) → ....` The Sort case previously had a guard
that wrapped the sort into a `derived_sort` subquery when
`already_projected()` was true. This guard was removed in DF52, causing
ORDER BY and LIMIT to be placed on the outer query where inner table
references are invalid.

## Fix ##

Re-add the guard at the top of the Sort match arm in
select_to_sql_recursively:

```rust
 if select.already_projected() {
     return self.derive_with_dialect_alias("derived_sort", plan, relation, false, vec![]);
 }
```

Author: krinart

datafusion/sql/src/unparser/plan.rs

@@ -499,6 +499,17 @@ impl Unparser<'_> {
                 )
             }
             LogicalPlan::Sort(sort) => {
+                // Sort can be top-level plan for derived table
+                if select.already_projected() {
+                    return self.derive_with_dialect_alias(
+                        "derived_sort",
+                        plan,
+                        relation,
+                        false,
+                        vec![],
+                    );
+                }
+
                 let Some(query_ref) = query else {
                     return internal_err!(
                         "Sort operator only valid in a statement context."

datafusion/sql/src/unparser/rewrite.rs

@@ -223,7 +223,15 @@ pub(super) fn rewrite_plan_for_sort_on_non_projected_fields(
 
     let mut collects = p.expr.clone();
     for sort in &sort.expr {
-        collects.push(sort.expr.clone());
+        // Strip aliases from sort expressions so the comparison matches
+        // the inner Projection's raw expressions. The optimizer may add
+        // sort expressions to the inner Projection without aliases, while
+        // the Sort node's expressions carry aliases from the original plan.
+        let mut expr = sort.expr.clone();
+        while let Expr::Alias(alias) = expr {
+            expr = *alias.expr;
+        }
+        collects.push(expr);
     }
 
     // Compare outer collects Expr::to_string with inner collected transformed values

datafusion/sql/tests/cases/plan_to_sql.rs

@@ -1740,6 +1740,42 @@ fn test_sort_with_push_down_fetch() -> Result<()> {
     Ok(())
 }
 
+#[test]
+fn test_sort_with_scalar_fn_and_push_down_fetch() -> Result<()> {
+    let schema = Schema::new(vec![
+        Field::new("search_phrase", DataType::Utf8, false),
+        Field::new("event_time", DataType::Utf8, false),
+    ]);
+
+    let substr_udf = unicode::substr();
+
+    // Build a plan that mimics the DF52 optimizer output:
+    // Projection(search_phrase) → Sort(substr(event_time), fetch=10)
+    //   → Projection(search_phrase, event_time) → Filter → TableScan
+    // This triggers a subquery because the outer projection differs from the inner one.
+    // The ORDER BY scalar function must not reference the inner table qualifier.
+    let plan = table_scan(Some("t1"), &schema, None)?
+        .filter(col("search_phrase").not_eq(lit("")))?
+        .project(vec![col("search_phrase"), col("event_time")])?
+        .sort_with_limit(
+            vec![
+                substr_udf
+                    .call(vec![col("event_time"), lit(1), lit(5)])
+                    .sort(true, true),
+            ],
+            Some(10),
+        )?
+        .project(vec![col("search_phrase")])?
+        .build()?;
+
+    let sql = plan_to_sql(&plan)?;
+    assert_snapshot!(
+        sql,
+        @"SELECT t1.search_phrase FROM (SELECT t1.search_phrase, t1.event_time FROM t1 WHERE (t1.search_phrase <> '') ORDER BY substr(t1.event_time, 1, 5) ASC NULLS FIRST LIMIT 10)"
+    );
+    Ok(())
+}
+
 #[test]
 fn test_join_with_table_scan_filters() -> Result<()> {
     let schema_left = Schema::new(vec![