Use SortMergeJoinExec name consistently in physical plan outputs (#19246)

## Which issue does this PR close?
- closes #19238

## Rationale for this change

`SortMergeJoinExec` is currently displayed inconsistently across
physical plan formats, see
[join.slt](https://github.com/apache/datafusion/blob/20870c18a418ec081d44ecf8a90a30a95aa53138/datafusion/sqllogictest/test_files/joins.slt#L2727)
vs.
[explain_tree.slt](https://github.com/apache/datafusion/blob/20870c18a418ec081d44ecf8a90a30a95aa53138/datafusion/sqllogictest/test_files/explain_tree.slt#L1203).

These examples show that the tree-fmt plan uses SortMergeJoinExec, while
the indent-fmt plan uses SortMergeJoin.

Standardizing the operator name improves clarity and aligns with the
naming conventions of other execution operators.

## What changes are included in this PR?

Updates the `DisplayAs` implementation for `SortMergeJoinExec` to output
`"SortMergeJoinExec: ..."`.

Updates SQL Logic Test expected outputs in `joins.slt` to reflect the
unified naming.

No functional behavior changes; this is a display/consistency fix.

## Are these changes tested?

Yes. This change is encapsulated in existing SQL Logic Tests. I updated
those expected outputs to match the new standardized naming.

All tests pass with the updated format.

## Are there any user-facing changes?

Yes—users inspecting physical plans will now consistently see
`SortMergeJoinExec` instead of `SortMergeJoin`.

Author: xavlee

datafusion/core/tests/physical_optimizer/enforce_distribution.rs

@@ -1424,8 +1424,8 @@ fn multi_smj_joins() -> Result<()> {
                     // Should include 6 RepartitionExecs (3 hash, 3 round-robin), 3 SortExecs
                     JoinType::Inner | JoinType::Left | JoinType::LeftSemi | JoinType::LeftAnti => {
                         assert_plan!(plan_distrib, @r"
-                        SortMergeJoin: join_type=..., on=[(a@0, c@2)]
-                          SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                        SortMergeJoinExec: join_type=..., on=[(a@0, c@2)]
+                          SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                             SortExec: expr=[a@0 ASC], preserve_partitioning=[true]
                               RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1
                                 DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1439,20 +1439,20 @@ fn multi_smj_joins() -> Result<()> {
                         ");
                     }
                     // Should include 7 RepartitionExecs (4 hash, 3 round-robin), 4 SortExecs
-                    // Since ordering of the left child is not preserved after SortMergeJoin
+                    // Since ordering of the left child is not preserved after SortMergeJoinExec
                     // when mode is Right, RightSemi, RightAnti, Full
-                    // - We need to add one additional SortExec after SortMergeJoin in contrast the test cases
+                    // - We need to add one additional SortExec after SortMergeJoinExec in contrast the test cases
                     //   when mode is Inner, Left, LeftSemi, LeftAnti
                     // Similarly, since partitioning of the left side is not preserved
                     // when mode is Right, RightSemi, RightAnti, Full
-                    // - We need to add one additional Hash Repartition after SortMergeJoin in contrast the test
+                    // - We need to add one additional Hash Repartition after SortMergeJoinExec in contrast the test
                     //   cases when mode is Inner, Left, LeftSemi, LeftAnti
                     _ => {
                         assert_plan!(plan_distrib, @r"
-                        SortMergeJoin: join_type=..., on=[(a@0, c@2)]
+                        SortMergeJoinExec: join_type=..., on=[(a@0, c@2)]
                           SortExec: expr=[a@0 ASC], preserve_partitioning=[true]
                             RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=10
-                              SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                              SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                 SortExec: expr=[a@0 ASC], preserve_partitioning=[true]
                                   RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1
                                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1474,8 +1474,8 @@ fn multi_smj_joins() -> Result<()> {
                     JoinType::Inner | JoinType::Left | JoinType::LeftSemi | JoinType::LeftAnti => {
                         // TODO(wiedld): show different test result if enforce distribution first.
                         assert_plan!(plan_sort, @r"
-                        SortMergeJoin: join_type=..., on=[(a@0, c@2)]
-                          SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                        SortMergeJoinExec: join_type=..., on=[(a@0, c@2)]
+                          SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                             RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1, maintains_sort_order=true
                               SortExec: expr=[a@0 ASC], preserve_partitioning=[false]
                                 DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1489,22 +1489,22 @@ fn multi_smj_joins() -> Result<()> {
                         ");
                     }
                     // Should include 8 RepartitionExecs (4 hash, 8 round-robin), 4 SortExecs
-                    // Since ordering of the left child is not preserved after SortMergeJoin
+                    // Since ordering of the left child is not preserved after SortMergeJoinExec
                     // when mode is Right, RightSemi, RightAnti, Full
-                    // - We need to add one additional SortExec after SortMergeJoin in contrast the test cases
+                    // - We need to add one additional SortExec after SortMergeJoinExec in contrast the test cases
                     //   when mode is Inner, Left, LeftSemi, LeftAnti
                     // Similarly, since partitioning of the left side is not preserved
                     // when mode is Right, RightSemi, RightAnti, Full
                     // - We need to add one additional Hash Repartition and Roundrobin repartition after
-                    //   SortMergeJoin in contrast the test cases when mode is Inner, Left, LeftSemi, LeftAnti
+                    //   SortMergeJoinExec in contrast the test cases when mode is Inner, Left, LeftSemi, LeftAnti
                     _ => {
                         // TODO(wiedld): show different test result if enforce distribution first.
                         assert_plan!(plan_sort, @r"
-                        SortMergeJoin: join_type=..., on=[(a@0, c@2)]
+                        SortMergeJoinExec: join_type=..., on=[(a@0, c@2)]
                           RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1, maintains_sort_order=true
                             SortExec: expr=[a@0 ASC], preserve_partitioning=[false]
                               CoalescePartitionsExec
-                                SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                                SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                   RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1, maintains_sort_order=true
                                     SortExec: expr=[a@0 ASC], preserve_partitioning=[false]
                                       DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1536,8 +1536,8 @@ fn multi_smj_joins() -> Result<()> {
                             JoinType::Inner | JoinType::Right => {
                                 // TODO(wiedld): show different test result if enforce sorting first.
                                 assert_plan!(plan_distrib, @r"
-                                SortMergeJoin: join_type=..., on=[(b1@6, c@2)]
-                                  SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                                SortMergeJoinExec: join_type=..., on=[(b1@6, c@2)]
+                                  SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                     SortExec: expr=[a@0 ASC], preserve_partitioning=[true]
                                       RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1
                                         DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1554,10 +1554,10 @@ fn multi_smj_joins() -> Result<()> {
                             JoinType::Left | JoinType::Full => {
                                 // TODO(wiedld): show different test result if enforce sorting first.
                                 assert_plan!(plan_distrib, @r"
-                                SortMergeJoin: join_type=..., on=[(b1@6, c@2)]
+                                SortMergeJoinExec: join_type=..., on=[(b1@6, c@2)]
                                   SortExec: expr=[b1@6 ASC], preserve_partitioning=[true]
                                     RepartitionExec: partitioning=Hash([b1@6], 10), input_partitions=10
-                                      SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                                      SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                         SortExec: expr=[a@0 ASC], preserve_partitioning=[true]
                                           RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1
                                             DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1581,8 +1581,8 @@ fn multi_smj_joins() -> Result<()> {
                             JoinType::Inner | JoinType::Right => {
                                 // TODO(wiedld): show different test result if enforce distribution first.
                                 assert_plan!(plan_sort, @r"
-                                SortMergeJoin: join_type=..., on=[(b1@6, c@2)]
-                                  SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                                SortMergeJoinExec: join_type=..., on=[(b1@6, c@2)]
+                                  SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                     RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1, maintains_sort_order=true
                                       SortExec: expr=[a@0 ASC], preserve_partitioning=[false]
                                         DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1599,11 +1599,11 @@ fn multi_smj_joins() -> Result<()> {
                             JoinType::Left | JoinType::Full => {
                                 // TODO(wiedld): show different test result if enforce distribution first.
                                 assert_plan!(plan_sort, @r"
-                                SortMergeJoin: join_type=..., on=[(b1@6, c@2)]
+                                SortMergeJoinExec: join_type=..., on=[(b1@6, c@2)]
                                   RepartitionExec: partitioning=Hash([b1@6], 10), input_partitions=1, maintains_sort_order=true
                                     SortExec: expr=[b1@6 ASC], preserve_partitioning=[false]
                                       CoalescePartitionsExec
-                                        SortMergeJoin: join_type=..., on=[(a@0, b1@1)]
+                                        SortMergeJoinExec: join_type=..., on=[(a@0, b1@1)]
                                           RepartitionExec: partitioning=Hash([a@0], 10), input_partitions=1, maintains_sort_order=true
                                             SortExec: expr=[a@0 ASC], preserve_partitioning=[false]
                                               DataSourceExec: file_groups={1 group: [[x]]}, projection=[a, b, c, d, e], file_type=parquet
@@ -1682,7 +1682,7 @@ fn smj_join_key_ordering() -> Result<()> {
     // Only two RepartitionExecs added
     let plan_distrib = test_config.to_plan(join.clone(), &DISTRIB_DISTRIB_SORT);
     assert_plan!(plan_distrib, @r"
-    SortMergeJoin: join_type=Inner, on=[(b3@1, b2@1), (a3@0, a2@0)]
+    SortMergeJoinExec: join_type=Inner, on=[(b3@1, b2@1), (a3@0, a2@0)]
       SortExec: expr=[b3@1 ASC, a3@0 ASC], preserve_partitioning=[true]
         ProjectionExec: expr=[a1@0 as a3, b1@1 as b3]
           ProjectionExec: expr=[a1@1 as a1, b1@0 as b1]
@@ -1703,7 +1703,7 @@ fn smj_join_key_ordering() -> Result<()> {
     // Test: result IS DIFFERENT, if EnforceSorting is run first:
     let plan_sort = test_config.to_plan(join, &SORT_DISTRIB_DISTRIB);
     assert_plan!(plan_sort, @r"
-    SortMergeJoin: join_type=Inner, on=[(b3@1, b2@1), (a3@0, a2@0)]
+    SortMergeJoinExec: join_type=Inner, on=[(b3@1, b2@1), (a3@0, a2@0)]
       RepartitionExec: partitioning=Hash([b3@1, a3@0], 10), input_partitions=1, maintains_sort_order=true
         SortExec: expr=[b3@1 ASC, a3@0 ASC], preserve_partitioning=[false]
           CoalescePartitionsExec

datafusion/core/tests/physical_optimizer/enforce_sorting.rs

@@ -1340,12 +1340,12 @@ async fn test_sort_merge_join_order_by_left() -> Result<()> {
                 assert_snapshot!(test.run(), @r"
                 Input Plan:
                 SortPreservingMergeExec: [nullable_col@0 ASC, non_nullable_col@1 ASC]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
                 Optimized Plan:
-                SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                   SortExec: expr=[nullable_col@0 ASC, non_nullable_col@1 ASC], preserve_partitioning=[false]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                   SortExec: expr=[col_a@0 ASC], preserve_partitioning=[false]
@@ -1357,13 +1357,13 @@ async fn test_sort_merge_join_order_by_left() -> Result<()> {
                 assert_snapshot!(test.run(), @r"
                 Input Plan:
                 SortPreservingMergeExec: [nullable_col@0 ASC, non_nullable_col@1 ASC]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
                 Optimized Plan:
                 SortExec: expr=[nullable_col@0 ASC, non_nullable_col@1 ASC], preserve_partitioning=[false]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
                       DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     SortExec: expr=[col_a@0 ASC], preserve_partitioning=[false]
@@ -1430,12 +1430,12 @@ async fn test_sort_merge_join_order_by_right() -> Result<()> {
                 assert_snapshot!(test.run(), @r"
                 Input Plan:
                 SortPreservingMergeExec: [col_a@2 ASC, col_b@3 ASC]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
                 Optimized Plan:
-                SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                   SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                   SortExec: expr=[col_a@0 ASC, col_b@1 ASC], preserve_partitioning=[false]
@@ -1447,12 +1447,12 @@ async fn test_sort_merge_join_order_by_right() -> Result<()> {
                 assert_snapshot!(test.run(), @r"
                 Input Plan:
                 SortPreservingMergeExec: [col_a@0 ASC, col_b@1 ASC]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
                 Optimized Plan:
-                SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                   SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                   SortExec: expr=[col_a@0 ASC, col_b@1 ASC], preserve_partitioning=[false]
@@ -1464,13 +1464,13 @@ async fn test_sort_merge_join_order_by_right() -> Result<()> {
                 assert_snapshot!(test.run(), @r"
                 Input Plan:
                 SortPreservingMergeExec: [col_a@2 ASC, col_b@3 ASC]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
                 Optimized Plan:
                 SortExec: expr=[col_a@2 ASC, col_b@3 ASC], preserve_partitioning=[false]
-                  SortMergeJoin: join_type=..., on=[(nullable_col@0, col_a@0)]
+                  SortMergeJoinExec: join_type=..., on=[(nullable_col@0, col_a@0)]
                     SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
                       DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
                     SortExec: expr=[col_a@0 ASC], preserve_partitioning=[false]
@@ -1513,13 +1513,13 @@ async fn test_sort_merge_join_complex_order_by() -> Result<()> {
     assert_snapshot!(test.run(), @r"
     Input Plan:
     SortPreservingMergeExec: [col_b@3 ASC, col_a@2 ASC]
-      SortMergeJoin: join_type=Inner, on=[(nullable_col@0, col_a@0)]
+      SortMergeJoinExec: join_type=Inner, on=[(nullable_col@0, col_a@0)]
         DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
         DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
     Optimized Plan:
     SortExec: expr=[col_b@3 ASC, nullable_col@0 ASC], preserve_partitioning=[false]
-      SortMergeJoin: join_type=Inner, on=[(nullable_col@0, col_a@0)]
+      SortMergeJoinExec: join_type=Inner, on=[(nullable_col@0, col_a@0)]
         SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
           DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
         SortExec: expr=[col_a@0 ASC], preserve_partitioning=[false]
@@ -1540,12 +1540,12 @@ async fn test_sort_merge_join_complex_order_by() -> Result<()> {
     assert_snapshot!(test.run(), @r"
     Input Plan:
     SortPreservingMergeExec: [nullable_col@0 ASC, col_b@3 ASC, col_a@2 ASC]
-      SortMergeJoin: join_type=Inner, on=[(nullable_col@0, col_a@0)]
+      SortMergeJoinExec: join_type=Inner, on=[(nullable_col@0, col_a@0)]
         DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
         DataSourceExec: file_groups={1 group: [[x]]}, projection=[col_a, col_b], file_type=parquet
 
     Optimized Plan:
-    SortMergeJoin: join_type=Inner, on=[(nullable_col@0, col_a@0)]
+    SortMergeJoinExec: join_type=Inner, on=[(nullable_col@0, col_a@0)]
       SortExec: expr=[nullable_col@0 ASC], preserve_partitioning=[false]
         DataSourceExec: file_groups={1 group: [[x]]}, projection=[nullable_col, non_nullable_col], file_type=parquet
       SortExec: expr=[col_a@0 ASC, col_b@1 ASC], preserve_partitioning=[false]