Display qualifiers in EXPLAIN

Sometimes we display qualifiers in plan's Display, e.g. for `Column`,
but sometimes not. This adds qualifiers to output for `SubqueryAlias`
and in `LogicalPlan::display_indent_schema`. Qualifiers are sometimes
necessary to understand the plan semantics, especially when dealing with
duplicate names, e.g. in joins.

Author: findepi

datafusion/expr/src/expr.rs

@@ -3456,7 +3456,12 @@ pub const UNNEST_COLUMN_PREFIX: &str = "UNNEST";
 impl Display for Expr {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         match self {
-            Expr::Alias(Alias { expr, name, .. }) => write!(f, "{expr} AS {name}"),
+            Expr::Alias(Alias { expr, relation, name, .. }) => {
+                match relation {
+                    None => write!(f, "{expr} AS {name}"),
+                    Some(relation) => write!(f, "{expr} AS {relation}.{name}"),
+                }
+            },
             Expr::Column(c) => write!(f, "{c}"),
             Expr::OuterReferenceColumn(_, c) => {
                 write!(f, "{OUTER_REFERENCE_COLUMN_PREFIX}({c})")

datafusion/expr/src/logical_plan/display.rs

@@ -31,7 +31,7 @@ use crate::dml::CopyTo;
 use arrow::datatypes::Schema;
 use datafusion_common::display::GraphvizBuilder;
 use datafusion_common::tree_node::{TreeNodeRecursion, TreeNodeVisitor};
-use datafusion_common::{Column, DataFusionError};
+use datafusion_common::{Column, DFSchema, DataFusionError};
 use serde_json::json;
 
 /// Formats plans with a single line per node. For example:
@@ -75,7 +75,7 @@ impl<'n> TreeNodeVisitor<'n> for IndentVisitor<'_, '_> {
             write!(
                 self.f,
                 " {}",
-                display_schema(&plan.schema().as_ref().to_owned().into())
+                display_df_schema(&plan.schema().as_ref())
             )?;
         }
 
@@ -92,7 +92,7 @@ impl<'n> TreeNodeVisitor<'n> for IndentVisitor<'_, '_> {
     }
 }
 
-/// Print the schema in a compact representation to `buf`
+/// Print the schema in a compact representation
 ///
 /// For example: `foo:Utf8` if `foo` can not be null, and
 /// `foo:Utf8;N` if `foo` is nullable.
@@ -135,6 +135,38 @@ pub fn display_schema(schema: &Schema) -> impl fmt::Display + '_ {
     Wrapper(schema)
 }
 
+/// Print the schema in a compact representation.
+/// Similar to `display_schema`, but includes field qualifiers if any.
+pub fn display_df_schema(schema: &DFSchema) -> impl fmt::Display + '_ {
+    struct Wrapper<'a>(&'a DFSchema);
+
+    impl fmt::Display for Wrapper<'_> {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "[")?;
+            for (idx, (qualifier, field)) in self.0.iter().enumerate() {
+                if idx > 0 {
+                    write!(f, ", ")?;
+                }
+                let nullable_str = if field.is_nullable() { ";N" } else { "" };
+                write!(
+                    f,
+                    "{}{}:{:?}{}",
+                    if let Some(q) = qualifier {
+                        format!("{q}.")
+                    } else {
+                        "".to_string()
+                    },
+                    field.name(),
+                    field.data_type(),
+                    nullable_str
+                )?;
+            }
+            write!(f, "]")
+        }
+    }
+    Wrapper(schema)
+}
+
 /// Formats plans for graphical display using the `DOT` language. This
 /// format can be visualized using software from
 /// [`graphviz`](https://graphviz.org/)